dev.c 148 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
9
/*
 * 	NET3	Protocol independent device support routines.
 *
 *		This program is free software; you can redistribute it and/or
 *		modify it under the terms of the GNU General Public License
 *		as published by the Free Software Foundation; either version
 *		2 of the License, or (at your option) any later version.
 *
 *	Derived from the non IP parts of dev.c 1.0.19
10
 * 		Authors:	Ross Biro
Linus Torvalds's avatar
Linus Torvalds committed
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 *				Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
 *				Mark Evans, <evansmp@uhura.aston.ac.uk>
 *
 *	Additional Authors:
 *		Florian la Roche <rzsfl@rz.uni-sb.de>
 *		Alan Cox <gw4pts@gw4pts.ampr.org>
 *		David Hinds <dahinds@users.sourceforge.net>
 *		Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
 *		Adam Sulmicki <adam@cfar.umd.edu>
 *              Pekka Riikonen <priikone@poesidon.pspt.fi>
 *
 *	Changes:
 *              D.J. Barrow     :       Fixed bug where dev->refcnt gets set
 *              			to 2 if register_netdev gets called
 *              			before net_dev_init & also removed a
 *              			few lines of code in the process.
 *		Alan Cox	:	device private ioctl copies fields back.
 *		Alan Cox	:	Transmit queue code does relevant
 *					stunts to keep the queue safe.
 *		Alan Cox	:	Fixed double lock.
 *		Alan Cox	:	Fixed promisc NULL pointer trap
 *		????????	:	Support the full private ioctl range
 *		Alan Cox	:	Moved ioctl permission check into
 *					drivers
 *		Tim Kordas	:	SIOCADDMULTI/SIOCDELMULTI
 *		Alan Cox	:	100 backlog just doesn't cut it when
 *					you start doing multicast video 8)
 *		Alan Cox	:	Rewrote net_bh and list manager.
 *		Alan Cox	: 	Fix ETH_P_ALL echoback lengths.
 *		Alan Cox	:	Took out transmit every packet pass
 *					Saved a few bytes in the ioctl handler
 *		Alan Cox	:	Network driver sets packet type before
 *					calling netif_rx. Saves a function
 *					call a packet.
 *		Alan Cox	:	Hashed net_bh()
 *		Richard Kooijman:	Timestamp fixes.
 *		Alan Cox	:	Wrong field in SIOCGIFDSTADDR
 *		Alan Cox	:	Device lock protection.
 *		Alan Cox	: 	Fixed nasty side effect of device close
 *					changes.
 *		Rudi Cilibrasi	:	Pass the right thing to
 *					set_mac_address()
 *		Dave Miller	:	32bit quantity for the device lock to
 *					make it work out on a Sparc.
 *		Bjorn Ekwall	:	Added KERNELD hack.
 *		Alan Cox	:	Cleaned up the backlog initialise.
 *		Craig Metz	:	SIOCGIFCONF fix if space for under
 *					1 device.
 *	    Thomas Bogendoerfer :	Return ENODEV for dev_open, if there
 *					is no device open function.
 *		Andi Kleen	:	Fix error reporting for SIOCGIFCONF
 *	    Michael Chastain	:	Fix signed/unsigned for SIOCGIFCONF
 *		Cyrus Durgin	:	Cleaned for KMOD
 *		Adam Sulmicki   :	Bug Fix : Network Device Unload
 *					A network device unload needs to purge
 *					the backlog queue.
 *	Paul Rusty Russell	:	SIOCSIFNAME
 *              Pekka Riikonen  :	Netdev boot-time settings code
 *              Andrew Morton   :       Make unregister_netdevice wait
 *              			indefinitely on dev->refcnt
 * 		J Hadi Salim	:	- Backlog queue sampling
 *				        - netif_rx() feedback
 */

#include <asm/uaccess.h>
#include <asm/system.h>
#include <linux/bitops.h>
78
#include <linux/capability.h>
Linus Torvalds's avatar
Linus Torvalds committed
79
80
81
#include <linux/cpu.h>
#include <linux/types.h>
#include <linux/kernel.h>
82
#include <linux/hash.h>
83
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
84
#include <linux/sched.h>
Arjan van de Ven's avatar
Arjan van de Ven committed
85
#include <linux/mutex.h>
Linus Torvalds's avatar
Linus Torvalds committed
86
87
88
89
90
91
92
93
94
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/if_ether.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
95
#include <linux/ethtool.h>
Linus Torvalds's avatar
Linus Torvalds committed
96
97
#include <linux/notifier.h>
#include <linux/skbuff.h>
98
#include <net/net_namespace.h>
Linus Torvalds's avatar
Linus Torvalds committed
99
100
101
102
103
104
105
106
#include <net/sock.h>
#include <linux/rtnetlink.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <net/dst.h>
#include <net/pkt_sched.h>
#include <net/checksum.h>
107
#include <net/xfrm.h>
Linus Torvalds's avatar
Linus Torvalds committed
108
109
110
111
112
113
114
#include <linux/highmem.h>
#include <linux/init.h>
#include <linux/kmod.h>
#include <linux/module.h>
#include <linux/netpoll.h>
#include <linux/rcupdate.h>
#include <linux/delay.h>
115
#include <net/wext.h>
Linus Torvalds's avatar
Linus Torvalds committed
116
117
#include <net/iw_handler.h>
#include <asm/current.h>
Steve Grubb's avatar
Steve Grubb committed
118
#include <linux/audit.h>
119
#include <linux/dmaengine.h>
120
#include <linux/err.h>
121
#include <linux/ctype.h>
122
#include <linux/if_arp.h>
123
#include <linux/if_vlan.h>
124
#include <linux/ip.h>
125
#include <net/ip.h>
126
127
#include <linux/ipv6.h>
#include <linux/in.h>
128
129
#include <linux/jhash.h>
#include <linux/random.h>
130
#include <trace/events/napi.h>
131
#include <linux/pci.h>
132
#include <linux/inetdevice.h>
Linus Torvalds's avatar
Linus Torvalds committed
133

