dev.c 209 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
 *				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
 */

75
#include <linux/uaccess.h>
Linus Torvalds's avatar
Linus Torvalds committed
76
#include <linux/bitops.h>
77
#include <linux/capability.h>
Linus Torvalds's avatar
Linus Torvalds committed
78
79
80
#include <linux/cpu.h>
#include <linux/types.h>
#include <linux/kernel.h>
81
#include <linux/hash.h>
82
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
83
#include <linux/sched.h>
Arjan van de Ven's avatar
Arjan van de Ven committed
84
#include <linux/mutex.h>
Linus Torvalds's avatar
Linus Torvalds committed
85
86
87
88
89
90
91
92
93
#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>
94
#include <linux/ethtool.h>
Linus Torvalds's avatar
Linus Torvalds committed
95
96
#include <linux/notifier.h>
#include <linux/skbuff.h>
97
#include <linux/bpf.h>
98
#include <net/net_namespace.h>
Linus Torvalds's avatar
Linus Torvalds committed
99
#include <net/sock.h>
Eric Dumazet's avatar
Eric Dumazet committed
100
#include <net/busy_poll.h>
Linus Torvalds's avatar
Linus Torvalds committed
101
102
103
#include <linux/rtnetlink.h>
#include <linux/stat.h>
#include <net/dst.h>
104
#include <net/dst_metadata.h>
Linus Torvalds's avatar
Linus Torvalds committed
105
106
#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
115
#include <linux/highmem.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/netpoll.h>
#include <linux/rcupdate.h>
#include <linux/delay.h>
#include <net/iw_handler.h>
#include <asm/current.h>
Steve Grubb's avatar
Steve Grubb committed
116
#include <linux/audit.h>
117
#include <linux/dmaengine.h>
118
#include <linux/err.h>
119
#include <linux/ctype.h>
120
#include <linux/if_arp.h>
121
#include <linux/if_vlan.h>
122
#include <linux/ip.h>
123
#include <net/ip.h>
124
#include <net/mpls.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>
130
#include <trace/events/net.h>
131
#include <trace/events/skb.h>
132
#include <linux/pci.h>
133
#include <linux/inetdevice.h>
134
#include <linux/cpu_rmap.h>
135
#include <linux/static_key.h>
Eliezer Tamir's avatar
Eliezer Tamir committed
136
#include <linux/hashtable.h>
137
#include <linux/vmalloc.h>
138
#include <linux/if_macvlan.h>
139
#include <linux/errqueue.h>
140
#include <linux/hrtimer.h>
141
#include <linux/netfilter_ingress.h>
142
#include <linux/crash_dump.h>
Linus Torvalds's avatar
Linus Torvalds committed
143

144
145
#include "net-sysfs.h"

146
147
148
/* Instead of increasing this, you should create a hash table. */
#define MAX_GRO_SKBS 8

Herbert Xu's avatar
Herbert Xu committed
149
150
151
/* 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
152
static DEFINE_SPINLOCK(ptype_lock);
153
static DEFINE_SPINLOCK(offload_lock);
154
155
struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
struct list_head ptype_all __read_mostly;	/* Taps */
156
static struct list_head offload_base __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
157

158
static int netif_rx_internal(struct sk_buff *skb);
159
160
161
static int call_netdevice_notifiers_info(unsigned long val,
					 struct net_device *dev,
					 struct netdev_notifier_info *info);
162

Linus Torvalds's avatar
Linus Torvalds committed
163
/*
164
 * The @dev_base_head list is protected by @dev_base_lock and the rtnl
Linus Torvalds's avatar
Linus Torvalds committed
165
166
 * semaphore.
 *
167
 * Pure readers hold dev_base_lock for reading, or rcu_read_lock()
Linus Torvalds's avatar
Linus Torvalds committed
168
169
 *
 * Writers must hold the rtnl semaphore while they loop through the
170
 * dev_base_head list, and hold dev_base_lock for writing when they do the
Linus Torvalds's avatar
Linus Torvalds committed
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 * 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);

Eliezer Tamir's avatar
Eliezer Tamir committed
185
186
187
/* protects napi_hash addition/deletion and napi_gen_id */
static DEFINE_SPINLOCK(napi_hash_lock);

