dev.c 147 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>
Linus Torvalds's avatar
Linus Torvalds committed
132

133
134
#include "net-sysfs.h"

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

Herbert Xu's avatar
Herbert Xu committed
138
139
140
/* 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
141
142
143
144
145
146
147
148
149
150
151
/*
 *	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
152
 *             the average user (w/out VLANs) will not be adversely affected.
Linus Torvalds's avatar
Linus Torvalds committed
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 *             --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
 */

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

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

/*
177
 * The @dev_base_head list is protected by @dev_base_lock and the rtnl
Linus Torvalds's avatar
Linus Torvalds committed
178
179
 * semaphore.
 *
180
 * Pure readers hold dev_base_lock for reading, or rcu_read_lock()
Linus Torvalds's avatar
Linus Torvalds committed
181
182
 *
 * Writers must hold the rtnl semaphore while they loop through the
183
 * dev_base_head list, and hold dev_base_lock for writing when they do the
Linus Torvalds's avatar
Linus Torvalds committed
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 * 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);

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

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

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

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

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

	ASSERT_RTNL();

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

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

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

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

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

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

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

268
#ifdef CONFIG_LOCKDEP
269
/*
270
 * register_netdevice() inits txq->_xmit_lock and sets lockdep class
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
 * 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,
287
	 ARPHRD_IEEE80211_PRISM, ARPHRD_IEEE80211_RADIOTAP, ARPHRD_PHONET,
288
	 ARPHRD_PHONET_PIPE, ARPHRD_IEEE802154,
289
	 ARPHRD_VOID, ARPHRD_NONE};
290

291
static const char *const netdev_lock_name[] =
292
293
294
295
296
297
298
299
300
301
302
303
304
	{"_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",
305
	 "_xmit_IEEE80211_PRISM", "_xmit_IEEE80211_RADIOTAP", "_xmit_PHONET",
306
	 "_xmit_PHONET_PIPE", "_xmit_IEEE802154",
307
	 "_xmit_VOID", "_xmit_NONE"};
308
309

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

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;
}

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

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

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]);
}
342
#else
343
344
345
346
347
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)
348
349
350
{
}
#endif
Linus Torvalds's avatar
Linus Torvalds committed
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381

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

		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)
 */

/**
 *	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.
 *
382
 *	This call does not sleep therefore it can not
Linus Torvalds's avatar
Linus Torvalds committed
383
384
385
386
387
388
389
390
391
 *	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)
{
	int hash;

	spin_lock_bh(&ptype_lock);
392
	if (pt->type == htons(ETH_P_ALL))
Linus Torvalds's avatar
Linus Torvalds committed
393
		list_add_rcu(&pt->list, &ptype_all);
394
	else {
395
		hash = ntohs(pt->type) & PTYPE_HASH_MASK;
Linus Torvalds's avatar
Linus Torvalds committed
396
397
398
399
		list_add_rcu(&pt->list, &ptype_base[hash]);
	}
	spin_unlock_bh(&ptype_lock);
}
Eric Dumazet's avatar
Eric Dumazet committed
400
EXPORT_SYMBOL(dev_add_pack);
Linus Torvalds's avatar
Linus Torvalds committed
401
402
403
404
405
406
407
408

/**
 *	__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
409
 *	returns.
Linus Torvalds's avatar
Linus Torvalds committed
410
411
412
413
414
415
416
417
418
419
420
421
 *
 *      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)
{
	struct list_head *head;
	struct packet_type *pt1;

	spin_lock_bh(&ptype_lock);

422
	if (pt->type == htons(ETH_P_ALL))
Linus Torvalds's avatar
Linus Torvalds committed
423
		head = &ptype_all;
424
	else
425
		head = &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK];
Linus Torvalds's avatar
Linus Torvalds committed
426
427
428
429
430
431
432
433
434
435
436
437

	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:
	spin_unlock_bh(&ptype_lock);
}
Eric Dumazet's avatar
Eric Dumazet committed
438
439
EXPORT_SYMBOL(__dev_remove_pack);

Linus Torvalds's avatar
Linus Torvalds committed
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
/**
 *	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);
455

Linus Torvalds's avatar
Linus Torvalds committed
456
457
	synchronize_net();
}
Eric Dumazet's avatar
Eric Dumazet committed
458
EXPORT_SYMBOL(dev_remove_pack);
Linus Torvalds's avatar
Linus Torvalds committed
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
486

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

		      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));
487
			strlcpy(s[i].name, name, IFNAMSIZ);
Linus Torvalds's avatar
Linus Torvalds committed
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
			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] != ' ' &&
512
		    !strcmp(dev->name, s[i].name)) {
Linus Torvalds's avatar
Linus Torvalds committed
513
514
515
516
517
518
519
520
521
			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
522
EXPORT_SYMBOL(netdev_boot_setup_check);
Linus Torvalds's avatar
Linus Torvalds committed
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546


/**
 *	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
	 */