134
135
#include "net-sysfs.h"

136
137
138
/* Instead of increasing this, you should create a hash table. */
#define MAX_GRO_SKBS 8

Herbert Xu's avatar
Herbert Xu committed
139
140
141
/* This should be increased if a protocol with a bigger head is added. */
#define GRO_MAX_HEAD (MAX_HEADER + 128)

Linus Torvalds's avatar
Linus Torvalds committed
142
143
144
145
146
147
148
149
150
151
152
/*
 *	The list of packet types we will receive (as opposed to discard)
 *	and the routines to invoke.
 *
 *	Why 16. Because with 16 the only overlap we get on a hash of the
 *	low nibble of the protocol value is RARP/SNAP/X.25.
 *
 *      NOTE:  That is no longer true with the addition of VLAN tags.  Not
 *             sure which should go first, but I bet it won't make much
 *             difference if we are running VLANs.  The good news is that
 *             this protocol won't be in the list unless compiled in, so
Stephen Hemminger's avatar
Stephen Hemminger committed
153
 *             the average user (w/out VLANs) will not be adversely affected.
Linus Torvalds's avatar
Linus Torvalds committed
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
 *             --BLG
 *
 *		0800	IP
 *		8100    802.1Q VLAN
 *		0001	802.3
 *		0002	AX.25
 *		0004	802.2
 *		8035	RARP
 *		0005	SNAP
 *		0805	X.25
 *		0806	ARP
 *		8137	IPX
 *		0009	Localtalk
 *		86DD	IPv6
 */

170
171
172
#define PTYPE_HASH_SIZE	(16)
#define PTYPE_HASH_MASK	(PTYPE_HASH_SIZE - 1)

Linus Torvalds's avatar
Linus Torvalds committed
173
static DEFINE_SPINLOCK(ptype_lock);
174
static struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
175
static struct list_head ptype_all __read_mostly;	/* Taps */
Linus Torvalds's avatar
Linus Torvalds committed
176
177

/*
178
 * The @dev_base_head list is protected by @dev_base_lock and the rtnl
Linus Torvalds's avatar
Linus Torvalds committed
179
180
 * semaphore.
 *
181
 * Pure readers hold dev_base_lock for reading, or rcu_read_lock()
Linus Torvalds's avatar
Linus Torvalds committed
182
183
 *
 * Writers must hold the rtnl semaphore while they loop through the
184
 * dev_base_head list, and hold dev_base_lock for writing when they do the
Linus Torvalds's avatar
Linus Torvalds committed
185
186
187
188
189
190
191
192
193
194
195
196
197
198
 * actual updates.  This allows pure readers to access the list even
 * while a writer is preparing to update it.
 *
 * To put it another way, dev_base_lock is held for writing only to
 * protect against pure readers; the rtnl semaphore provides the
 * protection against other writers.
 *
 * See, for example usages, register_netdevice() and
 * unregister_netdevice(), which must be called with the rtnl
 * semaphore held.
 */
DEFINE_RWLOCK(dev_base_lock);
EXPORT_SYMBOL(dev_base_lock);

