dev.c 135 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
82
#include <linux/cpu.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
Arjan van de Ven's avatar
Arjan van de Ven committed
83
#include <linux/mutex.h>
Linus Torvalds's avatar
Linus Torvalds committed
84
85
86
87
88
89
90
91
92
#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>
93
#include <linux/ethtool.h>
Linus Torvalds's avatar
Linus Torvalds committed
94
95
#include <linux/notifier.h>
#include <linux/skbuff.h>
96
#include <net/net_namespace.h>
Linus Torvalds's avatar
Linus Torvalds committed
97
98
99
100
101
102
#include <net/sock.h>
#include <linux/rtnetlink.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/if_bridge.h>
Patrick McHardy's avatar
Patrick McHardy committed
103
#include <linux/if_macvlan.h>
Linus Torvalds's avatar
Linus Torvalds committed
104
105
106
107
108
109
110
111
112
113
#include <net/dst.h>
#include <net/pkt_sched.h>
#include <net/checksum.h>
#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>
114
#include <net/wext.h>
Linus Torvalds's avatar
Linus Torvalds committed
115
116
#include <net/iw_handler.h>
#include <asm/current.h>
Steve Grubb's avatar
Steve Grubb committed
117
#include <linux/audit.h>
118
#include <linux/dmaengine.h>
119
#include <linux/err.h>
120
#include <linux/ctype.h>
121
#include <linux/if_arp.h>
122
#include <linux/if_vlan.h>
123
#include <linux/ip.h>
124
#include <net/ip.h>
125
126
#include <linux/ipv6.h>
#include <linux/in.h>
127
128
#include <linux/jhash.h>
#include <linux/random.h>
129
#include <trace/events/napi.h>
Linus Torvalds's avatar
Linus Torvalds committed
130

131
132
#include "net-sysfs.h"

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

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

167
168
169
#define PTYPE_HASH_SIZE	(16)
#define PTYPE_HASH_MASK	(PTYPE_HASH_SIZE - 1)

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

/*
175
 * The @dev_base_head list is protected by @dev_base_lock and the rtnl
Linus Torvalds's avatar
Linus Torvalds committed
176
177
178
179
180
 * semaphore.
 *
 * Pure readers hold dev_base_lock for reading.
 *
 * Writers must hold the rtnl semaphore while they loop through the
181
 * dev_base_head list, and hold dev_base_lock for writing when they do the
Linus Torvalds's avatar
Linus Torvalds committed
182
183
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);

#define NETDEV_HASHBITS	8
198
#define NETDEV_HASHENTRIES (1 << NETDEV_HASHBITS)
Linus Torvalds's avatar
Linus Torvalds committed
199

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

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

211
212
213
/* Device list insertion */
static int list_netdevice(struct net_device *dev)
{
214
	struct net *net = dev_net(dev);
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238

	ASSERT_RTNL();

	write_lock_bh(&dev_base_lock);
	list_add_tail(&dev->dev_list, &net->dev_base_head);
	hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
	hlist_add_head(&dev->index_hlist, dev_index_hash(net, dev->ifindex));
	write_unlock_bh(&dev_base_lock);
	return 0;
}

/* Device list removal */
static void unlist_netdevice(struct net_device *dev)
{
	ASSERT_RTNL();

	/* Unlink dev from the device chain */
	write_lock_bh(&dev_base_lock);
	list_del(&dev->dev_list);
	hlist_del(&dev->name_hlist);
	hlist_del(&dev->index_hlist);
	write_unlock_bh(&dev_base_lock);
}

Linus Torvalds's avatar
Linus Torvalds committed
239
240
241
242
/*
 *	Our notifier list
 */

243
static RAW_NOTIFIER_HEAD(netdev_chain);
Linus Torvalds's avatar
Linus Torvalds committed
244
245
246
247
248

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

DEFINE_PER_CPU(struct softnet_data, softnet_data);
Linus Torvalds's avatar
Linus Torvalds committed
251