547
	if (__dev_get_by_name(&init_net, name))
Linus Torvalds's avatar
Linus Torvalds committed
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
592
		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
593
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
594
595
596
597
598
599
600
601
602
 *	@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.
 */

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

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

Linus Torvalds's avatar
Linus Torvalds committed
613
614
	return NULL;
}
Eric Dumazet's avatar
Eric Dumazet committed
615
EXPORT_SYMBOL(__dev_get_by_name);
Linus Torvalds's avatar
Linus Torvalds committed
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
642
/**
 *	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
643
644
/**
 *	dev_get_by_name		- find a device by its name
645
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
646
647
648
649
650
651
652
653
654
 *	@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.
 */

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

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

/**
 *	__dev_get_by_index - find a device by its ifindex
670
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
671
672
673
674
675
676
677
678
679
 *	@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.
 */

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

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

Linus Torvalds's avatar
Linus Torvalds committed
690
691
	return NULL;
}
Eric Dumazet's avatar
Eric Dumazet committed
692
EXPORT_SYMBOL(__dev_get_by_index);
Linus Torvalds's avatar
Linus Torvalds committed
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
718
/**
 *	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
719
720
721

/**
 *	dev_get_by_index - find a device by its ifindex
722
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
723
724
725
726
727
728
729
730
 *	@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.
 */

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

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

/**
 *	dev_getbyhwaddr - find a device by its hardware address
746
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
747
748
749
750
751
752
753
754
755
756
757
758
 *	@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
 */

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

	ASSERT_RTNL();

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

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

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

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

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

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

791
792
793
794
795
796
797
798
799
	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
800
801
802
803
}
EXPORT_SYMBOL(dev_getfirstbyhwtype);

/**
Eric Dumazet's avatar
Eric Dumazet committed
804
 *	dev_get_by_flags_rcu - find any device with given flags
805
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
806
807
808
809
 *	@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
810
811
 *	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
812
813
 */

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

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

/**
 *	dev_valid_name - check if name is okay for network device
 *	@name: name string
 *
 *	Network device names need to be valid file names to
835
836
 *	to allow sysfs to work.  We also disallow any kind of
 *	whitespace.
Linus Torvalds's avatar
Linus Torvalds committed
837
 */