199
static inline struct hlist_head *dev_name_hash(struct net *net, const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
200
201
{
	unsigned hash = full_name_hash(name, strnlen(name, IFNAMSIZ));
202
	return &net->dev_name_head[hash_32(hash, NETDEV_HASHBITS)];
Linus Torvalds's avatar
Linus Torvalds committed
203
204
}

205
static inline struct hlist_head *dev_index_hash(struct net *net, int ifindex)
Linus Torvalds's avatar
Linus Torvalds committed
206
{
207
	return &net->dev_index_head[ifindex & (NETDEV_HASHENTRIES - 1)];
Linus Torvalds's avatar
Linus Torvalds committed
208
209
}

Eric Dumazet's avatar
Eric Dumazet committed
210
static inline void rps_lock(struct softnet_data *sd)
211
212
{
#ifdef CONFIG_RPS
Eric Dumazet's avatar
Eric Dumazet committed
213
	spin_lock(&sd->input_pkt_queue.lock);
214
215
216
#endif
}

Eric Dumazet's avatar
Eric Dumazet committed
217
static inline void rps_unlock(struct softnet_data *sd)
218
219
{
#ifdef CONFIG_RPS
Eric Dumazet's avatar
Eric Dumazet committed
220
	spin_unlock(&sd->input_pkt_queue.lock);
221
222
223
#endif
}

224
225
226
/* Device list insertion */
static int list_netdevice(struct net_device *dev)
{
227
	struct net *net = dev_net(dev);
228
229
230
231

	ASSERT_RTNL();

	write_lock_bh(&dev_base_lock);
232
	list_add_tail_rcu(&dev->dev_list, &net->dev_base_head);
233
	hlist_add_head_rcu(&dev->name_hlist, dev_name_hash(net, dev->name));
234
235
	hlist_add_head_rcu(&dev->index_hlist,
			   dev_index_hash(net, dev->ifindex));
236
237
238
239
	write_unlock_bh(&dev_base_lock);
	return 0;
}

240
241
242
/* Device list removal
 * caller must respect a RCU grace period before freeing/reusing dev
 */
243
244
245
246
247
248
static void unlist_netdevice(struct net_device *dev)
{
	ASSERT_RTNL();

	/* Unlink dev from the device chain */
	write_lock_bh(&dev_base_lock);
249
	list_del_rcu(&dev->dev_list);
250
	hlist_del_rcu(&dev->name_hlist);
251
	hlist_del_rcu(&dev->index_hlist);
252
253
254
	write_unlock_bh(&dev_base_lock);
}

Linus Torvalds's avatar
Linus Torvalds committed
255
256
257
258
/*
 *	Our notifier list
 */

259
static RAW_NOTIFIER_HEAD(netdev_chain);
Linus Torvalds's avatar
Linus Torvalds committed
260
261
262
263
264

/*
 *	Device drivers call our routines to queue packets here. We empty the
 *	queue in the local softnet handler.
 */
265

266
DEFINE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
Eric Dumazet's avatar
Eric Dumazet committed
267
EXPORT_PER_CPU_SYMBOL(softnet_data);
Linus Torvalds's avatar
Linus Torvalds committed
268

269
#ifdef CONFIG_LOCKDEP
270
/*
271
 * register_netdevice() inits txq->_xmit_lock and sets lockdep class
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
 * according to dev->type
 */
static const unsigned short netdev_lock_type[] =
	{ARPHRD_NETROM, ARPHRD_ETHER, ARPHRD_EETHER, ARPHRD_AX25,
	 ARPHRD_PRONET, ARPHRD_CHAOS, ARPHRD_IEEE802, ARPHRD_ARCNET,
	 ARPHRD_APPLETLK, ARPHRD_DLCI, ARPHRD_ATM, ARPHRD_METRICOM,
	 ARPHRD_IEEE1394, ARPHRD_EUI64, ARPHRD_INFINIBAND, ARPHRD_SLIP,
	 ARPHRD_CSLIP, ARPHRD_SLIP6, ARPHRD_CSLIP6, ARPHRD_RSRVD,
	 ARPHRD_ADAPT, ARPHRD_ROSE, ARPHRD_X25, ARPHRD_HWX25,
	 ARPHRD_PPP, ARPHRD_CISCO, ARPHRD_LAPB, ARPHRD_DDCMP,
	 ARPHRD_RAWHDLC, ARPHRD_TUNNEL, ARPHRD_TUNNEL6, ARPHRD_FRAD,
	 ARPHRD_SKIP, ARPHRD_LOOPBACK, ARPHRD_LOCALTLK, ARPHRD_FDDI,
	 ARPHRD_BIF, ARPHRD_SIT, ARPHRD_IPDDP, ARPHRD_IPGRE,
	 ARPHRD_PIMREG, ARPHRD_HIPPI, ARPHRD_ASH, ARPHRD_ECONET,
	 ARPHRD_IRDA, ARPHRD_FCPP, ARPHRD_FCAL, ARPHRD_FCPL,
	 ARPHRD_FCFABRIC, ARPHRD_IEEE802_TR, ARPHRD_IEEE80211,
288
	 ARPHRD_IEEE80211_PRISM, ARPHRD_IEEE80211_RADIOTAP, ARPHRD_PHONET,
289
	 ARPHRD_PHONET_PIPE, ARPHRD_IEEE802154,
290
	 ARPHRD_VOID, ARPHRD_NONE};
291

292
static const char *const netdev_lock_name[] =
293
294
295
296
297
298
299
300
301
302
303
304
305
	{"_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25",
	 "_xmit_PRONET", "_xmit_CHAOS", "_xmit_IEEE802", "_xmit_ARCNET",
	 "_xmit_APPLETLK", "_xmit_DLCI", "_xmit_ATM", "_xmit_METRICOM",
	 "_xmit_IEEE1394", "_xmit_EUI64", "_xmit_INFINIBAND", "_xmit_SLIP",
	 "_xmit_CSLIP", "_xmit_SLIP6", "_xmit_CSLIP6", "_xmit_RSRVD",
	 "_xmit_ADAPT", "_xmit_ROSE", "_xmit_X25", "_xmit_HWX25",
	 "_xmit_PPP", "_xmit_CISCO", "_xmit_LAPB", "_xmit_DDCMP",
	 "_xmit_RAWHDLC", "_xmit_TUNNEL", "_xmit_TUNNEL6", "_xmit_FRAD",
	 "_xmit_SKIP", "_xmit_LOOPBACK", "_xmit_LOCALTLK", "_xmit_FDDI",
	 "_xmit_BIF", "_xmit_SIT", "_xmit_IPDDP", "_xmit_IPGRE",
	 "_xmit_PIMREG", "_xmit_HIPPI", "_xmit_ASH", "_xmit_ECONET",
	 "_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL",
	 "_xmit_FCFABRIC", "_xmit_IEEE802_TR", "_xmit_IEEE80211",
306
	 "_xmit_IEEE80211_PRISM", "_xmit_IEEE80211_RADIOTAP", "_xmit_PHONET",
307
	 "_xmit_PHONET_PIPE", "_xmit_IEEE802154",
308
	 "_xmit_VOID", "_xmit_NONE"};
309
310

static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
311
static struct lock_class_key netdev_addr_lock_key[ARRAY_SIZE(netdev_lock_type)];
312
313
314
315
316
317
318
319
320
321
322
323

static inline unsigned short netdev_lock_pos(unsigned short dev_type)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(netdev_lock_type); i++)
		if (netdev_lock_type[i] == dev_type)
			return i;
	/* the last key is used by default */
	return ARRAY_SIZE(netdev_lock_type) - 1;
}