252
#ifdef CONFIG_LOCKDEP
253
/*
254
 * register_netdevice() inits txq->_xmit_lock and sets lockdep class
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
 * 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,
271
	 ARPHRD_IEEE80211_PRISM, ARPHRD_IEEE80211_RADIOTAP, ARPHRD_PHONET,
272
273
	 ARPHRD_PHONET_PIPE, ARPHRD_IEEE802154, ARPHRD_IEEE802154_PHY,
	 ARPHRD_VOID, ARPHRD_NONE};
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288

static const char *netdev_lock_name[] =
	{"_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",
289
	 "_xmit_IEEE80211_PRISM", "_xmit_IEEE80211_RADIOTAP", "_xmit_PHONET",
290
291
	 "_xmit_PHONET_PIPE", "_xmit_IEEE802154", "_xmit_IEEE802154_PHY",
	 "_xmit_VOID", "_xmit_NONE"};
292
293

static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
294
static struct lock_class_key netdev_addr_lock_key[ARRAY_SIZE(netdev_lock_type)];
295
296
297
298
299
300
301
302
303
304
305
306

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

307
308
static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
						 unsigned short dev_type)
309
310
311
312
313
314
315
{
	int i;

	i = netdev_lock_pos(dev_type);
	lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i],
				   netdev_lock_name[i]);
}
316
317
318
319
320
321
322
323
324
325

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]);
}
326
#else
327
328
329
330
331
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)
332
333
334
{
}
#endif
Linus Torvalds's avatar
Linus Torvalds committed
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365

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

		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.
 *
366
 *	This call does not sleep therefore it can not
Linus Torvalds's avatar
Linus Torvalds committed
367
368
369
370
371
372
373
374
375
 *	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);
376
	if (pt->type == htons(ETH_P_ALL))
Linus Torvalds's avatar
Linus Torvalds committed
377
		list_add_rcu(&pt->list, &ptype_all);
378
	else {
379
		hash = ntohs(pt->type) & PTYPE_HASH_MASK;
Linus Torvalds's avatar
Linus Torvalds committed
380
381
382
383
384
385
386
387
388
389
390
391
		list_add_rcu(&pt->list, &ptype_base[hash]);
	}
	spin_unlock_bh(&ptype_lock);
}

/**
 *	__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
392
 *	returns.
Linus Torvalds's avatar
Linus Torvalds committed
393
394
395
396
397
398
399
400
401
402
403
404
 *
 *      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);

405
	if (pt->type == htons(ETH_P_ALL))
Linus Torvalds's avatar
Linus Torvalds committed
406
		head = &ptype_all;
407
	else
408
		head = &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK];
Linus Torvalds's avatar
Linus Torvalds committed
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435

	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);
}
/**
 *	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);
436

Linus Torvalds's avatar
Linus Torvalds committed
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
	synchronize_net();
}

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

		      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));
467
			strlcpy(s[i].name, name, IFNAMSIZ);
Linus Torvalds's avatar
Linus Torvalds committed
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
			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] != ' ' &&
492
		    !strcmp(dev->name, s[i].name)) {
Linus Torvalds's avatar
Linus Torvalds committed
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
			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;
}


/**
 *	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
	 */
526
	if (__dev_get_by_name(&init_net, name))
Linus Torvalds's avatar
Linus Torvalds committed
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
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
		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
572
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
573
574
575
576
577
578
579
580
581
 *	@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.
 */