188
static unsigned int napi_gen_id = NR_CPUS;
189
static DEFINE_READ_MOSTLY_HASHTABLE(napi_hash, 8);
Eliezer Tamir's avatar
Eliezer Tamir committed
190

191
static seqcount_t devnet_rename_seq;
192

193
194
195
196
197
static inline void dev_base_seq_inc(struct net *net)
{
	while (++net->dev_base_seq == 0);
}

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 int hash = full_name_hash(net, name, strnlen(name, IFNAMSIZ));
201

202
	return &net->dev_name_head[hash_32(hash, NETDEV_HASHBITS)];
Linus Torvalds's avatar
Linus Torvalds committed
203
204
}

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

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

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

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

	ASSERT_RTNL();

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

	dev_base_seq_inc(net);
239
240
}

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

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

	dev_base_seq_inc(dev_net(dev));
256
257
}

Linus Torvalds's avatar
Linus Torvalds committed
258
259
260
261
/*
 *	Our notifier list
 */

262
static RAW_NOTIFIER_HEAD(netdev_chain);
Linus Torvalds's avatar
Linus Torvalds committed
263
264
265
266
267

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

269
DEFINE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
Eric Dumazet's avatar
Eric Dumazet committed
270
EXPORT_PER_CPU_SYMBOL(softnet_data);
Linus Torvalds's avatar
Linus Torvalds committed
271

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

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

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

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

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

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

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

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

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

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

Linus Torvalds's avatar
Linus Torvalds committed
385
386
387
388
389
390
391
392
/**
 *	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.
 *
393
 *	This call does not sleep therefore it can not
Linus Torvalds's avatar
Linus Torvalds committed
394
395
396
397
398
399
 *	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)
{
400
	struct list_head *head = ptype_head(pt);
Linus Torvalds's avatar
Linus Torvalds committed
401

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

/**
 *	__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
415
 *	returns.
Linus Torvalds's avatar
Linus Torvalds committed
416
417
418
419
420
421
422
 *
 *      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)
{
423
	struct list_head *head = ptype_head(pt);
Linus Torvalds's avatar
Linus Torvalds committed
424
425
	struct packet_type *pt1;

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

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

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

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

Linus Torvalds's avatar
Linus Torvalds committed
457
458
	synchronize_net();
}
Eric Dumazet's avatar
Eric Dumazet committed
459
EXPORT_SYMBOL(dev_remove_pack);
Linus Torvalds's avatar
Linus Torvalds committed
460

461
462
463
464
465
466
467
468
469
470
471
472
473
474
475

/**
 *	dev_add_offload - register offload handlers
 *	@po: protocol offload declaration
 *
 *	Add protocol offload handlers to the networking stack. The passed
 *	&proto_offload is linked into kernel lists and may not be freed until
 *	it has been removed from the kernel lists.
 *
 *	This call does not sleep therefore it can not
 *	guarantee all CPU's that are in middle of receiving packets
 *	will see the new offload handlers (until the next received packet).
 */
void dev_add_offload(struct packet_offload *po)
{
476
	struct packet_offload *elem;
477
478

	spin_lock(&offload_lock);
479
480
481
482
483
	list_for_each_entry(elem, &offload_base, list) {
		if (po->priority < elem->priority)
			break;
	}
	list_add_rcu(&po->list, elem->list.prev);
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
	spin_unlock(&offload_lock);
}
EXPORT_SYMBOL(dev_add_offload);

/**
 *	__dev_remove_offload	 - remove offload handler
 *	@po: packet offload declaration
 *
 *	Remove a protocol offload handler that was previously added to the
 *	kernel offload handlers by dev_add_offload(). The passed &offload_type
 *	is removed from the kernel lists and can be freed or reused once this
 *	function returns.
 *
 *      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.
 */