324
325
static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
						 unsigned short dev_type)
326
327
328
329
330
331
332
{
	int i;

	i = netdev_lock_pos(dev_type);
	lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i],
				   netdev_lock_name[i]);
}
333
334
335
336
337
338
339
340
341
342

static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
{
	int i;

	i = netdev_lock_pos(dev->type);
	lockdep_set_class_and_name(&dev->addr_list_lock,
				   &netdev_addr_lock_key[i],
				   netdev_lock_name[i]);
}
343
#else
344
345
346
347
348
static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
						 unsigned short dev_type)
{
}
static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
349
350
351
{
}
#endif
Linus Torvalds's avatar
Linus Torvalds committed
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374

/*******************************************************************************

		Protocol management and registration routines

*******************************************************************************/

/*
 *	Add a protocol ID to the list. Now that the input handler is
 *	smarter we can dispense with all the messy stuff that used to be
 *	here.
 *
 *	BEWARE!!! Protocol handlers, mangling input packets,
 *	MUST BE last in hash buckets and checking protocol handlers
 *	MUST start from promiscuous ptype_all chain in net_bh.
 *	It is true now, do not change it.
 *	Explanation follows: if protocol handler, mangling packet, will
 *	be the first on list, it is not able to sense, that packet
 *	is cloned and should be copied-on-write, so that it will
 *	change it and subsequent readers will get broken packet.
 *							--ANK (980803)
 */

375
376
377
378
379
380
381
382
static inline struct list_head *ptype_head(const struct packet_type *pt)
{
	if (pt->type == htons(ETH_P_ALL))
		return &ptype_all;
	else
		return &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK];
}

Linus Torvalds's avatar
Linus Torvalds committed
383
384
385
386
387
388
389
390
/**
 *	dev_add_pack - add packet handler
 *	@pt: packet type declaration
 *
 *	Add a protocol handler to the networking stack. The passed &packet_type
 *	is linked into kernel lists and may not be freed until it has been
 *	removed from the kernel lists.
 *
391
 *	This call does not sleep therefore it can not
Linus Torvalds's avatar
Linus Torvalds committed
392
393
394
395
396
397
 *	guarantee all CPU's that are in middle of receiving packets
 *	will see the new packet type (until the next received packet).
 */

void dev_add_pack(struct packet_type *pt)
{
398
	struct list_head *head = ptype_head(pt);
Linus Torvalds's avatar
Linus Torvalds committed
399

400
401
402
	spin_lock(&ptype_lock);
	list_add_rcu(&pt->list, head);
	spin_unlock(&ptype_lock);
Linus Torvalds's avatar
Linus Torvalds committed
403
}
Eric Dumazet's avatar
Eric Dumazet committed
404
EXPORT_SYMBOL(dev_add_pack);
Linus Torvalds's avatar
Linus Torvalds committed
405
406
407
408
409
410
411
412

/**
 *	__dev_remove_pack	 - remove packet handler
 *	@pt: packet type declaration
 *
 *	Remove a protocol handler that was previously added to the kernel
 *	protocol handlers by dev_add_pack(). The passed &packet_type is removed
 *	from the kernel lists and can be freed or reused once this function
413
 *	returns.
Linus Torvalds's avatar
Linus Torvalds committed
414
415
416
417
418
419
420
 *
 *      The packet type might still be in use by receivers
 *	and must not be freed until after all the CPU's have gone
 *	through a quiescent state.
 */
void __dev_remove_pack(struct packet_type *pt)
{
421
	struct list_head *head = ptype_head(pt);
Linus Torvalds's avatar
Linus Torvalds committed
422
423
	struct packet_type *pt1;

424
	spin_lock(&ptype_lock);
Linus Torvalds's avatar
Linus Torvalds committed
425
426
427
428
429
430
431
432
433
434

	list_for_each_entry(pt1, head, list) {
		if (pt == pt1) {
			list_del_rcu(&pt->list);
			goto out;
		}
	}

	printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt);
out:
435
	spin_unlock(&ptype_lock);
Linus Torvalds's avatar
Linus Torvalds committed
436
}
Eric Dumazet's avatar
Eric Dumazet committed
437
438
EXPORT_SYMBOL(__dev_remove_pack);

Linus Torvalds's avatar
Linus Torvalds committed
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
/**
 *	dev_remove_pack	 - remove packet handler
 *	@pt: packet type declaration
 *
 *	Remove a protocol handler that was previously added to the kernel
 *	protocol handlers by dev_add_pack(). The passed &packet_type is removed
 *	from the kernel lists and can be freed or reused once this function
 *	returns.
 *
 *	This call sleeps to guarantee that no CPU is looking at the packet
 *	type after return.
 */