838
int dev_valid_name(const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
839
{
840
841
	if (*name == '\0')
		return 0;
842
843
	if (strlen(name) >= IFNAMSIZ)
		return 0;
844
845
846
847
848
849
850
851
852
	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
853
}
Eric Dumazet's avatar
Eric Dumazet committed
854
EXPORT_SYMBOL(dev_valid_name);
Linus Torvalds's avatar
Linus Torvalds committed
855
856

/**
857
858
 *	__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
859
 *	@name: name format string
860
 *	@buf:  scratch buffer and result name string
Linus Torvalds's avatar
Linus Torvalds committed
861
862
 *
 *	Passed a format string - eg "lt%d" it will try and find a suitable
Stephen Hemminger's avatar
Stephen Hemminger committed
863
864
865
866
867
868
 *	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
869
870
 */

871
static int __dev_alloc_name(struct net *net, const char *name, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
872
873
874
875
{
	int i = 0;
	const char *p;
	const int max_netdevices = 8*PAGE_SIZE;
876
	unsigned long *inuse;
Linus Torvalds's avatar
Linus Torvalds committed
877
878
879
880
881
882
883
884
885
886
887
888
889
	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 */
890
		inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
Linus Torvalds's avatar
Linus Torvalds committed
891
892
893
		if (!inuse)
			return -ENOMEM;

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

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

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

910
911
	if (buf != name)
		snprintf(buf, IFNAMSIZ, name, i);
912
	if (!__dev_get_by_name(net, buf))
Linus Torvalds's avatar
Linus Torvalds committed
913
914
915
916
917
918
919
920
921
		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;
}

922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
/**
 *	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;

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

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

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

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

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

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

/**
 *	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.
 */
979
int dev_change_name(struct net_device *dev, const char *newname)
Linus Torvalds's avatar
Linus Torvalds committed
980
{
981
	char oldname[IFNAMSIZ];
Linus Torvalds's avatar
Linus Torvalds committed
982
	int err = 0;
983
	int ret;
984
	struct net *net;
Linus Torvalds's avatar
Linus Torvalds committed
985
986

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

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

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

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

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

1002
rollback:
1003
1004
1005
1006
	ret = device_rename(&dev->dev, dev->name);
	if (ret) {
		memcpy(dev->name, oldname, IFNAMSIZ);
		return ret;
1007
	}
1008
1009

	write_lock_bh(&dev_base_lock);
1010
	hlist_del(&dev->name_hlist);
1011
1012
1013
1014
1015
1016
	write_unlock_bh(&dev_base_lock);

	synchronize_rcu();

	write_lock_bh(&dev_base_lock);
	hlist_add_head_rcu(&dev->name_hlist, dev_name_hash(net, dev->name));
1017
1018
	write_unlock_bh(&dev_base_lock);

1019
	ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
1020
1021
1022
	ret = notifier_to_errno(ret);

	if (ret) {
1023
1024
		/* err >= 0 after dev_alloc_name() or stores the first errno */
		if (err >= 0) {
1025
1026
1027
			err = ret;
			memcpy(dev->name, oldname, IFNAMSIZ);
			goto rollback;
1028
1029
1030
1031
		} else {
			printk(KERN_ERR
			       "%s: name change rollback failed: %d.\n",
			       dev->name, ret);
1032
1033
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
1034
1035
1036
1037

	return err;
}

1038
1039
1040
1041
/**
 *	dev_set_alias - change ifalias of a device
 *	@dev: device
 *	@alias: name up to IFALIASZ
1042
 *	@len: limit of bytes to copy from info
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
 *
 *	Set ifalias for a device,
 */
int dev_set_alias(struct net_device *dev, const char *alias, size_t len)
{
	ASSERT_RTNL();

	if (len >= IFALIASZ)
		return -EINVAL;

1053
1054
1055
1056
1057
1058
1059
1060
	if (!len) {
		if (dev->ifalias) {
			kfree(dev->ifalias);
			dev->ifalias = NULL;
		}
		return 0;
	}

Eric Dumazet's avatar
Eric Dumazet committed
1061
	dev->ifalias = krealloc(dev->ifalias, len + 1, GFP_KERNEL);
1062
1063
1064
1065
1066
1067
1068
1069
	if (!dev->ifalias)
		return -ENOMEM;

	strlcpy(dev->ifalias, alias, len+1);
	return len;
}


1070
/**
Stephen Hemminger's avatar
Stephen Hemminger committed
1071
 *	netdev_features_change - device changes features
1072
1073
1074
1075
1076
1077
 *	@dev: device to cause notification
 *
 *	Called to indicate a device has changed features.
 */
void netdev_features_change(struct net_device *dev)
{
1078
	call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev);
1079
1080
1081
}
EXPORT_SYMBOL(netdev_features_change);

Linus Torvalds's avatar
Linus Torvalds committed
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
/**
 *	netdev_state_change - device changes state
 *	@dev: device to cause notification
 *
 *	Called to indicate a device has changed state. This function calls
 *	the notifier chains for netdev_chain and sends a NEWLINK message
 *	to the routing socket.
 */
void netdev_state_change(struct net_device *dev)
{
	if (dev->flags & IFF_UP) {
1093
		call_netdevice_notifiers(NETDEV_CHANGE, dev);
Linus Torvalds's avatar
Linus Torvalds committed
1094
1095
1096
		rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
	}
}
Eric Dumazet's avatar
Eric Dumazet committed
1097
EXPORT_SYMBOL(netdev_state_change);
Linus Torvalds's avatar
Linus Torvalds committed
1098

1099
int netdev_bonding_change(struct net_device *dev, unsigned long event)
1100
{
1101
	return call_netdevice_notifiers(event, dev);
1102
1103
1104
}
EXPORT_SYMBOL(netdev_bonding_change);

Linus Torvalds's avatar
Linus Torvalds committed
1105
1106
/**
 *	dev_load 	- load a network module
1107
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
1108
1109
1110
1111
1112
1113
1114
 *	@name: name of interface
 *
 *	If a network interface is not present and the process has suitable
 *	privileges this function loads the module. If module loading is not
 *	available in this kernel then it becomes a nop.
 */

1115
void dev_load(struct net *net, const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
1116
{
1117
	struct net_device *dev;
Linus Torvalds's avatar
Linus Torvalds committed
1118

1119
1120
1121
	rcu_read_lock();
	dev = dev_get_by_name_rcu(net, name);
	rcu_read_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
1122

1123
	if (!dev && capable(CAP_NET_ADMIN))
Linus Torvalds's avatar
Linus Torvalds committed
1124
1125
		request_module("%s", name);
}
Eric Dumazet's avatar
Eric Dumazet committed
1126
EXPORT_SYMBOL(dev_load);
Linus Torvalds's avatar
Linus Torvalds committed
1127

1128
static int __dev_open(struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
1129
{
1130
	const struct net_device_ops *ops = dev->netdev_ops;
1131
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
1132

1133
1134
	ASSERT_RTNL();

Linus Torvalds's avatar
Linus Torvalds committed
1135
1136
1137
1138
1139
1140
	/*
	 *	Is it even present?
	 */
	if (!netif_device_present(dev))
		return -ENODEV;

1141
1142
1143
1144
1145
	ret = call_netdevice_notifiers(NETDEV_PRE_UP, dev);
	ret = notifier_to_errno(ret);
	if (ret)
		return ret;

Linus Torvalds's avatar
Linus Torvalds committed
1146
1147
1148
1149
	/*
	 *	Call device private open method
	 */
	set_bit(__LINK_STATE_START, &dev->state);
1150

1151
1152
	if (ops->ndo_validate_addr)
		ret = ops->ndo_validate_addr(dev);
1153

1154
1155
	if (!ret && ops->ndo_open)
		ret = ops->ndo_open(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1156

1157
	/*
Linus Torvalds's avatar
Linus Torvalds committed
1158
1159
1160
	 *	If it went open OK then:
	 */

1161
1162
1163
	if (ret)
		clear_bit(__LINK_STATE_START, &dev->state);
	else {
Linus Torvalds's avatar
Linus Torvalds committed
1164
1165
1166
1167
1168
		/*
		 *	Set the flags.
		 */
		dev->flags |= IFF_UP;

1169
1170
1171
		/*
		 *	Enable NET_DMA
		 */
1172
		net_dmaengine_get();
1173

Linus Torvalds's avatar
Linus Torvalds committed
1174
1175
1176
		/*
		 *	Initialize multicasting status
		 */
1177
		dev_set_rx_mode(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1178
1179
1180
1181
1182
1183

		/*
		 *	Wakeup transmit queue engine
		 */
		dev_activate(dev);
	}
1184

Linus Torvalds's avatar
Linus Torvalds committed
1185
1186
1187
1188
	return ret;
}

/**
1189
1190
 *	dev_open	- prepare an interface for use.
 *	@dev:	device to open
Linus Torvalds's avatar
Linus Torvalds committed
1191
 *
1192
1193
1194
1195
1196
1197
1198
 *	Takes a device from down to up state. The device's private open
 *	function is invoked and then the multicast lists are loaded. Finally
 *	the device is moved into the up state and a %NETDEV_UP message is
 *	sent to the netdev notifier chain.
 *
 *	Calling this function on an active interface is a nop. On a failure
 *	a negative errno code is returned.
Linus Torvalds's avatar
Linus Torvalds committed
1199
 */
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
int dev_open(struct net_device *dev)
{
	int ret;

	/*
	 *	Is it already up?
	 */
	if (dev->flags & IFF_UP)
		return 0;

	/*
	 *	Open device
	 */
	ret = __dev_open(dev);
	if (ret < 0)
		return ret;

	/*
	 *	... and announce new interface.
	 */
	rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING);
	call_netdevice_notifiers(NETDEV_UP, dev);

	return ret;
}
EXPORT_SYMBOL(dev_open);

static int __dev_close(struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
1228
{
1229
	const struct net_device_ops *ops = dev->netdev_ops;
1230

1231
	ASSERT_RTNL();
1232
1233
	might_sleep();

Linus Torvalds's avatar
Linus Torvalds committed
1234
1235
1236
1237
	/*
	 *	Tell people we are going down, so that they can
	 *	prepare to death, when device is still operating.
	 */
1238
	call_netdevice_notifiers(NETDEV_GOING_DOWN, dev);
Linus Torvalds's avatar
Linus Torvalds committed
1239
1240
1241
1242

	clear_bit(__LINK_STATE_START, &dev->state);

	/* Synchronize to scheduled poll. We cannot touch poll list,
1243
1244
1245
1246
1247
	 * it can be even on different cpu. So just clear netif_running().
	 *
	 * dev->stop() will invoke napi_disable() on all of it's
	 * napi_struct instances on this device.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
1248
1249
	smp_mb__after_clear_bit(); /* Commit netif_running(). */

1250
1251
	dev_deactivate(dev);

Linus Torvalds's avatar
Linus Torvalds committed
1252
1253
1254
1255
1256
1257
1258
	/*
	 *	Call the device specific close. This cannot fail.
	 *	Only if device is UP
	 *
	 *	We allow it to be called even after a DETACH hot-plug
	 *	event.
	 */
1259
1260
	if (ops->ndo_stop)
		ops->ndo_stop(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1261
1262
1263
1264
1265
1266
1267
1268

	/*
	 *	Device is now down.
	 */

	dev->flags &= ~IFF_UP;

	/*
1269
	 *	Shutdown NET_DMA
Linus Torvalds's avatar
Linus Torvalds committed
1270
	 */
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
	net_dmaengine_put();

	return 0;
}

/**
 *	dev_close - shutdown an interface.
 *	@dev: device to shutdown
 *
 *	This function moves an active device into down state. A
 *	%NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
 *	is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
 *	chain.
 */
int dev_close(struct net_device *dev)
{
	if (!(dev->flags & IFF_UP))
		return 0;

	__dev_close(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1291

1292
	/*
1293
	 * Tell people we are down
1294
	 */
1295
1296
	rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING);
	call_netdevice_notifiers(NETDEV_DOWN, dev);
1297

Linus Torvalds's avatar
Linus Torvalds committed
1298
1299
	return 0;
}
Eric Dumazet's avatar
Eric Dumazet committed
1300
EXPORT_SYMBOL(dev_close);
Linus Torvalds's avatar
Linus Torvalds committed
1301
1302


1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
/**
 *	dev_disable_lro - disable Large Receive Offload on a device
 *	@dev: device
 *
 *	Disable Large Receive Offload (LRO) on a net device.  Must be
 *	called under RTNL.  This is needed if received packets may be
 *	forwarded to another interface.
 */
void dev_disable_lro(struct net_device *dev)
{
	if (dev->ethtool_ops && dev->ethtool_ops->get_flags &&
	    dev->ethtool_ops->set_flags) {
		u32 flags = dev->ethtool_ops->get_flags(dev);
		if (flags & ETH_FLAG_LRO) {
			flags &= ~ETH_FLAG_LRO;
			dev->ethtool_ops->set_flags(dev, flags);
		}
	}
	WARN_ON(dev->features & NETIF_F_LRO);
}
EXPORT_SYMBOL(dev_disable_lro);


1326
1327
static int dev_boot_phase = 1;

Linus Torvalds's avatar
Linus Torvalds committed
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
/*
 *	Device change register/unregister. These are not inline or static
 *	as we export them to the world.
 */

/**
 *	register_netdevice_notifier - register a network notifier block
 *	@nb: notifier
 *
 *	Register a notifier to be called when network device events occur.
 *	The notifier passed is linked into the kernel structures and must
 *	not be reused until it has been unregistered. A negative errno code
 *	is returned on a failure.
 *
 * 	When registered all registration and up events are replayed
1343
 *	to the new notifier to allow device to have a race free
Linus Torvalds's avatar
Linus Torvalds committed
1344
1345
1346
1347
1348
1349
 *	view of the network device list.
 */

int register_netdevice_notifier(struct notifier_block *nb)
{
	struct net_device *dev;
1350
	struct net_device *last;
1351
	struct net *net;
Linus Torvalds's avatar
Linus Torvalds committed
1352
1353
1354
	int err;

	rtnl_lock();
1355
	err = raw_notifier_chain_register(&netdev_chain, nb);
1356
1357
	if (err)
		goto unlock;
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
	if (dev_boot_phase)
		goto unlock;
	for_each_net(net) {
		for_each_netdev(net, dev) {
			err = nb->notifier_call(nb, NETDEV_REGISTER, dev);
			err = notifier_to_errno(err);
			if (err)
				goto rollback;

			if (!(dev->flags & IFF_UP))
				continue;
Linus Torvalds's avatar
Linus Torvalds committed
1369

1370
1371
			nb->notifier_call(nb, NETDEV_UP, dev);
		}
Linus Torvalds's avatar
Linus Torvalds committed
1372
	}