blob: 2dd484ed3dbb8d4eb4d353312908c8d779422000 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * NET3 Protocol independent device support routines.
3 *
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.
8 *
9 * Derived from the non IP parts of dev.c 1.0.19
Jesper Juhl02c30a82005-05-05 16:16:16 -070010 * Authors: Ross Biro
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Mark Evans, <evansmp@uhura.aston.ac.uk>
13 *
14 * Additional Authors:
15 * Florian la Roche <rzsfl@rz.uni-sb.de>
16 * Alan Cox <gw4pts@gw4pts.ampr.org>
17 * David Hinds <dahinds@users.sourceforge.net>
18 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
19 * Adam Sulmicki <adam@cfar.umd.edu>
20 * Pekka Riikonen <priikone@poesidon.pspt.fi>
21 *
22 * Changes:
23 * D.J. Barrow : Fixed bug where dev->refcnt gets set
24 * to 2 if register_netdev gets called
25 * before net_dev_init & also removed a
26 * few lines of code in the process.
27 * Alan Cox : device private ioctl copies fields back.
28 * Alan Cox : Transmit queue code does relevant
29 * stunts to keep the queue safe.
30 * Alan Cox : Fixed double lock.
31 * Alan Cox : Fixed promisc NULL pointer trap
32 * ???????? : Support the full private ioctl range
33 * Alan Cox : Moved ioctl permission check into
34 * drivers
35 * Tim Kordas : SIOCADDMULTI/SIOCDELMULTI
36 * Alan Cox : 100 backlog just doesn't cut it when
37 * you start doing multicast video 8)
38 * Alan Cox : Rewrote net_bh and list manager.
39 * Alan Cox : Fix ETH_P_ALL echoback lengths.
40 * Alan Cox : Took out transmit every packet pass
41 * Saved a few bytes in the ioctl handler
42 * Alan Cox : Network driver sets packet type before
43 * calling netif_rx. Saves a function
44 * call a packet.
45 * Alan Cox : Hashed net_bh()
46 * Richard Kooijman: Timestamp fixes.
47 * Alan Cox : Wrong field in SIOCGIFDSTADDR
48 * Alan Cox : Device lock protection.
49 * Alan Cox : Fixed nasty side effect of device close
50 * changes.
51 * Rudi Cilibrasi : Pass the right thing to
52 * set_mac_address()
53 * Dave Miller : 32bit quantity for the device lock to
54 * make it work out on a Sparc.
55 * Bjorn Ekwall : Added KERNELD hack.
56 * Alan Cox : Cleaned up the backlog initialise.
57 * Craig Metz : SIOCGIFCONF fix if space for under
58 * 1 device.
59 * Thomas Bogendoerfer : Return ENODEV for dev_open, if there
60 * is no device open function.
61 * Andi Kleen : Fix error reporting for SIOCGIFCONF
62 * Michael Chastain : Fix signed/unsigned for SIOCGIFCONF
63 * Cyrus Durgin : Cleaned for KMOD
64 * Adam Sulmicki : Bug Fix : Network Device Unload
65 * A network device unload needs to purge
66 * the backlog queue.
67 * Paul Rusty Russell : SIOCSIFNAME
68 * Pekka Riikonen : Netdev boot-time settings code
69 * Andrew Morton : Make unregister_netdevice wait
70 * indefinitely on dev->refcnt
71 * J Hadi Salim : - Backlog queue sampling
72 * - netif_rx() feedback
73 */
74
75#include <asm/uaccess.h>
76#include <asm/system.h>
77#include <linux/bitops.h>
Randy Dunlap4fc268d2006-01-11 12:17:47 -080078#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070079#include <linux/cpu.h>
80#include <linux/types.h>
81#include <linux/kernel.h>
82#include <linux/sched.h>
Arjan van de Ven4a3e2f72006-03-20 22:33:17 -080083#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070084#include <linux/string.h>
85#include <linux/mm.h>
86#include <linux/socket.h>
87#include <linux/sockios.h>
88#include <linux/errno.h>
89#include <linux/interrupt.h>
90#include <linux/if_ether.h>
91#include <linux/netdevice.h>
92#include <linux/etherdevice.h>
Ben Hutchings0187bdf2008-06-19 16:15:47 -070093#include <linux/ethtool.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070094#include <linux/notifier.h>
95#include <linux/skbuff.h>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020096#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070097#include <net/sock.h>
98#include <linux/rtnetlink.h>
99#include <linux/proc_fs.h>
100#include <linux/seq_file.h>
101#include <linux/stat.h>
102#include <linux/if_bridge.h>
Patrick McHardyb863ceb2007-07-14 18:55:06 -0700103#include <linux/if_macvlan.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104#include <net/dst.h>
105#include <net/pkt_sched.h>
106#include <net/checksum.h>
107#include <linux/highmem.h>
108#include <linux/init.h>
109#include <linux/kmod.h>
110#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111#include <linux/netpoll.h>
112#include <linux/rcupdate.h>
113#include <linux/delay.h>
Johannes Berg295f4a12007-04-26 20:43:56 -0700114#include <net/wext.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115#include <net/iw_handler.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116#include <asm/current.h>
Steve Grubb5bdb9882005-12-03 08:39:35 -0500117#include <linux/audit.h>
Chris Leechdb217332006-06-17 21:24:58 -0700118#include <linux/dmaengine.h>
Herbert Xuf6a78bf2006-06-22 02:57:17 -0700119#include <linux/err.h>
David S. Millerc7fa9d12006-08-15 16:34:13 -0700120#include <linux/ctype.h>
Jarek Poplawski723e98b2007-05-15 22:46:18 -0700121#include <linux/if_arp.h>
Ben Hutchings6de329e2008-06-16 17:02:28 -0700122#include <linux/if_vlan.h>
David S. Miller8f0f2222008-07-15 03:47:03 -0700123#include <linux/ip.h>
Alexander Duyckad55dca2008-09-20 22:05:50 -0700124#include <net/ip.h>
David S. Miller8f0f2222008-07-15 03:47:03 -0700125#include <linux/ipv6.h>
126#include <linux/in.h>
David S. Millerb6b2fed2008-07-21 09:48:06 -0700127#include <linux/jhash.h>
128#include <linux/random.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129
Pavel Emelyanov342709e2007-10-23 21:14:45 -0700130#include "net-sysfs.h"
131
Herbert Xud565b0a2008-12-15 23:38:52 -0800132/* Instead of increasing this, you should create a hash table. */
133#define MAX_GRO_SKBS 8
134
Herbert Xu5d38a072009-01-04 16:13:40 -0800135/* This should be increased if a protocol with a bigger head is added. */
136#define GRO_MAX_HEAD (MAX_HEADER + 128)
137
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138/*
139 * The list of packet types we will receive (as opposed to discard)
140 * and the routines to invoke.
141 *
142 * Why 16. Because with 16 the only overlap we get on a hash of the
143 * low nibble of the protocol value is RARP/SNAP/X.25.
144 *
145 * NOTE: That is no longer true with the addition of VLAN tags. Not
146 * sure which should go first, but I bet it won't make much
147 * difference if we are running VLANs. The good news is that
148 * this protocol won't be in the list unless compiled in, so
Stephen Hemminger3041a062006-05-26 13:25:24 -0700149 * the average user (w/out VLANs) will not be adversely affected.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 * --BLG
151 *
152 * 0800 IP
153 * 8100 802.1Q VLAN
154 * 0001 802.3
155 * 0002 AX.25
156 * 0004 802.2
157 * 8035 RARP
158 * 0005 SNAP
159 * 0805 X.25
160 * 0806 ARP
161 * 8137 IPX
162 * 0009 Localtalk
163 * 86DD IPv6
164 */
165
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +0800166#define PTYPE_HASH_SIZE (16)
167#define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1)
168
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169static DEFINE_SPINLOCK(ptype_lock);
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +0800170static struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
Stephen Hemminger6b2bedc2007-03-12 14:33:50 -0700171static struct list_head ptype_all __read_mostly; /* Taps */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173/*
Pavel Emelianov7562f872007-05-03 15:13:45 -0700174 * The @dev_base_head list is protected by @dev_base_lock and the rtnl
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 * semaphore.
176 *
177 * Pure readers hold dev_base_lock for reading.
178 *
179 * Writers must hold the rtnl semaphore while they loop through the
Pavel Emelianov7562f872007-05-03 15:13:45 -0700180 * dev_base_head list, and hold dev_base_lock for writing when they do the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 * actual updates. This allows pure readers to access the list even
182 * while a writer is preparing to update it.
183 *
184 * To put it another way, dev_base_lock is held for writing only to
185 * protect against pure readers; the rtnl semaphore provides the
186 * protection against other writers.
187 *
188 * See, for example usages, register_netdevice() and
189 * unregister_netdevice(), which must be called with the rtnl
190 * semaphore held.
191 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192DEFINE_RWLOCK(dev_base_lock);
193
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194EXPORT_SYMBOL(dev_base_lock);
195
196#define NETDEV_HASHBITS 8
Eric W. Biederman881d9662007-09-17 11:56:21 -0700197#define NETDEV_HASHENTRIES (1 << NETDEV_HASHBITS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198
Eric W. Biederman881d9662007-09-17 11:56:21 -0700199static inline struct hlist_head *dev_name_hash(struct net *net, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200{
201 unsigned hash = full_name_hash(name, strnlen(name, IFNAMSIZ));
Eric W. Biederman881d9662007-09-17 11:56:21 -0700202 return &net->dev_name_head[hash & ((1 << NETDEV_HASHBITS) - 1)];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203}
204
Eric W. Biederman881d9662007-09-17 11:56:21 -0700205static inline struct hlist_head *dev_index_hash(struct net *net, int ifindex)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206{
Eric W. Biederman881d9662007-09-17 11:56:21 -0700207 return &net->dev_index_head[ifindex & ((1 << NETDEV_HASHBITS) - 1)];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208}
209
Eric W. Biedermance286d32007-09-12 13:53:49 +0200210/* Device list insertion */
211static int list_netdevice(struct net_device *dev)
212{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900213 struct net *net = dev_net(dev);
Eric W. Biedermance286d32007-09-12 13:53:49 +0200214
215 ASSERT_RTNL();
216
217 write_lock_bh(&dev_base_lock);
218 list_add_tail(&dev->dev_list, &net->dev_base_head);
219 hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
220 hlist_add_head(&dev->index_hlist, dev_index_hash(net, dev->ifindex));
221 write_unlock_bh(&dev_base_lock);
222 return 0;
223}
224
225/* Device list removal */
226static void unlist_netdevice(struct net_device *dev)
227{
228 ASSERT_RTNL();
229
230 /* Unlink dev from the device chain */
231 write_lock_bh(&dev_base_lock);
232 list_del(&dev->dev_list);
233 hlist_del(&dev->name_hlist);
234 hlist_del(&dev->index_hlist);
235 write_unlock_bh(&dev_base_lock);
236}
237
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238/*
239 * Our notifier list
240 */
241
Alan Sternf07d5b92006-05-09 15:23:03 -0700242static RAW_NOTIFIER_HEAD(netdev_chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
244/*
245 * Device drivers call our routines to queue packets here. We empty the
246 * queue in the local softnet handler.
247 */
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700248
249DEFINE_PER_CPU(struct softnet_data, softnet_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
David S. Millercf508b12008-07-22 14:16:42 -0700251#ifdef CONFIG_LOCKDEP
Jarek Poplawski723e98b2007-05-15 22:46:18 -0700252/*
David S. Millerc773e842008-07-08 23:13:53 -0700253 * register_netdevice() inits txq->_xmit_lock and sets lockdep class
Jarek Poplawski723e98b2007-05-15 22:46:18 -0700254 * according to dev->type
255 */
256static const unsigned short netdev_lock_type[] =
257 {ARPHRD_NETROM, ARPHRD_ETHER, ARPHRD_EETHER, ARPHRD_AX25,
258 ARPHRD_PRONET, ARPHRD_CHAOS, ARPHRD_IEEE802, ARPHRD_ARCNET,
259 ARPHRD_APPLETLK, ARPHRD_DLCI, ARPHRD_ATM, ARPHRD_METRICOM,
260 ARPHRD_IEEE1394, ARPHRD_EUI64, ARPHRD_INFINIBAND, ARPHRD_SLIP,
261 ARPHRD_CSLIP, ARPHRD_SLIP6, ARPHRD_CSLIP6, ARPHRD_RSRVD,
262 ARPHRD_ADAPT, ARPHRD_ROSE, ARPHRD_X25, ARPHRD_HWX25,
263 ARPHRD_PPP, ARPHRD_CISCO, ARPHRD_LAPB, ARPHRD_DDCMP,
264 ARPHRD_RAWHDLC, ARPHRD_TUNNEL, ARPHRD_TUNNEL6, ARPHRD_FRAD,
265 ARPHRD_SKIP, ARPHRD_LOOPBACK, ARPHRD_LOCALTLK, ARPHRD_FDDI,
266 ARPHRD_BIF, ARPHRD_SIT, ARPHRD_IPDDP, ARPHRD_IPGRE,
267 ARPHRD_PIMREG, ARPHRD_HIPPI, ARPHRD_ASH, ARPHRD_ECONET,
268 ARPHRD_IRDA, ARPHRD_FCPP, ARPHRD_FCAL, ARPHRD_FCPL,
269 ARPHRD_FCFABRIC, ARPHRD_IEEE802_TR, ARPHRD_IEEE80211,
Rémi Denis-Courmont2d91d782008-12-17 15:47:29 -0800270 ARPHRD_IEEE80211_PRISM, ARPHRD_IEEE80211_RADIOTAP, ARPHRD_PHONET,
Rémi Denis-Courmont57c81ff2008-12-17 15:47:48 -0800271 ARPHRD_PHONET_PIPE, ARPHRD_VOID, ARPHRD_NONE};
Jarek Poplawski723e98b2007-05-15 22:46:18 -0700272
273static const char *netdev_lock_name[] =
274 {"_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25",
275 "_xmit_PRONET", "_xmit_CHAOS", "_xmit_IEEE802", "_xmit_ARCNET",
276 "_xmit_APPLETLK", "_xmit_DLCI", "_xmit_ATM", "_xmit_METRICOM",
277 "_xmit_IEEE1394", "_xmit_EUI64", "_xmit_INFINIBAND", "_xmit_SLIP",
278 "_xmit_CSLIP", "_xmit_SLIP6", "_xmit_CSLIP6", "_xmit_RSRVD",
279 "_xmit_ADAPT", "_xmit_ROSE", "_xmit_X25", "_xmit_HWX25",
280 "_xmit_PPP", "_xmit_CISCO", "_xmit_LAPB", "_xmit_DDCMP",
281 "_xmit_RAWHDLC", "_xmit_TUNNEL", "_xmit_TUNNEL6", "_xmit_FRAD",
282 "_xmit_SKIP", "_xmit_LOOPBACK", "_xmit_LOCALTLK", "_xmit_FDDI",
283 "_xmit_BIF", "_xmit_SIT", "_xmit_IPDDP", "_xmit_IPGRE",
284 "_xmit_PIMREG", "_xmit_HIPPI", "_xmit_ASH", "_xmit_ECONET",
285 "_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL",
286 "_xmit_FCFABRIC", "_xmit_IEEE802_TR", "_xmit_IEEE80211",
Rémi Denis-Courmont2d91d782008-12-17 15:47:29 -0800287 "_xmit_IEEE80211_PRISM", "_xmit_IEEE80211_RADIOTAP", "_xmit_PHONET",
Rémi Denis-Courmont57c81ff2008-12-17 15:47:48 -0800288 "_xmit_PHONET_PIPE", "_xmit_VOID", "_xmit_NONE"};
Jarek Poplawski723e98b2007-05-15 22:46:18 -0700289
290static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
David S. Millercf508b12008-07-22 14:16:42 -0700291static struct lock_class_key netdev_addr_lock_key[ARRAY_SIZE(netdev_lock_type)];
Jarek Poplawski723e98b2007-05-15 22:46:18 -0700292
293static inline unsigned short netdev_lock_pos(unsigned short dev_type)
294{
295 int i;
296
297 for (i = 0; i < ARRAY_SIZE(netdev_lock_type); i++)
298 if (netdev_lock_type[i] == dev_type)
299 return i;
300 /* the last key is used by default */
301 return ARRAY_SIZE(netdev_lock_type) - 1;
302}
303
David S. Millercf508b12008-07-22 14:16:42 -0700304static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
305 unsigned short dev_type)
Jarek Poplawski723e98b2007-05-15 22:46:18 -0700306{
307 int i;
308
309 i = netdev_lock_pos(dev_type);
310 lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i],
311 netdev_lock_name[i]);
312}
David S. Millercf508b12008-07-22 14:16:42 -0700313
314static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
315{
316 int i;
317
318 i = netdev_lock_pos(dev->type);
319 lockdep_set_class_and_name(&dev->addr_list_lock,
320 &netdev_addr_lock_key[i],
321 netdev_lock_name[i]);
322}
Jarek Poplawski723e98b2007-05-15 22:46:18 -0700323#else
David S. Millercf508b12008-07-22 14:16:42 -0700324static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
325 unsigned short dev_type)
326{
327}
328static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
Jarek Poplawski723e98b2007-05-15 22:46:18 -0700329{
330}
331#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332
333/*******************************************************************************
334
335 Protocol management and registration routines
336
337*******************************************************************************/
338
339/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 * Add a protocol ID to the list. Now that the input handler is
341 * smarter we can dispense with all the messy stuff that used to be
342 * here.
343 *
344 * BEWARE!!! Protocol handlers, mangling input packets,
345 * MUST BE last in hash buckets and checking protocol handlers
346 * MUST start from promiscuous ptype_all chain in net_bh.
347 * It is true now, do not change it.
348 * Explanation follows: if protocol handler, mangling packet, will
349 * be the first on list, it is not able to sense, that packet
350 * is cloned and should be copied-on-write, so that it will
351 * change it and subsequent readers will get broken packet.
352 * --ANK (980803)
353 */
354
355/**
356 * dev_add_pack - add packet handler
357 * @pt: packet type declaration
358 *
359 * Add a protocol handler to the networking stack. The passed &packet_type
360 * is linked into kernel lists and may not be freed until it has been
361 * removed from the kernel lists.
362 *
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900363 * This call does not sleep therefore it can not
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 * guarantee all CPU's that are in middle of receiving packets
365 * will see the new packet type (until the next received packet).
366 */
367
368void dev_add_pack(struct packet_type *pt)
369{
370 int hash;
371
372 spin_lock_bh(&ptype_lock);
Stephen Hemminger9be9a6b2007-04-20 17:02:45 -0700373 if (pt->type == htons(ETH_P_ALL))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 list_add_rcu(&pt->list, &ptype_all);
Stephen Hemminger9be9a6b2007-04-20 17:02:45 -0700375 else {
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +0800376 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 list_add_rcu(&pt->list, &ptype_base[hash]);
378 }
379 spin_unlock_bh(&ptype_lock);
380}
381
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382/**
383 * __dev_remove_pack - remove packet handler
384 * @pt: packet type declaration
385 *
386 * Remove a protocol handler that was previously added to the kernel
387 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
388 * from the kernel lists and can be freed or reused once this function
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900389 * returns.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 *
391 * The packet type might still be in use by receivers
392 * and must not be freed until after all the CPU's have gone
393 * through a quiescent state.
394 */
395void __dev_remove_pack(struct packet_type *pt)
396{
397 struct list_head *head;
398 struct packet_type *pt1;
399
400 spin_lock_bh(&ptype_lock);
401
Stephen Hemminger9be9a6b2007-04-20 17:02:45 -0700402 if (pt->type == htons(ETH_P_ALL))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 head = &ptype_all;
Stephen Hemminger9be9a6b2007-04-20 17:02:45 -0700404 else
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +0800405 head = &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
407 list_for_each_entry(pt1, head, list) {
408 if (pt == pt1) {
409 list_del_rcu(&pt->list);
410 goto out;
411 }
412 }
413
414 printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt);
415out:
416 spin_unlock_bh(&ptype_lock);
417}
418/**
419 * dev_remove_pack - remove packet handler
420 * @pt: packet type declaration
421 *
422 * Remove a protocol handler that was previously added to the kernel
423 * protocol handlers by dev_add_pack(). The passed &packet_type is removed
424 * from the kernel lists and can be freed or reused once this function
425 * returns.
426 *
427 * This call sleeps to guarantee that no CPU is looking at the packet
428 * type after return.
429 */
430void dev_remove_pack(struct packet_type *pt)
431{
432 __dev_remove_pack(pt);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900433
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 synchronize_net();
435}
436
437/******************************************************************************
438
439 Device Boot-time Settings Routines
440
441*******************************************************************************/
442
443/* Boot time configuration table */
444static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX];
445
446/**
447 * netdev_boot_setup_add - add new setup entry
448 * @name: name of the device
449 * @map: configured settings for the device
450 *
451 * Adds new setup entry to the dev_boot_setup list. The function
452 * returns 0 on error and 1 on success. This is a generic routine to
453 * all netdevices.
454 */
455static int netdev_boot_setup_add(char *name, struct ifmap *map)
456{
457 struct netdev_boot_setup *s;
458 int i;
459
460 s = dev_boot_setup;
461 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
462 if (s[i].name[0] == '\0' || s[i].name[0] == ' ') {
463 memset(s[i].name, 0, sizeof(s[i].name));
Wang Chen93b3cff2008-07-01 19:57:19 -0700464 strlcpy(s[i].name, name, IFNAMSIZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 memcpy(&s[i].map, map, sizeof(s[i].map));
466 break;
467 }
468 }
469
470 return i >= NETDEV_BOOT_SETUP_MAX ? 0 : 1;
471}
472
473/**
474 * netdev_boot_setup_check - check boot time settings
475 * @dev: the netdevice
476 *
477 * Check boot time settings for the device.
478 * The found settings are set for the device to be used
479 * later in the device probing.
480 * Returns 0 if no settings found, 1 if they are.
481 */
482int netdev_boot_setup_check(struct net_device *dev)
483{
484 struct netdev_boot_setup *s = dev_boot_setup;
485 int i;
486
487 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
488 if (s[i].name[0] != '\0' && s[i].name[0] != ' ' &&
Wang Chen93b3cff2008-07-01 19:57:19 -0700489 !strcmp(dev->name, s[i].name)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 dev->irq = s[i].map.irq;
491 dev->base_addr = s[i].map.base_addr;
492 dev->mem_start = s[i].map.mem_start;
493 dev->mem_end = s[i].map.mem_end;
494 return 1;
495 }
496 }
497 return 0;
498}
499
500
501/**
502 * netdev_boot_base - get address from boot time settings
503 * @prefix: prefix for network device
504 * @unit: id for network device
505 *
506 * Check boot time settings for the base address of device.
507 * The found settings are set for the device to be used
508 * later in the device probing.
509 * Returns 0 if no settings found.
510 */
511unsigned long netdev_boot_base(const char *prefix, int unit)
512{
513 const struct netdev_boot_setup *s = dev_boot_setup;
514 char name[IFNAMSIZ];
515 int i;
516
517 sprintf(name, "%s%d", prefix, unit);
518
519 /*
520 * If device already registered then return base of 1
521 * to indicate not to probe for this interface
522 */
Eric W. Biederman881d9662007-09-17 11:56:21 -0700523 if (__dev_get_by_name(&init_net, name))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 return 1;
525
526 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
527 if (!strcmp(name, s[i].name))
528 return s[i].map.base_addr;
529 return 0;
530}
531
532/*
533 * Saves at boot time configured settings for any netdevice.
534 */
535int __init netdev_boot_setup(char *str)
536{
537 int ints[5];
538 struct ifmap map;
539
540 str = get_options(str, ARRAY_SIZE(ints), ints);
541 if (!str || !*str)
542 return 0;
543
544 /* Save settings */
545 memset(&map, 0, sizeof(map));
546 if (ints[0] > 0)
547 map.irq = ints[1];
548 if (ints[0] > 1)
549 map.base_addr = ints[2];
550 if (ints[0] > 2)
551 map.mem_start = ints[3];
552 if (ints[0] > 3)
553 map.mem_end = ints[4];
554
555 /* Add new entry to the list */
556 return netdev_boot_setup_add(str, &map);
557}
558
559__setup("netdev=", netdev_boot_setup);
560
561/*******************************************************************************
562
563 Device Interface Subroutines
564
565*******************************************************************************/
566
567/**
568 * __dev_get_by_name - find a device by its name
Randy Dunlapc4ea43c2007-10-12 21:17:49 -0700569 * @net: the applicable net namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 * @name: name to find
571 *
572 * Find an interface by name. Must be called under RTNL semaphore
573 * or @dev_base_lock. If the name is found a pointer to the device
574 * is returned. If the name is not found then %NULL is returned. The
575 * reference counters are not incremented so the caller must be
576 * careful with locks.
577 */
578
Eric W. Biederman881d9662007-09-17 11:56:21 -0700579struct net_device *__dev_get_by_name(struct net *net, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580{
581 struct hlist_node *p;
582
Eric W. Biederman881d9662007-09-17 11:56:21 -0700583 hlist_for_each(p, dev_name_hash(net, name)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 struct net_device *dev
585 = hlist_entry(p, struct net_device, name_hlist);
586 if (!strncmp(dev->name, name, IFNAMSIZ))
587 return dev;
588 }
589 return NULL;
590}
591
592/**
593 * dev_get_by_name - find a device by its name
Randy Dunlapc4ea43c2007-10-12 21:17:49 -0700594 * @net: the applicable net namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 * @name: name to find
596 *
597 * Find an interface by name. This can be called from any
598 * context and does its own locking. The returned handle has
599 * the usage count incremented and the caller must use dev_put() to
600 * release it when it is no longer needed. %NULL is returned if no
601 * matching device is found.
602 */
603
Eric W. Biederman881d9662007-09-17 11:56:21 -0700604struct net_device *dev_get_by_name(struct net *net, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605{
606 struct net_device *dev;
607
608 read_lock(&dev_base_lock);
Eric W. Biederman881d9662007-09-17 11:56:21 -0700609 dev = __dev_get_by_name(net, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 if (dev)
611 dev_hold(dev);
612 read_unlock(&dev_base_lock);
613 return dev;
614}
615
616/**
617 * __dev_get_by_index - find a device by its ifindex
Randy Dunlapc4ea43c2007-10-12 21:17:49 -0700618 * @net: the applicable net namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 * @ifindex: index of device
620 *
621 * Search for an interface by index. Returns %NULL if the device
622 * is not found or a pointer to the device. The device has not
623 * had its reference counter increased so the caller must be careful
624 * about locking. The caller must hold either the RTNL semaphore
625 * or @dev_base_lock.
626 */
627
Eric W. Biederman881d9662007-09-17 11:56:21 -0700628struct net_device *__dev_get_by_index(struct net *net, int ifindex)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629{
630 struct hlist_node *p;
631
Eric W. Biederman881d9662007-09-17 11:56:21 -0700632 hlist_for_each(p, dev_index_hash(net, ifindex)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 struct net_device *dev
634 = hlist_entry(p, struct net_device, index_hlist);
635 if (dev->ifindex == ifindex)
636 return dev;
637 }
638 return NULL;
639}
640
641
642/**
643 * dev_get_by_index - find a device by its ifindex
Randy Dunlapc4ea43c2007-10-12 21:17:49 -0700644 * @net: the applicable net namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 * @ifindex: index of device
646 *
647 * Search for an interface by index. Returns NULL if the device
648 * is not found or a pointer to the device. The device returned has
649 * had a reference added and the pointer is safe until the user calls
650 * dev_put to indicate they have finished with it.
651 */
652
Eric W. Biederman881d9662007-09-17 11:56:21 -0700653struct net_device *dev_get_by_index(struct net *net, int ifindex)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654{
655 struct net_device *dev;
656
657 read_lock(&dev_base_lock);
Eric W. Biederman881d9662007-09-17 11:56:21 -0700658 dev = __dev_get_by_index(net, ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 if (dev)
660 dev_hold(dev);
661 read_unlock(&dev_base_lock);
662 return dev;
663}
664
665/**
666 * dev_getbyhwaddr - find a device by its hardware address
Randy Dunlapc4ea43c2007-10-12 21:17:49 -0700667 * @net: the applicable net namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 * @type: media type of device
669 * @ha: hardware address
670 *
671 * Search for an interface by MAC address. Returns NULL if the device
672 * is not found or a pointer to the device. The caller must hold the
673 * rtnl semaphore. The returned device has not had its ref count increased
674 * and the caller must therefore be careful about locking
675 *
676 * BUGS:
677 * If the API was consistent this would be __dev_get_by_hwaddr
678 */
679
Eric W. Biederman881d9662007-09-17 11:56:21 -0700680struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *ha)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681{
682 struct net_device *dev;
683
684 ASSERT_RTNL();
685
Denis V. Lunev81103a52007-12-12 10:47:38 -0800686 for_each_netdev(net, dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 if (dev->type == type &&
688 !memcmp(dev->dev_addr, ha, dev->addr_len))
Pavel Emelianov7562f872007-05-03 15:13:45 -0700689 return dev;
690
691 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692}
693
Jochen Friedrichcf309e32005-09-22 04:44:55 -0300694EXPORT_SYMBOL(dev_getbyhwaddr);
695
Eric W. Biederman881d9662007-09-17 11:56:21 -0700696struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
Patrick McHardy4e9cac22007-05-03 03:28:13 -0700697{
698 struct net_device *dev;
699
700 ASSERT_RTNL();
Eric W. Biederman881d9662007-09-17 11:56:21 -0700701 for_each_netdev(net, dev)
Patrick McHardy4e9cac22007-05-03 03:28:13 -0700702 if (dev->type == type)
Pavel Emelianov7562f872007-05-03 15:13:45 -0700703 return dev;
704
705 return NULL;
Patrick McHardy4e9cac22007-05-03 03:28:13 -0700706}
707
708EXPORT_SYMBOL(__dev_getfirstbyhwtype);
709
Eric W. Biederman881d9662007-09-17 11:56:21 -0700710struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711{
712 struct net_device *dev;
713
714 rtnl_lock();
Eric W. Biederman881d9662007-09-17 11:56:21 -0700715 dev = __dev_getfirstbyhwtype(net, type);
Patrick McHardy4e9cac22007-05-03 03:28:13 -0700716 if (dev)
717 dev_hold(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 rtnl_unlock();
719 return dev;
720}
721
722EXPORT_SYMBOL(dev_getfirstbyhwtype);
723
724/**
725 * dev_get_by_flags - find any device with given flags
Randy Dunlapc4ea43c2007-10-12 21:17:49 -0700726 * @net: the applicable net namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 * @if_flags: IFF_* values
728 * @mask: bitmask of bits in if_flags to check
729 *
730 * Search for any interface with the given flags. Returns NULL if a device
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900731 * is not found or a pointer to the device. The device returned has
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 * had a reference added and the pointer is safe until the user calls
733 * dev_put to indicate they have finished with it.
734 */
735
Eric W. Biederman881d9662007-09-17 11:56:21 -0700736struct net_device * dev_get_by_flags(struct net *net, unsigned short if_flags, unsigned short mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737{
Pavel Emelianov7562f872007-05-03 15:13:45 -0700738 struct net_device *dev, *ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739
Pavel Emelianov7562f872007-05-03 15:13:45 -0700740 ret = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 read_lock(&dev_base_lock);
Eric W. Biederman881d9662007-09-17 11:56:21 -0700742 for_each_netdev(net, dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 if (((dev->flags ^ if_flags) & mask) == 0) {
744 dev_hold(dev);
Pavel Emelianov7562f872007-05-03 15:13:45 -0700745 ret = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 break;
747 }
748 }
749 read_unlock(&dev_base_lock);
Pavel Emelianov7562f872007-05-03 15:13:45 -0700750 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751}
752
753/**
754 * dev_valid_name - check if name is okay for network device
755 * @name: name string
756 *
757 * Network device names need to be valid file names to
David S. Millerc7fa9d12006-08-15 16:34:13 -0700758 * to allow sysfs to work. We also disallow any kind of
759 * whitespace.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 */
Mitch Williamsc2373ee2005-11-09 10:34:45 -0800761int dev_valid_name(const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762{
David S. Millerc7fa9d12006-08-15 16:34:13 -0700763 if (*name == '\0')
764 return 0;
Stephen Hemmingerb6fe17d2006-08-29 17:06:13 -0700765 if (strlen(name) >= IFNAMSIZ)
766 return 0;
David S. Millerc7fa9d12006-08-15 16:34:13 -0700767 if (!strcmp(name, ".") || !strcmp(name, ".."))
768 return 0;
769
770 while (*name) {
771 if (*name == '/' || isspace(*name))
772 return 0;
773 name++;
774 }
775 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776}
777
778/**
Eric W. Biedermanb267b172007-09-12 13:48:45 +0200779 * __dev_alloc_name - allocate a name for a device
780 * @net: network namespace to allocate the device name in
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 * @name: name format string
Eric W. Biedermanb267b172007-09-12 13:48:45 +0200782 * @buf: scratch buffer and result name string
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 *
784 * Passed a format string - eg "lt%d" it will try and find a suitable
Stephen Hemminger3041a062006-05-26 13:25:24 -0700785 * id. It scans list of devices to build up a free map, then chooses
786 * the first empty slot. The caller must hold the dev_base or rtnl lock
787 * while allocating the name and adding the device in order to avoid
788 * duplicates.
789 * Limited to bits_per_byte * page size devices (ie 32K on most platforms).
790 * Returns the number of the unit assigned or a negative errno code.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 */
792
Eric W. Biedermanb267b172007-09-12 13:48:45 +0200793static int __dev_alloc_name(struct net *net, const char *name, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794{
795 int i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 const char *p;
797 const int max_netdevices = 8*PAGE_SIZE;
Stephen Hemmingercfcabdc2007-10-09 01:59:42 -0700798 unsigned long *inuse;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 struct net_device *d;
800
801 p = strnchr(name, IFNAMSIZ-1, '%');
802 if (p) {
803 /*
804 * Verify the string as this thing may have come from
805 * the user. There must be either one "%d" and no other "%"
806 * characters.
807 */
808 if (p[1] != 'd' || strchr(p + 2, '%'))
809 return -EINVAL;
810
811 /* Use one page as a bit array of possible slots */
Stephen Hemmingercfcabdc2007-10-09 01:59:42 -0700812 inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 if (!inuse)
814 return -ENOMEM;
815
Eric W. Biederman881d9662007-09-17 11:56:21 -0700816 for_each_netdev(net, d) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 if (!sscanf(d->name, name, &i))
818 continue;
819 if (i < 0 || i >= max_netdevices)
820 continue;
821
822 /* avoid cases where sscanf is not exact inverse of printf */
Eric W. Biedermanb267b172007-09-12 13:48:45 +0200823 snprintf(buf, IFNAMSIZ, name, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 if (!strncmp(buf, d->name, IFNAMSIZ))
825 set_bit(i, inuse);
826 }
827
828 i = find_first_zero_bit(inuse, max_netdevices);
829 free_page((unsigned long) inuse);
830 }
831
Eric W. Biedermanb267b172007-09-12 13:48:45 +0200832 snprintf(buf, IFNAMSIZ, name, i);
833 if (!__dev_get_by_name(net, buf))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 return i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835
836 /* It is possible to run out of possible slots
837 * when the name is long and there isn't enough space left
838 * for the digits, or if all bits are used.
839 */
840 return -ENFILE;
841}
842
Eric W. Biedermanb267b172007-09-12 13:48:45 +0200843/**
844 * dev_alloc_name - allocate a name for a device
845 * @dev: device
846 * @name: name format string
847 *
848 * Passed a format string - eg "lt%d" it will try and find a suitable
849 * id. It scans list of devices to build up a free map, then chooses
850 * the first empty slot. The caller must hold the dev_base or rtnl lock
851 * while allocating the name and adding the device in order to avoid
852 * duplicates.
853 * Limited to bits_per_byte * page size devices (ie 32K on most platforms).
854 * Returns the number of the unit assigned or a negative errno code.
855 */
856
857int dev_alloc_name(struct net_device *dev, const char *name)
858{
859 char buf[IFNAMSIZ];
860 struct net *net;
861 int ret;
862
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900863 BUG_ON(!dev_net(dev));
864 net = dev_net(dev);
Eric W. Biedermanb267b172007-09-12 13:48:45 +0200865 ret = __dev_alloc_name(net, name, buf);
866 if (ret >= 0)
867 strlcpy(dev->name, buf, IFNAMSIZ);
868 return ret;
869}
870
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
872/**
873 * dev_change_name - change name of a device
874 * @dev: device
875 * @newname: name (or format string) must be at least IFNAMSIZ
876 *
877 * Change name of a device, can pass format strings "eth%d".
878 * for wildcarding.
879 */
Stephen Hemmingercf04a4c72008-09-30 02:22:14 -0700880int dev_change_name(struct net_device *dev, const char *newname)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881{
Herbert Xufcc5a032007-07-30 17:03:38 -0700882 char oldname[IFNAMSIZ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 int err = 0;
Herbert Xufcc5a032007-07-30 17:03:38 -0700884 int ret;
Eric W. Biederman881d9662007-09-17 11:56:21 -0700885 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886
887 ASSERT_RTNL();
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900888 BUG_ON(!dev_net(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900890 net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 if (dev->flags & IFF_UP)
892 return -EBUSY;
893
894 if (!dev_valid_name(newname))
895 return -EINVAL;
896
Stephen Hemmingerc8d90dc2007-10-26 03:53:42 -0700897 if (strncmp(newname, dev->name, IFNAMSIZ) == 0)
898 return 0;
899
Herbert Xufcc5a032007-07-30 17:03:38 -0700900 memcpy(oldname, dev->name, IFNAMSIZ);
901
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 if (strchr(newname, '%')) {
903 err = dev_alloc_name(dev, newname);
904 if (err < 0)
905 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 }
Eric W. Biederman881d9662007-09-17 11:56:21 -0700907 else if (__dev_get_by_name(net, newname))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 return -EEXIST;
909 else
910 strlcpy(dev->name, newname, IFNAMSIZ);
911
Herbert Xufcc5a032007-07-30 17:03:38 -0700912rollback:
Eric W. Biederman38918452008-10-27 17:51:47 -0700913 /* For now only devices in the initial network namespace
914 * are in sysfs.
915 */
916 if (net == &init_net) {
917 ret = device_rename(&dev->dev, dev->name);
918 if (ret) {
919 memcpy(dev->name, oldname, IFNAMSIZ);
920 return ret;
921 }
Stephen Hemmingerdcc99772008-05-14 22:33:38 -0700922 }
Herbert Xu7f988ea2007-07-30 16:35:46 -0700923
924 write_lock_bh(&dev_base_lock);
Eric W. Biederman92749822007-04-03 00:07:30 -0600925 hlist_del(&dev->name_hlist);
Eric W. Biederman881d9662007-09-17 11:56:21 -0700926 hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
Herbert Xu7f988ea2007-07-30 16:35:46 -0700927 write_unlock_bh(&dev_base_lock);
928
Pavel Emelyanov056925a2007-09-16 15:42:43 -0700929 ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
Herbert Xufcc5a032007-07-30 17:03:38 -0700930 ret = notifier_to_errno(ret);
931
932 if (ret) {
933 if (err) {
934 printk(KERN_ERR
935 "%s: name change rollback failed: %d.\n",
936 dev->name, ret);
937 } else {
938 err = ret;
939 memcpy(dev->name, oldname, IFNAMSIZ);
940 goto rollback;
941 }
942 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943
944 return err;
945}
946
947/**
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700948 * dev_set_alias - change ifalias of a device
949 * @dev: device
950 * @alias: name up to IFALIASZ
Stephen Hemmingerf0db2752008-09-30 02:23:58 -0700951 * @len: limit of bytes to copy from info
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700952 *
953 * Set ifalias for a device,
954 */
955int dev_set_alias(struct net_device *dev, const char *alias, size_t len)
956{
957 ASSERT_RTNL();
958
959 if (len >= IFALIASZ)
960 return -EINVAL;
961
Oliver Hartkopp96ca4a22008-09-23 21:23:19 -0700962 if (!len) {
963 if (dev->ifalias) {
964 kfree(dev->ifalias);
965 dev->ifalias = NULL;
966 }
967 return 0;
968 }
969
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700970 dev->ifalias = krealloc(dev->ifalias, len+1, GFP_KERNEL);
971 if (!dev->ifalias)
972 return -ENOMEM;
973
974 strlcpy(dev->ifalias, alias, len+1);
975 return len;
976}
977
978
979/**
Stephen Hemminger3041a062006-05-26 13:25:24 -0700980 * netdev_features_change - device changes features
Stephen Hemmingerd8a33ac2005-05-29 14:13:47 -0700981 * @dev: device to cause notification
982 *
983 * Called to indicate a device has changed features.
984 */
985void netdev_features_change(struct net_device *dev)
986{
Pavel Emelyanov056925a2007-09-16 15:42:43 -0700987 call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev);
Stephen Hemmingerd8a33ac2005-05-29 14:13:47 -0700988}
989EXPORT_SYMBOL(netdev_features_change);
990
991/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 * netdev_state_change - device changes state
993 * @dev: device to cause notification
994 *
995 * Called to indicate a device has changed state. This function calls
996 * the notifier chains for netdev_chain and sends a NEWLINK message
997 * to the routing socket.
998 */
999void netdev_state_change(struct net_device *dev)
1000{
1001 if (dev->flags & IFF_UP) {
Pavel Emelyanov056925a2007-09-16 15:42:43 -07001002 call_netdevice_notifiers(NETDEV_CHANGE, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
1004 }
1005}
1006
Or Gerlitzc1da4ac2008-06-13 18:12:00 -07001007void netdev_bonding_change(struct net_device *dev)
1008{
1009 call_netdevice_notifiers(NETDEV_BONDING_FAILOVER, dev);
1010}
1011EXPORT_SYMBOL(netdev_bonding_change);
1012
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013/**
1014 * dev_load - load a network module
Randy Dunlapc4ea43c2007-10-12 21:17:49 -07001015 * @net: the applicable net namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 * @name: name of interface
1017 *
1018 * If a network interface is not present and the process has suitable
1019 * privileges this function loads the module. If module loading is not
1020 * available in this kernel then it becomes a nop.
1021 */
1022
Eric W. Biederman881d9662007-09-17 11:56:21 -07001023void dev_load(struct net *net, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024{
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001025 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026
1027 read_lock(&dev_base_lock);
Eric W. Biederman881d9662007-09-17 11:56:21 -07001028 dev = __dev_get_by_name(net, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 read_unlock(&dev_base_lock);
1030
1031 if (!dev && capable(CAP_SYS_MODULE))
1032 request_module("%s", name);
1033}
1034
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035/**
1036 * dev_open - prepare an interface for use.
1037 * @dev: device to open
1038 *
1039 * Takes a device from down to up state. The device's private open
1040 * function is invoked and then the multicast lists are loaded. Finally
1041 * the device is moved into the up state and a %NETDEV_UP message is
1042 * sent to the netdev notifier chain.
1043 *
1044 * Calling this function on an active interface is a nop. On a failure
1045 * a negative errno code is returned.
1046 */
1047int dev_open(struct net_device *dev)
1048{
Stephen Hemmingerd3147742008-11-19 21:32:24 -08001049 const struct net_device_ops *ops = dev->netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 int ret = 0;
1051
Ben Hutchingse46b66b2008-05-08 02:53:17 -07001052 ASSERT_RTNL();
1053
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 /*
1055 * Is it already up?
1056 */
1057
1058 if (dev->flags & IFF_UP)
1059 return 0;
1060
1061 /*
1062 * Is it even present?
1063 */
1064 if (!netif_device_present(dev))
1065 return -ENODEV;
1066
1067 /*
1068 * Call device private open method
1069 */
1070 set_bit(__LINK_STATE_START, &dev->state);
Jeff Garzikbada3392007-10-23 20:19:37 -07001071
Stephen Hemmingerd3147742008-11-19 21:32:24 -08001072 if (ops->ndo_validate_addr)
1073 ret = ops->ndo_validate_addr(dev);
Jeff Garzikbada3392007-10-23 20:19:37 -07001074
Stephen Hemmingerd3147742008-11-19 21:32:24 -08001075 if (!ret && ops->ndo_open)
1076 ret = ops->ndo_open(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001078 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 * If it went open OK then:
1080 */
1081
Jeff Garzikbada3392007-10-23 20:19:37 -07001082 if (ret)
1083 clear_bit(__LINK_STATE_START, &dev->state);
1084 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 /*
1086 * Set the flags.
1087 */
1088 dev->flags |= IFF_UP;
1089
1090 /*
Dan Williams649274d2009-01-11 00:20:39 -08001091 * Enable NET_DMA
1092 */
David S. Millerb4bd07c2009-02-06 22:06:43 -08001093 net_dmaengine_get();
Dan Williams649274d2009-01-11 00:20:39 -08001094
1095 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 * Initialize multicasting status
1097 */
Patrick McHardy4417da62007-06-27 01:28:10 -07001098 dev_set_rx_mode(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099
1100 /*
1101 * Wakeup transmit queue engine
1102 */
1103 dev_activate(dev);
1104
1105 /*
1106 * ... and announce new interface.
1107 */
Pavel Emelyanov056925a2007-09-16 15:42:43 -07001108 call_netdevice_notifiers(NETDEV_UP, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 }
Jeff Garzikbada3392007-10-23 20:19:37 -07001110
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 return ret;
1112}
1113
1114/**
1115 * dev_close - shutdown an interface.
1116 * @dev: device to shutdown
1117 *
1118 * This function moves an active device into down state. A
1119 * %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
1120 * is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
1121 * chain.
1122 */
1123int dev_close(struct net_device *dev)
1124{
Stephen Hemmingerd3147742008-11-19 21:32:24 -08001125 const struct net_device_ops *ops = dev->netdev_ops;
Ben Hutchingse46b66b2008-05-08 02:53:17 -07001126 ASSERT_RTNL();
1127
David S. Miller9d5010d2007-09-12 14:33:25 +02001128 might_sleep();
1129
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 if (!(dev->flags & IFF_UP))
1131 return 0;
1132
1133 /*
1134 * Tell people we are going down, so that they can
1135 * prepare to death, when device is still operating.
1136 */
Pavel Emelyanov056925a2007-09-16 15:42:43 -07001137 call_netdevice_notifiers(NETDEV_GOING_DOWN, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 clear_bit(__LINK_STATE_START, &dev->state);
1140
1141 /* Synchronize to scheduled poll. We cannot touch poll list,
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001142 * it can be even on different cpu. So just clear netif_running().
1143 *
1144 * dev->stop() will invoke napi_disable() on all of it's
1145 * napi_struct instances on this device.
1146 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 smp_mb__after_clear_bit(); /* Commit netif_running(). */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148
Matti Linnanvuorid8b2a4d2008-02-12 23:10:11 -08001149 dev_deactivate(dev);
1150
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 /*
1152 * Call the device specific close. This cannot fail.
1153 * Only if device is UP
1154 *
1155 * We allow it to be called even after a DETACH hot-plug
1156 * event.
1157 */
Stephen Hemmingerd3147742008-11-19 21:32:24 -08001158 if (ops->ndo_stop)
1159 ops->ndo_stop(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160
1161 /*
1162 * Device is now down.
1163 */
1164
1165 dev->flags &= ~IFF_UP;
1166
1167 /*
1168 * Tell people we are down
1169 */
Pavel Emelyanov056925a2007-09-16 15:42:43 -07001170 call_netdevice_notifiers(NETDEV_DOWN, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171
Dan Williams649274d2009-01-11 00:20:39 -08001172 /*
1173 * Shutdown NET_DMA
1174 */
David S. Millerb4bd07c2009-02-06 22:06:43 -08001175 net_dmaengine_put();
Dan Williams649274d2009-01-11 00:20:39 -08001176
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 return 0;
1178}
1179
1180
Ben Hutchings0187bdf2008-06-19 16:15:47 -07001181/**
1182 * dev_disable_lro - disable Large Receive Offload on a device
1183 * @dev: device
1184 *
1185 * Disable Large Receive Offload (LRO) on a net device. Must be
1186 * called under RTNL. This is needed if received packets may be
1187 * forwarded to another interface.
1188 */
1189void dev_disable_lro(struct net_device *dev)
1190{
1191 if (dev->ethtool_ops && dev->ethtool_ops->get_flags &&
1192 dev->ethtool_ops->set_flags) {
1193 u32 flags = dev->ethtool_ops->get_flags(dev);
1194 if (flags & ETH_FLAG_LRO) {
1195 flags &= ~ETH_FLAG_LRO;
1196 dev->ethtool_ops->set_flags(dev, flags);
1197 }
1198 }
1199 WARN_ON(dev->features & NETIF_F_LRO);
1200}
1201EXPORT_SYMBOL(dev_disable_lro);
1202
1203
Eric W. Biederman881d9662007-09-17 11:56:21 -07001204static int dev_boot_phase = 1;
1205
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206/*
1207 * Device change register/unregister. These are not inline or static
1208 * as we export them to the world.
1209 */
1210
1211/**
1212 * register_netdevice_notifier - register a network notifier block
1213 * @nb: notifier
1214 *
1215 * Register a notifier to be called when network device events occur.
1216 * The notifier passed is linked into the kernel structures and must
1217 * not be reused until it has been unregistered. A negative errno code
1218 * is returned on a failure.
1219 *
1220 * When registered all registration and up events are replayed
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001221 * to the new notifier to allow device to have a race free
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 * view of the network device list.
1223 */
1224
1225int register_netdevice_notifier(struct notifier_block *nb)
1226{
1227 struct net_device *dev;
Herbert Xufcc5a032007-07-30 17:03:38 -07001228 struct net_device *last;
Eric W. Biederman881d9662007-09-17 11:56:21 -07001229 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230 int err;
1231
1232 rtnl_lock();
Alan Sternf07d5b92006-05-09 15:23:03 -07001233 err = raw_notifier_chain_register(&netdev_chain, nb);
Herbert Xufcc5a032007-07-30 17:03:38 -07001234 if (err)
1235 goto unlock;
Eric W. Biederman881d9662007-09-17 11:56:21 -07001236 if (dev_boot_phase)
1237 goto unlock;
1238 for_each_net(net) {
1239 for_each_netdev(net, dev) {
1240 err = nb->notifier_call(nb, NETDEV_REGISTER, dev);
1241 err = notifier_to_errno(err);
1242 if (err)
1243 goto rollback;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244
Eric W. Biederman881d9662007-09-17 11:56:21 -07001245 if (!(dev->flags & IFF_UP))
1246 continue;
Herbert Xufcc5a032007-07-30 17:03:38 -07001247
Eric W. Biederman881d9662007-09-17 11:56:21 -07001248 nb->notifier_call(nb, NETDEV_UP, dev);
1249 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 }
Herbert Xufcc5a032007-07-30 17:03:38 -07001251
1252unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 rtnl_unlock();
1254 return err;
Herbert Xufcc5a032007-07-30 17:03:38 -07001255
1256rollback:
1257 last = dev;
Eric W. Biederman881d9662007-09-17 11:56:21 -07001258 for_each_net(net) {
1259 for_each_netdev(net, dev) {
1260 if (dev == last)
1261 break;
Herbert Xufcc5a032007-07-30 17:03:38 -07001262
Eric W. Biederman881d9662007-09-17 11:56:21 -07001263 if (dev->flags & IFF_UP) {
1264 nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
1265 nb->notifier_call(nb, NETDEV_DOWN, dev);
1266 }
1267 nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
Herbert Xufcc5a032007-07-30 17:03:38 -07001268 }
Herbert Xufcc5a032007-07-30 17:03:38 -07001269 }
Pavel Emelyanovc67625a2007-11-14 15:53:16 -08001270
1271 raw_notifier_chain_unregister(&netdev_chain, nb);
Herbert Xufcc5a032007-07-30 17:03:38 -07001272 goto unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273}
1274
1275/**
1276 * unregister_netdevice_notifier - unregister a network notifier block
1277 * @nb: notifier
1278 *
1279 * Unregister a notifier previously registered by
1280 * register_netdevice_notifier(). The notifier is unlinked into the
1281 * kernel structures and may then be reused. A negative errno code
1282 * is returned on a failure.
1283 */
1284
1285int unregister_netdevice_notifier(struct notifier_block *nb)
1286{
Herbert Xu9f514952006-03-25 01:24:25 -08001287 int err;
1288
1289 rtnl_lock();
Alan Sternf07d5b92006-05-09 15:23:03 -07001290 err = raw_notifier_chain_unregister(&netdev_chain, nb);
Herbert Xu9f514952006-03-25 01:24:25 -08001291 rtnl_unlock();
1292 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293}
1294
1295/**
1296 * call_netdevice_notifiers - call all network notifier blocks
1297 * @val: value passed unmodified to notifier function
Randy Dunlapc4ea43c2007-10-12 21:17:49 -07001298 * @dev: net_device pointer passed unmodified to notifier function
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 *
1300 * Call all network notifier blocks. Parameters and return value
Alan Sternf07d5b92006-05-09 15:23:03 -07001301 * are as for raw_notifier_call_chain().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 */
1303
Eric W. Biedermanad7379d2007-09-16 15:33:32 -07001304int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305{
Eric W. Biedermanad7379d2007-09-16 15:33:32 -07001306 return raw_notifier_call_chain(&netdev_chain, val, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307}
1308
1309/* When > 0 there are consumers of rx skb time stamps */
1310static atomic_t netstamp_needed = ATOMIC_INIT(0);
1311
1312void net_enable_timestamp(void)
1313{
1314 atomic_inc(&netstamp_needed);
1315}
1316
1317void net_disable_timestamp(void)
1318{
1319 atomic_dec(&netstamp_needed);
1320}
1321
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001322static inline void net_timestamp(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323{
1324 if (atomic_read(&netstamp_needed))
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001325 __net_timestamp(skb);
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001326 else
1327 skb->tstamp.tv64 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328}
1329
1330/*
1331 * Support routine. Sends outgoing frames to any network
1332 * taps currently in use.
1333 */
1334
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001335static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336{
1337 struct packet_type *ptype;
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001338
1339 net_timestamp(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340
1341 rcu_read_lock();
1342 list_for_each_entry_rcu(ptype, &ptype_all, list) {
1343 /* Never send packets back to the socket
1344 * they originated from - MvS (miquels@drinkel.ow.org)
1345 */
1346 if ((ptype->dev == dev || !ptype->dev) &&
1347 (ptype->af_packet_priv == NULL ||
1348 (struct sock *)ptype->af_packet_priv != skb->sk)) {
1349 struct sk_buff *skb2= skb_clone(skb, GFP_ATOMIC);
1350 if (!skb2)
1351 break;
1352
1353 /* skb->nh should be correctly
1354 set by sender, so that the second statement is
1355 just protection against buggy protocols.
1356 */
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07001357 skb_reset_mac_header(skb2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -07001359 if (skb_network_header(skb2) < skb2->data ||
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001360 skb2->network_header > skb2->tail) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 if (net_ratelimit())
1362 printk(KERN_CRIT "protocol %04x is "
1363 "buggy, dev %s\n",
1364 skb2->protocol, dev->name);
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07001365 skb_reset_network_header(skb2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 }
1367
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001368 skb2->transport_header = skb2->network_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 skb2->pkt_type = PACKET_OUTGOING;
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001370 ptype->func(skb2, skb->dev, ptype, skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 }
1372 }
1373 rcu_read_unlock();
1374}
1375
Denis Vlasenko56079432006-03-29 15:57:29 -08001376
Jarek Poplawskidef82a12008-08-17 21:54:43 -07001377static inline void __netif_reschedule(struct Qdisc *q)
1378{
1379 struct softnet_data *sd;
1380 unsigned long flags;
1381
1382 local_irq_save(flags);
1383 sd = &__get_cpu_var(softnet_data);
1384 q->next_sched = sd->output_queue;
1385 sd->output_queue = q;
1386 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1387 local_irq_restore(flags);
1388}
1389
David S. Miller37437bb2008-07-16 02:15:04 -07001390void __netif_schedule(struct Qdisc *q)
Denis Vlasenko56079432006-03-29 15:57:29 -08001391{
Jarek Poplawskidef82a12008-08-17 21:54:43 -07001392 if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state))
1393 __netif_reschedule(q);
Denis Vlasenko56079432006-03-29 15:57:29 -08001394}
1395EXPORT_SYMBOL(__netif_schedule);
1396
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001397void dev_kfree_skb_irq(struct sk_buff *skb)
Denis Vlasenko56079432006-03-29 15:57:29 -08001398{
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001399 if (atomic_dec_and_test(&skb->users)) {
1400 struct softnet_data *sd;
1401 unsigned long flags;
Denis Vlasenko56079432006-03-29 15:57:29 -08001402
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001403 local_irq_save(flags);
1404 sd = &__get_cpu_var(softnet_data);
1405 skb->next = sd->completion_queue;
1406 sd->completion_queue = skb;
1407 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1408 local_irq_restore(flags);
1409 }
Denis Vlasenko56079432006-03-29 15:57:29 -08001410}
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001411EXPORT_SYMBOL(dev_kfree_skb_irq);
Denis Vlasenko56079432006-03-29 15:57:29 -08001412
1413void dev_kfree_skb_any(struct sk_buff *skb)
1414{
1415 if (in_irq() || irqs_disabled())
1416 dev_kfree_skb_irq(skb);
1417 else
1418 dev_kfree_skb(skb);
1419}
1420EXPORT_SYMBOL(dev_kfree_skb_any);
1421
1422
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001423/**
1424 * netif_device_detach - mark device as removed
1425 * @dev: network device
1426 *
1427 * Mark device as removed from system and therefore no longer available.
1428 */
Denis Vlasenko56079432006-03-29 15:57:29 -08001429void netif_device_detach(struct net_device *dev)
1430{
1431 if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
1432 netif_running(dev)) {
1433 netif_stop_queue(dev);
1434 }
1435}
1436EXPORT_SYMBOL(netif_device_detach);
1437
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001438/**
1439 * netif_device_attach - mark device as attached
1440 * @dev: network device
1441 *
1442 * Mark device as attached from system and restart if needed.
1443 */
Denis Vlasenko56079432006-03-29 15:57:29 -08001444void netif_device_attach(struct net_device *dev)
1445{
1446 if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
1447 netif_running(dev)) {
1448 netif_wake_queue(dev);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001449 __netdev_watchdog_up(dev);
Denis Vlasenko56079432006-03-29 15:57:29 -08001450 }
1451}
1452EXPORT_SYMBOL(netif_device_attach);
1453
Ben Hutchings6de329e2008-06-16 17:02:28 -07001454static bool can_checksum_protocol(unsigned long features, __be16 protocol)
1455{
1456 return ((features & NETIF_F_GEN_CSUM) ||
1457 ((features & NETIF_F_IP_CSUM) &&
1458 protocol == htons(ETH_P_IP)) ||
1459 ((features & NETIF_F_IPV6_CSUM) &&
1460 protocol == htons(ETH_P_IPV6)));
1461}
1462
1463static bool dev_can_checksum(struct net_device *dev, struct sk_buff *skb)
1464{
1465 if (can_checksum_protocol(dev->features, skb->protocol))
1466 return true;
1467
1468 if (skb->protocol == htons(ETH_P_8021Q)) {
1469 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
1470 if (can_checksum_protocol(dev->features & dev->vlan_features,
1471 veh->h_vlan_encapsulated_proto))
1472 return true;
1473 }
1474
1475 return false;
1476}
Denis Vlasenko56079432006-03-29 15:57:29 -08001477
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478/*
1479 * Invalidate hardware checksum when packet is to be mangled, and
1480 * complete checksum manually on outgoing path.
1481 */
Patrick McHardy84fa7932006-08-29 16:44:56 -07001482int skb_checksum_help(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483{
Al Virod3bc23e2006-11-14 21:24:49 -08001484 __wsum csum;
Herbert Xu663ead32007-04-09 11:59:07 -07001485 int ret = 0, offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486
Patrick McHardy84fa7932006-08-29 16:44:56 -07001487 if (skb->ip_summed == CHECKSUM_COMPLETE)
Herbert Xua430a432006-07-08 13:34:56 -07001488 goto out_set_summed;
1489
1490 if (unlikely(skb_shinfo(skb)->gso_size)) {
Herbert Xua430a432006-07-08 13:34:56 -07001491 /* Let GSO fix up the checksum. */
1492 goto out_set_summed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 }
1494
Herbert Xua0308472007-10-15 01:47:15 -07001495 offset = skb->csum_start - skb_headroom(skb);
1496 BUG_ON(offset >= skb_headlen(skb));
1497 csum = skb_checksum(skb, offset, skb->len - offset, 0);
1498
1499 offset += skb->csum_offset;
1500 BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
1501
1502 if (skb_cloned(skb) &&
1503 !skb_clone_writable(skb, offset + sizeof(__sum16))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1505 if (ret)
1506 goto out;
1507 }
1508
Herbert Xua0308472007-10-15 01:47:15 -07001509 *(__sum16 *)(skb->data + offset) = csum_fold(csum);
Herbert Xua430a432006-07-08 13:34:56 -07001510out_set_summed:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 skb->ip_summed = CHECKSUM_NONE;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001512out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513 return ret;
1514}
1515
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001516/**
1517 * skb_gso_segment - Perform segmentation on skb.
1518 * @skb: buffer to segment
Herbert Xu576a30e2006-06-27 13:22:38 -07001519 * @features: features for the output path (see dev->features)
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001520 *
1521 * This function segments the given skb and returns a list of segments.
Herbert Xu576a30e2006-06-27 13:22:38 -07001522 *
1523 * It may return NULL if the skb requires no segmentation. This is
1524 * only possible when GSO is used for verifying header integrity.
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001525 */
Herbert Xu576a30e2006-06-27 13:22:38 -07001526struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001527{
1528 struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
1529 struct packet_type *ptype;
Al Viro252e33462006-11-14 20:48:11 -08001530 __be16 type = skb->protocol;
Herbert Xua430a432006-07-08 13:34:56 -07001531 int err;
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001532
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07001533 skb_reset_mac_header(skb);
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001534 skb->mac_len = skb->network_header - skb->mac_header;
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001535 __skb_pull(skb, skb->mac_len);
1536
Herbert Xu67fd1a72009-01-19 16:26:44 -08001537 if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1538 struct net_device *dev = skb->dev;
1539 struct ethtool_drvinfo info = {};
1540
1541 if (dev && dev->ethtool_ops && dev->ethtool_ops->get_drvinfo)
1542 dev->ethtool_ops->get_drvinfo(dev, &info);
1543
1544 WARN(1, "%s: caps=(0x%lx, 0x%lx) len=%d data_len=%d "
1545 "ip_summed=%d",
1546 info.driver, dev ? dev->features : 0L,
1547 skb->sk ? skb->sk->sk_route_caps : 0L,
1548 skb->len, skb->data_len, skb->ip_summed);
1549
Herbert Xua430a432006-07-08 13:34:56 -07001550 if (skb_header_cloned(skb) &&
1551 (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
1552 return ERR_PTR(err);
1553 }
1554
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001555 rcu_read_lock();
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +08001556 list_for_each_entry_rcu(ptype,
1557 &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001558 if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
Patrick McHardy84fa7932006-08-29 16:44:56 -07001559 if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
Herbert Xua430a432006-07-08 13:34:56 -07001560 err = ptype->gso_send_check(skb);
1561 segs = ERR_PTR(err);
1562 if (err || skb_gso_ok(skb, features))
1563 break;
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -07001564 __skb_push(skb, (skb->data -
1565 skb_network_header(skb)));
Herbert Xua430a432006-07-08 13:34:56 -07001566 }
Herbert Xu576a30e2006-06-27 13:22:38 -07001567 segs = ptype->gso_segment(skb, features);
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001568 break;
1569 }
1570 }
1571 rcu_read_unlock();
1572
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001573 __skb_push(skb, skb->data - skb_mac_header(skb));
Herbert Xu576a30e2006-06-27 13:22:38 -07001574
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001575 return segs;
1576}
1577
1578EXPORT_SYMBOL(skb_gso_segment);
1579
Herbert Xufb286bb2005-11-10 13:01:24 -08001580/* Take action when hardware reception checksum errors are detected. */
1581#ifdef CONFIG_BUG
1582void netdev_rx_csum_fault(struct net_device *dev)
1583{
1584 if (net_ratelimit()) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001585 printk(KERN_ERR "%s: hw csum failure.\n",
Stephen Hemminger246a4212005-12-08 15:21:39 -08001586 dev ? dev->name : "<unknown>");
Herbert Xufb286bb2005-11-10 13:01:24 -08001587 dump_stack();
1588 }
1589}
1590EXPORT_SYMBOL(netdev_rx_csum_fault);
1591#endif
1592
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593/* Actually, we should eliminate this check as soon as we know, that:
1594 * 1. IOMMU is present and allows to map all the memory.
1595 * 2. No high memory really exists on this machine.
1596 */
1597
1598static inline int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
1599{
Herbert Xu3d3a8532006-06-27 13:33:10 -07001600#ifdef CONFIG_HIGHMEM
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 int i;
1602
1603 if (dev->features & NETIF_F_HIGHDMA)
1604 return 0;
1605
1606 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1607 if (PageHighMem(skb_shinfo(skb)->frags[i].page))
1608 return 1;
1609
Herbert Xu3d3a8532006-06-27 13:33:10 -07001610#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 return 0;
1612}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001614struct dev_gso_cb {
1615 void (*destructor)(struct sk_buff *skb);
1616};
1617
1618#define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
1619
1620static void dev_gso_skb_destructor(struct sk_buff *skb)
1621{
1622 struct dev_gso_cb *cb;
1623
1624 do {
1625 struct sk_buff *nskb = skb->next;
1626
1627 skb->next = nskb->next;
1628 nskb->next = NULL;
1629 kfree_skb(nskb);
1630 } while (skb->next);
1631
1632 cb = DEV_GSO_CB(skb);
1633 if (cb->destructor)
1634 cb->destructor(skb);
1635}
1636
1637/**
1638 * dev_gso_segment - Perform emulated hardware segmentation on skb.
1639 * @skb: buffer to segment
1640 *
1641 * This function segments the given skb and stores the list of segments
1642 * in skb->next.
1643 */
1644static int dev_gso_segment(struct sk_buff *skb)
1645{
1646 struct net_device *dev = skb->dev;
1647 struct sk_buff *segs;
Herbert Xu576a30e2006-06-27 13:22:38 -07001648 int features = dev->features & ~(illegal_highdma(dev, skb) ?
1649 NETIF_F_SG : 0);
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001650
Herbert Xu576a30e2006-06-27 13:22:38 -07001651 segs = skb_gso_segment(skb, features);
1652
1653 /* Verifying header integrity only. */
1654 if (!segs)
1655 return 0;
1656
Hirofumi Nakagawa801678c2008-04-29 01:03:09 -07001657 if (IS_ERR(segs))
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001658 return PTR_ERR(segs);
1659
1660 skb->next = segs;
1661 DEV_GSO_CB(skb)->destructor = skb->destructor;
1662 skb->destructor = dev_gso_skb_destructor;
1663
1664 return 0;
1665}
1666
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001667int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
1668 struct netdev_queue *txq)
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001669{
Stephen Hemminger00829822008-11-20 20:14:53 -08001670 const struct net_device_ops *ops = dev->netdev_ops;
1671
1672 prefetch(&dev->netdev_ops->ndo_start_xmit);
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001673 if (likely(!skb->next)) {
Stephen Hemminger9be9a6b2007-04-20 17:02:45 -07001674 if (!list_empty(&ptype_all))
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001675 dev_queue_xmit_nit(skb, dev);
1676
Herbert Xu576a30e2006-06-27 13:22:38 -07001677 if (netif_needs_gso(dev, skb)) {
1678 if (unlikely(dev_gso_segment(skb)))
1679 goto out_kfree_skb;
1680 if (skb->next)
1681 goto gso;
1682 }
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001683
Stephen Hemminger00829822008-11-20 20:14:53 -08001684 return ops->ndo_start_xmit(skb, dev);
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001685 }
1686
Herbert Xu576a30e2006-06-27 13:22:38 -07001687gso:
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001688 do {
1689 struct sk_buff *nskb = skb->next;
1690 int rc;
1691
1692 skb->next = nskb->next;
1693 nskb->next = NULL;
Stephen Hemminger00829822008-11-20 20:14:53 -08001694 rc = ops->ndo_start_xmit(nskb, dev);
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001695 if (unlikely(rc)) {
Michael Chanf54d9e82006-06-25 23:57:04 -07001696 nskb->next = skb->next;
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001697 skb->next = nskb;
1698 return rc;
1699 }
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001700 if (unlikely(netif_tx_queue_stopped(txq) && skb->next))
Michael Chanf54d9e82006-06-25 23:57:04 -07001701 return NETDEV_TX_BUSY;
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001702 } while (skb->next);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001703
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001704 skb->destructor = DEV_GSO_CB(skb)->destructor;
1705
1706out_kfree_skb:
1707 kfree_skb(skb);
1708 return 0;
1709}
1710
David S. Millerb6b2fed2008-07-21 09:48:06 -07001711static u32 simple_tx_hashrnd;
1712static int simple_tx_hashrnd_initialized = 0;
1713
David S. Miller8f0f2222008-07-15 03:47:03 -07001714static u16 simple_tx_hash(struct net_device *dev, struct sk_buff *skb)
1715{
David S. Millerb6b2fed2008-07-21 09:48:06 -07001716 u32 addr1, addr2, ports;
1717 u32 hash, ihl;
Alexander Duyckad55dca2008-09-20 22:05:50 -07001718 u8 ip_proto = 0;
David S. Millerb6b2fed2008-07-21 09:48:06 -07001719
1720 if (unlikely(!simple_tx_hashrnd_initialized)) {
1721 get_random_bytes(&simple_tx_hashrnd, 4);
1722 simple_tx_hashrnd_initialized = 1;
1723 }
David S. Miller8f0f2222008-07-15 03:47:03 -07001724
1725 switch (skb->protocol) {
Arnaldo Carvalho de Melo60678042008-09-20 22:20:49 -07001726 case htons(ETH_P_IP):
Alexander Duyckad55dca2008-09-20 22:05:50 -07001727 if (!(ip_hdr(skb)->frag_off & htons(IP_MF | IP_OFFSET)))
1728 ip_proto = ip_hdr(skb)->protocol;
David S. Millerb6b2fed2008-07-21 09:48:06 -07001729 addr1 = ip_hdr(skb)->saddr;
1730 addr2 = ip_hdr(skb)->daddr;
David S. Miller8f0f2222008-07-15 03:47:03 -07001731 ihl = ip_hdr(skb)->ihl;
David S. Miller8f0f2222008-07-15 03:47:03 -07001732 break;
Arnaldo Carvalho de Melo60678042008-09-20 22:20:49 -07001733 case htons(ETH_P_IPV6):
David S. Miller8f0f2222008-07-15 03:47:03 -07001734 ip_proto = ipv6_hdr(skb)->nexthdr;
David S. Millerb6b2fed2008-07-21 09:48:06 -07001735 addr1 = ipv6_hdr(skb)->saddr.s6_addr32[3];
1736 addr2 = ipv6_hdr(skb)->daddr.s6_addr32[3];
David S. Miller8f0f2222008-07-15 03:47:03 -07001737 ihl = (40 >> 2);
David S. Miller8f0f2222008-07-15 03:47:03 -07001738 break;
1739 default:
1740 return 0;
1741 }
1742
David S. Miller8f0f2222008-07-15 03:47:03 -07001743
1744 switch (ip_proto) {
1745 case IPPROTO_TCP:
1746 case IPPROTO_UDP:
1747 case IPPROTO_DCCP:
1748 case IPPROTO_ESP:
1749 case IPPROTO_AH:
1750 case IPPROTO_SCTP:
1751 case IPPROTO_UDPLITE:
David S. Millerb6b2fed2008-07-21 09:48:06 -07001752 ports = *((u32 *) (skb_network_header(skb) + (ihl * 4)));
David S. Miller8f0f2222008-07-15 03:47:03 -07001753 break;
1754
1755 default:
David S. Millerb6b2fed2008-07-21 09:48:06 -07001756 ports = 0;
David S. Miller8f0f2222008-07-15 03:47:03 -07001757 break;
1758 }
1759
David S. Millerb6b2fed2008-07-21 09:48:06 -07001760 hash = jhash_3words(addr1, addr2, ports, simple_tx_hashrnd);
1761
1762 return (u16) (((u64) hash * dev->real_num_tx_queues) >> 32);
David S. Miller8f0f2222008-07-15 03:47:03 -07001763}
1764
David S. Millere8a04642008-07-17 00:34:19 -07001765static struct netdev_queue *dev_pick_tx(struct net_device *dev,
1766 struct sk_buff *skb)
1767{
Stephen Hemminger00829822008-11-20 20:14:53 -08001768 const struct net_device_ops *ops = dev->netdev_ops;
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001769 u16 queue_index = 0;
1770
Stephen Hemminger00829822008-11-20 20:14:53 -08001771 if (ops->ndo_select_queue)
1772 queue_index = ops->ndo_select_queue(dev, skb);
David S. Miller8f0f2222008-07-15 03:47:03 -07001773 else if (dev->real_num_tx_queues > 1)
1774 queue_index = simple_tx_hash(dev, skb);
David S. Millereae792b2008-07-15 03:03:33 -07001775
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001776 skb_set_queue_mapping(skb, queue_index);
1777 return netdev_get_tx_queue(dev, queue_index);
David S. Millere8a04642008-07-17 00:34:19 -07001778}
1779
Dave Jonesd29f7492008-07-22 14:09:06 -07001780/**
1781 * dev_queue_xmit - transmit a buffer
1782 * @skb: buffer to transmit
1783 *
1784 * Queue a buffer for transmission to a network device. The caller must
1785 * have set the device and priority and built the buffer before calling
1786 * this function. The function can be called from an interrupt.
1787 *
1788 * A negative errno code is returned on a failure. A success does not
1789 * guarantee the frame will be transmitted as it may be dropped due
1790 * to congestion or traffic shaping.
1791 *
1792 * -----------------------------------------------------------------------------------
1793 * I notice this method can also return errors from the queue disciplines,
1794 * including NET_XMIT_DROP, which is a positive value. So, errors can also
1795 * be positive.
1796 *
1797 * Regardless of the return value, the skb is consumed, so it is currently
1798 * difficult to retry a send to this method. (You can bump the ref count
1799 * before sending to hold a reference for retry if you are careful.)
1800 *
1801 * When calling this method, interrupts MUST be enabled. This is because
1802 * the BH enable code must have IRQs enabled so that it will not deadlock.
1803 * --BLG
1804 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805int dev_queue_xmit(struct sk_buff *skb)
1806{
1807 struct net_device *dev = skb->dev;
David S. Millerdc2b4842008-07-08 17:18:23 -07001808 struct netdev_queue *txq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809 struct Qdisc *q;
1810 int rc = -ENOMEM;
1811
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001812 /* GSO will handle the following emulations directly. */
1813 if (netif_needs_gso(dev, skb))
1814 goto gso;
1815
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816 if (skb_shinfo(skb)->frag_list &&
1817 !(dev->features & NETIF_F_FRAGLIST) &&
Herbert Xu364c6ba2006-06-09 16:10:40 -07001818 __skb_linearize(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819 goto out_kfree_skb;
1820
1821 /* Fragmented skb is linearized if device does not support SG,
1822 * or if at least one of fragments is in highmem and device
1823 * does not support DMA from it.
1824 */
1825 if (skb_shinfo(skb)->nr_frags &&
1826 (!(dev->features & NETIF_F_SG) || illegal_highdma(dev, skb)) &&
Herbert Xu364c6ba2006-06-09 16:10:40 -07001827 __skb_linearize(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 goto out_kfree_skb;
1829
1830 /* If packet is not checksummed and device does not support
1831 * checksumming for this protocol, complete checksumming here.
1832 */
Herbert Xu663ead32007-04-09 11:59:07 -07001833 if (skb->ip_summed == CHECKSUM_PARTIAL) {
1834 skb_set_transport_header(skb, skb->csum_start -
1835 skb_headroom(skb));
Ben Hutchings6de329e2008-06-16 17:02:28 -07001836 if (!dev_can_checksum(dev, skb) && skb_checksum_help(skb))
1837 goto out_kfree_skb;
Herbert Xu663ead32007-04-09 11:59:07 -07001838 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839
Herbert Xuf6a78bf2006-06-22 02:57:17 -07001840gso:
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001841 /* Disable soft irqs for various locks below. Also
1842 * stops preemption for RCU.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 */
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001844 rcu_read_lock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845
David S. Millereae792b2008-07-15 03:03:33 -07001846 txq = dev_pick_tx(dev, skb);
David S. Millerb0e1e642008-07-08 17:42:10 -07001847 q = rcu_dereference(txq->qdisc);
David S. Miller37437bb2008-07-16 02:15:04 -07001848
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849#ifdef CONFIG_NET_CLS_ACT
1850 skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_EGRESS);
1851#endif
1852 if (q->enqueue) {
David S. Miller5fb66222008-08-02 20:02:43 -07001853 spinlock_t *root_lock = qdisc_lock(q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854
David S. Miller37437bb2008-07-16 02:15:04 -07001855 spin_lock(root_lock);
1856
David S. Millera9312ae2008-08-17 21:51:03 -07001857 if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) {
David S. Miller96d20312008-08-17 23:37:16 -07001858 kfree_skb(skb);
David S. Millera9312ae2008-08-17 21:51:03 -07001859 rc = NET_XMIT_DROP;
David S. Miller96d20312008-08-17 23:37:16 -07001860 } else {
1861 rc = qdisc_enqueue_root(skb, q);
1862 qdisc_run(q);
David S. Millera9312ae2008-08-17 21:51:03 -07001863 }
David S. Miller37437bb2008-07-16 02:15:04 -07001864 spin_unlock(root_lock);
1865
David S. Miller37437bb2008-07-16 02:15:04 -07001866 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 }
1868
1869 /* The device has no queue. Common case for software devices:
1870 loopback, all the sorts of tunnels...
1871
Herbert Xu932ff272006-06-09 12:20:56 -07001872 Really, it is unlikely that netif_tx_lock protection is necessary
1873 here. (f.e. loopback and IP tunnels are clean ignoring statistics
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 counters.)
1875 However, it is possible, that they rely on protection
1876 made by us here.
1877
1878 Check this and shot the lock. It is not prone from deadlocks.
1879 Either shot noqueue qdisc, it is even simpler 8)
1880 */
1881 if (dev->flags & IFF_UP) {
1882 int cpu = smp_processor_id(); /* ok because BHs are off */
1883
David S. Millerc773e842008-07-08 23:13:53 -07001884 if (txq->xmit_lock_owner != cpu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885
David S. Millerc773e842008-07-08 23:13:53 -07001886 HARD_TX_LOCK(dev, txq, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001888 if (!netif_tx_queue_stopped(txq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889 rc = 0;
David S. Millerfd2ea0a2008-07-17 01:56:23 -07001890 if (!dev_hard_start_xmit(skb, dev, txq)) {
David S. Millerc773e842008-07-08 23:13:53 -07001891 HARD_TX_UNLOCK(dev, txq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 goto out;
1893 }
1894 }
David S. Millerc773e842008-07-08 23:13:53 -07001895 HARD_TX_UNLOCK(dev, txq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896 if (net_ratelimit())
1897 printk(KERN_CRIT "Virtual device %s asks to "
1898 "queue packet!\n", dev->name);
1899 } else {
1900 /* Recursion is detected! It is possible,
1901 * unfortunately */
1902 if (net_ratelimit())
1903 printk(KERN_CRIT "Dead loop on virtual device "
1904 "%s, fix it urgently!\n", dev->name);
1905 }
1906 }
1907
1908 rc = -ENETDOWN;
Herbert Xud4828d82006-06-22 02:28:18 -07001909 rcu_read_unlock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910
1911out_kfree_skb:
1912 kfree_skb(skb);
1913 return rc;
1914out:
Herbert Xud4828d82006-06-22 02:28:18 -07001915 rcu_read_unlock_bh();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 return rc;
1917}
1918
1919
1920/*=======================================================================
1921 Receiver routines
1922 =======================================================================*/
1923
Stephen Hemminger6b2bedc2007-03-12 14:33:50 -07001924int netdev_max_backlog __read_mostly = 1000;
1925int netdev_budget __read_mostly = 300;
1926int weight_p __read_mostly = 64; /* old backlog weight */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927
1928DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
1929
1930
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931/**
1932 * netif_rx - post buffer to the network code
1933 * @skb: buffer to post
1934 *
1935 * This function receives a packet from a device driver and queues it for
1936 * the upper (protocol) levels to process. It always succeeds. The buffer
1937 * may be dropped during processing for congestion control or by the
1938 * protocol layers.
1939 *
1940 * return values:
1941 * NET_RX_SUCCESS (no congestion)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 * NET_RX_DROP (packet was dropped)
1943 *
1944 */
1945
1946int netif_rx(struct sk_buff *skb)
1947{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 struct softnet_data *queue;
1949 unsigned long flags;
1950
1951 /* if netpoll wants it, pretend we never saw it */
1952 if (netpoll_rx(skb))
1953 return NET_RX_DROP;
1954
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001955 if (!skb->tstamp.tv64)
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001956 net_timestamp(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957
1958 /*
1959 * The code is rearranged so that the path is the most
1960 * short when CPU is congested, but is still operating.
1961 */
1962 local_irq_save(flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963 queue = &__get_cpu_var(softnet_data);
1964
1965 __get_cpu_var(netdev_rx_stat).total++;
1966 if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
1967 if (queue->input_pkt_queue.qlen) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968enqueue:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969 __skb_queue_tail(&queue->input_pkt_queue, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 local_irq_restore(flags);
Stephen Hemminger34008d82005-06-23 20:10:00 -07001971 return NET_RX_SUCCESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972 }
1973
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001974 napi_schedule(&queue->backlog);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 goto enqueue;
1976 }
1977
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978 __get_cpu_var(netdev_rx_stat).dropped++;
1979 local_irq_restore(flags);
1980
1981 kfree_skb(skb);
1982 return NET_RX_DROP;
1983}
1984
1985int netif_rx_ni(struct sk_buff *skb)
1986{
1987 int err;
1988
1989 preempt_disable();
1990 err = netif_rx(skb);
1991 if (local_softirq_pending())
1992 do_softirq();
1993 preempt_enable();
1994
1995 return err;
1996}
1997
1998EXPORT_SYMBOL(netif_rx_ni);
1999
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000static void net_tx_action(struct softirq_action *h)
2001{
2002 struct softnet_data *sd = &__get_cpu_var(softnet_data);
2003
2004 if (sd->completion_queue) {
2005 struct sk_buff *clist;
2006
2007 local_irq_disable();
2008 clist = sd->completion_queue;
2009 sd->completion_queue = NULL;
2010 local_irq_enable();
2011
2012 while (clist) {
2013 struct sk_buff *skb = clist;
2014 clist = clist->next;
2015
Ilpo Järvinen547b7922008-07-25 21:43:18 -07002016 WARN_ON(atomic_read(&skb->users));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 __kfree_skb(skb);
2018 }
2019 }
2020
2021 if (sd->output_queue) {
David S. Miller37437bb2008-07-16 02:15:04 -07002022 struct Qdisc *head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023
2024 local_irq_disable();
2025 head = sd->output_queue;
2026 sd->output_queue = NULL;
2027 local_irq_enable();
2028
2029 while (head) {
David S. Miller37437bb2008-07-16 02:15:04 -07002030 struct Qdisc *q = head;
2031 spinlock_t *root_lock;
2032
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033 head = head->next_sched;
2034
David S. Miller5fb66222008-08-02 20:02:43 -07002035 root_lock = qdisc_lock(q);
David S. Miller37437bb2008-07-16 02:15:04 -07002036 if (spin_trylock(root_lock)) {
Jarek Poplawskidef82a12008-08-17 21:54:43 -07002037 smp_mb__before_clear_bit();
2038 clear_bit(__QDISC_STATE_SCHED,
2039 &q->state);
David S. Miller37437bb2008-07-16 02:15:04 -07002040 qdisc_run(q);
2041 spin_unlock(root_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 } else {
David S. Miller195648b2008-08-19 04:00:36 -07002043 if (!test_bit(__QDISC_STATE_DEACTIVATED,
Jarek Poplawskie8a83e12008-09-07 18:41:21 -07002044 &q->state)) {
David S. Miller195648b2008-08-19 04:00:36 -07002045 __netif_reschedule(q);
Jarek Poplawskie8a83e12008-09-07 18:41:21 -07002046 } else {
2047 smp_mb__before_clear_bit();
2048 clear_bit(__QDISC_STATE_SCHED,
2049 &q->state);
2050 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051 }
2052 }
2053 }
2054}
2055
Stephen Hemminger6f05f622007-03-08 20:46:03 -08002056static inline int deliver_skb(struct sk_buff *skb,
2057 struct packet_type *pt_prev,
2058 struct net_device *orig_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059{
2060 atomic_inc(&skb->users);
David S. Millerf2ccd8f2005-08-09 19:34:12 -07002061 return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062}
2063
2064#if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
Stephen Hemminger6229e362007-03-21 13:38:47 -07002065/* These hooks defined here for ATM */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066struct net_bridge;
2067struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
2068 unsigned char *addr);
Stephen Hemminger6229e362007-03-21 13:38:47 -07002069void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent) __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070
Stephen Hemminger6229e362007-03-21 13:38:47 -07002071/*
2072 * If bridge module is loaded call bridging hook.
2073 * returns NULL if packet was consumed.
2074 */
2075struct sk_buff *(*br_handle_frame_hook)(struct net_bridge_port *p,
2076 struct sk_buff *skb) __read_mostly;
2077static inline struct sk_buff *handle_bridge(struct sk_buff *skb,
2078 struct packet_type **pt_prev, int *ret,
2079 struct net_device *orig_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080{
2081 struct net_bridge_port *port;
2082
Stephen Hemminger6229e362007-03-21 13:38:47 -07002083 if (skb->pkt_type == PACKET_LOOPBACK ||
2084 (port = rcu_dereference(skb->dev->br_port)) == NULL)
2085 return skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086
2087 if (*pt_prev) {
Stephen Hemminger6229e362007-03-21 13:38:47 -07002088 *ret = deliver_skb(skb, *pt_prev, orig_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089 *pt_prev = NULL;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002090 }
2091
Stephen Hemminger6229e362007-03-21 13:38:47 -07002092 return br_handle_frame_hook(port, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093}
2094#else
Stephen Hemminger6229e362007-03-21 13:38:47 -07002095#define handle_bridge(skb, pt_prev, ret, orig_dev) (skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096#endif
2097
Patrick McHardyb863ceb2007-07-14 18:55:06 -07002098#if defined(CONFIG_MACVLAN) || defined(CONFIG_MACVLAN_MODULE)
2099struct sk_buff *(*macvlan_handle_frame_hook)(struct sk_buff *skb) __read_mostly;
2100EXPORT_SYMBOL_GPL(macvlan_handle_frame_hook);
2101
2102static inline struct sk_buff *handle_macvlan(struct sk_buff *skb,
2103 struct packet_type **pt_prev,
2104 int *ret,
2105 struct net_device *orig_dev)
2106{
2107 if (skb->dev->macvlan_port == NULL)
2108 return skb;
2109
2110 if (*pt_prev) {
2111 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2112 *pt_prev = NULL;
2113 }
2114 return macvlan_handle_frame_hook(skb);
2115}
2116#else
2117#define handle_macvlan(skb, pt_prev, ret, orig_dev) (skb)
2118#endif
2119
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120#ifdef CONFIG_NET_CLS_ACT
2121/* TODO: Maybe we should just force sch_ingress to be compiled in
2122 * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
2123 * a compare and 2 stores extra right now if we dont have it on
2124 * but have CONFIG_NET_CLS_ACT
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002125 * NOTE: This doesnt stop any functionality; if you dont have
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126 * the ingress scheduler, you just cant add policies on ingress.
2127 *
2128 */
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002129static int ing_filter(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131 struct net_device *dev = skb->dev;
Herbert Xuf697c3e2007-10-14 00:38:47 -07002132 u32 ttl = G_TC_RTTL(skb->tc_verd);
David S. Miller555353c2008-07-08 17:33:13 -07002133 struct netdev_queue *rxq;
2134 int result = TC_ACT_OK;
2135 struct Qdisc *q;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002136
Herbert Xuf697c3e2007-10-14 00:38:47 -07002137 if (MAX_RED_LOOP < ttl++) {
2138 printk(KERN_WARNING
2139 "Redir loop detected Dropping packet (%d->%d)\n",
2140 skb->iif, dev->ifindex);
2141 return TC_ACT_SHOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142 }
2143
Herbert Xuf697c3e2007-10-14 00:38:47 -07002144 skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
2145 skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
2146
David S. Miller555353c2008-07-08 17:33:13 -07002147 rxq = &dev->rx_queue;
2148
David S. Miller83874002008-07-17 00:53:03 -07002149 q = rxq->qdisc;
David S. Miller8d50b532008-07-30 02:37:46 -07002150 if (q != &noop_qdisc) {
David S. Miller83874002008-07-17 00:53:03 -07002151 spin_lock(qdisc_lock(q));
David S. Millera9312ae2008-08-17 21:51:03 -07002152 if (likely(!test_bit(__QDISC_STATE_DEACTIVATED, &q->state)))
2153 result = qdisc_enqueue_root(skb, q);
David S. Miller83874002008-07-17 00:53:03 -07002154 spin_unlock(qdisc_lock(q));
2155 }
Herbert Xuf697c3e2007-10-14 00:38:47 -07002156
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157 return result;
2158}
Herbert Xuf697c3e2007-10-14 00:38:47 -07002159
2160static inline struct sk_buff *handle_ing(struct sk_buff *skb,
2161 struct packet_type **pt_prev,
2162 int *ret, struct net_device *orig_dev)
2163{
David S. Miller8d50b532008-07-30 02:37:46 -07002164 if (skb->dev->rx_queue.qdisc == &noop_qdisc)
Herbert Xuf697c3e2007-10-14 00:38:47 -07002165 goto out;
2166
2167 if (*pt_prev) {
2168 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2169 *pt_prev = NULL;
2170 } else {
2171 /* Huh? Why does turning on AF_PACKET affect this? */
2172 skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
2173 }
2174
2175 switch (ing_filter(skb)) {
2176 case TC_ACT_SHOT:
2177 case TC_ACT_STOLEN:
2178 kfree_skb(skb);
2179 return NULL;
2180 }
2181
2182out:
2183 skb->tc_verd = 0;
2184 return skb;
2185}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186#endif
2187
Patrick McHardybc1d0412008-07-14 22:49:30 -07002188/*
2189 * netif_nit_deliver - deliver received packets to network taps
2190 * @skb: buffer
2191 *
2192 * This function is used to deliver incoming packets to network
2193 * taps. It should be used when the normal netif_receive_skb path
2194 * is bypassed, for example because of VLAN acceleration.
2195 */
2196void netif_nit_deliver(struct sk_buff *skb)
2197{
2198 struct packet_type *ptype;
2199
2200 if (list_empty(&ptype_all))
2201 return;
2202
2203 skb_reset_network_header(skb);
2204 skb_reset_transport_header(skb);
2205 skb->mac_len = skb->network_header - skb->mac_header;
2206
2207 rcu_read_lock();
2208 list_for_each_entry_rcu(ptype, &ptype_all, list) {
2209 if (!ptype->dev || ptype->dev == skb->dev)
2210 deliver_skb(skb, ptype, skb->dev);
2211 }
2212 rcu_read_unlock();
2213}
2214
Stephen Hemminger3b582cc2007-11-01 02:21:47 -07002215/**
2216 * netif_receive_skb - process receive buffer from network
2217 * @skb: buffer to process
2218 *
2219 * netif_receive_skb() is the main receive data processing function.
2220 * It always succeeds. The buffer may be dropped during processing
2221 * for congestion control or by the protocol layers.
2222 *
2223 * This function may only be called from softirq context and interrupts
2224 * should be enabled.
2225 *
2226 * Return values (usually ignored):
2227 * NET_RX_SUCCESS: no congestion
2228 * NET_RX_DROP: packet was dropped
2229 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230int netif_receive_skb(struct sk_buff *skb)
2231{
2232 struct packet_type *ptype, *pt_prev;
David S. Millerf2ccd8f2005-08-09 19:34:12 -07002233 struct net_device *orig_dev;
Joe Eykholt0d7a3682008-07-02 18:22:01 -07002234 struct net_device *null_or_orig;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235 int ret = NET_RX_DROP;
Al Viro252e33462006-11-14 20:48:11 -08002236 __be16 type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237
Patrick McHardy9b22ea52008-11-04 14:49:57 -08002238 if (skb->vlan_tci && vlan_hwaccel_do_receive(skb))
2239 return NET_RX_SUCCESS;
2240
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241 /* if we've gotten here through NAPI, check netpoll */
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002242 if (netpoll_receive_skb(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243 return NET_RX_DROP;
2244
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07002245 if (!skb->tstamp.tv64)
Patrick McHardya61bbcf2005-08-14 17:24:31 -07002246 net_timestamp(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247
Patrick McHardyc01003c2007-03-29 11:46:52 -07002248 if (!skb->iif)
2249 skb->iif = skb->dev->ifindex;
David S. Miller86e65da2005-08-09 19:36:29 -07002250
Joe Eykholt0d7a3682008-07-02 18:22:01 -07002251 null_or_orig = NULL;
Joe Eykholtcc9bd5c2008-07-02 18:22:00 -07002252 orig_dev = skb->dev;
2253 if (orig_dev->master) {
Joe Eykholt0d7a3682008-07-02 18:22:01 -07002254 if (skb_bond_should_drop(skb))
2255 null_or_orig = orig_dev; /* deliver only exact match */
2256 else
2257 skb->dev = orig_dev->master;
Joe Eykholtcc9bd5c2008-07-02 18:22:00 -07002258 }
Jay Vosburgh8f903c72006-02-21 16:36:44 -08002259
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260 __get_cpu_var(netdev_rx_stat).total++;
2261
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07002262 skb_reset_network_header(skb);
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03002263 skb_reset_transport_header(skb);
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07002264 skb->mac_len = skb->network_header - skb->mac_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265
2266 pt_prev = NULL;
2267
2268 rcu_read_lock();
2269
2270#ifdef CONFIG_NET_CLS_ACT
2271 if (skb->tc_verd & TC_NCLS) {
2272 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
2273 goto ncls;
2274 }
2275#endif
2276
2277 list_for_each_entry_rcu(ptype, &ptype_all, list) {
Joe Eykholtf9823072008-07-02 18:22:02 -07002278 if (ptype->dev == null_or_orig || ptype->dev == skb->dev ||
2279 ptype->dev == orig_dev) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002280 if (pt_prev)
David S. Millerf2ccd8f2005-08-09 19:34:12 -07002281 ret = deliver_skb(skb, pt_prev, orig_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282 pt_prev = ptype;
2283 }
2284 }
2285
2286#ifdef CONFIG_NET_CLS_ACT
Herbert Xuf697c3e2007-10-14 00:38:47 -07002287 skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
2288 if (!skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290ncls:
2291#endif
2292
Stephen Hemminger6229e362007-03-21 13:38:47 -07002293 skb = handle_bridge(skb, &pt_prev, &ret, orig_dev);
2294 if (!skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295 goto out;
Patrick McHardyb863ceb2007-07-14 18:55:06 -07002296 skb = handle_macvlan(skb, &pt_prev, &ret, orig_dev);
2297 if (!skb)
2298 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299
2300 type = skb->protocol;
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +08002301 list_for_each_entry_rcu(ptype,
2302 &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303 if (ptype->type == type &&
Joe Eykholtf9823072008-07-02 18:22:02 -07002304 (ptype->dev == null_or_orig || ptype->dev == skb->dev ||
2305 ptype->dev == orig_dev)) {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002306 if (pt_prev)
David S. Millerf2ccd8f2005-08-09 19:34:12 -07002307 ret = deliver_skb(skb, pt_prev, orig_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002308 pt_prev = ptype;
2309 }
2310 }
2311
2312 if (pt_prev) {
David S. Millerf2ccd8f2005-08-09 19:34:12 -07002313 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314 } else {
2315 kfree_skb(skb);
2316 /* Jamal, now you will not able to escape explaining
2317 * me how you were going to use this. :-)
2318 */
2319 ret = NET_RX_DROP;
2320 }
2321
2322out:
2323 rcu_read_unlock();
2324 return ret;
2325}
2326
Stephen Hemminger6e583ce2008-08-03 21:29:57 -07002327/* Network device is going away, flush any packets still pending */
2328static void flush_backlog(void *arg)
2329{
2330 struct net_device *dev = arg;
2331 struct softnet_data *queue = &__get_cpu_var(softnet_data);
2332 struct sk_buff *skb, *tmp;
2333
2334 skb_queue_walk_safe(&queue->input_pkt_queue, skb, tmp)
2335 if (skb->dev == dev) {
2336 __skb_unlink(skb, &queue->input_pkt_queue);
2337 kfree_skb(skb);
2338 }
2339}
2340
Herbert Xud565b0a2008-12-15 23:38:52 -08002341static int napi_gro_complete(struct sk_buff *skb)
2342{
2343 struct packet_type *ptype;
2344 __be16 type = skb->protocol;
2345 struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
2346 int err = -ENOENT;
2347
Herbert Xu5d38a072009-01-04 16:13:40 -08002348 if (NAPI_GRO_CB(skb)->count == 1)
Herbert Xud565b0a2008-12-15 23:38:52 -08002349 goto out;
2350
2351 rcu_read_lock();
2352 list_for_each_entry_rcu(ptype, head, list) {
2353 if (ptype->type != type || ptype->dev || !ptype->gro_complete)
2354 continue;
2355
2356 err = ptype->gro_complete(skb);
2357 break;
2358 }
2359 rcu_read_unlock();
2360
2361 if (err) {
2362 WARN_ON(&ptype->list == head);
2363 kfree_skb(skb);
2364 return NET_RX_SUCCESS;
2365 }
2366
2367out:
Herbert Xub5302562009-01-04 16:13:19 -08002368 skb_shinfo(skb)->gso_size = 0;
Herbert Xud565b0a2008-12-15 23:38:52 -08002369 __skb_push(skb, -skb_network_offset(skb));
2370 return netif_receive_skb(skb);
2371}
2372
2373void napi_gro_flush(struct napi_struct *napi)
2374{
2375 struct sk_buff *skb, *next;
2376
2377 for (skb = napi->gro_list; skb; skb = next) {
2378 next = skb->next;
2379 skb->next = NULL;
2380 napi_gro_complete(skb);
2381 }
2382
2383 napi->gro_list = NULL;
2384}
2385EXPORT_SYMBOL(napi_gro_flush);
2386
Herbert Xu96e93ea2009-01-06 10:49:34 -08002387int dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
Herbert Xud565b0a2008-12-15 23:38:52 -08002388{
2389 struct sk_buff **pp = NULL;
2390 struct packet_type *ptype;
2391 __be16 type = skb->protocol;
2392 struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
2393 int count = 0;
Herbert Xu0da2afd52008-12-26 14:57:42 -08002394 int same_flow;
Herbert Xud565b0a2008-12-15 23:38:52 -08002395 int mac_len;
Herbert Xu5d38a072009-01-04 16:13:40 -08002396 int free;
Herbert Xud565b0a2008-12-15 23:38:52 -08002397
2398 if (!(skb->dev->features & NETIF_F_GRO))
2399 goto normal;
2400
Herbert Xuf17f5c92009-01-14 14:36:12 -08002401 if (skb_is_gso(skb) || skb_shinfo(skb)->frag_list)
2402 goto normal;
2403
Herbert Xud565b0a2008-12-15 23:38:52 -08002404 rcu_read_lock();
2405 list_for_each_entry_rcu(ptype, head, list) {
2406 struct sk_buff *p;
2407
2408 if (ptype->type != type || ptype->dev || !ptype->gro_receive)
2409 continue;
2410
2411 skb_reset_network_header(skb);
2412 mac_len = skb->network_header - skb->mac_header;
2413 skb->mac_len = mac_len;
2414 NAPI_GRO_CB(skb)->same_flow = 0;
2415 NAPI_GRO_CB(skb)->flush = 0;
Herbert Xu5d38a072009-01-04 16:13:40 -08002416 NAPI_GRO_CB(skb)->free = 0;
Herbert Xud565b0a2008-12-15 23:38:52 -08002417
2418 for (p = napi->gro_list; p; p = p->next) {
2419 count++;
Herbert Xu96e93ea2009-01-06 10:49:34 -08002420
2421 if (!NAPI_GRO_CB(p)->same_flow)
2422 continue;
2423
2424 if (p->mac_len != mac_len ||
2425 memcmp(skb_mac_header(p), skb_mac_header(skb),
2426 mac_len))
2427 NAPI_GRO_CB(p)->same_flow = 0;
Herbert Xud565b0a2008-12-15 23:38:52 -08002428 }
2429
2430 pp = ptype->gro_receive(&napi->gro_list, skb);
2431 break;
2432 }
2433 rcu_read_unlock();
2434
2435 if (&ptype->list == head)
2436 goto normal;
2437
Herbert Xu0da2afd52008-12-26 14:57:42 -08002438 same_flow = NAPI_GRO_CB(skb)->same_flow;
Herbert Xu5d38a072009-01-04 16:13:40 -08002439 free = NAPI_GRO_CB(skb)->free;
Herbert Xu0da2afd52008-12-26 14:57:42 -08002440
Herbert Xud565b0a2008-12-15 23:38:52 -08002441 if (pp) {
2442 struct sk_buff *nskb = *pp;
2443
2444 *pp = nskb->next;
2445 nskb->next = NULL;
2446 napi_gro_complete(nskb);
2447 count--;
2448 }
2449
Herbert Xu0da2afd52008-12-26 14:57:42 -08002450 if (same_flow)
Herbert Xud565b0a2008-12-15 23:38:52 -08002451 goto ok;
2452
2453 if (NAPI_GRO_CB(skb)->flush || count >= MAX_GRO_SKBS) {
2454 __skb_push(skb, -skb_network_offset(skb));
2455 goto normal;
2456 }
2457
2458 NAPI_GRO_CB(skb)->count = 1;
Herbert Xub5302562009-01-04 16:13:19 -08002459 skb_shinfo(skb)->gso_size = skb->len;
Herbert Xud565b0a2008-12-15 23:38:52 -08002460 skb->next = napi->gro_list;
2461 napi->gro_list = skb;
2462
2463ok:
Herbert Xu5d38a072009-01-04 16:13:40 -08002464 return free;
Herbert Xud565b0a2008-12-15 23:38:52 -08002465
2466normal:
Herbert Xu5d38a072009-01-04 16:13:40 -08002467 return -1;
2468}
Herbert Xu96e93ea2009-01-06 10:49:34 -08002469EXPORT_SYMBOL(dev_gro_receive);
2470
2471static int __napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
2472{
2473 struct sk_buff *p;
2474
2475 for (p = napi->gro_list; p; p = p->next) {
2476 NAPI_GRO_CB(p)->same_flow = 1;
2477 NAPI_GRO_CB(p)->flush = 0;
2478 }
2479
2480 return dev_gro_receive(napi, skb);
2481}
Herbert Xu5d38a072009-01-04 16:13:40 -08002482
2483int napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
2484{
Herbert Xu4ead4432009-03-01 00:11:52 -08002485 if (netpoll_receive_skb(skb))
2486 return NET_RX_DROP;
2487
Herbert Xu5d38a072009-01-04 16:13:40 -08002488 switch (__napi_gro_receive(napi, skb)) {
2489 case -1:
2490 return netif_receive_skb(skb);
2491
2492 case 1:
2493 kfree_skb(skb);
2494 break;
2495 }
2496
2497 return NET_RX_SUCCESS;
Herbert Xud565b0a2008-12-15 23:38:52 -08002498}
2499EXPORT_SYMBOL(napi_gro_receive);
2500
Herbert Xu96e93ea2009-01-06 10:49:34 -08002501void napi_reuse_skb(struct napi_struct *napi, struct sk_buff *skb)
2502{
Herbert Xu96e93ea2009-01-06 10:49:34 -08002503 __skb_pull(skb, skb_headlen(skb));
2504 skb_reserve(skb, NET_IP_ALIGN - skb_headroom(skb));
2505
2506 napi->skb = skb;
2507}
2508EXPORT_SYMBOL(napi_reuse_skb);
2509
2510struct sk_buff *napi_fraginfo_skb(struct napi_struct *napi,
2511 struct napi_gro_fraginfo *info)
Herbert Xu5d38a072009-01-04 16:13:40 -08002512{
2513 struct net_device *dev = napi->dev;
2514 struct sk_buff *skb = napi->skb;
Herbert Xu5d38a072009-01-04 16:13:40 -08002515
2516 napi->skb = NULL;
2517
2518 if (!skb) {
2519 skb = netdev_alloc_skb(dev, GRO_MAX_HEAD + NET_IP_ALIGN);
2520 if (!skb)
2521 goto out;
2522
2523 skb_reserve(skb, NET_IP_ALIGN);
2524 }
2525
2526 BUG_ON(info->nr_frags > MAX_SKB_FRAGS);
2527 skb_shinfo(skb)->nr_frags = info->nr_frags;
2528 memcpy(skb_shinfo(skb)->frags, info->frags, sizeof(info->frags));
2529
2530 skb->data_len = info->len;
2531 skb->len += info->len;
2532 skb->truesize += info->len;
2533
Herbert Xu96e93ea2009-01-06 10:49:34 -08002534 if (!pskb_may_pull(skb, ETH_HLEN)) {
2535 napi_reuse_skb(napi, skb);
Herbert Xu9a8e47f2009-01-17 19:47:18 +00002536 skb = NULL;
Herbert Xu96e93ea2009-01-06 10:49:34 -08002537 goto out;
2538 }
Herbert Xu5d38a072009-01-04 16:13:40 -08002539
2540 skb->protocol = eth_type_trans(skb, dev);
2541
2542 skb->ip_summed = info->ip_summed;
2543 skb->csum = info->csum;
2544
Herbert Xu96e93ea2009-01-06 10:49:34 -08002545out:
2546 return skb;
2547}
2548EXPORT_SYMBOL(napi_fraginfo_skb);
2549
2550int napi_gro_frags(struct napi_struct *napi, struct napi_gro_fraginfo *info)
2551{
2552 struct sk_buff *skb = napi_fraginfo_skb(napi, info);
2553 int err = NET_RX_DROP;
2554
2555 if (!skb)
2556 goto out;
2557
Herbert Xu4ead4432009-03-01 00:11:52 -08002558 if (netpoll_receive_skb(skb))
2559 goto out;
2560
Herbert Xu96e93ea2009-01-06 10:49:34 -08002561 err = NET_RX_SUCCESS;
2562
Herbert Xu5d38a072009-01-04 16:13:40 -08002563 switch (__napi_gro_receive(napi, skb)) {
2564 case -1:
2565 return netif_receive_skb(skb);
2566
2567 case 0:
2568 goto out;
2569 }
2570
Herbert Xu96e93ea2009-01-06 10:49:34 -08002571 napi_reuse_skb(napi, skb);
Herbert Xu5d38a072009-01-04 16:13:40 -08002572
2573out:
2574 return err;
2575}
2576EXPORT_SYMBOL(napi_gro_frags);
2577
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002578static int process_backlog(struct napi_struct *napi, int quota)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002579{
2580 int work = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002581 struct softnet_data *queue = &__get_cpu_var(softnet_data);
2582 unsigned long start_time = jiffies;
2583
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002584 napi->weight = weight_p;
2585 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002586 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002587
2588 local_irq_disable();
2589 skb = __skb_dequeue(&queue->input_pkt_queue);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002590 if (!skb) {
2591 __napi_complete(napi);
2592 local_irq_enable();
2593 break;
2594 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002595 local_irq_enable();
2596
Herbert Xud565b0a2008-12-15 23:38:52 -08002597 napi_gro_receive(napi, skb);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002598 } while (++work < quota && jiffies == start_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002599
Herbert Xud565b0a2008-12-15 23:38:52 -08002600 napi_gro_flush(napi);
2601
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002602 return work;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002603}
2604
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002605/**
2606 * __napi_schedule - schedule for receive
Randy Dunlapc4ea43c2007-10-12 21:17:49 -07002607 * @n: entry to schedule
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002608 *
2609 * The entry's receive function will be scheduled to run
2610 */
Harvey Harrisonb5606c22008-02-13 15:03:16 -08002611void __napi_schedule(struct napi_struct *n)
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002612{
2613 unsigned long flags;
2614
2615 local_irq_save(flags);
2616 list_add_tail(&n->poll_list, &__get_cpu_var(softnet_data).poll_list);
2617 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2618 local_irq_restore(flags);
2619}
2620EXPORT_SYMBOL(__napi_schedule);
2621
Herbert Xud565b0a2008-12-15 23:38:52 -08002622void __napi_complete(struct napi_struct *n)
2623{
2624 BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
2625 BUG_ON(n->gro_list);
2626
2627 list_del(&n->poll_list);
2628 smp_mb__before_clear_bit();
2629 clear_bit(NAPI_STATE_SCHED, &n->state);
2630}
2631EXPORT_SYMBOL(__napi_complete);
2632
2633void napi_complete(struct napi_struct *n)
2634{
2635 unsigned long flags;
2636
2637 /*
2638 * don't let napi dequeue from the cpu poll list
2639 * just in case its running on a different cpu
2640 */
2641 if (unlikely(test_bit(NAPI_STATE_NPSVC, &n->state)))
2642 return;
2643
2644 napi_gro_flush(n);
2645 local_irq_save(flags);
2646 __napi_complete(n);
2647 local_irq_restore(flags);
2648}
2649EXPORT_SYMBOL(napi_complete);
2650
2651void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
2652 int (*poll)(struct napi_struct *, int), int weight)
2653{
2654 INIT_LIST_HEAD(&napi->poll_list);
2655 napi->gro_list = NULL;
Herbert Xu5d38a072009-01-04 16:13:40 -08002656 napi->skb = NULL;
Herbert Xud565b0a2008-12-15 23:38:52 -08002657 napi->poll = poll;
2658 napi->weight = weight;
2659 list_add(&napi->dev_list, &dev->napi_list);
Herbert Xud565b0a2008-12-15 23:38:52 -08002660 napi->dev = dev;
Herbert Xu5d38a072009-01-04 16:13:40 -08002661#ifdef CONFIG_NETPOLL
Herbert Xud565b0a2008-12-15 23:38:52 -08002662 spin_lock_init(&napi->poll_lock);
2663 napi->poll_owner = -1;
2664#endif
2665 set_bit(NAPI_STATE_SCHED, &napi->state);
2666}
2667EXPORT_SYMBOL(netif_napi_add);
2668
2669void netif_napi_del(struct napi_struct *napi)
2670{
2671 struct sk_buff *skb, *next;
2672
Peter P Waskiewicz Jrd7b06632008-12-26 01:35:35 -08002673 list_del_init(&napi->dev_list);
Herbert Xu5d38a072009-01-04 16:13:40 -08002674 kfree(napi->skb);
Herbert Xud565b0a2008-12-15 23:38:52 -08002675
2676 for (skb = napi->gro_list; skb; skb = next) {
2677 next = skb->next;
2678 skb->next = NULL;
2679 kfree_skb(skb);
2680 }
2681
2682 napi->gro_list = NULL;
2683}
2684EXPORT_SYMBOL(netif_napi_del);
2685
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002686
Linus Torvalds1da177e2005-04-16 15:20:36 -07002687static void net_rx_action(struct softirq_action *h)
2688{
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002689 struct list_head *list = &__get_cpu_var(softnet_data).poll_list;
Stephen Hemminger24f8b232008-11-03 17:14:38 -08002690 unsigned long time_limit = jiffies + 2;
Stephen Hemminger51b0bde2005-06-23 20:14:40 -07002691 int budget = netdev_budget;
Matt Mackall53fb95d2005-08-11 19:27:43 -07002692 void *have;
2693
Linus Torvalds1da177e2005-04-16 15:20:36 -07002694 local_irq_disable();
2695
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002696 while (!list_empty(list)) {
2697 struct napi_struct *n;
2698 int work, weight;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002699
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002700 /* If softirq window is exhuasted then punt.
Stephen Hemminger24f8b232008-11-03 17:14:38 -08002701 * Allow this to run for 2 jiffies since which will allow
2702 * an average latency of 1.5/HZ.
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002703 */
Stephen Hemminger24f8b232008-11-03 17:14:38 -08002704 if (unlikely(budget <= 0 || time_after(jiffies, time_limit)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705 goto softnet_break;
2706
2707 local_irq_enable();
2708
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002709 /* Even though interrupts have been re-enabled, this
2710 * access is safe because interrupts can only add new
2711 * entries to the tail of this list, and only ->poll()
2712 * calls can remove this head entry from the list.
2713 */
2714 n = list_entry(list->next, struct napi_struct, poll_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002715
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002716 have = netpoll_poll_lock(n);
2717
2718 weight = n->weight;
2719
David S. Miller0a7606c2007-10-29 21:28:47 -07002720 /* This NAPI_STATE_SCHED test is for avoiding a race
2721 * with netpoll's poll_napi(). Only the entity which
2722 * obtains the lock and sees NAPI_STATE_SCHED set will
2723 * actually make the ->poll() call. Therefore we avoid
2724 * accidently calling ->poll() when NAPI is not scheduled.
2725 */
2726 work = 0;
2727 if (test_bit(NAPI_STATE_SCHED, &n->state))
2728 work = n->poll(n, weight);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002729
2730 WARN_ON_ONCE(work > weight);
2731
2732 budget -= work;
2733
2734 local_irq_disable();
2735
2736 /* Drivers must not modify the NAPI state if they
2737 * consume the entire weight. In such cases this code
2738 * still "owns" the NAPI instance and therefore can
2739 * move the instance around on the list at-will.
2740 */
David S. Millerfed17f32008-01-07 21:00:40 -08002741 if (unlikely(work == weight)) {
2742 if (unlikely(napi_disable_pending(n)))
2743 __napi_complete(n);
2744 else
2745 list_move_tail(&n->poll_list, list);
2746 }
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002747
2748 netpoll_poll_unlock(have);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002749 }
2750out:
Shannon Nelson515e06c2007-06-23 23:09:23 -07002751 local_irq_enable();
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002752
Chris Leechdb217332006-06-17 21:24:58 -07002753#ifdef CONFIG_NET_DMA
2754 /*
2755 * There may not be any more sk_buffs coming right now, so push
2756 * any pending DMA copies to hardware
2757 */
Dan Williams2ba05622009-01-06 11:38:14 -07002758 dma_issue_pending_all();
Chris Leechdb217332006-06-17 21:24:58 -07002759#endif
Stephen Hemmingerbea33482007-10-03 16:41:36 -07002760
Linus Torvalds1da177e2005-04-16 15:20:36 -07002761 return;
2762
2763softnet_break:
2764 __get_cpu_var(netdev_rx_stat).time_squeeze++;
2765 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2766 goto out;
2767}
2768
2769static gifconf_func_t * gifconf_list [NPROTO];
2770
2771/**
2772 * register_gifconf - register a SIOCGIF handler
2773 * @family: Address family
2774 * @gifconf: Function handler
2775 *
2776 * Register protocol dependent address dumping routines. The handler
2777 * that is passed must not be freed or reused until it has been replaced
2778 * by another handler.
2779 */
2780int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
2781{
2782 if (family >= NPROTO)
2783 return -EINVAL;
2784 gifconf_list[family] = gifconf;
2785 return 0;
2786}
2787
2788
2789/*
2790 * Map an interface index to its name (SIOCGIFNAME)
2791 */
2792
2793/*
2794 * We need this ioctl for efficient implementation of the
2795 * if_indextoname() function required by the IPv6 API. Without
2796 * it, we would have to search all the interfaces to find a
2797 * match. --pb
2798 */
2799
Eric W. Biederman881d9662007-09-17 11:56:21 -07002800static int dev_ifname(struct net *net, struct ifreq __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801{
2802 struct net_device *dev;
2803 struct ifreq ifr;
2804
2805 /*
2806 * Fetch the caller's info block.
2807 */
2808
2809 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
2810 return -EFAULT;
2811
2812 read_lock(&dev_base_lock);
Eric W. Biederman881d9662007-09-17 11:56:21 -07002813 dev = __dev_get_by_index(net, ifr.ifr_ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002814 if (!dev) {
2815 read_unlock(&dev_base_lock);
2816 return -ENODEV;
2817 }
2818
2819 strcpy(ifr.ifr_name, dev->name);
2820 read_unlock(&dev_base_lock);
2821
2822 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
2823 return -EFAULT;
2824 return 0;
2825}
2826
2827/*
2828 * Perform a SIOCGIFCONF call. This structure will change
2829 * size eventually, and there is nothing I can do about it.
2830 * Thus we will need a 'compatibility mode'.
2831 */
2832
Eric W. Biederman881d9662007-09-17 11:56:21 -07002833static int dev_ifconf(struct net *net, char __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834{
2835 struct ifconf ifc;
2836 struct net_device *dev;
2837 char __user *pos;
2838 int len;
2839 int total;
2840 int i;
2841
2842 /*
2843 * Fetch the caller's info block.
2844 */
2845
2846 if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
2847 return -EFAULT;
2848
2849 pos = ifc.ifc_buf;
2850 len = ifc.ifc_len;
2851
2852 /*
2853 * Loop over the interfaces, and write an info block for each.
2854 */
2855
2856 total = 0;
Eric W. Biederman881d9662007-09-17 11:56:21 -07002857 for_each_netdev(net, dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002858 for (i = 0; i < NPROTO; i++) {
2859 if (gifconf_list[i]) {
2860 int done;
2861 if (!pos)
2862 done = gifconf_list[i](dev, NULL, 0);
2863 else
2864 done = gifconf_list[i](dev, pos + total,
2865 len - total);
2866 if (done < 0)
2867 return -EFAULT;
2868 total += done;
2869 }
2870 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002871 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002872
2873 /*
2874 * All done. Write the updated control block back to the caller.
2875 */
2876 ifc.ifc_len = total;
2877
2878 /*
2879 * Both BSD and Solaris return 0 here, so we do too.
2880 */
2881 return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
2882}
2883
2884#ifdef CONFIG_PROC_FS
2885/*
2886 * This is invoked by the /proc filesystem handler to display a device
2887 * in detail.
2888 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889void *dev_seq_start(struct seq_file *seq, loff_t *pos)
Eric Dumazet9a429c42008-01-01 21:58:02 -08002890 __acquires(dev_base_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002891{
Denis V. Luneve372c412007-11-19 22:31:54 -08002892 struct net *net = seq_file_net(seq);
Pavel Emelianov7562f872007-05-03 15:13:45 -07002893 loff_t off;
2894 struct net_device *dev;
2895
Linus Torvalds1da177e2005-04-16 15:20:36 -07002896 read_lock(&dev_base_lock);
Pavel Emelianov7562f872007-05-03 15:13:45 -07002897 if (!*pos)
2898 return SEQ_START_TOKEN;
2899
2900 off = 1;
Eric W. Biederman881d9662007-09-17 11:56:21 -07002901 for_each_netdev(net, dev)
Pavel Emelianov7562f872007-05-03 15:13:45 -07002902 if (off++ == *pos)
2903 return dev;
2904
2905 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002906}
2907
2908void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2909{
Denis V. Luneve372c412007-11-19 22:31:54 -08002910 struct net *net = seq_file_net(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002911 ++*pos;
Pavel Emelianov7562f872007-05-03 15:13:45 -07002912 return v == SEQ_START_TOKEN ?
Eric W. Biederman881d9662007-09-17 11:56:21 -07002913 first_net_device(net) : next_net_device((struct net_device *)v);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002914}
2915
2916void dev_seq_stop(struct seq_file *seq, void *v)
Eric Dumazet9a429c42008-01-01 21:58:02 -08002917 __releases(dev_base_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918{
2919 read_unlock(&dev_base_lock);
2920}
2921
2922static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
2923{
Stephen Hemmingereeda3fd2008-11-19 21:40:23 -08002924 const struct net_device_stats *stats = dev_get_stats(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002925
Rusty Russell5a1b5892007-04-28 21:04:03 -07002926 seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
2927 "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
2928 dev->name, stats->rx_bytes, stats->rx_packets,
2929 stats->rx_errors,
2930 stats->rx_dropped + stats->rx_missed_errors,
2931 stats->rx_fifo_errors,
2932 stats->rx_length_errors + stats->rx_over_errors +
2933 stats->rx_crc_errors + stats->rx_frame_errors,
2934 stats->rx_compressed, stats->multicast,
2935 stats->tx_bytes, stats->tx_packets,
2936 stats->tx_errors, stats->tx_dropped,
2937 stats->tx_fifo_errors, stats->collisions,
2938 stats->tx_carrier_errors +
2939 stats->tx_aborted_errors +
2940 stats->tx_window_errors +
2941 stats->tx_heartbeat_errors,
2942 stats->tx_compressed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002943}
2944
2945/*
2946 * Called from the PROCfs module. This now uses the new arbitrary sized
2947 * /proc/net interface to create /proc/net/dev
2948 */
2949static int dev_seq_show(struct seq_file *seq, void *v)
2950{
2951 if (v == SEQ_START_TOKEN)
2952 seq_puts(seq, "Inter-| Receive "
2953 " | Transmit\n"
2954 " face |bytes packets errs drop fifo frame "
2955 "compressed multicast|bytes packets errs "
2956 "drop fifo colls carrier compressed\n");
2957 else
2958 dev_seq_printf_stats(seq, v);
2959 return 0;
2960}
2961
2962static struct netif_rx_stats *softnet_get_online(loff_t *pos)
2963{
2964 struct netif_rx_stats *rc = NULL;
2965
Mike Travis0c0b0ac2008-05-02 16:43:08 -07002966 while (*pos < nr_cpu_ids)
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09002967 if (cpu_online(*pos)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002968 rc = &per_cpu(netdev_rx_stat, *pos);
2969 break;
2970 } else
2971 ++*pos;
2972 return rc;
2973}
2974
2975static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
2976{
2977 return softnet_get_online(pos);
2978}
2979
2980static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2981{
2982 ++*pos;
2983 return softnet_get_online(pos);
2984}
2985
2986static void softnet_seq_stop(struct seq_file *seq, void *v)
2987{
2988}
2989
2990static int softnet_seq_show(struct seq_file *seq, void *v)
2991{
2992 struct netif_rx_stats *s = v;
2993
2994 seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
Stephen Hemminger31aa02c2005-06-23 20:12:48 -07002995 s->total, s->dropped, s->time_squeeze, 0,
Stephen Hemmingerc1ebcdb2005-06-23 20:08:59 -07002996 0, 0, 0, 0, /* was fastroute */
2997 s->cpu_collision );
Linus Torvalds1da177e2005-04-16 15:20:36 -07002998 return 0;
2999}
3000
Stephen Hemmingerf6908082007-03-12 14:34:29 -07003001static const struct seq_operations dev_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003002 .start = dev_seq_start,
3003 .next = dev_seq_next,
3004 .stop = dev_seq_stop,
3005 .show = dev_seq_show,
3006};
3007
3008static int dev_seq_open(struct inode *inode, struct file *file)
3009{
Denis V. Luneve372c412007-11-19 22:31:54 -08003010 return seq_open_net(inode, file, &dev_seq_ops,
3011 sizeof(struct seq_net_private));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003012}
3013
Arjan van de Ven9a321442007-02-12 00:55:35 -08003014static const struct file_operations dev_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003015 .owner = THIS_MODULE,
3016 .open = dev_seq_open,
3017 .read = seq_read,
3018 .llseek = seq_lseek,
Denis V. Luneve372c412007-11-19 22:31:54 -08003019 .release = seq_release_net,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003020};
3021
Stephen Hemmingerf6908082007-03-12 14:34:29 -07003022static const struct seq_operations softnet_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003023 .start = softnet_seq_start,
3024 .next = softnet_seq_next,
3025 .stop = softnet_seq_stop,
3026 .show = softnet_seq_show,
3027};
3028
3029static int softnet_seq_open(struct inode *inode, struct file *file)
3030{
3031 return seq_open(file, &softnet_seq_ops);
3032}
3033
Arjan van de Ven9a321442007-02-12 00:55:35 -08003034static const struct file_operations softnet_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003035 .owner = THIS_MODULE,
3036 .open = softnet_seq_open,
3037 .read = seq_read,
3038 .llseek = seq_lseek,
3039 .release = seq_release,
3040};
3041
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07003042static void *ptype_get_idx(loff_t pos)
3043{
3044 struct packet_type *pt = NULL;
3045 loff_t i = 0;
3046 int t;
3047
3048 list_for_each_entry_rcu(pt, &ptype_all, list) {
3049 if (i == pos)
3050 return pt;
3051 ++i;
3052 }
3053
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +08003054 for (t = 0; t < PTYPE_HASH_SIZE; t++) {
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07003055 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
3056 if (i == pos)
3057 return pt;
3058 ++i;
3059 }
3060 }
3061 return NULL;
3062}
3063
3064static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
Stephen Hemminger72348a42008-01-21 02:27:29 -08003065 __acquires(RCU)
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07003066{
3067 rcu_read_lock();
3068 return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
3069}
3070
3071static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3072{
3073 struct packet_type *pt;
3074 struct list_head *nxt;
3075 int hash;
3076
3077 ++*pos;
3078 if (v == SEQ_START_TOKEN)
3079 return ptype_get_idx(0);
3080
3081 pt = v;
3082 nxt = pt->list.next;
3083 if (pt->type == htons(ETH_P_ALL)) {
3084 if (nxt != &ptype_all)
3085 goto found;
3086 hash = 0;
3087 nxt = ptype_base[0].next;
3088 } else
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +08003089 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07003090
3091 while (nxt == &ptype_base[hash]) {
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +08003092 if (++hash >= PTYPE_HASH_SIZE)
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07003093 return NULL;
3094 nxt = ptype_base[hash].next;
3095 }
3096found:
3097 return list_entry(nxt, struct packet_type, list);
3098}
3099
3100static void ptype_seq_stop(struct seq_file *seq, void *v)
Stephen Hemminger72348a42008-01-21 02:27:29 -08003101 __releases(RCU)
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07003102{
3103 rcu_read_unlock();
3104}
3105
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07003106static int ptype_seq_show(struct seq_file *seq, void *v)
3107{
3108 struct packet_type *pt = v;
3109
3110 if (v == SEQ_START_TOKEN)
3111 seq_puts(seq, "Type Device Function\n");
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09003112 else if (pt->dev == NULL || dev_net(pt->dev) == seq_file_net(seq)) {
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07003113 if (pt->type == htons(ETH_P_ALL))
3114 seq_puts(seq, "ALL ");
3115 else
3116 seq_printf(seq, "%04x", ntohs(pt->type));
3117
Alexey Dobriyan908cd2d2008-11-16 19:50:35 -08003118 seq_printf(seq, " %-8s %pF\n",
3119 pt->dev ? pt->dev->name : "", pt->func);
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07003120 }
3121
3122 return 0;
3123}
3124
3125static const struct seq_operations ptype_seq_ops = {
3126 .start = ptype_seq_start,
3127 .next = ptype_seq_next,
3128 .stop = ptype_seq_stop,
3129 .show = ptype_seq_show,
3130};
3131
3132static int ptype_seq_open(struct inode *inode, struct file *file)
3133{
Pavel Emelyanov2feb27d2008-03-24 14:57:45 -07003134 return seq_open_net(inode, file, &ptype_seq_ops,
3135 sizeof(struct seq_net_private));
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07003136}
3137
3138static const struct file_operations ptype_seq_fops = {
3139 .owner = THIS_MODULE,
3140 .open = ptype_seq_open,
3141 .read = seq_read,
3142 .llseek = seq_lseek,
Pavel Emelyanov2feb27d2008-03-24 14:57:45 -07003143 .release = seq_release_net,
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07003144};
3145
3146
Pavel Emelyanov46650792007-10-08 20:38:39 -07003147static int __net_init dev_proc_net_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003148{
3149 int rc = -ENOMEM;
3150
Eric W. Biederman881d9662007-09-17 11:56:21 -07003151 if (!proc_net_fops_create(net, "dev", S_IRUGO, &dev_seq_fops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003152 goto out;
Eric W. Biederman881d9662007-09-17 11:56:21 -07003153 if (!proc_net_fops_create(net, "softnet_stat", S_IRUGO, &softnet_seq_fops))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003154 goto out_dev;
Eric W. Biederman881d9662007-09-17 11:56:21 -07003155 if (!proc_net_fops_create(net, "ptype", S_IRUGO, &ptype_seq_fops))
Eric W. Biederman457c4cb2007-09-12 12:01:34 +02003156 goto out_softnet;
Stephen Hemminger0e1256f2007-03-12 14:35:37 -07003157
Eric W. Biederman881d9662007-09-17 11:56:21 -07003158 if (wext_proc_init(net))
Eric W. Biederman457c4cb2007-09-12 12:01:34 +02003159 goto out_ptype;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003160 rc = 0;
3161out:
3162 return rc;
Eric W. Biederman457c4cb2007-09-12 12:01:34 +02003163out_ptype:
Eric W. Biederman881d9662007-09-17 11:56:21 -07003164 proc_net_remove(net, "ptype");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003165out_softnet:
Eric W. Biederman881d9662007-09-17 11:56:21 -07003166 proc_net_remove(net, "softnet_stat");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003167out_dev:
Eric W. Biederman881d9662007-09-17 11:56:21 -07003168 proc_net_remove(net, "dev");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003169 goto out;
3170}
Eric W. Biederman881d9662007-09-17 11:56:21 -07003171
Pavel Emelyanov46650792007-10-08 20:38:39 -07003172static void __net_exit dev_proc_net_exit(struct net *net)
Eric W. Biederman881d9662007-09-17 11:56:21 -07003173{
3174 wext_proc_exit(net);
3175
3176 proc_net_remove(net, "ptype");
3177 proc_net_remove(net, "softnet_stat");
3178 proc_net_remove(net, "dev");
3179}
3180
Denis V. Lunev022cbae2007-11-13 03:23:50 -08003181static struct pernet_operations __net_initdata dev_proc_ops = {
Eric W. Biederman881d9662007-09-17 11:56:21 -07003182 .init = dev_proc_net_init,
3183 .exit = dev_proc_net_exit,
3184};
3185
3186static int __init dev_proc_init(void)
3187{
3188 return register_pernet_subsys(&dev_proc_ops);
3189}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003190#else
3191#define dev_proc_init() 0
3192#endif /* CONFIG_PROC_FS */
3193
3194
3195/**
3196 * netdev_set_master - set up master/slave pair
3197 * @slave: slave device
3198 * @master: new master device
3199 *
3200 * Changes the master device of the slave. Pass %NULL to break the
3201 * bonding. The caller must hold the RTNL semaphore. On a failure
3202 * a negative errno code is returned. On success the reference counts
3203 * are adjusted, %RTM_NEWLINK is sent to the routing socket and the
3204 * function returns zero.
3205 */
3206int netdev_set_master(struct net_device *slave, struct net_device *master)
3207{
3208 struct net_device *old = slave->master;
3209
3210 ASSERT_RTNL();
3211
3212 if (master) {
3213 if (old)
3214 return -EBUSY;
3215 dev_hold(master);
3216 }
3217
3218 slave->master = master;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09003219
Linus Torvalds1da177e2005-04-16 15:20:36 -07003220 synchronize_net();
3221
3222 if (old)
3223 dev_put(old);
3224
3225 if (master)
3226 slave->flags |= IFF_SLAVE;
3227 else
3228 slave->flags &= ~IFF_SLAVE;
3229
3230 rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
3231 return 0;
3232}
3233
Patrick McHardyb6c40d62008-10-07 15:26:48 -07003234static void dev_change_rx_flags(struct net_device *dev, int flags)
3235{
Stephen Hemmingerd3147742008-11-19 21:32:24 -08003236 const struct net_device_ops *ops = dev->netdev_ops;
3237
3238 if ((dev->flags & IFF_UP) && ops->ndo_change_rx_flags)
3239 ops->ndo_change_rx_flags(dev, flags);
Patrick McHardyb6c40d62008-10-07 15:26:48 -07003240}
3241
Wang Chendad9b332008-06-18 01:48:28 -07003242static int __dev_set_promiscuity(struct net_device *dev, int inc)
Patrick McHardy4417da62007-06-27 01:28:10 -07003243{
3244 unsigned short old_flags = dev->flags;
David Howells8192b0c2008-11-14 10:39:10 +11003245 uid_t uid;
3246 gid_t gid;
Patrick McHardy4417da62007-06-27 01:28:10 -07003247
Patrick McHardy24023452007-07-14 18:51:31 -07003248 ASSERT_RTNL();
3249
Wang Chendad9b332008-06-18 01:48:28 -07003250 dev->flags |= IFF_PROMISC;
3251 dev->promiscuity += inc;
3252 if (dev->promiscuity == 0) {
3253 /*
3254 * Avoid overflow.
3255 * If inc causes overflow, untouch promisc and return error.
3256 */
3257 if (inc < 0)
3258 dev->flags &= ~IFF_PROMISC;
3259 else {
3260 dev->promiscuity -= inc;
3261 printk(KERN_WARNING "%s: promiscuity touches roof, "
3262 "set promiscuity failed, promiscuity feature "
3263 "of device might be broken.\n", dev->name);
3264 return -EOVERFLOW;
3265 }
3266 }
Patrick McHardy4417da62007-06-27 01:28:10 -07003267 if (dev->flags != old_flags) {
3268 printk(KERN_INFO "device %s %s promiscuous mode\n",
3269 dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
3270 "left");
David Howells8192b0c2008-11-14 10:39:10 +11003271 if (audit_enabled) {
3272 current_uid_gid(&uid, &gid);
Klaus Heinrich Kiwi7759db82008-01-23 22:57:45 -05003273 audit_log(current->audit_context, GFP_ATOMIC,
3274 AUDIT_ANOM_PROMISCUOUS,
3275 "dev=%s prom=%d old_prom=%d auid=%u uid=%u gid=%u ses=%u",
3276 dev->name, (dev->flags & IFF_PROMISC),
3277 (old_flags & IFF_PROMISC),
3278 audit_get_loginuid(current),
David Howells8192b0c2008-11-14 10:39:10 +11003279 uid, gid,
Klaus Heinrich Kiwi7759db82008-01-23 22:57:45 -05003280 audit_get_sessionid(current));
David Howells8192b0c2008-11-14 10:39:10 +11003281 }
Patrick McHardy24023452007-07-14 18:51:31 -07003282
Patrick McHardyb6c40d62008-10-07 15:26:48 -07003283 dev_change_rx_flags(dev, IFF_PROMISC);
Patrick McHardy4417da62007-06-27 01:28:10 -07003284 }
Wang Chendad9b332008-06-18 01:48:28 -07003285 return 0;
Patrick McHardy4417da62007-06-27 01:28:10 -07003286}
3287
Linus Torvalds1da177e2005-04-16 15:20:36 -07003288/**
3289 * dev_set_promiscuity - update promiscuity count on a device
3290 * @dev: device
3291 * @inc: modifier
3292 *
Stephen Hemminger3041a062006-05-26 13:25:24 -07003293 * Add or remove promiscuity from a device. While the count in the device
Linus Torvalds1da177e2005-04-16 15:20:36 -07003294 * remains above zero the interface remains promiscuous. Once it hits zero
3295 * the device reverts back to normal filtering operation. A negative inc
3296 * value is used to drop promiscuity on the device.
Wang Chendad9b332008-06-18 01:48:28 -07003297 * Return 0 if successful or a negative errno code on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003298 */
Wang Chendad9b332008-06-18 01:48:28 -07003299int dev_set_promiscuity(struct net_device *dev, int inc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003300{
3301 unsigned short old_flags = dev->flags;
Wang Chendad9b332008-06-18 01:48:28 -07003302 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003303
Wang Chendad9b332008-06-18 01:48:28 -07003304 err = __dev_set_promiscuity(dev, inc);
Patrick McHardy4b5a6982008-07-06 15:49:08 -07003305 if (err < 0)
Wang Chendad9b332008-06-18 01:48:28 -07003306 return err;
Patrick McHardy4417da62007-06-27 01:28:10 -07003307 if (dev->flags != old_flags)
3308 dev_set_rx_mode(dev);
Wang Chendad9b332008-06-18 01:48:28 -07003309 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003310}
3311
3312/**
3313 * dev_set_allmulti - update allmulti count on a device
3314 * @dev: device
3315 * @inc: modifier
3316 *
3317 * Add or remove reception of all multicast frames to a device. While the
3318 * count in the device remains above zero the interface remains listening
3319 * to all interfaces. Once it hits zero the device reverts back to normal
3320 * filtering operation. A negative @inc value is used to drop the counter
3321 * when releasing a resource needing all multicasts.
Wang Chendad9b332008-06-18 01:48:28 -07003322 * Return 0 if successful or a negative errno code on error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003323 */
3324
Wang Chendad9b332008-06-18 01:48:28 -07003325int dev_set_allmulti(struct net_device *dev, int inc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003326{
3327 unsigned short old_flags = dev->flags;
3328
Patrick McHardy24023452007-07-14 18:51:31 -07003329 ASSERT_RTNL();
3330
Linus Torvalds1da177e2005-04-16 15:20:36 -07003331 dev->flags |= IFF_ALLMULTI;
Wang Chendad9b332008-06-18 01:48:28 -07003332 dev->allmulti += inc;
3333 if (dev->allmulti == 0) {
3334 /*
3335 * Avoid overflow.
3336 * If inc causes overflow, untouch allmulti and return error.
3337 */
3338 if (inc < 0)
3339 dev->flags &= ~IFF_ALLMULTI;
3340 else {
3341 dev->allmulti -= inc;
3342 printk(KERN_WARNING "%s: allmulti touches roof, "
3343 "set allmulti failed, allmulti feature of "
3344 "device might be broken.\n", dev->name);
3345 return -EOVERFLOW;
3346 }
3347 }
Patrick McHardy24023452007-07-14 18:51:31 -07003348 if (dev->flags ^ old_flags) {
Patrick McHardyb6c40d62008-10-07 15:26:48 -07003349 dev_change_rx_flags(dev, IFF_ALLMULTI);
Patrick McHardy4417da62007-06-27 01:28:10 -07003350 dev_set_rx_mode(dev);
Patrick McHardy24023452007-07-14 18:51:31 -07003351 }
Wang Chendad9b332008-06-18 01:48:28 -07003352 return 0;
Patrick McHardy4417da62007-06-27 01:28:10 -07003353}
3354
3355/*
3356 * Upload unicast and multicast address lists to device and
3357 * configure RX filtering. When the device doesn't support unicast
Joe Perches53ccaae2007-12-20 14:02:06 -08003358 * filtering it is put in promiscuous mode while unicast addresses
Patrick McHardy4417da62007-06-27 01:28:10 -07003359 * are present.
3360 */
3361void __dev_set_rx_mode(struct net_device *dev)
3362{
Stephen Hemmingerd3147742008-11-19 21:32:24 -08003363 const struct net_device_ops *ops = dev->netdev_ops;
3364
Patrick McHardy4417da62007-06-27 01:28:10 -07003365 /* dev_open will call this function so the list will stay sane. */
3366 if (!(dev->flags&IFF_UP))
3367 return;
3368
3369 if (!netif_device_present(dev))
YOSHIFUJI Hideaki40b77c92007-07-19 10:43:23 +09003370 return;
Patrick McHardy4417da62007-06-27 01:28:10 -07003371
Stephen Hemmingerd3147742008-11-19 21:32:24 -08003372 if (ops->ndo_set_rx_mode)
3373 ops->ndo_set_rx_mode(dev);
Patrick McHardy4417da62007-06-27 01:28:10 -07003374 else {
3375 /* Unicast addresses changes may only happen under the rtnl,
3376 * therefore calling __dev_set_promiscuity here is safe.
3377 */
3378 if (dev->uc_count > 0 && !dev->uc_promisc) {
3379 __dev_set_promiscuity(dev, 1);
3380 dev->uc_promisc = 1;
3381 } else if (dev->uc_count == 0 && dev->uc_promisc) {
3382 __dev_set_promiscuity(dev, -1);
3383 dev->uc_promisc = 0;
3384 }
3385
Stephen Hemmingerd3147742008-11-19 21:32:24 -08003386 if (ops->ndo_set_multicast_list)
3387 ops->ndo_set_multicast_list(dev);
Patrick McHardy4417da62007-06-27 01:28:10 -07003388 }
3389}
3390
3391void dev_set_rx_mode(struct net_device *dev)
3392{
David S. Millerb9e40852008-07-15 00:15:08 -07003393 netif_addr_lock_bh(dev);
Patrick McHardy4417da62007-06-27 01:28:10 -07003394 __dev_set_rx_mode(dev);
David S. Millerb9e40852008-07-15 00:15:08 -07003395 netif_addr_unlock_bh(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003396}
3397
Patrick McHardy61cbc2f2007-06-30 13:35:52 -07003398int __dev_addr_delete(struct dev_addr_list **list, int *count,
3399 void *addr, int alen, int glbl)
Patrick McHardybf742482007-06-27 01:26:19 -07003400{
3401 struct dev_addr_list *da;
3402
3403 for (; (da = *list) != NULL; list = &da->next) {
3404 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
3405 alen == da->da_addrlen) {
3406 if (glbl) {
3407 int old_glbl = da->da_gusers;
3408 da->da_gusers = 0;
3409 if (old_glbl == 0)
3410 break;
3411 }
3412 if (--da->da_users)
3413 return 0;
3414
3415 *list = da->next;
3416 kfree(da);
Patrick McHardy61cbc2f2007-06-30 13:35:52 -07003417 (*count)--;
Patrick McHardybf742482007-06-27 01:26:19 -07003418 return 0;
3419 }
3420 }
3421 return -ENOENT;
3422}
3423
Patrick McHardy61cbc2f2007-06-30 13:35:52 -07003424int __dev_addr_add(struct dev_addr_list **list, int *count,
3425 void *addr, int alen, int glbl)
Patrick McHardybf742482007-06-27 01:26:19 -07003426{
3427 struct dev_addr_list *da;
3428
3429 for (da = *list; da != NULL; da = da->next) {
3430 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
3431 da->da_addrlen == alen) {
3432 if (glbl) {
3433 int old_glbl = da->da_gusers;
3434 da->da_gusers = 1;
3435 if (old_glbl)
3436 return 0;
3437 }
3438 da->da_users++;
3439 return 0;
3440 }
3441 }
3442
Jorge Boncompte [DTI2]12aa3432008-02-19 14:17:04 -08003443 da = kzalloc(sizeof(*da), GFP_ATOMIC);
Patrick McHardybf742482007-06-27 01:26:19 -07003444 if (da == NULL)
3445 return -ENOMEM;
3446 memcpy(da->da_addr, addr, alen);
3447 da->da_addrlen = alen;
3448 da->da_users = 1;
3449 da->da_gusers = glbl ? 1 : 0;
3450 da->next = *list;
3451 *list = da;
Patrick McHardy61cbc2f2007-06-30 13:35:52 -07003452 (*count)++;
Patrick McHardybf742482007-06-27 01:26:19 -07003453 return 0;
3454}
3455
Patrick McHardy4417da62007-06-27 01:28:10 -07003456/**
3457 * dev_unicast_delete - Release secondary unicast address.
3458 * @dev: device
Randy Dunlap0ed72ec2007-07-26 00:03:29 -07003459 * @addr: address to delete
3460 * @alen: length of @addr
Patrick McHardy4417da62007-06-27 01:28:10 -07003461 *
3462 * Release reference to a secondary unicast address and remove it
Randy Dunlap0ed72ec2007-07-26 00:03:29 -07003463 * from the device if the reference count drops to zero.
Patrick McHardy4417da62007-06-27 01:28:10 -07003464 *
3465 * The caller must hold the rtnl_mutex.
3466 */
3467int dev_unicast_delete(struct net_device *dev, void *addr, int alen)
3468{
3469 int err;
3470
3471 ASSERT_RTNL();
3472
David S. Millerb9e40852008-07-15 00:15:08 -07003473 netif_addr_lock_bh(dev);
Patrick McHardy61cbc2f2007-06-30 13:35:52 -07003474 err = __dev_addr_delete(&dev->uc_list, &dev->uc_count, addr, alen, 0);
3475 if (!err)
Patrick McHardy4417da62007-06-27 01:28:10 -07003476 __dev_set_rx_mode(dev);
David S. Millerb9e40852008-07-15 00:15:08 -07003477 netif_addr_unlock_bh(dev);
Patrick McHardy4417da62007-06-27 01:28:10 -07003478 return err;
3479}
3480EXPORT_SYMBOL(dev_unicast_delete);
3481
3482/**
3483 * dev_unicast_add - add a secondary unicast address
3484 * @dev: device
Wang Chen5dbaec52008-06-27 19:35:16 -07003485 * @addr: address to add
Randy Dunlap0ed72ec2007-07-26 00:03:29 -07003486 * @alen: length of @addr
Patrick McHardy4417da62007-06-27 01:28:10 -07003487 *
3488 * Add a secondary unicast address to the device or increase
3489 * the reference count if it already exists.
3490 *
3491 * The caller must hold the rtnl_mutex.
3492 */
3493int dev_unicast_add(struct net_device *dev, void *addr, int alen)
3494{
3495 int err;
3496
3497 ASSERT_RTNL();
3498
David S. Millerb9e40852008-07-15 00:15:08 -07003499 netif_addr_lock_bh(dev);
Patrick McHardy61cbc2f2007-06-30 13:35:52 -07003500 err = __dev_addr_add(&dev->uc_list, &dev->uc_count, addr, alen, 0);
3501 if (!err)
Patrick McHardy4417da62007-06-27 01:28:10 -07003502 __dev_set_rx_mode(dev);
David S. Millerb9e40852008-07-15 00:15:08 -07003503 netif_addr_unlock_bh(dev);
Patrick McHardy4417da62007-06-27 01:28:10 -07003504 return err;
3505}
3506EXPORT_SYMBOL(dev_unicast_add);
3507
Chris Leeche83a2ea2008-01-31 16:53:23 -08003508int __dev_addr_sync(struct dev_addr_list **to, int *to_count,
3509 struct dev_addr_list **from, int *from_count)
3510{
3511 struct dev_addr_list *da, *next;
3512 int err = 0;
3513
3514 da = *from;
3515 while (da != NULL) {
3516 next = da->next;
3517 if (!da->da_synced) {
3518 err = __dev_addr_add(to, to_count,
3519 da->da_addr, da->da_addrlen, 0);
3520 if (err < 0)
3521 break;
3522 da->da_synced = 1;
3523 da->da_users++;
3524 } else if (da->da_users == 1) {
3525 __dev_addr_delete(to, to_count,
3526 da->da_addr, da->da_addrlen, 0);
3527 __dev_addr_delete(from, from_count,
3528 da->da_addr, da->da_addrlen, 0);
3529 }
3530 da = next;
3531 }
3532 return err;
3533}
3534
3535void __dev_addr_unsync(struct dev_addr_list **to, int *to_count,
3536 struct dev_addr_list **from, int *from_count)
3537{
3538 struct dev_addr_list *da, *next;
3539
3540 da = *from;
3541 while (da != NULL) {
3542 next = da->next;
3543 if (da->da_synced) {
3544 __dev_addr_delete(to, to_count,
3545 da->da_addr, da->da_addrlen, 0);
3546 da->da_synced = 0;
3547 __dev_addr_delete(from, from_count,
3548 da->da_addr, da->da_addrlen, 0);
3549 }
3550 da = next;
3551 }
3552}
3553
3554/**
3555 * dev_unicast_sync - Synchronize device's unicast list to another device
3556 * @to: destination device
3557 * @from: source device
3558 *
3559 * Add newly added addresses to the destination device and release
3560 * addresses that have no users left. The source device must be
3561 * locked by netif_tx_lock_bh.
3562 *
3563 * This function is intended to be called from the dev->set_rx_mode
3564 * function of layered software devices.
3565 */
3566int dev_unicast_sync(struct net_device *to, struct net_device *from)
3567{
3568 int err = 0;
3569
David S. Millerb9e40852008-07-15 00:15:08 -07003570 netif_addr_lock_bh(to);
Chris Leeche83a2ea2008-01-31 16:53:23 -08003571 err = __dev_addr_sync(&to->uc_list, &to->uc_count,
3572 &from->uc_list, &from->uc_count);
3573 if (!err)
3574 __dev_set_rx_mode(to);
David S. Millerb9e40852008-07-15 00:15:08 -07003575 netif_addr_unlock_bh(to);
Chris Leeche83a2ea2008-01-31 16:53:23 -08003576 return err;
3577}
3578EXPORT_SYMBOL(dev_unicast_sync);
3579
3580/**
Randy Dunlapbc2cda12008-02-13 15:03:25 -08003581 * dev_unicast_unsync - Remove synchronized addresses from the destination device
Chris Leeche83a2ea2008-01-31 16:53:23 -08003582 * @to: destination device
3583 * @from: source device
3584 *
3585 * Remove all addresses that were added to the destination device by
3586 * dev_unicast_sync(). This function is intended to be called from the
3587 * dev->stop function of layered software devices.
3588 */
3589void dev_unicast_unsync(struct net_device *to, struct net_device *from)
3590{
David S. Millerb9e40852008-07-15 00:15:08 -07003591 netif_addr_lock_bh(from);
David S. Millere308a5d2008-07-15 00:13:44 -07003592 netif_addr_lock(to);
Chris Leeche83a2ea2008-01-31 16:53:23 -08003593
3594 __dev_addr_unsync(&to->uc_list, &to->uc_count,
3595 &from->uc_list, &from->uc_count);
3596 __dev_set_rx_mode(to);
3597
David S. Millere308a5d2008-07-15 00:13:44 -07003598 netif_addr_unlock(to);
David S. Millerb9e40852008-07-15 00:15:08 -07003599 netif_addr_unlock_bh(from);
Chris Leeche83a2ea2008-01-31 16:53:23 -08003600}
3601EXPORT_SYMBOL(dev_unicast_unsync);
3602
Denis Cheng12972622007-07-18 02:12:56 -07003603static void __dev_addr_discard(struct dev_addr_list **list)
3604{
3605 struct dev_addr_list *tmp;
3606
3607 while (*list != NULL) {
3608 tmp = *list;
3609 *list = tmp->next;
3610 if (tmp->da_users > tmp->da_gusers)
3611 printk("__dev_addr_discard: address leakage! "
3612 "da_users=%d\n", tmp->da_users);
3613 kfree(tmp);
3614 }
3615}
3616
Denis Cheng26cc2522007-07-18 02:12:03 -07003617static void dev_addr_discard(struct net_device *dev)
Patrick McHardy4417da62007-06-27 01:28:10 -07003618{
David S. Millerb9e40852008-07-15 00:15:08 -07003619 netif_addr_lock_bh(dev);
Denis Cheng26cc2522007-07-18 02:12:03 -07003620
Patrick McHardy4417da62007-06-27 01:28:10 -07003621 __dev_addr_discard(&dev->uc_list);
3622 dev->uc_count = 0;
Patrick McHardy4417da62007-06-27 01:28:10 -07003623
Denis Cheng456ad752007-07-18 02:10:54 -07003624 __dev_addr_discard(&dev->mc_list);
3625 dev->mc_count = 0;
Denis Cheng26cc2522007-07-18 02:12:03 -07003626
David S. Millerb9e40852008-07-15 00:15:08 -07003627 netif_addr_unlock_bh(dev);
Denis Cheng456ad752007-07-18 02:10:54 -07003628}
3629
Stephen Hemmingerf0db2752008-09-30 02:23:58 -07003630/**
3631 * dev_get_flags - get flags reported to userspace
3632 * @dev: device
3633 *
3634 * Get the combination of flag bits exported through APIs to userspace.
3635 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003636unsigned dev_get_flags(const struct net_device *dev)
3637{
3638 unsigned flags;
3639
3640 flags = (dev->flags & ~(IFF_PROMISC |
3641 IFF_ALLMULTI |
Stefan Rompfb00055a2006-03-20 17:09:11 -08003642 IFF_RUNNING |
3643 IFF_LOWER_UP |
3644 IFF_DORMANT)) |
Linus Torvalds1da177e2005-04-16 15:20:36 -07003645 (dev->gflags & (IFF_PROMISC |
3646 IFF_ALLMULTI));
3647
Stefan Rompfb00055a2006-03-20 17:09:11 -08003648 if (netif_running(dev)) {
3649 if (netif_oper_up(dev))
3650 flags |= IFF_RUNNING;
3651 if (netif_carrier_ok(dev))
3652 flags |= IFF_LOWER_UP;
3653 if (netif_dormant(dev))
3654 flags |= IFF_DORMANT;
3655 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003656
3657 return flags;
3658}
3659
Stephen Hemmingerf0db2752008-09-30 02:23:58 -07003660/**
3661 * dev_change_flags - change device settings
3662 * @dev: device
3663 * @flags: device state flags
3664 *
3665 * Change settings on device based state flags. The flags are
3666 * in the userspace exported format.
3667 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003668int dev_change_flags(struct net_device *dev, unsigned flags)
3669{
Thomas Graf7c355f52007-06-05 16:03:03 -07003670 int ret, changes;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003671 int old_flags = dev->flags;
3672
Patrick McHardy24023452007-07-14 18:51:31 -07003673 ASSERT_RTNL();
3674
Linus Torvalds1da177e2005-04-16 15:20:36 -07003675 /*
3676 * Set the flags on our device.
3677 */
3678
3679 dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
3680 IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
3681 IFF_AUTOMEDIA)) |
3682 (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
3683 IFF_ALLMULTI));
3684
3685 /*
3686 * Load in the correct multicast list now the flags have changed.
3687 */
3688
Patrick McHardyb6c40d62008-10-07 15:26:48 -07003689 if ((old_flags ^ flags) & IFF_MULTICAST)
3690 dev_change_rx_flags(dev, IFF_MULTICAST);
Patrick McHardy24023452007-07-14 18:51:31 -07003691
Patrick McHardy4417da62007-06-27 01:28:10 -07003692 dev_set_rx_mode(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003693
3694 /*
3695 * Have we downed the interface. We handle IFF_UP ourselves
3696 * according to user attempts to set it, rather than blindly
3697 * setting it.
3698 */
3699
3700 ret = 0;
3701 if ((old_flags ^ flags) & IFF_UP) { /* Bit is different ? */
3702 ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
3703
3704 if (!ret)
Patrick McHardy4417da62007-06-27 01:28:10 -07003705 dev_set_rx_mode(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003706 }
3707
3708 if (dev->flags & IFF_UP &&
3709 ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
3710 IFF_VOLATILE)))
Pavel Emelyanov056925a2007-09-16 15:42:43 -07003711 call_netdevice_notifiers(NETDEV_CHANGE, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003712
3713 if ((flags ^ dev->gflags) & IFF_PROMISC) {
3714 int inc = (flags & IFF_PROMISC) ? +1 : -1;
3715 dev->gflags ^= IFF_PROMISC;
3716 dev_set_promiscuity(dev, inc);
3717 }
3718
3719 /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
3720 is important. Some (broken) drivers set IFF_PROMISC, when
3721 IFF_ALLMULTI is requested not asking us and not reporting.
3722 */
3723 if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
3724 int inc = (flags & IFF_ALLMULTI) ? +1 : -1;
3725 dev->gflags ^= IFF_ALLMULTI;
3726 dev_set_allmulti(dev, inc);
3727 }
3728
Thomas Graf7c355f52007-06-05 16:03:03 -07003729 /* Exclude state transition flags, already notified */
3730 changes = (old_flags ^ dev->flags) & ~(IFF_UP | IFF_RUNNING);
3731 if (changes)
3732 rtmsg_ifinfo(RTM_NEWLINK, dev, changes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003733
3734 return ret;
3735}
3736
Stephen Hemmingerf0db2752008-09-30 02:23:58 -07003737/**
3738 * dev_set_mtu - Change maximum transfer unit
3739 * @dev: device
3740 * @new_mtu: new transfer unit
3741 *
3742 * Change the maximum transfer size of the network device.
3743 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003744int dev_set_mtu(struct net_device *dev, int new_mtu)
3745{
Stephen Hemmingerd3147742008-11-19 21:32:24 -08003746 const struct net_device_ops *ops = dev->netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003747 int err;
3748
3749 if (new_mtu == dev->mtu)
3750 return 0;
3751
3752 /* MTU must be positive. */
3753 if (new_mtu < 0)
3754 return -EINVAL;
3755
3756 if (!netif_device_present(dev))
3757 return -ENODEV;
3758
3759 err = 0;
Stephen Hemmingerd3147742008-11-19 21:32:24 -08003760 if (ops->ndo_change_mtu)
3761 err = ops->ndo_change_mtu(dev, new_mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003762 else
3763 dev->mtu = new_mtu;
Stephen Hemmingerd3147742008-11-19 21:32:24 -08003764
Linus Torvalds1da177e2005-04-16 15:20:36 -07003765 if (!err && dev->flags & IFF_UP)
Pavel Emelyanov056925a2007-09-16 15:42:43 -07003766 call_netdevice_notifiers(NETDEV_CHANGEMTU, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003767 return err;
3768}
3769
Stephen Hemmingerf0db2752008-09-30 02:23:58 -07003770/**
3771 * dev_set_mac_address - Change Media Access Control Address
3772 * @dev: device
3773 * @sa: new address
3774 *
3775 * Change the hardware (MAC) address of the device
3776 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003777int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
3778{
Stephen Hemmingerd3147742008-11-19 21:32:24 -08003779 const struct net_device_ops *ops = dev->netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003780 int err;
3781
Stephen Hemmingerd3147742008-11-19 21:32:24 -08003782 if (!ops->ndo_set_mac_address)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003783 return -EOPNOTSUPP;
3784 if (sa->sa_family != dev->type)
3785 return -EINVAL;
3786 if (!netif_device_present(dev))
3787 return -ENODEV;
Stephen Hemmingerd3147742008-11-19 21:32:24 -08003788 err = ops->ndo_set_mac_address(dev, sa);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003789 if (!err)
Pavel Emelyanov056925a2007-09-16 15:42:43 -07003790 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003791 return err;
3792}
3793
3794/*
Jeff Garzik14e3e072007-10-08 00:06:32 -07003795 * Perform the SIOCxIFxxx calls, inside read_lock(dev_base_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003796 */
Jeff Garzik14e3e072007-10-08 00:06:32 -07003797static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003798{
3799 int err;
Eric W. Biederman881d9662007-09-17 11:56:21 -07003800 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003801
3802 if (!dev)
3803 return -ENODEV;
3804
3805 switch (cmd) {
3806 case SIOCGIFFLAGS: /* Get interface flags */
3807 ifr->ifr_flags = dev_get_flags(dev);
3808 return 0;
3809
Linus Torvalds1da177e2005-04-16 15:20:36 -07003810 case SIOCGIFMETRIC: /* Get the metric on the interface
3811 (currently unused) */
3812 ifr->ifr_metric = 0;
3813 return 0;
3814
Linus Torvalds1da177e2005-04-16 15:20:36 -07003815 case SIOCGIFMTU: /* Get the MTU of a device */
3816 ifr->ifr_mtu = dev->mtu;
3817 return 0;
3818
Linus Torvalds1da177e2005-04-16 15:20:36 -07003819 case SIOCGIFHWADDR:
3820 if (!dev->addr_len)
3821 memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
3822 else
3823 memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
3824 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3825 ifr->ifr_hwaddr.sa_family = dev->type;
3826 return 0;
3827
Jeff Garzik14e3e072007-10-08 00:06:32 -07003828 case SIOCGIFSLAVE:
3829 err = -EINVAL;
3830 break;
3831
3832 case SIOCGIFMAP:
3833 ifr->ifr_map.mem_start = dev->mem_start;
3834 ifr->ifr_map.mem_end = dev->mem_end;
3835 ifr->ifr_map.base_addr = dev->base_addr;
3836 ifr->ifr_map.irq = dev->irq;
3837 ifr->ifr_map.dma = dev->dma;
3838 ifr->ifr_map.port = dev->if_port;
3839 return 0;
3840
3841 case SIOCGIFINDEX:
3842 ifr->ifr_ifindex = dev->ifindex;
3843 return 0;
3844
3845 case SIOCGIFTXQLEN:
3846 ifr->ifr_qlen = dev->tx_queue_len;
3847 return 0;
3848
3849 default:
3850 /* dev_ioctl() should ensure this case
3851 * is never reached
3852 */
3853 WARN_ON(1);
3854 err = -EINVAL;
3855 break;
3856
3857 }
3858 return err;
3859}
3860
3861/*
3862 * Perform the SIOCxIFxxx calls, inside rtnl_lock()
3863 */
3864static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
3865{
3866 int err;
3867 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
Jarek Poplawski5f2f6da2008-12-22 19:35:28 -08003868 const struct net_device_ops *ops;
Jeff Garzik14e3e072007-10-08 00:06:32 -07003869
3870 if (!dev)
3871 return -ENODEV;
3872
Jarek Poplawski5f2f6da2008-12-22 19:35:28 -08003873 ops = dev->netdev_ops;
3874
Jeff Garzik14e3e072007-10-08 00:06:32 -07003875 switch (cmd) {
3876 case SIOCSIFFLAGS: /* Set interface flags */
3877 return dev_change_flags(dev, ifr->ifr_flags);
3878
3879 case SIOCSIFMETRIC: /* Set the metric on the interface
3880 (currently unused) */
3881 return -EOPNOTSUPP;
3882
3883 case SIOCSIFMTU: /* Set the MTU of a device */
3884 return dev_set_mtu(dev, ifr->ifr_mtu);
3885
Linus Torvalds1da177e2005-04-16 15:20:36 -07003886 case SIOCSIFHWADDR:
3887 return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
3888
3889 case SIOCSIFHWBROADCAST:
3890 if (ifr->ifr_hwaddr.sa_family != dev->type)
3891 return -EINVAL;
3892 memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
3893 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
Pavel Emelyanov056925a2007-09-16 15:42:43 -07003894 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003895 return 0;
3896
Linus Torvalds1da177e2005-04-16 15:20:36 -07003897 case SIOCSIFMAP:
Stephen Hemmingerd3147742008-11-19 21:32:24 -08003898 if (ops->ndo_set_config) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003899 if (!netif_device_present(dev))
3900 return -ENODEV;
Stephen Hemmingerd3147742008-11-19 21:32:24 -08003901 return ops->ndo_set_config(dev, &ifr->ifr_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003902 }
3903 return -EOPNOTSUPP;
3904
3905 case SIOCADDMULTI:
Stephen Hemmingerd3147742008-11-19 21:32:24 -08003906 if ((!ops->ndo_set_multicast_list && !ops->ndo_set_rx_mode) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07003907 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3908 return -EINVAL;
3909 if (!netif_device_present(dev))
3910 return -ENODEV;
3911 return dev_mc_add(dev, ifr->ifr_hwaddr.sa_data,
3912 dev->addr_len, 1);
3913
3914 case SIOCDELMULTI:
Stephen Hemmingerd3147742008-11-19 21:32:24 -08003915 if ((!ops->ndo_set_multicast_list && !ops->ndo_set_rx_mode) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07003916 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3917 return -EINVAL;
3918 if (!netif_device_present(dev))
3919 return -ENODEV;
3920 return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
3921 dev->addr_len, 1);
3922
Linus Torvalds1da177e2005-04-16 15:20:36 -07003923 case SIOCSIFTXQLEN:
3924 if (ifr->ifr_qlen < 0)
3925 return -EINVAL;
3926 dev->tx_queue_len = ifr->ifr_qlen;
3927 return 0;
3928
3929 case SIOCSIFNAME:
3930 ifr->ifr_newname[IFNAMSIZ-1] = '\0';
3931 return dev_change_name(dev, ifr->ifr_newname);
3932
3933 /*
3934 * Unknown or private ioctl
3935 */
3936
3937 default:
3938 if ((cmd >= SIOCDEVPRIVATE &&
3939 cmd <= SIOCDEVPRIVATE + 15) ||
3940 cmd == SIOCBONDENSLAVE ||
3941 cmd == SIOCBONDRELEASE ||
3942 cmd == SIOCBONDSETHWADDR ||
3943 cmd == SIOCBONDSLAVEINFOQUERY ||
3944 cmd == SIOCBONDINFOQUERY ||
3945 cmd == SIOCBONDCHANGEACTIVE ||
3946 cmd == SIOCGMIIPHY ||
3947 cmd == SIOCGMIIREG ||
3948 cmd == SIOCSMIIREG ||
3949 cmd == SIOCBRADDIF ||
3950 cmd == SIOCBRDELIF ||
3951 cmd == SIOCWANDEV) {
3952 err = -EOPNOTSUPP;
Stephen Hemmingerd3147742008-11-19 21:32:24 -08003953 if (ops->ndo_do_ioctl) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003954 if (netif_device_present(dev))
Stephen Hemmingerd3147742008-11-19 21:32:24 -08003955 err = ops->ndo_do_ioctl(dev, ifr, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003956 else
3957 err = -ENODEV;
3958 }
3959 } else
3960 err = -EINVAL;
3961
3962 }
3963 return err;
3964}
3965
3966/*
3967 * This function handles all "interface"-type I/O control requests. The actual
3968 * 'doing' part of this is dev_ifsioc above.
3969 */
3970
3971/**
3972 * dev_ioctl - network device ioctl
Randy Dunlapc4ea43c2007-10-12 21:17:49 -07003973 * @net: the applicable net namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -07003974 * @cmd: command to issue
3975 * @arg: pointer to a struct ifreq in user space
3976 *
3977 * Issue ioctl functions to devices. This is normally called by the
3978 * user space syscall interfaces but can sometimes be useful for
3979 * other purposes. The return value is the return from the syscall if
3980 * positive or a negative errno code on error.
3981 */
3982
Eric W. Biederman881d9662007-09-17 11:56:21 -07003983int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003984{
3985 struct ifreq ifr;
3986 int ret;
3987 char *colon;
3988
3989 /* One special case: SIOCGIFCONF takes ifconf argument
3990 and requires shared lock, because it sleeps writing
3991 to user space.
3992 */
3993
3994 if (cmd == SIOCGIFCONF) {
Stephen Hemminger6756ae42006-03-20 22:23:58 -08003995 rtnl_lock();
Eric W. Biederman881d9662007-09-17 11:56:21 -07003996 ret = dev_ifconf(net, (char __user *) arg);
Stephen Hemminger6756ae42006-03-20 22:23:58 -08003997 rtnl_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003998 return ret;
3999 }
4000 if (cmd == SIOCGIFNAME)
Eric W. Biederman881d9662007-09-17 11:56:21 -07004001 return dev_ifname(net, (struct ifreq __user *)arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004002
4003 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
4004 return -EFAULT;
4005
4006 ifr.ifr_name[IFNAMSIZ-1] = 0;
4007
4008 colon = strchr(ifr.ifr_name, ':');
4009 if (colon)
4010 *colon = 0;
4011
4012 /*
4013 * See which interface the caller is talking about.
4014 */
4015
4016 switch (cmd) {
4017 /*
4018 * These ioctl calls:
4019 * - can be done by all.
4020 * - atomic and do not require locking.
4021 * - return a value
4022 */
4023 case SIOCGIFFLAGS:
4024 case SIOCGIFMETRIC:
4025 case SIOCGIFMTU:
4026 case SIOCGIFHWADDR:
4027 case SIOCGIFSLAVE:
4028 case SIOCGIFMAP:
4029 case SIOCGIFINDEX:
4030 case SIOCGIFTXQLEN:
Eric W. Biederman881d9662007-09-17 11:56:21 -07004031 dev_load(net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004032 read_lock(&dev_base_lock);
Jeff Garzik14e3e072007-10-08 00:06:32 -07004033 ret = dev_ifsioc_locked(net, &ifr, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004034 read_unlock(&dev_base_lock);
4035 if (!ret) {
4036 if (colon)
4037 *colon = ':';
4038 if (copy_to_user(arg, &ifr,
4039 sizeof(struct ifreq)))
4040 ret = -EFAULT;
4041 }
4042 return ret;
4043
4044 case SIOCETHTOOL:
Eric W. Biederman881d9662007-09-17 11:56:21 -07004045 dev_load(net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004046 rtnl_lock();
Eric W. Biederman881d9662007-09-17 11:56:21 -07004047 ret = dev_ethtool(net, &ifr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004048 rtnl_unlock();
4049 if (!ret) {
4050 if (colon)
4051 *colon = ':';
4052 if (copy_to_user(arg, &ifr,
4053 sizeof(struct ifreq)))
4054 ret = -EFAULT;
4055 }
4056 return ret;
4057
4058 /*
4059 * These ioctl calls:
4060 * - require superuser power.
4061 * - require strict serialization.
4062 * - return a value
4063 */
4064 case SIOCGMIIPHY:
4065 case SIOCGMIIREG:
4066 case SIOCSIFNAME:
4067 if (!capable(CAP_NET_ADMIN))
4068 return -EPERM;
Eric W. Biederman881d9662007-09-17 11:56:21 -07004069 dev_load(net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004070 rtnl_lock();
Eric W. Biederman881d9662007-09-17 11:56:21 -07004071 ret = dev_ifsioc(net, &ifr, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004072 rtnl_unlock();
4073 if (!ret) {
4074 if (colon)
4075 *colon = ':';
4076 if (copy_to_user(arg, &ifr,
4077 sizeof(struct ifreq)))
4078 ret = -EFAULT;
4079 }
4080 return ret;
4081
4082 /*
4083 * These ioctl calls:
4084 * - require superuser power.
4085 * - require strict serialization.
4086 * - do not return a value
4087 */
4088 case SIOCSIFFLAGS:
4089 case SIOCSIFMETRIC:
4090 case SIOCSIFMTU:
4091 case SIOCSIFMAP:
4092 case SIOCSIFHWADDR:
4093 case SIOCSIFSLAVE:
4094 case SIOCADDMULTI:
4095 case SIOCDELMULTI:
4096 case SIOCSIFHWBROADCAST:
4097 case SIOCSIFTXQLEN:
4098 case SIOCSMIIREG:
4099 case SIOCBONDENSLAVE:
4100 case SIOCBONDRELEASE:
4101 case SIOCBONDSETHWADDR:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004102 case SIOCBONDCHANGEACTIVE:
4103 case SIOCBRADDIF:
4104 case SIOCBRDELIF:
4105 if (!capable(CAP_NET_ADMIN))
4106 return -EPERM;
Thomas Grafcabcac02006-01-24 12:46:33 -08004107 /* fall through */
4108 case SIOCBONDSLAVEINFOQUERY:
4109 case SIOCBONDINFOQUERY:
Eric W. Biederman881d9662007-09-17 11:56:21 -07004110 dev_load(net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004111 rtnl_lock();
Eric W. Biederman881d9662007-09-17 11:56:21 -07004112 ret = dev_ifsioc(net, &ifr, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004113 rtnl_unlock();
4114 return ret;
4115
4116 case SIOCGIFMEM:
4117 /* Get the per device memory space. We can add this but
4118 * currently do not support it */
4119 case SIOCSIFMEM:
4120 /* Set the per device memory buffer space.
4121 * Not applicable in our case */
4122 case SIOCSIFLINK:
4123 return -EINVAL;
4124
4125 /*
4126 * Unknown or private ioctl.
4127 */
4128 default:
4129 if (cmd == SIOCWANDEV ||
4130 (cmd >= SIOCDEVPRIVATE &&
4131 cmd <= SIOCDEVPRIVATE + 15)) {
Eric W. Biederman881d9662007-09-17 11:56:21 -07004132 dev_load(net, ifr.ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004133 rtnl_lock();
Eric W. Biederman881d9662007-09-17 11:56:21 -07004134 ret = dev_ifsioc(net, &ifr, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004135 rtnl_unlock();
4136 if (!ret && copy_to_user(arg, &ifr,
4137 sizeof(struct ifreq)))
4138 ret = -EFAULT;
4139 return ret;
4140 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004141 /* Take care of Wireless Extensions */
Johannes Berg295f4a12007-04-26 20:43:56 -07004142 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
Eric W. Biederman881d9662007-09-17 11:56:21 -07004143 return wext_handle_ioctl(net, &ifr, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004144 return -EINVAL;
4145 }
4146}
4147
4148
4149/**
4150 * dev_new_index - allocate an ifindex
Randy Dunlapc4ea43c2007-10-12 21:17:49 -07004151 * @net: the applicable net namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -07004152 *
4153 * Returns a suitable unique value for a new device interface
4154 * number. The caller must hold the rtnl semaphore or the
4155 * dev_base_lock to be sure it remains unique.
4156 */
Eric W. Biederman881d9662007-09-17 11:56:21 -07004157static int dev_new_index(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004158{
4159 static int ifindex;
4160 for (;;) {
4161 if (++ifindex <= 0)
4162 ifindex = 1;
Eric W. Biederman881d9662007-09-17 11:56:21 -07004163 if (!__dev_get_by_index(net, ifindex))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004164 return ifindex;
4165 }
4166}
4167
Linus Torvalds1da177e2005-04-16 15:20:36 -07004168/* Delayed registration/unregisteration */
Denis Cheng3b5b34f2007-12-07 00:49:17 -08004169static LIST_HEAD(net_todo_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004170
Stephen Hemminger6f05f622007-03-08 20:46:03 -08004171static void net_set_todo(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004172{
Linus Torvalds1da177e2005-04-16 15:20:36 -07004173 list_add_tail(&dev->todo_list, &net_todo_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004174}
4175
Daniel Lezcano93ee31f2007-10-30 15:38:18 -07004176static void rollback_registered(struct net_device *dev)
4177{
4178 BUG_ON(dev_boot_phase);
4179 ASSERT_RTNL();
4180
4181 /* Some devices call without registering for initialization unwind. */
4182 if (dev->reg_state == NETREG_UNINITIALIZED) {
4183 printk(KERN_DEBUG "unregister_netdevice: device %s/%p never "
4184 "was registered\n", dev->name, dev);
4185
4186 WARN_ON(1);
4187 return;
4188 }
4189
4190 BUG_ON(dev->reg_state != NETREG_REGISTERED);
4191
4192 /* If device is running, close it first. */
4193 dev_close(dev);
4194
4195 /* And unlink it from device chain. */
4196 unlist_netdevice(dev);
4197
4198 dev->reg_state = NETREG_UNREGISTERING;
4199
4200 synchronize_net();
4201
4202 /* Shutdown queueing discipline. */
4203 dev_shutdown(dev);
4204
4205
4206 /* Notify protocols, that we are about to destroy
4207 this device. They should clean all the things.
4208 */
4209 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4210
4211 /*
4212 * Flush the unicast and multicast chains
4213 */
4214 dev_addr_discard(dev);
4215
Stephen Hemmingerd3147742008-11-19 21:32:24 -08004216 if (dev->netdev_ops->ndo_uninit)
4217 dev->netdev_ops->ndo_uninit(dev);
Daniel Lezcano93ee31f2007-10-30 15:38:18 -07004218
4219 /* Notifier chain MUST detach us from master device. */
Ilpo Järvinen547b7922008-07-25 21:43:18 -07004220 WARN_ON(dev->master);
Daniel Lezcano93ee31f2007-10-30 15:38:18 -07004221
4222 /* Remove entries from kobject tree */
4223 netdev_unregister_kobject(dev);
4224
4225 synchronize_net();
4226
4227 dev_put(dev);
4228}
4229
David S. Millere8a04642008-07-17 00:34:19 -07004230static void __netdev_init_queue_locks_one(struct net_device *dev,
4231 struct netdev_queue *dev_queue,
4232 void *_unused)
David S. Millerc773e842008-07-08 23:13:53 -07004233{
4234 spin_lock_init(&dev_queue->_xmit_lock);
David S. Millercf508b12008-07-22 14:16:42 -07004235 netdev_set_xmit_lockdep_class(&dev_queue->_xmit_lock, dev->type);
David S. Millerc773e842008-07-08 23:13:53 -07004236 dev_queue->xmit_lock_owner = -1;
4237}
4238
4239static void netdev_init_queue_locks(struct net_device *dev)
4240{
David S. Millere8a04642008-07-17 00:34:19 -07004241 netdev_for_each_tx_queue(dev, __netdev_init_queue_locks_one, NULL);
4242 __netdev_init_queue_locks_one(dev, &dev->rx_queue, NULL);
David S. Millerc773e842008-07-08 23:13:53 -07004243}
4244
Herbert Xub63365a2008-10-23 01:11:29 -07004245unsigned long netdev_fix_features(unsigned long features, const char *name)
4246{
4247 /* Fix illegal SG+CSUM combinations. */
4248 if ((features & NETIF_F_SG) &&
4249 !(features & NETIF_F_ALL_CSUM)) {
4250 if (name)
4251 printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no "
4252 "checksum feature.\n", name);
4253 features &= ~NETIF_F_SG;
4254 }
4255
4256 /* TSO requires that SG is present as well. */
4257 if ((features & NETIF_F_TSO) && !(features & NETIF_F_SG)) {
4258 if (name)
4259 printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no "
4260 "SG feature.\n", name);
4261 features &= ~NETIF_F_TSO;
4262 }
4263
4264 if (features & NETIF_F_UFO) {
4265 if (!(features & NETIF_F_GEN_CSUM)) {
4266 if (name)
4267 printk(KERN_ERR "%s: Dropping NETIF_F_UFO "
4268 "since no NETIF_F_HW_CSUM feature.\n",
4269 name);
4270 features &= ~NETIF_F_UFO;
4271 }
4272
4273 if (!(features & NETIF_F_SG)) {
4274 if (name)
4275 printk(KERN_ERR "%s: Dropping NETIF_F_UFO "
4276 "since no NETIF_F_SG feature.\n", name);
4277 features &= ~NETIF_F_UFO;
4278 }
4279 }
4280
4281 return features;
4282}
4283EXPORT_SYMBOL(netdev_fix_features);
4284
Linus Torvalds1da177e2005-04-16 15:20:36 -07004285/**
4286 * register_netdevice - register a network device
4287 * @dev: device to register
4288 *
4289 * Take a completed network device structure and add it to the kernel
4290 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
4291 * chain. 0 is returned on success. A negative errno code is returned
4292 * on a failure to set up the device, or if the name is a duplicate.
4293 *
4294 * Callers must hold the rtnl semaphore. You may want
4295 * register_netdev() instead of this.
4296 *
4297 * BUGS:
4298 * The locking appears insufficient to guarantee two parallel registers
4299 * will not get the same name.
4300 */
4301
4302int register_netdevice(struct net_device *dev)
4303{
4304 struct hlist_head *head;
4305 struct hlist_node *p;
4306 int ret;
Stephen Hemmingerd3147742008-11-19 21:32:24 -08004307 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004308
4309 BUG_ON(dev_boot_phase);
4310 ASSERT_RTNL();
4311
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07004312 might_sleep();
4313
Linus Torvalds1da177e2005-04-16 15:20:36 -07004314 /* When net_device's are persistent, this will be fatal. */
4315 BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
Stephen Hemmingerd3147742008-11-19 21:32:24 -08004316 BUG_ON(!net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004317
David S. Millerf1f28aa2008-07-15 00:08:33 -07004318 spin_lock_init(&dev->addr_list_lock);
David S. Millercf508b12008-07-22 14:16:42 -07004319 netdev_set_addr_lockdep_class(dev);
David S. Millerc773e842008-07-08 23:13:53 -07004320 netdev_init_queue_locks(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004321
Linus Torvalds1da177e2005-04-16 15:20:36 -07004322 dev->iflink = -1;
4323
Stephen Hemmingerd3147742008-11-19 21:32:24 -08004324#ifdef CONFIG_COMPAT_NET_DEV_OPS
4325 /* Netdevice_ops API compatiability support.
4326 * This is temporary until all network devices are converted.
4327 */
4328 if (dev->netdev_ops) {
4329 const struct net_device_ops *ops = dev->netdev_ops;
4330
4331 dev->init = ops->ndo_init;
4332 dev->uninit = ops->ndo_uninit;
4333 dev->open = ops->ndo_open;
4334 dev->change_rx_flags = ops->ndo_change_rx_flags;
4335 dev->set_rx_mode = ops->ndo_set_rx_mode;
4336 dev->set_multicast_list = ops->ndo_set_multicast_list;
4337 dev->set_mac_address = ops->ndo_set_mac_address;
4338 dev->validate_addr = ops->ndo_validate_addr;
4339 dev->do_ioctl = ops->ndo_do_ioctl;
4340 dev->set_config = ops->ndo_set_config;
4341 dev->change_mtu = ops->ndo_change_mtu;
David S. Miller54acd0e2009-03-04 23:01:02 -08004342 dev->neigh_setup = ops->ndo_neigh_setup;
Stephen Hemmingerd3147742008-11-19 21:32:24 -08004343 dev->tx_timeout = ops->ndo_tx_timeout;
4344 dev->get_stats = ops->ndo_get_stats;
4345 dev->vlan_rx_register = ops->ndo_vlan_rx_register;
4346 dev->vlan_rx_add_vid = ops->ndo_vlan_rx_add_vid;
4347 dev->vlan_rx_kill_vid = ops->ndo_vlan_rx_kill_vid;
4348#ifdef CONFIG_NET_POLL_CONTROLLER
4349 dev->poll_controller = ops->ndo_poll_controller;
4350#endif
4351 } else {
4352 char drivername[64];
4353 pr_info("%s (%s): not using net_device_ops yet\n",
4354 dev->name, netdev_drivername(dev, drivername, 64));
4355
4356 /* This works only because net_device_ops and the
4357 compatiablity structure are the same. */
4358 dev->netdev_ops = (void *) &(dev->init);
4359 }
4360#endif
4361
Linus Torvalds1da177e2005-04-16 15:20:36 -07004362 /* Init, if this function is available */
Stephen Hemmingerd3147742008-11-19 21:32:24 -08004363 if (dev->netdev_ops->ndo_init) {
4364 ret = dev->netdev_ops->ndo_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004365 if (ret) {
4366 if (ret > 0)
4367 ret = -EIO;
Adrian Bunk90833aa2006-11-13 16:02:22 -08004368 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004369 }
4370 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09004371
Linus Torvalds1da177e2005-04-16 15:20:36 -07004372 if (!dev_valid_name(dev->name)) {
4373 ret = -EINVAL;
Herbert Xu7ce1b0e2007-07-30 16:29:40 -07004374 goto err_uninit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004375 }
4376
Eric W. Biederman881d9662007-09-17 11:56:21 -07004377 dev->ifindex = dev_new_index(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004378 if (dev->iflink == -1)
4379 dev->iflink = dev->ifindex;
4380
4381 /* Check for existence of name */
Eric W. Biederman881d9662007-09-17 11:56:21 -07004382 head = dev_name_hash(net, dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004383 hlist_for_each(p, head) {
4384 struct net_device *d
4385 = hlist_entry(p, struct net_device, name_hlist);
4386 if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
4387 ret = -EEXIST;
Herbert Xu7ce1b0e2007-07-30 16:29:40 -07004388 goto err_uninit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004389 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09004390 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004391
Stephen Hemmingerd212f872007-06-27 00:47:37 -07004392 /* Fix illegal checksum combinations */
4393 if ((dev->features & NETIF_F_HW_CSUM) &&
4394 (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
4395 printk(KERN_NOTICE "%s: mixed HW and IP checksum settings.\n",
4396 dev->name);
4397 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
4398 }
4399
4400 if ((dev->features & NETIF_F_NO_CSUM) &&
4401 (dev->features & (NETIF_F_HW_CSUM|NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
4402 printk(KERN_NOTICE "%s: mixed no checksumming and other settings.\n",
4403 dev->name);
4404 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM|NETIF_F_HW_CSUM);
4405 }
4406
Herbert Xub63365a2008-10-23 01:11:29 -07004407 dev->features = netdev_fix_features(dev->features, dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004408
Lennert Buytenheke5a4a722008-08-03 01:23:10 -07004409 /* Enable software GSO if SG is supported. */
4410 if (dev->features & NETIF_F_SG)
4411 dev->features |= NETIF_F_GSO;
4412
Daniel Lezcanoaaf8cdc2008-05-02 17:00:58 -07004413 netdev_initialize_kobject(dev);
Eric W. Biederman8b41d182007-09-26 22:02:53 -07004414 ret = netdev_register_kobject(dev);
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07004415 if (ret)
Herbert Xu7ce1b0e2007-07-30 16:29:40 -07004416 goto err_uninit;
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07004417 dev->reg_state = NETREG_REGISTERED;
4418
Linus Torvalds1da177e2005-04-16 15:20:36 -07004419 /*
4420 * Default initial state at registry is that the
4421 * device is present.
4422 */
4423
4424 set_bit(__LINK_STATE_PRESENT, &dev->state);
4425
Linus Torvalds1da177e2005-04-16 15:20:36 -07004426 dev_init_scheduler(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004427 dev_hold(dev);
Eric W. Biedermance286d32007-09-12 13:53:49 +02004428 list_netdevice(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004429
4430 /* Notify protocols, that a new device appeared. */
Pavel Emelyanov056925a2007-09-16 15:42:43 -07004431 ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);
Herbert Xufcc5a032007-07-30 17:03:38 -07004432 ret = notifier_to_errno(ret);
Daniel Lezcano93ee31f2007-10-30 15:38:18 -07004433 if (ret) {
4434 rollback_registered(dev);
4435 dev->reg_state = NETREG_UNREGISTERED;
4436 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004437
4438out:
4439 return ret;
Herbert Xu7ce1b0e2007-07-30 16:29:40 -07004440
4441err_uninit:
Stephen Hemmingerd3147742008-11-19 21:32:24 -08004442 if (dev->netdev_ops->ndo_uninit)
4443 dev->netdev_ops->ndo_uninit(dev);
Herbert Xu7ce1b0e2007-07-30 16:29:40 -07004444 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004445}
4446
4447/**
Benjamin Herrenschmidt937f1ba2009-01-14 21:05:05 -08004448 * init_dummy_netdev - init a dummy network device for NAPI
4449 * @dev: device to init
4450 *
4451 * This takes a network device structure and initialize the minimum
4452 * amount of fields so it can be used to schedule NAPI polls without
4453 * registering a full blown interface. This is to be used by drivers
4454 * that need to tie several hardware interfaces to a single NAPI
4455 * poll scheduler due to HW limitations.
4456 */
4457int init_dummy_netdev(struct net_device *dev)
4458{
4459 /* Clear everything. Note we don't initialize spinlocks
4460 * are they aren't supposed to be taken by any of the
4461 * NAPI code and this dummy netdev is supposed to be
4462 * only ever used for NAPI polls
4463 */
4464 memset(dev, 0, sizeof(struct net_device));
4465
4466 /* make sure we BUG if trying to hit standard
4467 * register/unregister code path
4468 */
4469 dev->reg_state = NETREG_DUMMY;
4470
4471 /* initialize the ref count */
4472 atomic_set(&dev->refcnt, 1);
4473
4474 /* NAPI wants this */
4475 INIT_LIST_HEAD(&dev->napi_list);
4476
4477 /* a dummy interface is started by default */
4478 set_bit(__LINK_STATE_PRESENT, &dev->state);
4479 set_bit(__LINK_STATE_START, &dev->state);
4480
4481 return 0;
4482}
4483EXPORT_SYMBOL_GPL(init_dummy_netdev);
4484
4485
4486/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004487 * register_netdev - register a network device
4488 * @dev: device to register
4489 *
4490 * Take a completed network device structure and add it to the kernel
4491 * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
4492 * chain. 0 is returned on success. A negative errno code is returned
4493 * on a failure to set up the device, or if the name is a duplicate.
4494 *
Borislav Petkov38b4da32007-04-20 22:14:10 -07004495 * This is a wrapper around register_netdevice that takes the rtnl semaphore
Linus Torvalds1da177e2005-04-16 15:20:36 -07004496 * and expands the device name if you passed a format string to
4497 * alloc_netdev.
4498 */
4499int register_netdev(struct net_device *dev)
4500{
4501 int err;
4502
4503 rtnl_lock();
4504
4505 /*
4506 * If the name is a format string the caller wants us to do a
4507 * name allocation.
4508 */
4509 if (strchr(dev->name, '%')) {
4510 err = dev_alloc_name(dev, dev->name);
4511 if (err < 0)
4512 goto out;
4513 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09004514
Linus Torvalds1da177e2005-04-16 15:20:36 -07004515 err = register_netdevice(dev);
4516out:
4517 rtnl_unlock();
4518 return err;
4519}
4520EXPORT_SYMBOL(register_netdev);
4521
4522/*
4523 * netdev_wait_allrefs - wait until all references are gone.
4524 *
4525 * This is called when unregistering network devices.
4526 *
4527 * Any protocol or device that holds a reference should register
4528 * for netdevice notification, and cleanup and put back the
4529 * reference if they receive an UNREGISTER event.
4530 * We can get stuck here if buggy protocols don't correctly
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09004531 * call dev_put.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004532 */
4533static void netdev_wait_allrefs(struct net_device *dev)
4534{
4535 unsigned long rebroadcast_time, warning_time;
4536
4537 rebroadcast_time = warning_time = jiffies;
4538 while (atomic_read(&dev->refcnt) != 0) {
4539 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
Stephen Hemminger6756ae42006-03-20 22:23:58 -08004540 rtnl_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004541
4542 /* Rebroadcast unregister notification */
Pavel Emelyanov056925a2007-09-16 15:42:43 -07004543 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004544
4545 if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
4546 &dev->state)) {
4547 /* We must not have linkwatch events
4548 * pending on unregister. If this
4549 * happens, we simply run the queue
4550 * unscheduled, resulting in a noop
4551 * for this device.
4552 */
4553 linkwatch_run_queue();
4554 }
4555
Stephen Hemminger6756ae42006-03-20 22:23:58 -08004556 __rtnl_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004557
4558 rebroadcast_time = jiffies;
4559 }
4560
4561 msleep(250);
4562
4563 if (time_after(jiffies, warning_time + 10 * HZ)) {
4564 printk(KERN_EMERG "unregister_netdevice: "
4565 "waiting for %s to become free. Usage "
4566 "count = %d\n",
4567 dev->name, atomic_read(&dev->refcnt));
4568 warning_time = jiffies;
4569 }
4570 }
4571}
4572
4573/* The sequence is:
4574 *
4575 * rtnl_lock();
4576 * ...
4577 * register_netdevice(x1);
4578 * register_netdevice(x2);
4579 * ...
4580 * unregister_netdevice(y1);
4581 * unregister_netdevice(y2);
4582 * ...
4583 * rtnl_unlock();
4584 * free_netdev(y1);
4585 * free_netdev(y2);
4586 *
Herbert Xu58ec3b42008-10-07 15:50:03 -07004587 * We are invoked by rtnl_unlock().
Linus Torvalds1da177e2005-04-16 15:20:36 -07004588 * This allows us to deal with problems:
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07004589 * 1) We can delete sysfs objects which invoke hotplug
Linus Torvalds1da177e2005-04-16 15:20:36 -07004590 * without deadlocking with linkwatch via keventd.
4591 * 2) Since we run with the RTNL semaphore not held, we can sleep
4592 * safely in order to wait for the netdev refcnt to drop to zero.
Herbert Xu58ec3b42008-10-07 15:50:03 -07004593 *
4594 * We must not return until all unregister events added during
4595 * the interval the lock was held have been completed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004596 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004597void netdev_run_todo(void)
4598{
Oleg Nesterov626ab0e2006-06-23 02:05:55 -07004599 struct list_head list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004600
Linus Torvalds1da177e2005-04-16 15:20:36 -07004601 /* Snapshot list, allow later requests */
Oleg Nesterov626ab0e2006-06-23 02:05:55 -07004602 list_replace_init(&net_todo_list, &list);
Herbert Xu58ec3b42008-10-07 15:50:03 -07004603
4604 __rtnl_unlock();
Oleg Nesterov626ab0e2006-06-23 02:05:55 -07004605
Linus Torvalds1da177e2005-04-16 15:20:36 -07004606 while (!list_empty(&list)) {
4607 struct net_device *dev
4608 = list_entry(list.next, struct net_device, todo_list);
4609 list_del(&dev->todo_list);
4610
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07004611 if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004612 printk(KERN_ERR "network todo '%s' but state %d\n",
4613 dev->name, dev->reg_state);
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07004614 dump_stack();
4615 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004616 }
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07004617
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07004618 dev->reg_state = NETREG_UNREGISTERED;
4619
Stephen Hemminger6e583ce2008-08-03 21:29:57 -07004620 on_each_cpu(flush_backlog, dev, 1);
4621
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07004622 netdev_wait_allrefs(dev);
4623
4624 /* paranoia */
4625 BUG_ON(atomic_read(&dev->refcnt));
Ilpo Järvinen547b7922008-07-25 21:43:18 -07004626 WARN_ON(dev->ip_ptr);
4627 WARN_ON(dev->ip6_ptr);
4628 WARN_ON(dev->dn_ptr);
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07004629
Stephen Hemmingerb17a7c12006-05-10 13:21:17 -07004630 if (dev->destructor)
4631 dev->destructor(dev);
Stephen Hemminger9093bbb2007-05-19 15:39:25 -07004632
4633 /* Free network device */
4634 kobject_put(&dev->dev.kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004635 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004636}
4637
Stephen Hemmingereeda3fd2008-11-19 21:40:23 -08004638/**
4639 * dev_get_stats - get network device statistics
4640 * @dev: device to get statistics from
4641 *
4642 * Get network statistics from device. The device driver may provide
4643 * its own method by setting dev->netdev_ops->get_stats; otherwise
4644 * the internal statistics structure is used.
4645 */
4646const struct net_device_stats *dev_get_stats(struct net_device *dev)
4647 {
4648 const struct net_device_ops *ops = dev->netdev_ops;
4649
4650 if (ops->ndo_get_stats)
4651 return ops->ndo_get_stats(dev);
4652 else
4653 return &dev->stats;
Rusty Russellc45d2862007-03-28 14:29:08 -07004654}
Stephen Hemmingereeda3fd2008-11-19 21:40:23 -08004655EXPORT_SYMBOL(dev_get_stats);
Rusty Russellc45d2862007-03-28 14:29:08 -07004656
David S. Millerdc2b4842008-07-08 17:18:23 -07004657static void netdev_init_one_queue(struct net_device *dev,
David S. Millere8a04642008-07-17 00:34:19 -07004658 struct netdev_queue *queue,
4659 void *_unused)
David S. Millerdc2b4842008-07-08 17:18:23 -07004660{
David S. Millerdc2b4842008-07-08 17:18:23 -07004661 queue->dev = dev;
4662}
4663
David S. Millerbb949fb2008-07-08 16:55:56 -07004664static void netdev_init_queues(struct net_device *dev)
4665{
David S. Millere8a04642008-07-17 00:34:19 -07004666 netdev_init_one_queue(dev, &dev->rx_queue, NULL);
4667 netdev_for_each_tx_queue(dev, netdev_init_one_queue, NULL);
David S. Millerc3f26a22008-07-31 16:58:50 -07004668 spin_lock_init(&dev->tx_global_lock);
David S. Millerbb949fb2008-07-08 16:55:56 -07004669}
4670
Linus Torvalds1da177e2005-04-16 15:20:36 -07004671/**
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07004672 * alloc_netdev_mq - allocate network device
Linus Torvalds1da177e2005-04-16 15:20:36 -07004673 * @sizeof_priv: size of private data to allocate space for
4674 * @name: device name format string
4675 * @setup: callback to initialize device
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07004676 * @queue_count: the number of subqueues to allocate
Linus Torvalds1da177e2005-04-16 15:20:36 -07004677 *
4678 * Allocates a struct net_device with private data area for driver use
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07004679 * and performs basic initialization. Also allocates subquue structs
4680 * for each queue on the device at the end of the netdevice.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004681 */
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07004682struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
4683 void (*setup)(struct net_device *), unsigned int queue_count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004684{
David S. Millere8a04642008-07-17 00:34:19 -07004685 struct netdev_queue *tx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004686 struct net_device *dev;
Stephen Hemminger79439862008-07-21 13:28:44 -07004687 size_t alloc_size;
David S. Millere8a04642008-07-17 00:34:19 -07004688 void *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004689
Stephen Hemmingerb6fe17d2006-08-29 17:06:13 -07004690 BUG_ON(strlen(name) >= sizeof(dev->name));
4691
David S. Millerfd2ea0a2008-07-17 01:56:23 -07004692 alloc_size = sizeof(struct net_device);
Alexey Dobriyand1643d22008-04-18 15:43:32 -07004693 if (sizeof_priv) {
4694 /* ensure 32-byte alignment of private area */
4695 alloc_size = (alloc_size + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST;
4696 alloc_size += sizeof_priv;
4697 }
4698 /* ensure 32-byte alignment of whole construct */
4699 alloc_size += NETDEV_ALIGN_CONST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004700
Paolo 'Blaisorblade' Giarrusso31380de2006-04-06 22:38:28 -07004701 p = kzalloc(alloc_size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004702 if (!p) {
Stephen Hemmingerb6fe17d2006-08-29 17:06:13 -07004703 printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004704 return NULL;
4705 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004706
Stephen Hemminger79439862008-07-21 13:28:44 -07004707 tx = kcalloc(queue_count, sizeof(struct netdev_queue), GFP_KERNEL);
David S. Millere8a04642008-07-17 00:34:19 -07004708 if (!tx) {
4709 printk(KERN_ERR "alloc_netdev: Unable to allocate "
4710 "tx qdiscs.\n");
4711 kfree(p);
4712 return NULL;
4713 }
4714
Linus Torvalds1da177e2005-04-16 15:20:36 -07004715 dev = (struct net_device *)
4716 (((long)p + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
4717 dev->padded = (char *)dev - (char *)p;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09004718 dev_net_set(dev, &init_net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004719
David S. Millere8a04642008-07-17 00:34:19 -07004720 dev->_tx = tx;
4721 dev->num_tx_queues = queue_count;
David S. Millerfd2ea0a2008-07-17 01:56:23 -07004722 dev->real_num_tx_queues = queue_count;
David S. Millere8a04642008-07-17 00:34:19 -07004723
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -07004724 dev->gso_max_size = GSO_MAX_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004725
David S. Millerbb949fb2008-07-08 16:55:56 -07004726 netdev_init_queues(dev);
4727
Herbert Xud565b0a2008-12-15 23:38:52 -08004728 INIT_LIST_HEAD(&dev->napi_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004729 setup(dev);
4730 strcpy(dev->name, name);
4731 return dev;
4732}
Peter P Waskiewicz Jrf25f4e42007-07-06 13:36:20 -07004733EXPORT_SYMBOL(alloc_netdev_mq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004734
4735/**
4736 * free_netdev - free network device
4737 * @dev: device
4738 *
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09004739 * This function does the last stage of destroying an allocated device
4740 * interface. The reference to the device object is released.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004741 * If this is the last reference then it will be freed.
4742 */
4743void free_netdev(struct net_device *dev)
4744{
Herbert Xud565b0a2008-12-15 23:38:52 -08004745 struct napi_struct *p, *n;
4746
Denis V. Lunevf3005d72008-04-16 02:02:18 -07004747 release_net(dev_net(dev));
4748
David S. Millere8a04642008-07-17 00:34:19 -07004749 kfree(dev->_tx);
4750
Herbert Xud565b0a2008-12-15 23:38:52 -08004751 list_for_each_entry_safe(p, n, &dev->napi_list, dev_list)
4752 netif_napi_del(p);
4753
Stephen Hemminger3041a062006-05-26 13:25:24 -07004754 /* Compatibility with error handling in drivers */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004755 if (dev->reg_state == NETREG_UNINITIALIZED) {
4756 kfree((char *)dev - dev->padded);
4757 return;
4758 }
4759
4760 BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
4761 dev->reg_state = NETREG_RELEASED;
4762
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07004763 /* will free via device release */
4764 put_device(&dev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004765}
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09004766
Stephen Hemmingerf0db2752008-09-30 02:23:58 -07004767/**
4768 * synchronize_net - Synchronize with packet receive processing
4769 *
4770 * Wait for packets currently being received to be done.
4771 * Does not block later packets from starting.
4772 */
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09004773void synchronize_net(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004774{
4775 might_sleep();
Paul E. McKenneyfbd568a3e2005-05-01 08:59:04 -07004776 synchronize_rcu();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004777}
4778
4779/**
4780 * unregister_netdevice - remove device from the kernel
4781 * @dev: device
4782 *
4783 * This function shuts down a device interface and removes it
Wang Chend59b54b2007-12-11 02:28:03 -08004784 * from the kernel tables.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004785 *
4786 * Callers must hold the rtnl semaphore. You may want
4787 * unregister_netdev() instead of this.
4788 */
4789
Stephen Hemminger22f8cde2007-02-07 00:09:58 -08004790void unregister_netdevice(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004791{
Herbert Xua6620712007-12-12 19:21:56 -08004792 ASSERT_RTNL();
4793
Daniel Lezcano93ee31f2007-10-30 15:38:18 -07004794 rollback_registered(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004795 /* Finish processing unregister after unlock */
4796 net_set_todo(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004797}
4798
4799/**
4800 * unregister_netdev - remove device from the kernel
4801 * @dev: device
4802 *
4803 * This function shuts down a device interface and removes it
Wang Chend59b54b2007-12-11 02:28:03 -08004804 * from the kernel tables.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004805 *
4806 * This is just a wrapper for unregister_netdevice that takes
4807 * the rtnl semaphore. In general you want to use this and not
4808 * unregister_netdevice.
4809 */
4810void unregister_netdev(struct net_device *dev)
4811{
4812 rtnl_lock();
4813 unregister_netdevice(dev);
4814 rtnl_unlock();
4815}
4816
4817EXPORT_SYMBOL(unregister_netdev);
4818
Eric W. Biedermance286d32007-09-12 13:53:49 +02004819/**
4820 * dev_change_net_namespace - move device to different nethost namespace
4821 * @dev: device
4822 * @net: network namespace
4823 * @pat: If not NULL name pattern to try if the current device name
4824 * is already taken in the destination network namespace.
4825 *
4826 * This function shuts down a device interface and moves it
4827 * to a new network namespace. On success 0 is returned, on
4828 * a failure a netagive errno code is returned.
4829 *
4830 * Callers must hold the rtnl semaphore.
4831 */
4832
4833int dev_change_net_namespace(struct net_device *dev, struct net *net, const char *pat)
4834{
4835 char buf[IFNAMSIZ];
4836 const char *destname;
4837 int err;
4838
4839 ASSERT_RTNL();
4840
4841 /* Don't allow namespace local devices to be moved. */
4842 err = -EINVAL;
4843 if (dev->features & NETIF_F_NETNS_LOCAL)
4844 goto out;
4845
Eric W. Biederman38918452008-10-27 17:51:47 -07004846#ifdef CONFIG_SYSFS
4847 /* Don't allow real devices to be moved when sysfs
4848 * is enabled.
4849 */
4850 err = -EINVAL;
4851 if (dev->dev.parent)
4852 goto out;
4853#endif
4854
Eric W. Biedermance286d32007-09-12 13:53:49 +02004855 /* Ensure the device has been registrered */
4856 err = -EINVAL;
4857 if (dev->reg_state != NETREG_REGISTERED)
4858 goto out;
4859
4860 /* Get out if there is nothing todo */
4861 err = 0;
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09004862 if (net_eq(dev_net(dev), net))
Eric W. Biedermance286d32007-09-12 13:53:49 +02004863 goto out;
4864
4865 /* Pick the destination device name, and ensure
4866 * we can use it in the destination network namespace.
4867 */
4868 err = -EEXIST;
4869 destname = dev->name;
4870 if (__dev_get_by_name(net, destname)) {
4871 /* We get here if we can't use the current device name */
4872 if (!pat)
4873 goto out;
4874 if (!dev_valid_name(pat))
4875 goto out;
4876 if (strchr(pat, '%')) {
4877 if (__dev_alloc_name(net, pat, buf) < 0)
4878 goto out;
4879 destname = buf;
4880 } else
4881 destname = pat;
4882 if (__dev_get_by_name(net, destname))
4883 goto out;
4884 }
4885
4886 /*
4887 * And now a mini version of register_netdevice unregister_netdevice.
4888 */
4889
4890 /* If device is running close it first. */
Pavel Emelyanov9b772652007-10-10 02:49:09 -07004891 dev_close(dev);
Eric W. Biedermance286d32007-09-12 13:53:49 +02004892
4893 /* And unlink it from device chain */
4894 err = -ENODEV;
4895 unlist_netdevice(dev);
4896
4897 synchronize_net();
4898
4899 /* Shutdown queueing discipline. */
4900 dev_shutdown(dev);
4901
4902 /* Notify protocols, that we are about to destroy
4903 this device. They should clean all the things.
4904 */
4905 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4906
4907 /*
4908 * Flush the unicast and multicast chains
4909 */
4910 dev_addr_discard(dev);
4911
Eric W. Biederman38918452008-10-27 17:51:47 -07004912 netdev_unregister_kobject(dev);
4913
Eric W. Biedermance286d32007-09-12 13:53:49 +02004914 /* Actually switch the network namespace */
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09004915 dev_net_set(dev, net);
Eric W. Biedermance286d32007-09-12 13:53:49 +02004916
4917 /* Assign the new device name */
4918 if (destname != dev->name)
4919 strcpy(dev->name, destname);
4920
4921 /* If there is an ifindex conflict assign a new one */
4922 if (__dev_get_by_index(net, dev->ifindex)) {
4923 int iflink = (dev->iflink == dev->ifindex);
4924 dev->ifindex = dev_new_index(net);
4925 if (iflink)
4926 dev->iflink = dev->ifindex;
4927 }
4928
Eric W. Biederman8b41d182007-09-26 22:02:53 -07004929 /* Fixup kobjects */
Daniel Lezcanoaaf8cdc2008-05-02 17:00:58 -07004930 err = netdev_register_kobject(dev);
Eric W. Biederman8b41d182007-09-26 22:02:53 -07004931 WARN_ON(err);
Eric W. Biedermance286d32007-09-12 13:53:49 +02004932
4933 /* Add the device back in the hashes */
4934 list_netdevice(dev);
4935
4936 /* Notify protocols, that a new device appeared. */
4937 call_netdevice_notifiers(NETDEV_REGISTER, dev);
4938
4939 synchronize_net();
4940 err = 0;
4941out:
4942 return err;
4943}
4944
Linus Torvalds1da177e2005-04-16 15:20:36 -07004945static int dev_cpu_callback(struct notifier_block *nfb,
4946 unsigned long action,
4947 void *ocpu)
4948{
4949 struct sk_buff **list_skb;
David S. Miller37437bb2008-07-16 02:15:04 -07004950 struct Qdisc **list_net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004951 struct sk_buff *skb;
4952 unsigned int cpu, oldcpu = (unsigned long)ocpu;
4953 struct softnet_data *sd, *oldsd;
4954
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -07004955 if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004956 return NOTIFY_OK;
4957
4958 local_irq_disable();
4959 cpu = smp_processor_id();
4960 sd = &per_cpu(softnet_data, cpu);
4961 oldsd = &per_cpu(softnet_data, oldcpu);
4962
4963 /* Find end of our completion_queue. */
4964 list_skb = &sd->completion_queue;
4965 while (*list_skb)
4966 list_skb = &(*list_skb)->next;
4967 /* Append completion queue from offline CPU. */
4968 *list_skb = oldsd->completion_queue;
4969 oldsd->completion_queue = NULL;
4970
4971 /* Find end of our output_queue. */
4972 list_net = &sd->output_queue;
4973 while (*list_net)
4974 list_net = &(*list_net)->next_sched;
4975 /* Append output queue from offline CPU. */
4976 *list_net = oldsd->output_queue;
4977 oldsd->output_queue = NULL;
4978
4979 raise_softirq_irqoff(NET_TX_SOFTIRQ);
4980 local_irq_enable();
4981
4982 /* Process offline CPU's input_pkt_queue */
4983 while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
4984 netif_rx(skb);
4985
4986 return NOTIFY_OK;
4987}
Linus Torvalds1da177e2005-04-16 15:20:36 -07004988
4989
Herbert Xu7f353bf2007-08-10 15:47:58 -07004990/**
Herbert Xub63365a2008-10-23 01:11:29 -07004991 * netdev_increment_features - increment feature set by one
4992 * @all: current feature set
4993 * @one: new feature set
4994 * @mask: mask feature set
Herbert Xu7f353bf2007-08-10 15:47:58 -07004995 *
4996 * Computes a new feature set after adding a device with feature set
Herbert Xub63365a2008-10-23 01:11:29 -07004997 * @one to the master device with current feature set @all. Will not
4998 * enable anything that is off in @mask. Returns the new feature set.
Herbert Xu7f353bf2007-08-10 15:47:58 -07004999 */
Herbert Xub63365a2008-10-23 01:11:29 -07005000unsigned long netdev_increment_features(unsigned long all, unsigned long one,
5001 unsigned long mask)
Herbert Xu7f353bf2007-08-10 15:47:58 -07005002{
Herbert Xub63365a2008-10-23 01:11:29 -07005003 /* If device needs checksumming, downgrade to it. */
5004 if (all & NETIF_F_NO_CSUM && !(one & NETIF_F_NO_CSUM))
5005 all ^= NETIF_F_NO_CSUM | (one & NETIF_F_ALL_CSUM);
5006 else if (mask & NETIF_F_ALL_CSUM) {
5007 /* If one device supports v4/v6 checksumming, set for all. */
5008 if (one & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM) &&
5009 !(all & NETIF_F_GEN_CSUM)) {
5010 all &= ~NETIF_F_ALL_CSUM;
5011 all |= one & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
5012 }
Herbert Xu7f353bf2007-08-10 15:47:58 -07005013
Herbert Xub63365a2008-10-23 01:11:29 -07005014 /* If one device supports hw checksumming, set for all. */
5015 if (one & NETIF_F_GEN_CSUM && !(all & NETIF_F_GEN_CSUM)) {
5016 all &= ~NETIF_F_ALL_CSUM;
5017 all |= NETIF_F_HW_CSUM;
5018 }
5019 }
Herbert Xu7f353bf2007-08-10 15:47:58 -07005020
Herbert Xub63365a2008-10-23 01:11:29 -07005021 one |= NETIF_F_ALL_CSUM;
Herbert Xu7f353bf2007-08-10 15:47:58 -07005022
Herbert Xub63365a2008-10-23 01:11:29 -07005023 one |= all & NETIF_F_ONE_FOR_ALL;
5024 all &= one | NETIF_F_LLTX | NETIF_F_GSO;
5025 all |= one & mask & NETIF_F_ONE_FOR_ALL;
Herbert Xu7f353bf2007-08-10 15:47:58 -07005026
5027 return all;
5028}
Herbert Xub63365a2008-10-23 01:11:29 -07005029EXPORT_SYMBOL(netdev_increment_features);
Herbert Xu7f353bf2007-08-10 15:47:58 -07005030
Pavel Emelyanov30d97d32007-09-16 15:40:33 -07005031static struct hlist_head *netdev_create_hash(void)
5032{
5033 int i;
5034 struct hlist_head *hash;
5035
5036 hash = kmalloc(sizeof(*hash) * NETDEV_HASHENTRIES, GFP_KERNEL);
5037 if (hash != NULL)
5038 for (i = 0; i < NETDEV_HASHENTRIES; i++)
5039 INIT_HLIST_HEAD(&hash[i]);
5040
5041 return hash;
5042}
5043
Eric W. Biederman881d9662007-09-17 11:56:21 -07005044/* Initialize per network namespace state */
Pavel Emelyanov46650792007-10-08 20:38:39 -07005045static int __net_init netdev_init(struct net *net)
Eric W. Biederman881d9662007-09-17 11:56:21 -07005046{
Eric W. Biederman881d9662007-09-17 11:56:21 -07005047 INIT_LIST_HEAD(&net->dev_base_head);
Eric W. Biederman881d9662007-09-17 11:56:21 -07005048
Pavel Emelyanov30d97d32007-09-16 15:40:33 -07005049 net->dev_name_head = netdev_create_hash();
5050 if (net->dev_name_head == NULL)
5051 goto err_name;
Eric W. Biederman881d9662007-09-17 11:56:21 -07005052
Pavel Emelyanov30d97d32007-09-16 15:40:33 -07005053 net->dev_index_head = netdev_create_hash();
5054 if (net->dev_index_head == NULL)
5055 goto err_idx;
Eric W. Biederman881d9662007-09-17 11:56:21 -07005056
5057 return 0;
Pavel Emelyanov30d97d32007-09-16 15:40:33 -07005058
5059err_idx:
5060 kfree(net->dev_name_head);
5061err_name:
5062 return -ENOMEM;
Eric W. Biederman881d9662007-09-17 11:56:21 -07005063}
5064
Stephen Hemmingerf0db2752008-09-30 02:23:58 -07005065/**
5066 * netdev_drivername - network driver for the device
5067 * @dev: network device
5068 * @buffer: buffer for resulting name
5069 * @len: size of buffer
5070 *
5071 * Determine network driver for device.
5072 */
Stephen Hemmingercf04a4c72008-09-30 02:22:14 -07005073char *netdev_drivername(const struct net_device *dev, char *buffer, int len)
Arjan van de Ven6579e572008-07-21 13:31:48 -07005074{
Stephen Hemmingercf04a4c72008-09-30 02:22:14 -07005075 const struct device_driver *driver;
5076 const struct device *parent;
Arjan van de Ven6579e572008-07-21 13:31:48 -07005077
5078 if (len <= 0 || !buffer)
5079 return buffer;
5080 buffer[0] = 0;
5081
5082 parent = dev->dev.parent;
5083
5084 if (!parent)
5085 return buffer;
5086
5087 driver = parent->driver;
5088 if (driver && driver->name)
5089 strlcpy(buffer, driver->name, len);
5090 return buffer;
5091}
5092
Pavel Emelyanov46650792007-10-08 20:38:39 -07005093static void __net_exit netdev_exit(struct net *net)
Eric W. Biederman881d9662007-09-17 11:56:21 -07005094{
5095 kfree(net->dev_name_head);
5096 kfree(net->dev_index_head);
5097}
5098
Denis V. Lunev022cbae2007-11-13 03:23:50 -08005099static struct pernet_operations __net_initdata netdev_net_ops = {
Eric W. Biederman881d9662007-09-17 11:56:21 -07005100 .init = netdev_init,
5101 .exit = netdev_exit,
5102};
5103
Pavel Emelyanov46650792007-10-08 20:38:39 -07005104static void __net_exit default_device_exit(struct net *net)
Eric W. Biedermance286d32007-09-12 13:53:49 +02005105{
Eric W. Biederman8eb79862008-12-29 18:21:48 -08005106 struct net_device *dev;
Eric W. Biedermance286d32007-09-12 13:53:49 +02005107 /*
5108 * Push all migratable of the network devices back to the
5109 * initial network namespace
5110 */
5111 rtnl_lock();
Eric W. Biederman8eb79862008-12-29 18:21:48 -08005112restart:
5113 for_each_netdev(net, dev) {
Eric W. Biedermance286d32007-09-12 13:53:49 +02005114 int err;
Pavel Emelyanovaca51392008-05-08 01:24:25 -07005115 char fb_name[IFNAMSIZ];
Eric W. Biedermance286d32007-09-12 13:53:49 +02005116
5117 /* Ignore unmoveable devices (i.e. loopback) */
5118 if (dev->features & NETIF_F_NETNS_LOCAL)
5119 continue;
5120
Eric W. Biedermand0c082c2008-11-05 15:59:38 -08005121 /* Delete virtual devices */
5122 if (dev->rtnl_link_ops && dev->rtnl_link_ops->dellink) {
5123 dev->rtnl_link_ops->dellink(dev);
Eric W. Biederman8eb79862008-12-29 18:21:48 -08005124 goto restart;
Eric W. Biedermand0c082c2008-11-05 15:59:38 -08005125 }
5126
Eric W. Biedermance286d32007-09-12 13:53:49 +02005127 /* Push remaing network devices to init_net */
Pavel Emelyanovaca51392008-05-08 01:24:25 -07005128 snprintf(fb_name, IFNAMSIZ, "dev%d", dev->ifindex);
5129 err = dev_change_net_namespace(dev, &init_net, fb_name);
Eric W. Biedermance286d32007-09-12 13:53:49 +02005130 if (err) {
Pavel Emelyanovaca51392008-05-08 01:24:25 -07005131 printk(KERN_EMERG "%s: failed to move %s to init_net: %d\n",
Eric W. Biedermance286d32007-09-12 13:53:49 +02005132 __func__, dev->name, err);
Pavel Emelyanovaca51392008-05-08 01:24:25 -07005133 BUG();
Eric W. Biedermance286d32007-09-12 13:53:49 +02005134 }
Eric W. Biederman8eb79862008-12-29 18:21:48 -08005135 goto restart;
Eric W. Biedermance286d32007-09-12 13:53:49 +02005136 }
5137 rtnl_unlock();
5138}
5139
Denis V. Lunev022cbae2007-11-13 03:23:50 -08005140static struct pernet_operations __net_initdata default_device_ops = {
Eric W. Biedermance286d32007-09-12 13:53:49 +02005141 .exit = default_device_exit,
5142};
5143
Linus Torvalds1da177e2005-04-16 15:20:36 -07005144/*
5145 * Initialize the DEV module. At boot time this walks the device list and
5146 * unhooks any devices that fail to initialise (normally hardware not
5147 * present) and leaves us with a valid list of present and active devices.
5148 *
5149 */
5150
5151/*
5152 * This is called single threaded during boot, so no need
5153 * to take the rtnl semaphore.
5154 */
5155static int __init net_dev_init(void)
5156{
5157 int i, rc = -ENOMEM;
5158
5159 BUG_ON(!dev_boot_phase);
5160
Linus Torvalds1da177e2005-04-16 15:20:36 -07005161 if (dev_proc_init())
5162 goto out;
5163
Eric W. Biederman8b41d182007-09-26 22:02:53 -07005164 if (netdev_kobject_init())
Linus Torvalds1da177e2005-04-16 15:20:36 -07005165 goto out;
5166
5167 INIT_LIST_HEAD(&ptype_all);
Pavel Emelyanov82d8a8672007-11-26 20:12:58 +08005168 for (i = 0; i < PTYPE_HASH_SIZE; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005169 INIT_LIST_HEAD(&ptype_base[i]);
5170
Eric W. Biederman881d9662007-09-17 11:56:21 -07005171 if (register_pernet_subsys(&netdev_net_ops))
5172 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005173
5174 /*
5175 * Initialise the packet receive queues.
5176 */
5177
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -07005178 for_each_possible_cpu(i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005179 struct softnet_data *queue;
5180
5181 queue = &per_cpu(softnet_data, i);
5182 skb_queue_head_init(&queue->input_pkt_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005183 queue->completion_queue = NULL;
5184 INIT_LIST_HEAD(&queue->poll_list);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07005185
5186 queue->backlog.poll = process_backlog;
5187 queue->backlog.weight = weight_p;
Herbert Xud565b0a2008-12-15 23:38:52 -08005188 queue->backlog.gro_list = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005189 }
5190
Linus Torvalds1da177e2005-04-16 15:20:36 -07005191 dev_boot_phase = 0;
5192
Eric W. Biederman505d4f72008-11-07 22:54:20 -08005193 /* The loopback device is special if any other network devices
5194 * is present in a network namespace the loopback device must
5195 * be present. Since we now dynamically allocate and free the
5196 * loopback device ensure this invariant is maintained by
5197 * keeping the loopback device as the first device on the
5198 * list of network devices. Ensuring the loopback devices
5199 * is the first device that appears and the last network device
5200 * that disappears.
5201 */
5202 if (register_pernet_device(&loopback_net_ops))
5203 goto out;
5204
5205 if (register_pernet_device(&default_device_ops))
5206 goto out;
5207
Carlos R. Mafra962cf362008-05-15 11:15:37 -03005208 open_softirq(NET_TX_SOFTIRQ, net_tx_action);
5209 open_softirq(NET_RX_SOFTIRQ, net_rx_action);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005210
5211 hotcpu_notifier(dev_cpu_callback, 0);
5212 dst_init();
5213 dev_mcast_init();
5214 rc = 0;
5215out:
5216 return rc;
5217}
5218
5219subsys_initcall(net_dev_init);
5220
5221EXPORT_SYMBOL(__dev_get_by_index);
5222EXPORT_SYMBOL(__dev_get_by_name);
5223EXPORT_SYMBOL(__dev_remove_pack);
Mitch Williamsc2373ee2005-11-09 10:34:45 -08005224EXPORT_SYMBOL(dev_valid_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005225EXPORT_SYMBOL(dev_add_pack);
5226EXPORT_SYMBOL(dev_alloc_name);
5227EXPORT_SYMBOL(dev_close);
5228EXPORT_SYMBOL(dev_get_by_flags);
5229EXPORT_SYMBOL(dev_get_by_index);
5230EXPORT_SYMBOL(dev_get_by_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005231EXPORT_SYMBOL(dev_open);
5232EXPORT_SYMBOL(dev_queue_xmit);
5233EXPORT_SYMBOL(dev_remove_pack);
5234EXPORT_SYMBOL(dev_set_allmulti);
5235EXPORT_SYMBOL(dev_set_promiscuity);
5236EXPORT_SYMBOL(dev_change_flags);
5237EXPORT_SYMBOL(dev_set_mtu);
5238EXPORT_SYMBOL(dev_set_mac_address);
5239EXPORT_SYMBOL(free_netdev);
5240EXPORT_SYMBOL(netdev_boot_setup_check);
5241EXPORT_SYMBOL(netdev_set_master);
5242EXPORT_SYMBOL(netdev_state_change);
5243EXPORT_SYMBOL(netif_receive_skb);
5244EXPORT_SYMBOL(netif_rx);
5245EXPORT_SYMBOL(register_gifconf);
5246EXPORT_SYMBOL(register_netdevice);
5247EXPORT_SYMBOL(register_netdevice_notifier);
5248EXPORT_SYMBOL(skb_checksum_help);
5249EXPORT_SYMBOL(synchronize_net);
5250EXPORT_SYMBOL(unregister_netdevice);
5251EXPORT_SYMBOL(unregister_netdevice_notifier);
5252EXPORT_SYMBOL(net_enable_timestamp);
5253EXPORT_SYMBOL(net_disable_timestamp);
5254EXPORT_SYMBOL(dev_get_flags);
5255
5256#if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
5257EXPORT_SYMBOL(br_handle_frame_hook);
5258EXPORT_SYMBOL(br_fdb_get_hook);
5259EXPORT_SYMBOL(br_fdb_put_hook);
5260#endif
5261
Linus Torvalds1da177e2005-04-16 15:20:36 -07005262EXPORT_SYMBOL(dev_load);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005263
5264EXPORT_PER_CPU_SYMBOL(softnet_data);