void dev_remove_pack(struct packet_type *pt)
{
	__dev_remove_pack(pt);
454

Linus Torvalds's avatar
Linus Torvalds committed
455
456
	synchronize_net();
}
Eric Dumazet's avatar
Eric Dumazet committed
457
EXPORT_SYMBOL(dev_remove_pack);
Linus Torvalds's avatar
Linus Torvalds committed
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485

/******************************************************************************

		      Device Boot-time Settings Routines

*******************************************************************************/

/* Boot time configuration table */
static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX];

/**
 *	netdev_boot_setup_add	- add new setup entry
 *	@name: name of the device
 *	@map: configured settings for the device
 *
 *	Adds new setup entry to the dev_boot_setup list.  The function
 *	returns 0 on error and 1 on success.  This is a generic routine to
 *	all netdevices.
 */
static int netdev_boot_setup_add(char *name, struct ifmap *map)
{
	struct netdev_boot_setup *s;
	int i;

	s = dev_boot_setup;
	for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
		if (s[i].name[0] == '\0' || s[i].name[0] == ' ') {
			memset(s[i].name, 0, sizeof(s[i].name));
486
			strlcpy(s[i].name, name, IFNAMSIZ);
Linus Torvalds's avatar
Linus Torvalds committed
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
			memcpy(&s[i].map, map, sizeof(s[i].map));
			break;
		}
	}

	return i >= NETDEV_BOOT_SETUP_MAX ? 0 : 1;
}

/**
 *	netdev_boot_setup_check	- check boot time settings
 *	@dev: the netdevice
 *
 * 	Check boot time settings for the device.
 *	The found settings are set for the device to be used
 *	later in the device probing.
 *	Returns 0 if no settings found, 1 if they are.
 */
int netdev_boot_setup_check(struct net_device *dev)
{
	struct netdev_boot_setup *s = dev_boot_setup;
	int i;

	for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
		if (s[i].name[0] != '\0' && s[i].name[0] != ' ' &&
511
		    !strcmp(dev->name, s[i].name)) {
Linus Torvalds's avatar
Linus Torvalds committed
512
513
514
515
516
517
518
519
520
			dev->irq 	= s[i].map.irq;
			dev->base_addr 	= s[i].map.base_addr;
			dev->mem_start 	= s[i].map.mem_start;
			dev->mem_end 	= s[i].map.mem_end;
			return 1;
		}
	}
	return 0;
}
Eric Dumazet's avatar
Eric Dumazet committed
521
EXPORT_SYMBOL(netdev_boot_setup_check);
Linus Torvalds's avatar
Linus Torvalds committed
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545


/**
 *	netdev_boot_base	- get address from boot time settings
 *	@prefix: prefix for network device
 *	@unit: id for network device
 *
 * 	Check boot time settings for the base address of device.
 *	The found settings are set for the device to be used
 *	later in the device probing.
 *	Returns 0 if no settings found.
 */
unsigned long netdev_boot_base(const char *prefix, int unit)
{
	const struct netdev_boot_setup *s = dev_boot_setup;
	char name[IFNAMSIZ];
	int i;

	sprintf(name, "%s%d", prefix, unit);

	/*
	 * If device already registered then return base of 1
	 * to indicate not to probe for this interface
	 */
546
	if (__dev_get_by_name(&init_net, name))
Linus Torvalds's avatar
Linus Torvalds committed
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
		return 1;

	for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
		if (!strcmp(name, s[i].name))
			return s[i].map.base_addr;
	return 0;
}

/*
 * Saves at boot time configured settings for any netdevice.
 */
int __init netdev_boot_setup(char *str)
{
	int ints[5];
	struct ifmap map;

	str = get_options(str, ARRAY_SIZE(ints), ints);
	if (!str || !*str)
		return 0;

	/* Save settings */
	memset(&map, 0, sizeof(map));
	if (ints[0] > 0)
		map.irq = ints[1];
	if (ints[0] > 1)
		map.base_addr = ints[2];
	if (ints[0] > 2)
		map.mem_start = ints[3];
	if (ints[0] > 3)
		map.mem_end = ints[4];

	/* Add new entry to the list */
	return netdev_boot_setup_add(str, &map);
}

__setup("netdev=", netdev_boot_setup);

/*******************************************************************************

			    Device Interface Subroutines

*******************************************************************************/

/**
 *	__dev_get_by_name	- find a device by its name
592
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
593
594
595
596
597
598
599
600
601
 *	@name: name to find
 *
 *	Find an interface by name. Must be called under RTNL semaphore
 *	or @dev_base_lock. If the name is found a pointer to the device
 *	is returned. If the name is not found then %NULL is returned. The
 *	reference counters are not incremented so the caller must be
 *	careful with locks.
 */