582
struct net_device *__dev_get_by_name(struct net *net, const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
583
584
585
{
	struct hlist_node *p;

586
	hlist_for_each(p, dev_name_hash(net, name)) {
Linus Torvalds's avatar
Linus Torvalds committed
587
588
589
590
591
592
593
594
595
596
		struct net_device *dev
			= hlist_entry(p, struct net_device, name_hlist);
		if (!strncmp(dev->name, name, IFNAMSIZ))
			return dev;
	}
	return NULL;
}

/**
 *	dev_get_by_name		- find a device by its name
597
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
598
599
600
601
602
603
604
605
606
 *	@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.
 */

607
struct net_device *dev_get_by_name(struct net *net, const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
608
609
610
611
{
	struct net_device *dev;

	read_lock(&dev_base_lock);
612
	dev = __dev_get_by_name(net, name);
Linus Torvalds's avatar
Linus Torvalds committed
613
614
615
616
617
618
619
620
	if (dev)
		dev_hold(dev);
	read_unlock(&dev_base_lock);
	return dev;
}

/**
 *	__dev_get_by_index - find a device by its ifindex
621
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
622
623
624
625
626
627
628
629
630
 *	@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.
 */

631
struct net_device *__dev_get_by_index(struct net *net, int ifindex)
Linus Torvalds's avatar
Linus Torvalds committed
632
633
634
{
	struct hlist_node *p;

635
	hlist_for_each(p, dev_index_hash(net, ifindex)) {
Linus Torvalds's avatar
Linus Torvalds committed
636
637
638
639
640
641
642
643
644
645
646
		struct net_device *dev
			= hlist_entry(p, struct net_device, index_hlist);
		if (dev->ifindex == ifindex)
			return dev;
	}
	return NULL;
}


/**
 *	dev_get_by_index - find a device by its ifindex
647
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
648
649
650
651
652
653
654
655
 *	@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.
 */

656
struct net_device *dev_get_by_index(struct net *net, int ifindex)
Linus Torvalds's avatar
Linus Torvalds committed
657
658
659
660
{
	struct net_device *dev;

	read_lock(&dev_base_lock);
661
	dev = __dev_get_by_index(net, ifindex);
Linus Torvalds's avatar
Linus Torvalds committed
662
663
664
665
666
667
668
669
	if (dev)
		dev_hold(dev);
	read_unlock(&dev_base_lock);
	return dev;
}

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

683
struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *ha)
Linus Torvalds's avatar
Linus Torvalds committed
684
685
686
687
688
{
	struct net_device *dev;

	ASSERT_RTNL();

689
	for_each_netdev(net, dev)
Linus Torvalds's avatar
Linus Torvalds committed
690
691
		if (dev->type == type &&
		    !memcmp(dev->dev_addr, ha, dev->addr_len))
692
693
694
			return dev;

	return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
695
696
}

697
698
EXPORT_SYMBOL(dev_getbyhwaddr);

699
struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
Linus Torvalds's avatar
Linus Torvalds committed
700
701
702
{
	struct net_device *dev;

703
	ASSERT_RTNL();
704
	for_each_netdev(net, dev)
705
		if (dev->type == type)
706
707
708
			return dev;

	return NULL;
709
710
711
712
}

EXPORT_SYMBOL(__dev_getfirstbyhwtype);

713
struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
714
715
716
717
{
	struct net_device *dev;

	rtnl_lock();
718
	dev = __dev_getfirstbyhwtype(net, type);
719
720
	if (dev)
		dev_hold(dev);
Linus Torvalds's avatar
Linus Torvalds committed
721
722
723
724
725
726
727
728
	rtnl_unlock();
	return dev;
}

EXPORT_SYMBOL(dev_getfirstbyhwtype);

/**
 *	dev_get_by_flags - find any device with given flags
729
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
730
731
732
733
 *	@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
734
 *	is not found or a pointer to the device. The device returned has
Linus Torvalds's avatar
Linus Torvalds committed
735
736
737
738
 *	had a reference added and the pointer is safe until the user calls
 *	dev_put to indicate they have finished with it.
 */

739
struct net_device * dev_get_by_flags(struct net *net, unsigned short if_flags, unsigned short mask)
Linus Torvalds's avatar
Linus Torvalds committed
740
{
741
	struct net_device *dev, *ret;
Linus Torvalds's avatar
Linus Torvalds committed
742

743
	ret = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
744
	read_lock(&dev_base_lock);
745
	for_each_netdev(net, dev) {
Linus Torvalds's avatar
Linus Torvalds committed
746
747
		if (((dev->flags ^ if_flags) & mask) == 0) {
			dev_hold(dev);
748
			ret = dev;
Linus Torvalds's avatar
Linus Torvalds committed
749
750
751
752
			break;
		}
	}
	read_unlock(&dev_base_lock);
753
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
754
755
756
757
758
759
760
}

/**
 *	dev_valid_name - check if name is okay for network device
 *	@name: name string
 *
 *	Network device names need to be valid file names to
761
762
 *	to allow sysfs to work.  We also disallow any kind of
 *	whitespace.
Linus Torvalds's avatar
Linus Torvalds committed
763
 */
764
int dev_valid_name(const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
765
{
766
767
	if (*name == '\0')
		return 0;
768
769
	if (strlen(name) >= IFNAMSIZ)
		return 0;
770
771
772
773
774
775
776
777
778
	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
779
780
781
}

/**
782
783
 *	__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
784
 *	@name: name format string
785
 *	@buf:  scratch buffer and result name string
Linus Torvalds's avatar
Linus Torvalds committed
786
787
 *
 *	Passed a format string - eg "lt%d" it will try and find a suitable
Stephen Hemminger's avatar
Stephen Hemminger committed
788
789
790
791
792
793
 *	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
794
795
 */

796
static int __dev_alloc_name(struct net *net, const char *name, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
797
798
799
800
{
	int i = 0;
	const char *p;
	const int max_netdevices = 8*PAGE_SIZE;
801
	unsigned long *inuse;
Linus Torvalds's avatar
Linus Torvalds committed
802
803
804
805
806
807
808
809
810
811
812
813
814
	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 */
815
		inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
Linus Torvalds's avatar
Linus Torvalds committed
816
817
818
		if (!inuse)
			return -ENOMEM;

819
		for_each_netdev(net, d) {
Linus Torvalds's avatar
Linus Torvalds committed
820
821
822
823
824
825
			if (!sscanf(d->name, name, &i))
				continue;
			if (i < 0 || i >= max_netdevices)
				continue;

			/*  avoid cases where sscanf is not exact inverse of printf */
826
			snprintf(buf, IFNAMSIZ, name, i);
Linus Torvalds's avatar
Linus Torvalds committed
827
828
829
830
831
832
833
834
			if (!strncmp(buf, d->name, IFNAMSIZ))
				set_bit(i, inuse);
		}

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

835
836
	snprintf(buf, IFNAMSIZ, name, i);
	if (!__dev_get_by_name(net, buf))
Linus Torvalds's avatar
Linus Torvalds committed
837
838
839
840
841
842
843
844
845
		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;
}

846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
/**
 *	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;

866
867
	BUG_ON(!dev_net(dev));
	net = dev_net(dev);
868
869
870
871
872
873
	ret = __dev_alloc_name(net, name, buf);
	if (ret >= 0)
		strlcpy(dev->name, buf, IFNAMSIZ);
	return ret;
}

Linus Torvalds's avatar
Linus Torvalds committed
874
875
876
877
878
879
880
881
882

/**
 *	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.
 */
883
int dev_change_name(struct net_device *dev, const char *newname)
Linus Torvalds's avatar
Linus Torvalds committed
884
{
885
	char oldname[IFNAMSIZ];
Linus Torvalds's avatar
Linus Torvalds committed
886
	int err = 0;
887
	int ret;
888
	struct net *net;
Linus Torvalds's avatar
Linus Torvalds committed
889
890

	ASSERT_RTNL();
891
	BUG_ON(!dev_net(dev));
Linus Torvalds's avatar
Linus Torvalds committed
892

893
	net = dev_net(dev);
Linus Torvalds's avatar
Linus Torvalds committed
894
895
896
897
898
899
	if (dev->flags & IFF_UP)
		return -EBUSY;

	if (!dev_valid_name(newname))
		return -EINVAL;

900
901
902
	if (strncmp(newname, dev->name, IFNAMSIZ) == 0)
		return 0;

903
904
	memcpy(oldname, dev->name, IFNAMSIZ);

Linus Torvalds's avatar
Linus Torvalds committed
905
906
907
908
909
	if (strchr(newname, '%')) {
		err = dev_alloc_name(dev, newname);
		if (err < 0)
			return err;
	}
910
	else if (__dev_get_by_name(net, newname))
Linus Torvalds's avatar
Linus Torvalds committed
911
912
913
914
		return -EEXIST;
	else
		strlcpy(dev->name, newname, IFNAMSIZ);

915
rollback:
916
917
918
919
920
921
922
923
924
	/* For now only devices in the initial network namespace
	 * are in sysfs.
	 */
	if (net == &init_net) {
		ret = device_rename(&dev->dev, dev->name);
		if (ret) {
			memcpy(dev->name, oldname, IFNAMSIZ);
			return ret;
		}
925
	}
926
927

	write_lock_bh(&dev_base_lock);
928
	hlist_del(&dev->name_hlist);
929
	hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
930
931
	write_unlock_bh(&dev_base_lock);

932
	ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
933
934
935
936
937
938
939
940
941
942
943
944
945
	ret = notifier_to_errno(ret);

	if (ret) {
		if (err) {
			printk(KERN_ERR
			       "%s: name change rollback failed: %d.\n",
			       dev->name, ret);
		} else {
			err = ret;
			memcpy(dev->name, oldname, IFNAMSIZ);
			goto rollback;
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
946
947
948
949

	return err;
}

950
951
952
953
/**
 *	dev_set_alias - change ifalias of a device
 *	@dev: device
 *	@alias: name up to IFALIASZ
954
 *	@len: limit of bytes to copy from info
955
956
957
958
959
960
961
962
963
964
 *
 *	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;

965
966
967
968
969
970
971
972
	if (!len) {
		if (dev->ifalias) {
			kfree(dev->ifalias);
			dev->ifalias = NULL;
		}
		return 0;
	}

973
974
975
976
977
978
979
980
981
	dev->ifalias = krealloc(dev->ifalias, len+1, GFP_KERNEL);
	if (!dev->ifalias)
		return -ENOMEM;

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


982
/**
Stephen Hemminger's avatar
Stephen Hemminger committed
983
 *	netdev_features_change - device changes features
984
985
986
987
988
989
 *	@dev: device to cause notification
 *
 *	Called to indicate a device has changed features.
 */
void netdev_features_change(struct net_device *dev)
{
990
	call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev);
991
992
993
}
EXPORT_SYMBOL(netdev_features_change);

Linus Torvalds's avatar
Linus Torvalds committed
994
995
996
997
998
999
1000
1001
1002
1003
1004
/**
 *	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) {
1005
		call_netdevice_notifiers(NETDEV_CHANGE, dev);
Linus Torvalds's avatar
Linus Torvalds committed
1006
1007
1008
1009
		rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
	}
}

1010
1011
1012
1013
1014
1015
void netdev_bonding_change(struct net_device *dev)
{
	call_netdevice_notifiers(NETDEV_BONDING_FAILOVER, dev);
}
EXPORT_SYMBOL(netdev_bonding_change);

Linus Torvalds's avatar
Linus Torvalds committed
1016
1017
/**
 *	dev_load 	- load a network module
1018
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
1019
1020
1021
1022
1023
1024
1025
 *	@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.
 */

1026
void dev_load(struct net *net, const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
1027
{
1028
	struct net_device *dev;
Linus Torvalds's avatar
Linus Torvalds committed
1029
1030

	read_lock(&dev_base_lock);
1031
	dev = __dev_get_by_name(net, name);
Linus Torvalds's avatar
Linus Torvalds committed
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
	read_unlock(&dev_base_lock);

	if (!dev && capable(CAP_SYS_MODULE))
		request_module("%s", name);
}

/**
 *	dev_open	- prepare an interface for use.
 *	@dev:	device to open
 *
 *	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.
 */
int dev_open(struct net_device *dev)
{
1052
	const struct net_device_ops *ops = dev->netdev_ops;
1053
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
1054

1055
1056
	ASSERT_RTNL();

Linus Torvalds's avatar
Linus Torvalds committed
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
	/*
	 *	Is it already up?
	 */

	if (dev->flags & IFF_UP)
		return 0;

	/*
	 *	Is it even present?
	 */
	if (!netif_device_present(dev))
		return -ENODEV;

1070
1071
1072
1073
1074
	ret = call_netdevice_notifiers(NETDEV_PRE_UP, dev);
	ret = notifier_to_errno(ret);
	if (ret)
		return ret;

Linus Torvalds's avatar
Linus Torvalds committed
1075
1076
1077
1078
	/*
	 *	Call device private open method
	 */
	set_bit(__LINK_STATE_START, &dev->state);
1079

1080
1081
	if (ops->ndo_validate_addr)
		ret = ops->ndo_validate_addr(dev);
1082

1083
1084
	if (!ret && ops->ndo_open)
		ret = ops->ndo_open(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1085

1086
	/*
Linus Torvalds's avatar
Linus Torvalds committed
1087
1088
1089
	 *	If it went open OK then:
	 */

1090
1091
1092
	if (ret)
		clear_bit(__LINK_STATE_START, &dev->state);
	else {
Linus Torvalds's avatar
Linus Torvalds committed
1093
1094
1095
1096
1097
		/*
		 *	Set the flags.
		 */
		dev->flags |= IFF_UP;

1098
1099
1100
		/*
		 *	Enable NET_DMA
		 */
1101
		net_dmaengine_get();
1102

Linus Torvalds's avatar
Linus Torvalds committed
1103
1104
1105
		/*
		 *	Initialize multicasting status
		 */
1106
		dev_set_rx_mode(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1107
1108
1109
1110
1111
1112
1113
1114
1115

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

		/*
		 *	... and announce new interface.
		 */
1116
		call_netdevice_notifiers(NETDEV_UP, dev);
Linus Torvalds's avatar
Linus Torvalds committed
1117
	}
1118

Linus Torvalds's avatar
Linus Torvalds committed
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
	return ret;
}

/**
 *	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)
{
1133
	const struct net_device_ops *ops = dev->netdev_ops;
1134
1135
	ASSERT_RTNL();

1136
1137
	might_sleep();

Linus Torvalds's avatar
Linus Torvalds committed
1138
1139
1140
1141
1142
1143
1144
	if (!(dev->flags & IFF_UP))
		return 0;

	/*
	 *	Tell people we are going down, so that they can
	 *	prepare to death, when device is still operating.
	 */
1145
	call_netdevice_notifiers(NETDEV_GOING_DOWN, dev);
Linus Torvalds's avatar
Linus Torvalds committed
1146
1147
1148
1149

	clear_bit(__LINK_STATE_START, &dev->state);

	/* Synchronize to scheduled poll. We cannot touch poll list,
1150
1151
1152
1153
1154
	 * 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
1155
1156
	smp_mb__after_clear_bit(); /* Commit netif_running(). */

1157
1158
	dev_deactivate(dev);

Linus Torvalds's avatar
Linus Torvalds committed
1159
1160
1161
1162
1163
1164
1165
	/*
	 *	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.
	 */
1166
1167
	if (ops->ndo_stop)
		ops->ndo_stop(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177

	/*
	 *	Device is now down.
	 */

	dev->flags &= ~IFF_UP;

	/*
	 * Tell people we are down
	 */
1178
	call_netdevice_notifiers(NETDEV_DOWN, dev);
Linus Torvalds's avatar
Linus Torvalds committed
1179

1180
1181
1182
	/*
	 *	Shutdown NET_DMA
	 */
1183
	net_dmaengine_put();
1184

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


1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
/**
 *	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);


1212
1213
static int dev_boot_phase = 1;

Linus Torvalds's avatar
Linus Torvalds committed
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
/*
 *	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
1229
 *	to the new notifier to allow device to have a race free
Linus Torvalds's avatar
Linus Torvalds committed
1230
1231
1232
1233
1234
1235
 *	view of the network device list.
 */

int register_netdevice_notifier(struct notifier_block *nb)
{
	struct net_device *dev;
1236
	struct net_device *last;
1237
	struct net *net;
Linus Torvalds's avatar
Linus Torvalds committed
1238
1239
1240
	int err;

	rtnl_lock();
1241
	err = raw_notifier_chain_register(&netdev_chain, nb);
1242
1243
	if (err)
		goto unlock;
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
	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
1255

1256
1257
			nb->notifier_call(nb, NETDEV_UP, dev);
		}
Linus Torvalds's avatar
Linus Torvalds committed
1258
	}
1259
1260

unlock:
Linus Torvalds's avatar
Linus Torvalds committed
1261
1262
	rtnl_unlock();
	return err;
1263
1264
1265

rollback:
	last = dev;
1266
1267
1268
1269
	for_each_net(net) {
		for_each_netdev(net, dev) {
			if (dev == last)
				break;
1270

1271
1272
1273
1274
1275
			if (dev->flags & IFF_UP) {
				nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
				nb->notifier_call(nb, NETDEV_DOWN, dev);
			}
			nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
1276
1277
		}
	}
1278
1279

	raw_notifier_chain_unregister(&netdev_chain, nb);
1280
	goto unlock;
Linus Torvalds's avatar
Linus Torvalds committed
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
}

/**
 *	unregister_netdevice_notifier - unregister a network notifier block
 *	@nb: notifier
 *
 *	Unregister a notifier previously registered by
 *	register_netdevice_notifier(). The notifier is unlinked into the
 *	kernel structures and may then be reused. A negative errno code
 *	is returned on a failure.
 */

int unregister_netdevice_notifier(struct notifier_block *nb)
{
1295
1296
1297
	int err;

	rtnl_lock();
1298
	err = raw_notifier_chain_unregister(&netdev_chain, nb);
1299
1300
	rtnl_unlock();
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
1301
1302
1303
1304
1305
}

/**
 *	call_netdevice_notifiers - call all network notifier blocks
 *      @val: value passed unmodified to notifier function
1306
 *      @dev: net_device pointer passed unmodified to notifier function
Linus Torvalds's avatar
Linus Torvalds committed
1307
1308
 *
 *	Call all network notifier blocks.  Parameters and return value
1309
 *	are as for raw_notifier_call_chain().
Linus Torvalds's avatar
Linus Torvalds committed
1310
1311
 */

1312
int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
1313
{
1314
	return raw_notifier_call_chain(&netdev_chain, val, dev);
Linus Torvalds's avatar
Linus Torvalds committed
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
}

/* When > 0 there are consumers of rx skb time stamps */
static atomic_t netstamp_needed = ATOMIC_INIT(0);

void net_enable_timestamp(void)
{
	atomic_inc(&netstamp_needed);
}

void net_disable_timestamp(void)
{
	atomic_dec(&netstamp_needed);
}

1330
static inline void net_timestamp(struct sk_buff *skb)
Linus Torvalds's avatar
Linus Torvalds committed
1331
1332
{
	if (atomic_read(&netstamp_needed))
1333
		__net_timestamp(skb);
1334
1335
	else
		skb->tstamp.tv64 = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1336
1337
1338
1339
1340
1341
1342
}

/*
 *	Support routine. Sends outgoing frames to any network
 *	taps currently in use.
 */

1343
static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
1344
1345
{
	struct packet_type *ptype;
1346

1347
1348
1349
1350
#ifdef CONFIG_NET_CLS_ACT
	if (!(skb->tstamp.tv64 && (G_TC_FROM(skb->tc_verd) & AT_INGRESS)))
		net_timestamp(skb);
#else
1351
	net_timestamp(skb);
1352
#endif
Linus Torvalds's avatar
Linus Torvalds committed
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369

	rcu_read_lock();
	list_for_each_entry_rcu(ptype, &ptype_all, list) {
		/* Never send packets back to the socket
		 * they originated from - MvS (miquels@drinkel.ow.org)
		 */
		if ((ptype->dev == dev || !ptype->dev) &&
		    (ptype->af_packet_priv == NULL ||
		     (struct sock *)ptype->af_packet_priv != skb->sk)) {
			struct sk_buff *skb2= skb_clone(skb, GFP_ATOMIC);
			if (!skb2)
				break;

			/* skb->nh should be correctly
			   set by sender, so that the second statement is
			   just protection against buggy protocols.
			 */
1370
			skb_reset_mac_header(skb2);
Linus Torvalds's avatar
Linus Torvalds committed
1371

1372
			if (skb_network_header(skb2) < skb2->data ||
1373
			    skb2->network_header > skb2->tail) {
Linus Torvalds's avatar
Linus Torvalds committed
1374
1375
1376
1377
				if (net_ratelimit())
					printk(KERN_CRIT "protocol %04x is "
					       "buggy, dev %s\n",
					       skb2->protocol, dev->name);
1378
				skb_reset_network_header(skb2);
Linus Torvalds's avatar
Linus Torvalds committed
1379
1380
			}

1381
			skb2->transport_header = skb2->network_header;
Linus Torvalds's avatar
Linus Torvalds committed
1382
			skb2->pkt_type = PACKET_OUTGOING;
David S. Miller's avatar
David S. Miller committed
1383
			ptype->func(skb2, skb->dev, ptype, skb->dev);
Linus Torvalds's avatar
Linus Torvalds committed
1384
1385
1386
1387
1388
		}
	}
	rcu_read_unlock();
}

1389

1390
static inline void __netif_reschedule(struct Qdisc *q)
1391
{
1392
1393
	struct softnet_data *sd;
	unsigned long flags;
1394

1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
	local_irq_save(flags);
	sd = &__get_cpu_var(softnet_data);
	q->next_sched = sd->output_queue;
	sd->output_queue = q;
	raise_softirq_irqoff(NET_TX_SOFTIRQ);
	local_irq_restore(flags);
}

void __netif_schedule(struct Qdisc *q)
{
	if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state))
		__netif_reschedule(q);
1407
1408
1409
}
EXPORT_SYMBOL(__netif_schedule);

1410
void dev_kfree_skb_irq(struct sk_buff *skb)
1411
{
1412
1413
1414
	if (atomic_dec_and_test(&skb->users)) {
		struct softnet_data *sd;
		unsigned long flags;
1415

1416
1417
1418
1419
1420
1421
1422
		local_irq_save(flags);
		sd = &__get_cpu_var(softnet_data);
		skb->next = sd->completion_queue;
		sd->completion_queue = skb;
		raise_softirq_irqoff(NET_TX_SOFTIRQ);
		local_irq_restore(flags);
	}
1423
}
1424
EXPORT_SYMBOL(dev_kfree_skb_irq);
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435

void dev_kfree_skb_any(struct sk_buff *skb)
{
	if (in_irq() || irqs_disabled())
		dev_kfree_skb_irq(skb);
	else
		dev_kfree_skb(skb);
}
EXPORT_SYMBOL(dev_kfree_skb_any);


1436
1437
1438
1439
1440
1441
/**
 * netif_device_detach - mark device as removed
 * @dev: network device
 *
 * Mark device as removed from system and therefore no longer available.
 */
1442
1443
1444
1445
void netif_device_detach(struct net_device *dev)
{
	if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
	    netif_running(dev)) {
1446
		netif_tx_stop_all_queues(dev);
1447
1448
1449
1450
	}
}
EXPORT_SYMBOL(netif_device_detach);

1451
1452
1453
1454
1455
1456
/**
 * netif_device_attach - mark device as attached
 * @dev: network device
 *
 * Mark device as attached from system and restart if needed.
 */
1457
1458
1459
1460
void netif_device_attach(struct net_device *dev)
{
	if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
	    netif_running(dev)) {
1461
		netif_tx_wake_all_queues(dev);
1462
		__netdev_watchdog_up(dev);
1463
1464
1465
1466
	}
}
EXPORT_SYMBOL(netif_device_attach);

1467
1468
1469
1470
1471
1472
static boo