501
static void __dev_remove_offload(struct packet_offload *po)
502
503
504
505
{
	struct list_head *head = &offload_base;
	struct packet_offload *po1;

506
	spin_lock(&offload_lock);
507
508
509
510
511
512
513
514
515
516

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

	pr_warn("dev_remove_offload: %p not found\n", po);
out:
517
	spin_unlock(&offload_lock);
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
}

/**
 *	dev_remove_offload	 - remove packet offload handler
 *	@po: packet offload declaration
 *
 *	Remove a packet offload handler that was previously added to the kernel
 *	offload handlers by dev_add_offload(). The passed &offload_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_offload(struct packet_offload *po)
{
	__dev_remove_offload(po);

	synchronize_net();
}
EXPORT_SYMBOL(dev_remove_offload);

Linus Torvalds's avatar
Linus Torvalds committed
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
/******************************************************************************

		      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));
567
			strlcpy(s[i].name, name, IFNAMSIZ);
Linus Torvalds's avatar
Linus Torvalds committed
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
			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] != ' ' &&
592
		    !strcmp(dev->name, s[i].name)) {
Linus Torvalds's avatar
Linus Torvalds committed
593
594
595
596
597
598
599
600
601
			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
602
EXPORT_SYMBOL(netdev_boot_setup_check);
Linus Torvalds's avatar
Linus Torvalds committed
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626


/**
 *	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
	 */
627
	if (__dev_get_by_name(&init_net, name))
Linus Torvalds's avatar
Linus Torvalds committed
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
		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

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

671
672
673
674
675
676
677
678
679
680
681
682
683
/**
 *	dev_get_iflink	- get 'iflink' value of a interface
 *	@dev: targeted interface
 *
 *	Indicates the ifindex the interface is linked to.
 *	Physical interfaces have the same 'ifindex' and 'iflink' values.
 */

int dev_get_iflink(const struct net_device *dev)
{
	if (dev->netdev_ops && dev->netdev_ops->ndo_get_iflink)
		return dev->netdev_ops->ndo_get_iflink(dev);

684
	return dev->ifindex;
685
686
687
}
EXPORT_SYMBOL(dev_get_iflink);

688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
/**
 *	dev_fill_metadata_dst - Retrieve tunnel egress information.
 *	@dev: targeted interface
 *	@skb: The packet.
 *
 *	For better visibility of tunnel traffic OVS needs to retrieve
 *	egress tunnel information for a packet. Following API allows
 *	user to get this info.
 */
int dev_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
{
	struct ip_tunnel_info *info;

	if (!dev->netdev_ops  || !dev->netdev_ops->ndo_fill_metadata_dst)
		return -EINVAL;

	info = skb_tunnel_info_unclone(skb);
	if (!info)
		return -ENOMEM;
	if (unlikely(!(info->mode & IP_TUNNEL_INFO_TX)))
		return -EINVAL;

	return dev->netdev_ops->ndo_fill_metadata_dst(dev, skb);
}
EXPORT_SYMBOL_GPL(dev_fill_metadata_dst);

Linus Torvalds's avatar
Linus Torvalds committed
714
715
/**
 *	__dev_get_by_name	- find a device by its name
716
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
717
718
719
720
721
722
723
724
725
 *	@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.
 */