602
struct net_device *__dev_get_by_name(struct net *net, const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
603
604
{
	struct hlist_node *p;
Eric Dumazet's avatar
Eric Dumazet committed
605
606
	struct net_device *dev;
	struct hlist_head *head = dev_name_hash(net, name);
Linus Torvalds's avatar
Linus Torvalds committed
607

Eric Dumazet's avatar
Eric Dumazet committed
608
	hlist_for_each_entry(dev, p, head, name_hlist)
Linus Torvalds's avatar
Linus Torvalds committed
609
610
		if (!strncmp(dev->name, name, IFNAMSIZ))
			return dev;
Eric Dumazet's avatar
Eric Dumazet committed
611

Linus Torvalds's avatar
Linus Torvalds committed
612
613
	return NULL;
}
Eric Dumazet's avatar
Eric Dumazet committed
614
EXPORT_SYMBOL(__dev_get_by_name);
Linus Torvalds's avatar
Linus Torvalds committed
615

616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
/**
 *	dev_get_by_name_rcu	- find a device by its name
 *	@net: the applicable net namespace
 *	@name: name to find
 *
 *	Find an interface by name.
 *	If the name is found a pointer to the device is returned.
 * 	If the name is not found then %NULL is returned.
 *	The reference counters are not incremented so the caller must be
 *	careful with locks. The caller must hold RCU lock.
 */

struct net_device *dev_get_by_name_rcu(struct net *net, const char *name)
{
	struct hlist_node *p;
	struct net_device *dev;
	struct hlist_head *head = dev_name_hash(net, name);

	hlist_for_each_entry_rcu(dev, p, head, name_hlist)
		if (!strncmp(dev->name, name, IFNAMSIZ))
			return dev;

	return NULL;
}
EXPORT_SYMBOL(dev_get_by_name_rcu);

Linus Torvalds's avatar
Linus Torvalds committed
642
643
/**
 *	dev_get_by_name		- find a device by its name
644
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
645
646
647
648
649
650
651
652
653
 *	@name: name to find
 *
 *	Find an interface by name. This can be called from any
 *	context and does its own locking. The returned handle has
 *	the usage count incremented and the caller must use dev_put() to
 *	release it when it is no longer needed. %NULL is returned if no
 *	matching device is found.
 */

654
struct net_device *dev_get_by_name(struct net *net, const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
655
656
657
{
	struct net_device *dev;

658
659
	rcu_read_lock();
	dev = dev_get_by_name_rcu(net, name);
Linus Torvalds's avatar
Linus Torvalds committed
660
661
	if (dev)
		dev_hold(dev);
662
	rcu_read_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
663
664
	return dev;
}
Eric Dumazet's avatar
Eric Dumazet committed
665
EXPORT_SYMBOL(dev_get_by_name);
Linus Torvalds's avatar
Linus Torvalds committed
666
667
668

/**
 *	__dev_get_by_index - find a device by its ifindex
669
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
670
671
672
673
674
675
676
677
678
 *	@ifindex: index of device
 *
 *	Search for an interface by index. Returns %NULL if the device
 *	is not found or a pointer to the device. The device has not
 *	had its reference counter increased so the caller must be careful
 *	about locking. The caller must hold either the RTNL semaphore
 *	or @dev_base_lock.
 */

679
struct net_device *__dev_get_by_index(struct net *net, int ifindex)
Linus Torvalds's avatar
Linus Torvalds committed
680
681
{
	struct hlist_node *p;
Eric Dumazet's avatar
Eric Dumazet committed
682
683
	struct net_device *dev;
	struct hlist_head *head = dev_index_hash(net, ifindex);
Linus Torvalds's avatar
Linus Torvalds committed
684

Eric Dumazet's avatar
Eric Dumazet committed
685
	hlist_for_each_entry(dev, p, head, index_hlist)
Linus Torvalds's avatar
Linus Torvalds committed
686
687
		if (dev->ifindex == ifindex)
			return dev;
Eric Dumazet's avatar
Eric Dumazet committed
688

Linus Torvalds's avatar
Linus Torvalds committed
689
690
	return NULL;
}
Eric Dumazet's avatar
Eric Dumazet committed
691
EXPORT_SYMBOL(__dev_get_by_index);
Linus Torvalds's avatar
Linus Torvalds committed
692

693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
/**
 *	dev_get_by_index_rcu - find a device by its ifindex
 *	@net: the applicable net namespace
 *	@ifindex: index of device
 *
 *	Search for an interface by index. Returns %NULL if the device
 *	is not found or a pointer to the device. The device has not
 *	had its reference counter increased so the caller must be careful
 *	about locking. The caller must hold RCU lock.
 */

struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex)
{
	struct hlist_node *p;
	struct net_device *dev;
	struct hlist_head *head = dev_index_hash(net, ifindex);

	hlist_for_each_entry_rcu(dev, p, head, index_hlist)
		if (dev->ifindex == ifindex)
			return dev;

	return NULL;
}
EXPORT_SYMBOL(dev_get_by_index_rcu);

Linus Torvalds's avatar
Linus Torvalds committed
718
719
720

/**
 *	dev_get_by_index - find a device by its ifindex
721
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
722
723
724
725
726
727
728
729
 *	@ifindex: index of device
 *
 *	Search for an interface by index. Returns NULL if the device
 *	is not found or a pointer to the device. The device returned has
 *	had a reference added and the pointer is safe until the user calls
 *	dev_put to indicate they have finished with it.
 */

730
struct net_device *dev_get_by_index(struct net *net, int ifindex)
Linus Torvalds's avatar
Linus Torvalds committed
731
732
733
{
	struct net_device *dev;

734
735
	rcu_read_lock();
	dev = dev_get_by_index_rcu(net, ifindex);
Linus Torvalds's avatar
Linus Torvalds committed
736
737
	if (dev)
		dev_hold(dev);
738
	rcu_read_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
739
740
	return dev;
}
Eric Dumazet's avatar
Eric Dumazet committed
741
EXPORT_SYMBOL(dev_get_by_index);
Linus Torvalds's avatar
Linus Torvalds committed
742
743
744

/**
 *	dev_getbyhwaddr - find a device by its hardware address
745
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
746
747
748
749
750
751
752
753
754
755
756
757
 *	@type: media type of device
 *	@ha: hardware address
 *
 *	Search for an interface by MAC address. Returns NULL if the device
 *	is not found or a pointer to the device. The caller must hold the
 *	rtnl semaphore. The returned device has not had its ref count increased
 *	and the caller must therefore be careful about locking
 *
 *	BUGS:
 *	If the API was consistent this would be __dev_get_by_hwaddr
 */

758
struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *ha)
Linus Torvalds's avatar
Linus Torvalds committed
759
760
761
762
763
{
	struct net_device *dev;

	ASSERT_RTNL();

764
	for_each_netdev(net, dev)
Linus Torvalds's avatar
Linus Torvalds committed
765
766
		if (dev->type == type &&
		    !memcmp(dev->dev_addr, ha, dev->addr_len))
767
768
769
			return dev;

	return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
770
}
771
772
EXPORT_SYMBOL(dev_getbyhwaddr);

773
struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
Linus Torvalds's avatar
Linus Torvalds committed
774
775
776
{
	struct net_device *dev;

777
	ASSERT_RTNL();
778
	for_each_netdev(net, dev)
779
		if (dev->type == type)
780
781
782
			return dev;

	return NULL;
783
784
785
}
EXPORT_SYMBOL(__dev_getfirstbyhwtype);

786
struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
787
{
788
	struct net_device *dev, *ret = NULL;
789

790
791
792
793
794
795
796
797
798
	rcu_read_lock();
	for_each_netdev_rcu(net, dev)
		if (dev->type == type) {
			dev_hold(dev);
			ret = dev;
			break;
		}
	rcu_read_unlock();
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
799
800
801
802
}
EXPORT_SYMBOL(dev_getfirstbyhwtype);

/**
Eric Dumazet's avatar
Eric Dumazet committed
803
 *	dev_get_by_flags_rcu - find any device with given flags
804
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
805
806
807
808
 *	@if_flags: IFF_* values
 *	@mask: bitmask of bits in if_flags to check
 *
 *	Search for any interface with the given flags. Returns NULL if a device
Eric Dumazet's avatar
Eric Dumazet committed
809
810
 *	is not found or a pointer to the device. Must be called inside
 *	rcu_read_lock(), and result refcount is unchanged.
Linus Torvalds's avatar
Linus Torvalds committed
811
812
 */

Eric Dumazet's avatar
Eric Dumazet committed
813
struct net_device *dev_get_by_flags_rcu(struct net *net, unsigned short if_flags,
Eric Dumazet's avatar
Eric Dumazet committed
814
				    unsigned short mask)
Linus Torvalds's avatar
Linus Torvalds committed
815
{
816
	struct net_device *dev, *ret;
Linus Torvalds's avatar
Linus Torvalds committed
817

818
	ret = NULL;
819
	for_each_netdev_rcu(net, dev) {
Linus Torvalds's avatar
Linus Torvalds committed
820
		if (((dev->flags ^ if_flags) & mask) == 0) {
821
			ret = dev;
Linus Torvalds's avatar
Linus Torvalds committed
822
823
824
			break;
		}
	}
825
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
826
}
Eric Dumazet's avatar
Eric Dumazet committed
827
EXPORT_SYMBOL(dev_get_by_flags_rcu);
Linus Torvalds's avatar
Linus Torvalds committed
828
829
830
831
832
833

/**
 *	dev_valid_name - check if name is okay for network device
 *	@name: name string
 *
 *	Network device names need to be valid file names to
834
835
 *	to allow sysfs to work.  We also disallow any kind of
 *	whitespace.
Linus Torvalds's avatar
Linus Torvalds committed
836
 */