726
struct net_device *__dev_get_by_name(struct net *net, const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
727
{
Eric Dumazet's avatar
Eric Dumazet committed
728
729
	struct net_device *dev;
	struct hlist_head *head = dev_name_hash(net, name);
Linus Torvalds's avatar
Linus Torvalds committed
730

731
	hlist_for_each_entry(dev, head, name_hlist)
Linus Torvalds's avatar
Linus Torvalds committed
732
733
		if (!strncmp(dev->name, name, IFNAMSIZ))
			return dev;
Eric Dumazet's avatar
Eric Dumazet committed
734

Linus Torvalds's avatar
Linus Torvalds committed
735
736
	return NULL;
}
Eric Dumazet's avatar
Eric Dumazet committed
737
EXPORT_SYMBOL(__dev_get_by_name);
Linus Torvalds's avatar
Linus Torvalds committed
738

739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
/**
 *	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 net_device *dev;
	struct hlist_head *head = dev_name_hash(net, name);

756
	hlist_for_each_entry_rcu(dev, head, name_hlist)
757
758
759
760
761
762
763
		if (!strncmp(dev->name, name, IFNAMSIZ))
			return dev;

	return NULL;
}
EXPORT_SYMBOL(dev_get_by_name_rcu);

Linus Torvalds's avatar
Linus Torvalds committed
764
765
/**
 *	dev_get_by_name		- find a device by its name
766
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
767
768
769
770
771
772
773
774
775
 *	@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.
 */

776
struct net_device *dev_get_by_name(struct net *net, const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
777
778
779
{
	struct net_device *dev;

780
781
	rcu_read_lock();
	dev = dev_get_by_name_rcu(net, name);
Linus Torvalds's avatar
Linus Torvalds committed
782
783
	if (dev)
		dev_hold(dev);
784
	rcu_read_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
785
786
	return dev;
}
Eric Dumazet's avatar
Eric Dumazet committed
787
EXPORT_SYMBOL(dev_get_by_name);
Linus Torvalds's avatar
Linus Torvalds committed
788
789
790

/**
 *	__dev_get_by_index - find a device by its ifindex
791
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
792
793
794
795
796
797
798
799
800
 *	@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.
 */

801
struct net_device *__dev_get_by_index(struct net *net, int ifindex)
Linus Torvalds's avatar
Linus Torvalds committed
802
{
Eric Dumazet's avatar
Eric Dumazet committed
803
804
	struct net_device *dev;
	struct hlist_head *head = dev_index_hash(net, ifindex);
Linus Torvalds's avatar
Linus Torvalds committed
805

806
	hlist_for_each_entry(dev, head, index_hlist)
Linus Torvalds's avatar
Linus Torvalds committed
807
808
		if (dev->ifindex == ifindex)
			return dev;
Eric Dumazet's avatar
Eric Dumazet committed
809

Linus Torvalds's avatar
Linus Torvalds committed
810
811
	return NULL;
}
Eric Dumazet's avatar
Eric Dumazet committed
812
EXPORT_SYMBOL(__dev_get_by_index);
Linus Torvalds's avatar
Linus Torvalds committed
813

814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
/**
 *	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 net_device *dev;
	struct hlist_head *head = dev_index_hash(net, ifindex);

830
	hlist_for_each_entry_rcu(dev, head, index_hlist)
831
832
833
834
835
836
837
		if (dev->ifindex == ifindex)
			return dev;

	return NULL;
}
EXPORT_SYMBOL(dev_get_by_index_rcu);

Linus Torvalds's avatar
Linus Torvalds committed
838
839
840

/**
 *	dev_get_by_index - find a device by its ifindex
841
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
842
843
844
845
846
847
848
849
 *	@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.
 */

850
struct net_device *dev_get_by_index(struct net *net, int ifindex)
Linus Torvalds's avatar
Linus Torvalds committed
851
852
853
{
	struct net_device *dev;

854
855
	rcu_read_lock();
	dev = dev_get_by_index_rcu(net, ifindex);
Linus Torvalds's avatar
Linus Torvalds committed
856
857
	if (dev)
		dev_hold(dev);
858
	rcu_read_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
859
860
	return dev;
}
Eric Dumazet's avatar
Eric Dumazet committed
861
EXPORT_SYMBOL(dev_get_by_index);
Linus Torvalds's avatar
Linus Torvalds committed
862

863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
/**
 *	netdev_get_name - get a netdevice name, knowing its ifindex.
 *	@net: network namespace
 *	@name: a pointer to the buffer where the name will be stored.
 *	@ifindex: the ifindex of the interface to get the name from.
 *
 *	The use of raw_seqcount_begin() and cond_resched() before
 *	retrying is required as we want to give the writers a chance
 *	to complete when CONFIG_PREEMPT is not set.
 */
int netdev_get_name(struct net *net, char *name, int ifindex)
{
	struct net_device *dev;
	unsigned int seq;

retry:
	seq = raw_seqcount_begin(&devnet_rename_seq);
	rcu_read_lock();
	dev = dev_get_by_index_rcu(net, ifindex);
	if (!dev) {
		rcu_read_unlock();
		return -ENODEV;
	}

	strcpy(name, dev->name);
	rcu_read_unlock();
	if (read_seqcount_retry(&devnet_rename_seq, seq)) {
		cond_resched();
		goto retry;
	}

	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
897
/**
898
 *	dev_getbyhwaddr_rcu - find a device by its hardware address
899
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
900
901
902
903
 *	@type: media type of device
 *	@ha: hardware address
 *
 *	Search for an interface by MAC address. Returns NULL if the device
Eric Dumazet's avatar
Eric Dumazet committed
904
905
 *	is not found or a pointer to the device.
 *	The caller must hold RCU or RTNL.
906
 *	The returned device has not had its ref count increased
Linus Torvalds's avatar
Linus Torvalds committed
907
908
909
910
 *	and the caller must therefore be careful about locking
 *
 */

911
912
struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
				       const char *ha)
Linus Torvalds's avatar
Linus Torvalds committed
913
914
915
{
	struct net_device *dev;

916
	for_each_netdev_rcu(net, dev)
Linus Torvalds's avatar
Linus Torvalds committed
917
918
		if (dev->type == type &&
		    !memcmp(dev->dev_addr, ha, dev->addr_len))
919
920
921
			return dev;

	return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
922
}
923
EXPORT_SYMBOL(dev_getbyhwaddr_rcu);
924

925
struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
Linus Torvalds's avatar
Linus Torvalds committed
926
927
928
{
	struct net_device *dev;

929
	ASSERT_RTNL();
930
	for_each_netdev(net, dev)
931
		if (dev->type == type)
932
933
934
			return dev;

	return NULL;
935
936
937
}
EXPORT_SYMBOL(__dev_getfirstbyhwtype);

938
struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
939
{
940
	struct net_device *dev, *ret = NULL;
941

942
943
944
945
946
947
948
949
950
	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
951
952
953
954
}
EXPORT_SYMBOL(dev_getfirstbyhwtype);

/**
955
 *	__dev_get_by_flags - find any device with given flags
956
 *	@net: the applicable net namespace
Linus Torvalds's avatar
Linus Torvalds committed
957
958
959
960
 *	@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
961
 *	is not found or a pointer to the device. Must be called inside
962
 *	rtnl_lock(), and result refcount is unchanged.
Linus Torvalds's avatar
Linus Torvalds committed
963
964
 */

965
966
struct net_device *__dev_get_by_flags(struct net *net, unsigned short if_flags,
				      unsigned short mask)
Linus Torvalds's avatar
Linus Torvalds committed
967
{
968
	struct net_device *dev, *ret;
Linus Torvalds's avatar
Linus Torvalds committed
969

970
971
	ASSERT_RTNL();

972
	ret = NULL;
973
	for_each_netdev(net, dev) {
Linus Torvalds's avatar
Linus Torvalds committed
974
		if (((dev->flags ^ if_flags) & mask) == 0) {
975
			ret = dev;
Linus Torvalds's avatar
Linus Torvalds committed
976
977
978
			break;
		}
	}
979
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
980
}
981
EXPORT_SYMBOL(__dev_get_by_flags);
Linus Torvalds's avatar
Linus Torvalds committed
982
983
984
985
986
987

/**
 *	dev_valid_name - check if name is okay for network device
 *	@name: name string
 *
 *	Network device names need to be valid file names to
988
989
 *	to allow sysfs to work.  We also disallow any kind of
 *	whitespace.
Linus Torvalds's avatar
Linus Torvalds committed
990
 */
991
bool dev_valid_name(const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
992
{
993
	if (*name == '\0')
994
		return false;
995
	if (strlen(name) >= IFNAMSIZ)
996
		return false;
997
	if (!strcmp(name, ".") || !strcmp(name, ".."))
998
		return false;
999
1000

	while (*name) {
For faster browsing, not all history is shown. View entire blame