837
int dev_valid_name(const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
838
{
839
840
	if (*name == '\0')
		return 0;
841
842
	if (strlen(name) >= IFNAMSIZ)
		return 0;
843
844
845
846
847
848
849
850
851
	if (!strcmp(name, ".") || !strcmp(name, ".."))
		return 0;

	while (*name) {
		if (*name == '/' || isspace(*name))
			return 0;
		name++;
	}
	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
852
}
Eric Dumazet's avatar
Eric Dumazet committed
853
EXPORT_SYMBOL(dev_valid_name);
Linus Torvalds's avatar
Linus Torvalds committed
854
855

/**
856
857
 *	__dev_alloc_name - allocate a name for a device
 *	@net: network namespace to allocate the device name in
Linus Torvalds's avatar
Linus Torvalds committed
858
 *	@name: name format string
859
 *	@buf:  scratch buffer and result name string
Linus Torvalds's avatar
Linus Torvalds committed
860
861
 *
 *	Passed a format string - eg "lt%d" it will try and find a suitable
Stephen Hemminger's avatar
Stephen Hemminger committed
862
863
864
865
866
867
 *	id. It scans list of devices to build up a free map, then chooses
 *	the first empty slot. The caller must hold the dev_base or rtnl lock
 *	while allocating the name and adding the device in order to avoid
 *	duplicates.
 *	Limited to bits_per_byte * page size devices (ie 32K on most platforms).
 *	Returns the number of the unit assigned or a negative errno code.
Linus Torvalds's avatar
Linus Torvalds committed
868
869
 */

870
static int __dev_alloc_name(struct net *net, const char *name, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
871
872
873
874
{
	int i = 0;
	const char *p;
	const int max_netdevices = 8*PAGE_SIZE;
875
	unsigned long *inuse;
Linus Torvalds's avatar
Linus Torvalds committed
876
877
878
879
880
881
882
883
884
885
886
887
888
	struct net_device *d;

	p = strnchr(name, IFNAMSIZ-1, '%');
	if (p) {
		/*
		 * Verify the string as this thing may have come from
		 * the user.  There must be either one "%d" and no other "%"
		 * characters.
		 */
		if (p[1] != 'd' || strchr(p + 2, '%'))
			return -EINVAL;

		/* Use one page as a bit array of possible slots */
889
		inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
Linus Torvalds's avatar
Linus Torvalds committed
890
891
892
		if (!inuse)
			return -ENOMEM;

893
		for_each_netdev(net, d) {
Linus Torvalds's avatar
Linus Torvalds committed
894
895
896
897
898
899
			if (!sscanf(d->name, name, &i))
				continue;
			if (i < 0 || i >= max_netdevices)
				continue;

			/*  avoid cases where sscanf is not exact inverse of printf */
900
			snprintf(buf, IFNAMSIZ, name, i);
Linus Torvalds's avatar
Linus Torvalds committed
901
902
903
904
905
906
907
908
			if (!strncmp(buf, d->name, IFNAMSIZ))
				set_bit(i, inuse);
		}

		i = find_first_zero_bit(inuse, max_netdevices);
		free_page((unsigned long) inuse);
	}

909
910
	if (buf != name)
		snprintf(buf, IFNAMSIZ, name, i);
911
	if (!__dev_get_by_name(net, buf))
Linus Torvalds's avatar
Linus Torvalds committed
912
913
914
915
916
917
918
919
920
		return i;

	/* It is possible to run out of possible slots
	 * when the name is long and there isn't enough space left
	 * for the digits, or if all bits are used.
	 */
	return -ENFILE;
}

921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
/**
 *	dev_alloc_name - allocate a name for a device
 *	@dev: device
 *	@name: name format string
 *
 *	Passed a format string - eg "lt%d" it will try and find a suitable
 *	id. It scans list of devices to build up a free map, then chooses
 *	the first empty slot. The caller must hold the dev_base or rtnl lock
 *	while allocating the name and adding the device in order to avoid
 *	duplicates.
 *	Limited to bits_per_byte * page size devices (ie 32K on most platforms).
 *	Returns the number of the unit assigned or a negative errno code.
 */

int dev_alloc_name(struct net_device *dev, const char *name)
{
	char buf[IFNAMSIZ];
	struct net *net;
	int ret;

941
942
	BUG_ON(!dev_net(dev));
	net = dev_net(dev);
943
944
945
946
947
	ret = __dev_alloc_name(net, name, buf);
	if (ret >= 0)
		strlcpy(dev->name, buf, IFNAMSIZ);
	return ret;
}
Eric Dumazet's avatar
Eric Dumazet committed
948
EXPORT_SYMBOL(dev_alloc_name);
949

950
static int dev_get_valid_name(struct net_device *dev, const char *name, bool fmt)
951
{
952
953
954
955
956
	struct net *net;

	BUG_ON(!dev_net(dev));
	net = dev_net(dev);

957
958
959
960
	if (!dev_valid_name(name))
		return -EINVAL;

	if (fmt && strchr(name, '%'))
961
		return dev_alloc_name(dev, name);
962
963
	else if (__dev_get_by_name(net, name))
		return -EEXIST;
964
965
	else if (dev->name != name)
		strlcpy(dev->name, name, IFNAMSIZ);
966
967
968

	return 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
969
970
971
972
973
974
975
976
977

/**
 *	dev_change_name - change name of a device
 *	@dev: device
 *	@newname: name (or format string) must be at least IFNAMSIZ
 *
 *	Change name of a device, can pass format strings "eth%d".
 *	for wildcarding.
 */
978
int dev_change_name(struct net_device *dev, const char *newname)
Linus Torvalds's avatar
Linus Torvalds committed
979
{
980
	char oldname[IFNAMSIZ];
Linus Torvalds's avatar
Linus Torvalds committed
981
	int err = 0;
982
	int ret;
983
	struct net *net;
Linus Torvalds's avatar
Linus Torvalds committed
984
985

	ASSERT_RTNL();
986
	BUG_ON(!dev_net(dev));
Linus Torvalds's avatar
Linus Torvalds committed
987

988
	net = dev_net(dev);
Linus Torvalds's avatar
Linus Torvalds committed
989
990
991
	if (dev->flags & IFF_UP)
		return -EBUSY;

992
993
994
	if (strncmp(newname, dev->name, IFNAMSIZ) == 0)
		return 0;

995
996
	memcpy(oldname, dev->name, IFNAMSIZ);

997
	err = dev_get_valid_name(dev, newname, 1);
998
999
	if (err < 0)
		return err;
Linus Torvalds's avatar
Linus Torvalds committed
1000

For faster browsing, not all history is shown. View entire blame