rtnetlink.c 66 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
9
10
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
/*
 * INET		An implementation of the TCP/IP protocol suite for the LINUX
 *		operating system.  INET is implemented using the  BSD Socket
 *		interface as the means of communication with the user level.
 *
 *		Routing netlink socket interface: protocol independent part.
 *
 * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 *
 *		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.
 *
 *	Fixes:
 *	Vitaly E. Lavrov		RTA_OK arithmetics was wrong.
 */

#include <linux/errno.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/kernel.h>
#include <linux/timer.h>
#include <linux/string.h>
#include <linux/sockios.h>
#include <linux/net.h>
#include <linux/fcntl.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/capability.h>
#include <linux/skbuff.h>
#include <linux/init.h>
#include <linux/security.h>
36
#include <linux/mutex.h>
37
#include <linux/if_addr.h>
38
#include <linux/if_bridge.h>
39
#include <linux/pci.h>
40
#include <linux/etherdevice.h>
Linus Torvalds's avatar
Linus Torvalds committed
41
42
43
44
45
46
47
48
49
50
51
52

#include <asm/uaccess.h>

#include <linux/inet.h>
#include <linux/netdevice.h>
#include <net/ip.h>
#include <net/protocol.h>
#include <net/arp.h>
#include <net/route.h>
#include <net/udp.h>
#include <net/sock.h>
#include <net/pkt_sched.h>
53
#include <net/fib_rules.h>
54
#include <net/rtnetlink.h>
55
#include <net/net_namespace.h>
Linus Torvalds's avatar
Linus Torvalds committed
56

Eric Dumazet's avatar
Eric Dumazet committed
57
struct rtnl_link {
58
59
	rtnl_doit_func		doit;
	rtnl_dumpit_func	dumpit;
60
	rtnl_calcit_func 	calcit;
61
62
};

63
static DEFINE_MUTEX(rtnl_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
64
65
66

void rtnl_lock(void)
{
67
	mutex_lock(&rtnl_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
68
}
Eric Dumazet's avatar
Eric Dumazet committed
69
EXPORT_SYMBOL(rtnl_lock);
Linus Torvalds's avatar
Linus Torvalds committed
70

71
void __rtnl_unlock(void)
Linus Torvalds's avatar
Linus Torvalds committed
72
{
73
	mutex_unlock(&rtnl_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
74
}
75

Linus Torvalds's avatar
Linus Torvalds committed
76
77
void rtnl_unlock(void)
{
78
	/* This fellow will unlock it for us. */
Linus Torvalds's avatar
Linus Torvalds committed
79
80
	netdev_run_todo();
}
Eric Dumazet's avatar
Eric Dumazet committed
81
EXPORT_SYMBOL(rtnl_unlock);
Linus Torvalds's avatar
Linus Torvalds committed
82

83
84
85
86
int rtnl_trylock(void)
{
	return mutex_trylock(&rtnl_mutex);
}
Eric Dumazet's avatar
Eric Dumazet committed
87
EXPORT_SYMBOL(rtnl_trylock);
88

89
90
91
92
int rtnl_is_locked(void)
{
	return mutex_is_locked(&rtnl_mutex);
}
Eric Dumazet's avatar
Eric Dumazet committed
93
EXPORT_SYMBOL(rtnl_is_locked);
94

95
96
97
98
99
100
101
102
#ifdef CONFIG_PROVE_LOCKING
int lockdep_rtnl_is_held(void)
{
	return lockdep_is_held(&rtnl_mutex);
}
EXPORT_SYMBOL(lockdep_rtnl_is_held);
#endif /* #ifdef CONFIG_PROVE_LOCKING */

103
static struct rtnl_link *rtnl_msg_handlers[RTNL_FAMILY_MAX + 1];
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

static inline int rtm_msgindex(int msgtype)
{
	int msgindex = msgtype - RTM_BASE;

	/*
	 * msgindex < 0 implies someone tried to register a netlink
	 * control code. msgindex >= RTM_NR_MSGTYPES may indicate that
	 * the message type has not been added to linux/rtnetlink.h
	 */
	BUG_ON(msgindex < 0 || msgindex >= RTM_NR_MSGTYPES);

	return msgindex;
}

static rtnl_doit_func rtnl_get_doit(int protocol, int msgindex)
{
	struct rtnl_link *tab;

123
	if (protocol <= RTNL_FAMILY_MAX)
124
125
126
127
		tab = rtnl_msg_handlers[protocol];
	else
		tab = NULL;

128
	if (tab == NULL || tab[msgindex].doit == NULL)
129
130
		tab = rtnl_msg_handlers[PF_UNSPEC];

131
	return tab[msgindex].doit;
132
133
134
135
136
137
}

static rtnl_dumpit_func rtnl_get_dumpit(int protocol, int msgindex)
{
	struct rtnl_link *tab;

138
	if (protocol <= RTNL_FAMILY_MAX)
139
140
141
142
		tab = rtnl_msg_handlers[protocol];
	else
		tab = NULL;

143
	if (tab == NULL || tab[msgindex].dumpit == NULL)
144
145
		tab = rtnl_msg_handlers[PF_UNSPEC];

146
	return tab[msgindex].dumpit;
147
148
}

149
150
151
152
153
154
155
156
157
158
159
160
static rtnl_calcit_func rtnl_get_calcit(int protocol, int msgindex)
{
	struct rtnl_link *tab;

	if (protocol <= RTNL_FAMILY_MAX)
		tab = rtnl_msg_handlers[protocol];
	else
		tab = NULL;

	if (tab == NULL || tab[msgindex].calcit == NULL)
		tab = rtnl_msg_handlers[PF_UNSPEC];

161
	return tab[msgindex].calcit;
162
163
}

164
165
166
167
168
169
/**
 * __rtnl_register - Register a rtnetlink message type
 * @protocol: Protocol family or PF_UNSPEC
 * @msgtype: rtnetlink message type
 * @doit: Function pointer called for each request message
 * @dumpit: Function pointer called for each dump request (NLM_F_DUMP) message
170
 * @calcit: Function pointer to calc size of dump message
171
172
173
174
175
176
177
178
179
180
181
182
 *
 * Registers the specified function pointers (at least one of them has
 * to be non-NULL) to be called whenever a request message for the
 * specified protocol family and message type is received.
 *
 * The special protocol family PF_UNSPEC may be used to define fallback
 * function pointers for the case when no entry for the specific protocol
 * family exists.
 *
 * Returns 0 on success or a negative error code.
 */
int __rtnl_register(int protocol, int msgtype,
183
184
		    rtnl_doit_func doit, rtnl_dumpit_func dumpit,
		    rtnl_calcit_func calcit)
185
186
187
188
{
	struct rtnl_link *tab;
	int msgindex;

189
	BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
	msgindex = rtm_msgindex(msgtype);

	tab = rtnl_msg_handlers[protocol];
	if (tab == NULL) {
		tab = kcalloc(RTM_NR_MSGTYPES, sizeof(*tab), GFP_KERNEL);
		if (tab == NULL)
			return -ENOBUFS;

		rtnl_msg_handlers[protocol] = tab;
	}

	if (doit)
		tab[msgindex].doit = doit;

	if (dumpit)
		tab[msgindex].dumpit = dumpit;

207
208
209
	if (calcit)
		tab[msgindex].calcit = calcit;

210
211
212
213
214
215
216
217
218
219
220
	return 0;
}
EXPORT_SYMBOL_GPL(__rtnl_register);

/**
 * rtnl_register - Register a rtnetlink message type
 *
 * Identical to __rtnl_register() but panics on failure. This is useful
 * as failure of this function is very unlikely, it can only happen due
 * to lack of memory when allocating the chain to store all message
 * handlers for a protocol. Meant for use in init functions where lack
Lucas De Marchi's avatar
Lucas De Marchi committed
221
 * of memory implies no sense in continuing.
222
223
 */
void rtnl_register(int protocol, int msgtype,
224
225
		   rtnl_doit_func doit, rtnl_dumpit_func dumpit,
		   rtnl_calcit_func calcit)
226
{
227
	if (__rtnl_register(protocol, msgtype, doit, dumpit, calcit) < 0)
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
		panic("Unable to register rtnetlink message handler, "
		      "protocol = %d, message type = %d\n",
		      protocol, msgtype);
}
EXPORT_SYMBOL_GPL(rtnl_register);

/**
 * rtnl_unregister - Unregister a rtnetlink message type
 * @protocol: Protocol family or PF_UNSPEC
 * @msgtype: rtnetlink message type
 *
 * Returns 0 on success or a negative error code.
 */
int rtnl_unregister(int protocol, int msgtype)
{
	int msgindex;

245
	BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
	msgindex = rtm_msgindex(msgtype);

	if (rtnl_msg_handlers[protocol] == NULL)
		return -ENOENT;

	rtnl_msg_handlers[protocol][msgindex].doit = NULL;
	rtnl_msg_handlers[protocol][msgindex].dumpit = NULL;

	return 0;
}
EXPORT_SYMBOL_GPL(rtnl_unregister);

/**
 * rtnl_unregister_all - Unregister all rtnetlink message type of a protocol
 * @protocol : Protocol family or PF_UNSPEC
 *
 * Identical to calling rtnl_unregster() for all registered message types
 * of a certain protocol family.
 */
void rtnl_unregister_all(int protocol)
{
267
	BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
268
269
270
271
272

	kfree(rtnl_msg_handlers[protocol]);
	rtnl_msg_handlers[protocol] = NULL;
}
EXPORT_SYMBOL_GPL(rtnl_unregister_all);
Linus Torvalds's avatar
Linus Torvalds committed
273

274
275
static LIST_HEAD(link_ops);

276
277
278
279
280
281
282
283
284
285
286
static const struct rtnl_link_ops *rtnl_link_ops_get(const char *kind)
{
	const struct rtnl_link_ops *ops;

	list_for_each_entry(ops, &link_ops, list) {
		if (!strcmp(ops->kind, kind))
			return ops;
	}
	return NULL;
}

287
288
289
290
291
292
293
294
295
296
297
298
/**
 * __rtnl_link_register - Register rtnl_link_ops with rtnetlink.
 * @ops: struct rtnl_link_ops * to register
 *
 * The caller must hold the rtnl_mutex. This function should be used
 * by drivers that create devices during module initialization. It
 * must be called before registering the devices.
 *
 * Returns 0 on success or a negative error code.
 */
int __rtnl_link_register(struct rtnl_link_ops *ops)
{
299
300
301
	if (rtnl_link_ops_get(ops->kind))
		return -EEXIST;

302
	if (!ops->dellink)
303
		ops->dellink = unregister_netdevice_queue;
304

305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
	list_add_tail(&ops->list, &link_ops);
	return 0;
}
EXPORT_SYMBOL_GPL(__rtnl_link_register);

/**
 * rtnl_link_register - Register rtnl_link_ops with rtnetlink.
 * @ops: struct rtnl_link_ops * to register
 *
 * Returns 0 on success or a negative error code.
 */
int rtnl_link_register(struct rtnl_link_ops *ops)
{
	int err;

	rtnl_lock();
	err = __rtnl_link_register(ops);
	rtnl_unlock();
	return err;
}
EXPORT_SYMBOL_GPL(rtnl_link_register);

327
328
329
static void __rtnl_kill_links(struct net *net, struct rtnl_link_ops *ops)
{
	struct net_device *dev;
330
331
	LIST_HEAD(list_kill);

332
	for_each_netdev(net, dev) {
333
334
		if (dev->rtnl_link_ops == ops)
			ops->dellink(dev, &list_kill);
335
	}
336
	unregister_netdevice_many(&list_kill);
337
338
}

339
340
341
342
/**
 * __rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink.
 * @ops: struct rtnl_link_ops * to unregister
 *
343
 * The caller must hold the rtnl_mutex.
344
345
346
 */
void __rtnl_link_unregister(struct rtnl_link_ops *ops)
{
347
	struct net *net;
348

349
	for_each_net(net) {
350
		__rtnl_kill_links(net, ops);
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
	list_del(&ops->list);
}
EXPORT_SYMBOL_GPL(__rtnl_link_unregister);

/**
 * rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink.
 * @ops: struct rtnl_link_ops * to unregister
 */
void rtnl_link_unregister(struct rtnl_link_ops *ops)
{
	rtnl_lock();
	__rtnl_link_unregister(ops);
	rtnl_unlock();
}
EXPORT_SYMBOL_GPL(rtnl_link_unregister);

static size_t rtnl_link_get_size(const struct net_device *dev)
{
	const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
	size_t size;

	if (!ops)
		return 0;

376
377
	size = nla_total_size(sizeof(struct nlattr)) + /* IFLA_LINKINFO */
	       nla_total_size(strlen(ops->kind) + 1);  /* IFLA_INFO_KIND */
378
379
380

	if (ops->get_size)
		/* IFLA_INFO_DATA + nested data */
381
		size += nla_total_size(sizeof(struct nlattr)) +
382
383
384
			ops->get_size(dev);

	if (ops->get_xstats_size)
385
386
		/* IFLA_INFO_XSTATS */
		size += nla_total_size(ops->get_xstats_size(dev));
387
388
389
390

	return size;
}

391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
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
436
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
467
468
469
470
471
472
473
474
475
476
477
478
479
static LIST_HEAD(rtnl_af_ops);

static const struct rtnl_af_ops *rtnl_af_lookup(const int family)
{
	const struct rtnl_af_ops *ops;

	list_for_each_entry(ops, &rtnl_af_ops, list) {
		if (ops->family == family)
			return ops;
	}

	return NULL;
}

/**
 * __rtnl_af_register - Register rtnl_af_ops with rtnetlink.
 * @ops: struct rtnl_af_ops * to register
 *
 * The caller must hold the rtnl_mutex.
 *
 * Returns 0 on success or a negative error code.
 */
int __rtnl_af_register(struct rtnl_af_ops *ops)
{
	list_add_tail(&ops->list, &rtnl_af_ops);
	return 0;
}
EXPORT_SYMBOL_GPL(__rtnl_af_register);

/**
 * rtnl_af_register - Register rtnl_af_ops with rtnetlink.
 * @ops: struct rtnl_af_ops * to register
 *
 * Returns 0 on success or a negative error code.
 */
int rtnl_af_register(struct rtnl_af_ops *ops)
{
	int err;

	rtnl_lock();
	err = __rtnl_af_register(ops);
	rtnl_unlock();
	return err;
}
EXPORT_SYMBOL_GPL(rtnl_af_register);

/**
 * __rtnl_af_unregister - Unregister rtnl_af_ops from rtnetlink.
 * @ops: struct rtnl_af_ops * to unregister
 *
 * The caller must hold the rtnl_mutex.
 */
void __rtnl_af_unregister(struct rtnl_af_ops *ops)
{
	list_del(&ops->list);
}
EXPORT_SYMBOL_GPL(__rtnl_af_unregister);

/**
 * rtnl_af_unregister - Unregister rtnl_af_ops from rtnetlink.
 * @ops: struct rtnl_af_ops * to unregister
 */
void rtnl_af_unregister(struct rtnl_af_ops *ops)
{
	rtnl_lock();
	__rtnl_af_unregister(ops);
	rtnl_unlock();
}
EXPORT_SYMBOL_GPL(rtnl_af_unregister);

static size_t rtnl_link_get_af_size(const struct net_device *dev)
{
	struct rtnl_af_ops *af_ops;
	size_t size;

	/* IFLA_AF_SPEC */
	size = nla_total_size(sizeof(struct nlattr));

	list_for_each_entry(af_ops, &rtnl_af_ops, list) {
		if (af_ops->get_link_af_size) {
			/* AF_* + nested data */
			size += nla_total_size(sizeof(struct nlattr)) +
				af_ops->get_link_af_size(dev);
		}
	}

	return size;
}

480
481
482
483
484
485
486
487
488
489
490
491
492
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
static int rtnl_link_fill(struct sk_buff *skb, const struct net_device *dev)
{
	const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
	struct nlattr *linkinfo, *data;
	int err = -EMSGSIZE;

	linkinfo = nla_nest_start(skb, IFLA_LINKINFO);
	if (linkinfo == NULL)
		goto out;

	if (nla_put_string(skb, IFLA_INFO_KIND, ops->kind) < 0)
		goto err_cancel_link;
	if (ops->fill_xstats) {
		err = ops->fill_xstats(skb, dev);
		if (err < 0)
			goto err_cancel_link;
	}
	if (ops->fill_info) {
		data = nla_nest_start(skb, IFLA_INFO_DATA);
		if (data == NULL)
			goto err_cancel_link;
		err = ops->fill_info(skb, dev);
		if (err < 0)
			goto err_cancel_data;
		nla_nest_end(skb, data);
	}

	nla_nest_end(skb, linkinfo);
	return 0;

err_cancel_data:
	nla_nest_cancel(skb, data);
err_cancel_link:
	nla_nest_cancel(skb, linkinfo);
out:
	return err;
}

518
static const int rtm_min[RTM_NR_FAMILIES] =
Linus Torvalds's avatar
Linus Torvalds committed
519
{
520
521
522
	[RTM_FAM(RTM_NEWLINK)]      = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
	[RTM_FAM(RTM_NEWADDR)]      = NLMSG_LENGTH(sizeof(struct ifaddrmsg)),
	[RTM_FAM(RTM_NEWROUTE)]     = NLMSG_LENGTH(sizeof(struct rtmsg)),
523
	[RTM_FAM(RTM_NEWRULE)]      = NLMSG_LENGTH(sizeof(struct fib_rule_hdr)),
524
525
526
527
528
529
	[RTM_FAM(RTM_NEWQDISC)]     = NLMSG_LENGTH(sizeof(struct tcmsg)),
	[RTM_FAM(RTM_NEWTCLASS)]    = NLMSG_LENGTH(sizeof(struct tcmsg)),
	[RTM_FAM(RTM_NEWTFILTER)]   = NLMSG_LENGTH(sizeof(struct tcmsg)),
	[RTM_FAM(RTM_NEWACTION)]    = NLMSG_LENGTH(sizeof(struct tcamsg)),
	[RTM_FAM(RTM_GETMULTICAST)] = NLMSG_LENGTH(sizeof(struct rtgenmsg)),
	[RTM_FAM(RTM_GETANYCAST)]   = NLMSG_LENGTH(sizeof(struct rtgenmsg)),
Linus Torvalds's avatar
Linus Torvalds committed
530
531
};

532
static const int rta_max[RTM_NR_FAMILIES] =
Linus Torvalds's avatar
Linus Torvalds committed
533
{
534
535
536
	[RTM_FAM(RTM_NEWLINK)]      = IFLA_MAX,
	[RTM_FAM(RTM_NEWADDR)]      = IFA_MAX,
	[RTM_FAM(RTM_NEWROUTE)]     = RTA_MAX,
537
	[RTM_FAM(RTM_NEWRULE)]      = FRA_MAX,
538
539
540
541
	[RTM_FAM(RTM_NEWQDISC)]     = TCA_MAX,
	[RTM_FAM(RTM_NEWTCLASS)]    = TCA_MAX,
	[RTM_FAM(RTM_NEWTFILTER)]   = TCA_MAX,
	[RTM_FAM(RTM_NEWACTION)]    = TCAA_MAX,
Linus Torvalds's avatar
Linus Torvalds committed
542
543
};

544
int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigned int group, int echo)
Linus Torvalds's avatar
Linus Torvalds committed
545
{
546
	struct sock *rtnl = net->rtnl;
Linus Torvalds's avatar
Linus Torvalds committed
547
548
	int err = 0;

549
	NETLINK_CB(skb).dst_group = group;
Linus Torvalds's avatar
Linus Torvalds committed
550
551
552
553
554
555
556
557
	if (echo)
		atomic_inc(&skb->users);
	netlink_broadcast(rtnl, skb, pid, group, GFP_KERNEL);
	if (echo)
		err = netlink_unicast(rtnl, skb, pid, MSG_DONTWAIT);
	return err;
}

558
int rtnl_unicast(struct sk_buff *skb, struct net *net, u32 pid)
559
{
560
561
	struct sock *rtnl = net->rtnl;

562
563
	return nlmsg_unicast(rtnl, skb, pid);
}
Eric Dumazet's avatar
Eric Dumazet committed
564
EXPORT_SYMBOL(rtnl_unicast);
565

566
567
void rtnl_notify(struct sk_buff *skb, struct net *net, u32 pid, u32 group,
		 struct nlmsghdr *nlh, gfp_t flags)
568
{
569
	struct sock *rtnl = net->rtnl;
570
571
572
573
574
	int report = 0;

	if (nlh)
		report = nlmsg_report(nlh);

575
	nlmsg_notify(rtnl, skb, pid, group, report, flags);
576
}
Eric Dumazet's avatar
Eric Dumazet committed
577
EXPORT_SYMBOL(rtnl_notify);
578

579
void rtnl_set_sk_err(struct net *net, u32 group, int error)
580
{
581
582
	struct sock *rtnl = net->rtnl;

583
584
	netlink_set_err(rtnl, 0, group, error);
}
Eric Dumazet's avatar
Eric Dumazet committed
585
EXPORT_SYMBOL(rtnl_set_sk_err);
586

Linus Torvalds's avatar
Linus Torvalds committed
587
588
int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics)
{
589
590
591
592
593
594
595
596
597
598
	struct nlattr *mx;
	int i, valid = 0;

	mx = nla_nest_start(skb, RTA_METRICS);
	if (mx == NULL)
		return -ENOBUFS;

	for (i = 0; i < RTAX_MAX; i++) {
		if (metrics[i]) {
			valid++;
599
600
			if (nla_put_u32(skb, i+1, metrics[i]))
				goto nla_put_failure;
601
		}
Linus Torvalds's avatar
Linus Torvalds committed
602
603
	}

604
605
606
607
	if (!valid) {
		nla_nest_cancel(skb, mx);
		return 0;
	}
608
609
610
611

	return nla_nest_end(skb, mx);

nla_put_failure:
612
613
	nla_nest_cancel(skb, mx);
	return -EMSGSIZE;
Linus Torvalds's avatar
Linus Torvalds committed
614
}
Eric Dumazet's avatar
Eric Dumazet committed
615
EXPORT_SYMBOL(rtnetlink_put_metrics);
Linus Torvalds's avatar
Linus Torvalds committed
616

617
int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id,
618
		       long expires, u32 error)
619
620
{
	struct rta_cacheinfo ci = {
621
		.rta_lastuse = jiffies_delta_to_clock_t(jiffies - dst->lastuse),
622
623
624
625
626
627
		.rta_used = dst->__use,
		.rta_clntref = atomic_read(&(dst->__refcnt)),
		.rta_error = error,
		.rta_id =  id,
	};

628
629
	if (expires) {
		unsigned long clock;
630

631
632
633
634
		clock = jiffies_to_clock_t(abs(expires));
		clock = min_t(unsigned long, clock, INT_MAX);
		ci.rta_expires = (expires > 0) ? clock : -clock;
	}
635
636
637
	return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci);
}
EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo);
Linus Torvalds's avatar
Linus Torvalds committed
638

639
static void set_operstate(struct net_device *dev, unsigned char transition)
640
641
642
{
	unsigned char operstate = dev->operstate;

Eric Dumazet's avatar
Eric Dumazet committed
643
	switch (transition) {
644
645
646
647
648
649
650
651
652
653
654
655
	case IF_OPER_UP:
		if ((operstate == IF_OPER_DORMANT ||
		     operstate == IF_OPER_UNKNOWN) &&
		    !netif_dormant(dev))
			operstate = IF_OPER_UP;
		break;

	case IF_OPER_DORMANT:
		if (operstate == IF_OPER_UP ||
		    operstate == IF_OPER_UNKNOWN)
			operstate = IF_OPER_DORMANT;
		break;
656
	}
657
658
659
660
661

	if (dev->operstate != operstate) {
		write_lock_bh(&dev_base_lock);
		dev->operstate = operstate;
		write_unlock_bh(&dev_base_lock);
662
663
		netdev_state_change(dev);
	}
664
665
}

666
667
668
669
670
671
static unsigned int rtnl_dev_get_flags(const struct net_device *dev)
{
	return (dev->flags & ~(IFF_PROMISC | IFF_ALLMULTI)) |
	       (dev->gflags & (IFF_PROMISC | IFF_ALLMULTI));
}

672
673
674
675
676
677
678
679
static unsigned int rtnl_dev_combine_flags(const struct net_device *dev,
					   const struct ifinfomsg *ifm)
{
	unsigned int flags = ifm->ifi_flags;

	/* bugwards compatibility: ifi_change == 0 is treated as ~0 */
	if (ifm->ifi_change)
		flags = (flags & ifm->ifi_change) |
680
			(rtnl_dev_get_flags(dev) & ~ifm->ifi_change);
681
682
683
684

	return flags;
}

685
static void copy_rtnl_link_stats(struct rtnl_link_stats *a,
686
				 const struct rtnl_link_stats64 *b)
Linus Torvalds's avatar
Linus Torvalds committed
687
{
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
714
	a->rx_packets = b->rx_packets;
	a->tx_packets = b->tx_packets;
	a->rx_bytes = b->rx_bytes;
	a->tx_bytes = b->tx_bytes;
	a->rx_errors = b->rx_errors;
	a->tx_errors = b->tx_errors;
	a->rx_dropped = b->rx_dropped;
	a->tx_dropped = b->tx_dropped;

	a->multicast = b->multicast;
	a->collisions = b->collisions;

	a->rx_length_errors = b->rx_length_errors;
	a->rx_over_errors = b->rx_over_errors;
	a->rx_crc_errors = b->rx_crc_errors;
	a->rx_frame_errors = b->rx_frame_errors;
	a->rx_fifo_errors = b->rx_fifo_errors;
	a->rx_missed_errors = b->rx_missed_errors;

	a->tx_aborted_errors = b->tx_aborted_errors;
	a->tx_carrier_errors = b->tx_carrier_errors;
	a->tx_fifo_errors = b->tx_fifo_errors;
	a->tx_heartbeat_errors = b->tx_heartbeat_errors;
	a->tx_window_errors = b->tx_window_errors;

	a->rx_compressed = b->rx_compressed;
	a->tx_compressed = b->tx_compressed;
715
716
}

717
static void copy_rtnl_link_stats64(void *v, const struct rtnl_link_stats64 *b)
718
{
719
	memcpy(v, b, sizeof(*b));
720
}
Linus Torvalds's avatar
Linus Torvalds committed
721

722
/* All VF info */
723
724
static inline int rtnl_vfinfo_size(const struct net_device *dev,
				   u32 ext_filter_mask)
725
{
726
727
	if (dev->dev.parent && dev_is_pci(dev->dev.parent) &&
	    (ext_filter_mask & RTEXT_FILTER_VF)) {
728
		int num_vfs = dev_num_vf(dev->dev.parent);
729
730
731
732
733
		size_t size = nla_total_size(sizeof(struct nlattr));
		size += nla_total_size(num_vfs * sizeof(struct nlattr));
		size += num_vfs *
			(nla_total_size(sizeof(struct ifla_vf_mac)) +
			 nla_total_size(sizeof(struct ifla_vf_vlan)) +
734
735
			 nla_total_size(sizeof(struct ifla_vf_tx_rate)) +
			 nla_total_size(sizeof(struct ifla_vf_spoofchk)));
736
737
		return size;
	} else
738
739
740
		return 0;
}

741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
static size_t rtnl_port_size(const struct net_device *dev)
{
	size_t port_size = nla_total_size(4)		/* PORT_VF */
		+ nla_total_size(PORT_PROFILE_MAX)	/* PORT_PROFILE */
		+ nla_total_size(sizeof(struct ifla_port_vsi))
							/* PORT_VSI_TYPE */
		+ nla_total_size(PORT_UUID_MAX)		/* PORT_INSTANCE_UUID */
		+ nla_total_size(PORT_UUID_MAX)		/* PORT_HOST_UUID */
		+ nla_total_size(1)			/* PROT_VDP_REQUEST */
		+ nla_total_size(2);			/* PORT_VDP_RESPONSE */
	size_t vf_ports_size = nla_total_size(sizeof(struct nlattr));
	size_t vf_port_size = nla_total_size(sizeof(struct nlattr))
		+ port_size;
	size_t port_self_size = nla_total_size(sizeof(struct nlattr))
		+ port_size;

	if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent)
		return 0;
	if (dev_num_vf(dev->dev.parent))
		return port_self_size + vf_ports_size +
			vf_port_size * dev_num_vf(dev->dev.parent);
	else
		return port_self_size;
}

766
767
static noinline size_t if_nlmsg_size(const struct net_device *dev,
				     u32 ext_filter_mask)
768
769
770
{
	return NLMSG_ALIGN(sizeof(struct ifinfomsg))
	       + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
771
	       + nla_total_size(IFALIASZ) /* IFLA_IFALIAS */
772
773
774
	       + nla_total_size(IFNAMSIZ) /* IFLA_QDISC */
	       + nla_total_size(sizeof(struct rtnl_link_ifmap))
	       + nla_total_size(sizeof(struct rtnl_link_stats))
775
	       + nla_total_size(sizeof(struct rtnl_link_stats64))
776
777
778
779
780
781
782
	       + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
	       + nla_total_size(MAX_ADDR_LEN) /* IFLA_BROADCAST */
	       + nla_total_size(4) /* IFLA_TXQLEN */
	       + nla_total_size(4) /* IFLA_WEIGHT */
	       + nla_total_size(4) /* IFLA_MTU */
	       + nla_total_size(4) /* IFLA_LINK */
	       + nla_total_size(4) /* IFLA_MASTER */
783
	       + nla_total_size(1) /* IFLA_CARRIER */
784
	       + nla_total_size(4) /* IFLA_PROMISCUITY */
785
786
	       + nla_total_size(4) /* IFLA_NUM_TX_QUEUES */
	       + nla_total_size(4) /* IFLA_NUM_RX_QUEUES */
787
	       + nla_total_size(1) /* IFLA_OPERSTATE */
788
	       + nla_total_size(1) /* IFLA_LINKMODE */
789
790
791
	       + nla_total_size(ext_filter_mask
			        & RTEXT_FILTER_VF ? 4 : 0) /* IFLA_NUM_VF */
	       + rtnl_vfinfo_size(dev, ext_filter_mask) /* IFLA_VFINFO_LIST */
792
	       + rtnl_port_size(dev) /* IFLA_VF_PORTS + IFLA_PORT_SELF */
793
794
	       + rtnl_link_get_size(dev) /* IFLA_LINKINFO */
	       + rtnl_link_get_af_size(dev); /* IFLA_AF_SPEC */
795
796
}

797
798
799
800
801
802
803
804
805
806
807
808
809
static int rtnl_vf_ports_fill(struct sk_buff *skb, struct net_device *dev)
{
	struct nlattr *vf_ports;
	struct nlattr *vf_port;
	int vf;
	int err;

	vf_ports = nla_nest_start(skb, IFLA_VF_PORTS);
	if (!vf_ports)
		return -EMSGSIZE;

	for (vf = 0; vf < dev_num_vf(dev->dev.parent); vf++) {
		vf_port = nla_nest_start(skb, IFLA_VF_PORT);
810
811
		if (!vf_port)
			goto nla_put_failure;
812
813
		if (nla_put_u32(skb, IFLA_PORT_VF, vf))
			goto nla_put_failure;
814
		err = dev->netdev_ops->ndo_get_vf_port(dev, vf, skb);
815
816
		if (err == -EMSGSIZE)
			goto nla_put_failure;
817
818
819
820
821
822
823
824
825
826
		if (err) {
			nla_nest_cancel(skb, vf_port);
			continue;
		}
		nla_nest_end(skb, vf_port);
	}

	nla_nest_end(skb, vf_ports);

	return 0;
827
828
829
830

nla_put_failure:
	nla_nest_cancel(skb, vf_ports);
	return -EMSGSIZE;
831
832
833
834
835
836
837
838
839
840
841
842
843
844
}

static int rtnl_port_self_fill(struct sk_buff *skb, struct net_device *dev)
{
	struct nlattr *port_self;
	int err;

	port_self = nla_nest_start(skb, IFLA_PORT_SELF);
	if (!port_self)
		return -EMSGSIZE;

	err = dev->netdev_ops->ndo_get_vf_port(dev, PORT_SELF_VF, skb);
	if (err) {
		nla_nest_cancel(skb, port_self);
845
		return (err == -EMSGSIZE) ? err : 0;
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
	}

	nla_nest_end(skb, port_self);

	return 0;
}

static int rtnl_port_fill(struct sk_buff *skb, struct net_device *dev)
{
	int err;

	if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent)
		return 0;

	err = rtnl_port_self_fill(skb, dev);
	if (err)
		return err;

	if (dev_num_vf(dev->dev.parent)) {
		err = rtnl_vf_ports_fill(skb, dev);
		if (err)
			return err;
	}

	return 0;
}

873
static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev,
874
			    int type, u32 pid, u32 seq, u32 change,
875
			    unsigned int flags, u32 ext_filter_mask)
876
877
878
{
	struct ifinfomsg *ifm;
	struct nlmsghdr *nlh;
879
	struct rtnl_link_stats64 temp;
880
	const struct rtnl_link_stats64 *stats;
881
882
	struct nlattr *attr, *af_spec;
	struct rtnl_af_ops *af_ops;
883
	struct net_device *upper_dev = netdev_master_upper_dev_get(dev);
Linus Torvalds's avatar
Linus Torvalds committed
884

885
	ASSERT_RTNL();
886
887
	nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags);
	if (nlh == NULL)
888
		return -EMSGSIZE;
Linus Torvalds's avatar
Linus Torvalds committed
889

890
891
892
893
894
895
896
897
	ifm = nlmsg_data(nlh);
	ifm->ifi_family = AF_UNSPEC;
	ifm->__ifi_pad = 0;
	ifm->ifi_type = dev->type;
	ifm->ifi_index = dev->ifindex;
	ifm->ifi_flags = dev_get_flags(dev);
	ifm->ifi_change = change;

898
899
900
901
902
903
904
	if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
	    nla_put_u32(skb, IFLA_TXQLEN, dev->tx_queue_len) ||
	    nla_put_u8(skb, IFLA_OPERSTATE,
		       netif_running(dev) ? dev->operstate : IF_OPER_DOWN) ||
	    nla_put_u8(skb, IFLA_LINKMODE, dev->link_mode) ||
	    nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
	    nla_put_u32(skb, IFLA_GROUP, dev->group) ||
905
	    nla_put_u32(skb, IFLA_PROMISCUITY, dev->promiscuity) ||
906
	    nla_put_u32(skb, IFLA_NUM_TX_QUEUES, dev->num_tx_queues) ||
907
#ifdef CONFIG_RPS
908
	    nla_put_u32(skb, IFLA_NUM_RX_QUEUES, dev->num_rx_queues) ||
909
#endif
910
911
	    (dev->ifindex != dev->iflink &&
	     nla_put_u32(skb, IFLA_LINK, dev->iflink)) ||
912
913
	    (upper_dev &&
	     nla_put_u32(skb, IFLA_MASTER, upper_dev->ifindex)) ||
914
	    nla_put_u8(skb, IFLA_CARRIER, netif_carrier_ok(dev)) ||
915
916
917
918
919
	    (dev->qdisc &&
	     nla_put_string(skb, IFLA_QDISC, dev->qdisc->ops->id)) ||
	    (dev->ifalias &&
	     nla_put_string(skb, IFLA_IFALIAS, dev->ifalias)))
		goto nla_put_failure;
920

Linus Torvalds's avatar
Linus Torvalds committed
921
922
923
924
925
926
927
928
929
	if (1) {
		struct rtnl_link_ifmap map = {
			.mem_start   = dev->mem_start,
			.mem_end     = dev->mem_end,
			.base_addr   = dev->base_addr,
			.irq         = dev->irq,
			.dma         = dev->dma,
			.port        = dev->if_port,
		};
930
931
		if (nla_put(skb, IFLA_MAP, sizeof(map), &map))
			goto nla_put_failure;
Linus Torvalds's avatar
Linus Torvalds committed
932
933
934
	}

	if (dev->addr_len) {
935
936
937
		if (nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr) ||
		    nla_put(skb, IFLA_BROADCAST, dev->addr_len, dev->broadcast))
			goto nla_put_failure;
Linus Torvalds's avatar
Linus Torvalds committed
938
939
	}

940
941
942
943
	attr = nla_reserve(skb, IFLA_STATS,
			sizeof(struct rtnl_link_stats));
	if (attr == NULL)
		goto nla_put_failure;
944

945
	stats = dev_get_stats(dev, &temp);
946
	copy_rtnl_link_stats(nla_data(attr), stats);
Linus Torvalds's avatar
Linus Torvalds committed
947

948
949
950
951
952
953
	attr = nla_reserve(skb, IFLA_STATS64,
			sizeof(struct rtnl_link_stats64));
	if (attr == NULL)
		goto nla_put_failure;
	copy_rtnl_link_stats64(nla_data(attr), stats);

954
955
956
	if (dev->dev.parent && (ext_filter_mask & RTEXT_FILTER_VF) &&
	    nla_put_u32(skb, IFLA_NUM_VF, dev_num_vf(dev->dev.parent)))
		goto nla_put_failure;
957

958
959
	if (dev->netdev_ops->ndo_get_vf_config && dev->dev.parent
	    && (ext_filter_mask & RTEXT_FILTER_VF)) {
960
961
		int i;

962
963
964
965
966
967
968
969
970
971
972
		struct nlattr *vfinfo, *vf;
		int num_vfs = dev_num_vf(dev->dev.parent);

		vfinfo = nla_nest_start(skb, IFLA_VFINFO_LIST);
		if (!vfinfo)
			goto nla_put_failure;
		for (i = 0; i < num_vfs; i++) {
			struct ifla_vf_info ivi;
			struct ifla_vf_mac vf_mac;
			struct ifla_vf_vlan vf_vlan;
			struct ifla_vf_tx_rate vf_tx_rate;
973
974
975
976
977
978
979
980
981
			struct ifla_vf_spoofchk vf_spoofchk;

			/*
			 * Not all SR-IOV capable drivers support the
			 * spoofcheck query.  Preset to -1 so the user
			 * space tool can detect that the driver didn't
			 * report anything.
			 */
			ivi.spoofchk = -1;
982
			memset(ivi.mac, 0, sizeof(ivi.mac));
983
984
			if (dev->netdev_ops->ndo_get_vf_config(dev, i, &ivi))
				break;
985
986
987
988
989
			vf_mac.vf =
				vf_vlan.vf =
				vf_tx_rate.vf =
				vf_spoofchk.vf = ivi.vf;

990
991
992
993
			memcpy(vf_mac.mac, ivi.mac, sizeof(ivi.mac));
			vf_vlan.vlan = ivi.vlan;
			vf_vlan.qos = ivi.qos;
			vf_tx_rate.rate = ivi.tx_rate;
994
			vf_spoofchk.setting = ivi.spoofchk;
995
996
997
998
999
			vf = nla_nest_start(skb, IFLA_VF_INFO);
			if (!vf) {
				nla_nest_cancel(skb, vfinfo);
				goto nla_put_failure;
			}
1000
1001
1002
1003
1004
1005
1006
			if (nla_put(skb, IFLA_VF_MAC, sizeof(vf_mac), &vf_mac) ||
			    nla_put(skb, IFLA_VF_VLAN, sizeof(vf_vlan), &vf_vlan) ||
			    nla_put(skb, IFLA_VF_TX_RATE, sizeof(vf_tx_rate),
				    &vf_tx_rate) ||
			    nla_put(skb, IFLA_VF_SPOOFCHK, sizeof(vf_spoofchk),
				    &vf_spoofchk))
				goto nla_put_failure;
1007
			nla_nest_end(skb, vf);
1008
		}
1009
		nla_nest_end(skb, vfinfo);
1010
	}
1011
1012
1013
1014

	if (rtnl_port_fill(skb, dev))
		goto nla_put_failure;

1015
1016
1017
1018
1019
	if (dev->rtnl_link_ops) {
		if (rtnl_link_fill(skb, dev) < 0)
			goto nla_put_failure;
	}

1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
	if (!(af_spec = nla_nest_start(skb, IFLA_AF_SPEC)))
		goto nla_put_failure;

	list_for_each_entry(af_ops, &rtnl_af_ops, list) {
		if (af_ops->fill_link_af) {
			struct nlattr *af;
			int err;

			if (!(af = nla_nest_start(skb, af_ops->family)))
				goto nla_put_failure;

			err = af_ops->fill_link_af(skb, dev);

			/*
			 * Caller may return ENODATA to indicate that there
			 * was no data to be dumped. This is not an error, it
			 * means we should trim the attribute header and
			 * continue.
			 */
			if (err == -ENODATA)
				nla_nest_cancel(skb, af);
			else if (err < 0)
				goto nla_put_failure;

			nla_nest_end(skb, af);
		}
	}

	nla_nest_end(skb, af_spec);

1050
1051
1052
	return nlmsg_end(skb, nlh);

nla_put_failure:
1053
1054
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
Linus Torvalds's avatar
Linus Torvalds committed
1055
1056
}

1057
static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
Linus Torvalds's avatar
Linus Torvalds committed
1058
{
1059
	struct net *net = sock_net(skb->sk);
1060
1061
	int h, s_h;
	int idx = 0, s_idx;
Linus Torvalds's avatar
Linus Torvalds committed
1062
	struct net_device *dev;
1063
	struct hlist_head *head;
1064
1065
	struct nlattr *tb[IFLA_MAX+1];
	u32 ext_filter_mask = 0;
1066
1067
1068
1069

	s_h = cb->args[0];
	s_idx = cb->args[1];

1070
	rcu_read_lock();
1071
1072
	cb->seq = net->dev_base_seq;

1073
1074
	if (nlmsg_parse(cb->nlh, sizeof(struct rtgenmsg), tb, IFLA_MAX,
			ifla_policy) >= 0) {
1075

1076
1077
1078
		if (tb[IFLA_EXT_MASK])
			ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
	}
1079

1080
1081
1082
	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
		idx = 0;
		head = &net->dev_index_head[h];
1083
		hlist_for_each_entry_rcu(dev, head, index_hlist) {
1084
1085
1086
			if (idx < s_idx)
				goto cont;
			if (rtnl_fill_ifinfo(skb, dev, RTM_NEWLINK,
1087
					     NETLINK_CB(cb->skb).portid,
1088
					     cb->nlh->nlmsg_seq, 0,
1089
1090
					     NLM_F_MULTI,
					     ext_filter_mask) <= 0)
1091
				goto out;
1092
1093

			nl_dump_check_consistent(cb, nlmsg_hdr(skb));
1094
cont:
1095
1096
			idx++;
		}
Linus Torvalds's avatar
Linus Torvalds committed
1097
	}
1098
out:
1099
	rcu_read_unlock();
1100
1101
	cb->args[1] = idx;
	cb->args[0] = h;
Linus Torvalds's avatar
Linus Torvalds committed
1102
1103
1104
1105

	return skb->len;
}

1106
const struct nla_policy ifla_policy[IFLA_MAX+1] = {
1107
	[IFLA_IFNAME]		= { .type = NLA_STRING, .len = IFNAMSIZ-1 },
1108
1109
	[IFLA_ADDRESS]		= { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
	[IFLA_BROADCAST]	= { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
1110
	[IFLA_MAP]		= { .len = sizeof(struct rtnl_link_ifmap) },
1111
	[IFLA_MTU]		= { .type = NLA_U32 },
1112
	[IFLA_LINK]		= { .type = NLA_U32 },
1113
	[IFLA_MASTER]		= { .type = NLA_U32 },
1114
	[IFLA_CARRIER]		= { .type = NLA_U8 },
1115
1116
1117
1118
	[IFLA_TXQLEN]		= { .type = NLA_U32 },
	[IFLA_WEIGHT]		= { .type = NLA_U32 },
	[IFLA_OPERSTATE]	= { .type = NLA_U8 },
	[IFLA_LINKMODE]		= { .type = NLA_U8 },
1119
	[IFLA_LINKINFO]		= { .type = NLA_NESTED },
1120
	[IFLA_NET_NS_PID]	= { .type = NLA_U32 },
1121
	[IFLA_NET_NS_FD]	= { .type = NLA_U32 },
1122
	[IFLA_IFALIAS]	        = { .type = NLA_STRING, .len = IFALIASZ-1 },
1123
	[IFLA_VFINFO_LIST]	= {. type = NLA_NESTED },
1124
1125
	[IFLA_VF_PORTS]		= { .type = NLA_NESTED },
	[IFLA_PORT_SELF]	= { .type = NLA_NESTED },
1126
	[IFLA_AF_SPEC]		= { .type = NLA_NESTED },
1127
	[IFLA_EXT_MASK]		= { .type = NLA_U32 },
1128
	[IFLA_PROMISCUITY]	= { .type = NLA_U32 },
1129
1130
	[IFLA_NUM_TX_QUEUES]	= { .type = NLA_U32 },
	[IFLA_NUM_RX_QUEUES]	= { .type = NLA_U32 },
1131
};
Eric Dumazet's avatar
Eric Dumazet committed
1132
EXPORT_SYMBOL(ifla_policy);
1133

1134
1135
1136
1137
1138
static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = {
	[IFLA_INFO_KIND]	= { .type = NLA_STRING },
	[IFLA_INFO_DATA]	= { .type = NLA_NESTED },
};

1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
static const struct nla_policy ifla_vfinfo_policy[IFLA_VF_INFO_MAX+1] = {
	[IFLA_VF_INFO]		= { .type = NLA_NESTED },
};

static const struct nla_policy ifla_vf_policy[IFLA_VF_MAX+1] = {
	[IFLA_VF_MAC]		= { .type = NLA_BINARY,
				    .len = sizeof(struct ifla_vf_mac) },
	[IFLA_VF_VLAN]		= { .type = NLA_BINARY,
				    .len = sizeof(struct ifla_vf_vlan) },
	[IFLA_VF_TX_RATE]	= { .type = NLA_BINARY,
				    .len = sizeof(struct ifla_vf_tx_rate) },
Greg Rose's avatar
Greg Rose committed
1150
1151
	[IFLA_VF_SPOOFCHK]	= { .type = NLA_BINARY,
				    .len = sizeof(struct ifla_vf_spoofchk) },
1152
1153
};

1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
static const struct nla_policy ifla_port_policy[IFLA_PORT_MAX+1] = {
	[IFLA_PORT_VF]		= { .type = NLA_U32 },
	[IFLA_PORT_PROFILE]	= { .type = NLA_STRING,
				    .len = PORT_PROFILE_MAX },
	[IFLA_PORT_VSI_TYPE]	= { .type = NLA_BINARY,
				    .len = sizeof(struct ifla_port_vsi)},
	[IFLA_PORT_INSTANCE_UUID] = { .type = NLA_BINARY,
				      .len = PORT_UUID_MAX },
	[IFLA_PORT_HOST_UUID]	= { .type = NLA_STRING,
				    .len = PORT_UUID_MAX },
	[IFLA_PORT_REQUEST]	= { .type = NLA_U8, },
	[IFLA_PORT_RESPONSE]	= { .type = NLA_U16, },
};

1168
1169
1170
1171
1172
1173
1174
1175
struct net *rtnl_link_get_net(struct net *src_net, struct nlattr *tb[])
{
	struct net *net;
	/* Examine the link attributes and figure out which
	 * network namespace we are talking about.
	 */
	if (tb[IFLA_NET_NS_PID])
		net = get_net_ns_by_pid(nla_get_u32(tb[IFLA_NET_NS_PID]));
1176
1177
	else if (tb[IFLA_NET_NS_FD])
		net = get_net_ns_by_fd(nla_get_u32(tb[IFLA_NET_NS_FD]));
1178
1179
1180
1181
1182
1183
	else
		net = get_net(src_net);
	return net;
}
EXPORT_SYMBOL(rtnl_link_get_net);

1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
static int validate_linkmsg(struct net_device *dev, struct nlattr *tb[])
{
	if (dev) {
		if (tb[IFLA_ADDRESS] &&
		    nla_len(tb[IFLA_ADDRESS]) < dev->addr_len)
			return -EINVAL;

		if (tb[IFLA_BROADCAST] &&
		    nla_len(tb[IFLA_BROADCAST]) < dev->addr_len)
			return -EINVAL;
	}

1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
	if (tb[IFLA_AF_SPEC]) {
		struct nlattr *af;
		int rem, err;

		nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
			const struct rtnl_af_ops *af_ops;

			if (!(af_ops = rtnl_af_lookup(nla_type(af))))
				return -EAFNOSUPPORT;

			if (!af_ops->set_link_af)
				return -EOPNOTSUPP;

			if (af_ops->validate_link_af) {
1210
				err = af_ops->validate_link_af(dev, af);
1211
1212
1213
1214
1215
1216
				if (err < 0)
					return err;
			}
		}
	}

1217
1218
1219
	return 0;
}

1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
static int do_setvfinfo(struct net_device *dev, struct nlattr *attr)
{
	int rem, err = -EINVAL;
	struct nlattr *vf;
	const struct net_device_ops *ops = dev->netdev_ops;

	nla_for_each_nested(vf, attr, rem) {
		switch (nla_type(vf)) {
		case IFLA_VF_MAC: {
			struct ifla_vf_mac *ivm;
			ivm = nla_data(vf);
			err = -EOPNOTSUPP;
			if (ops->ndo_set_vf_mac)
				err = ops->ndo_set_vf_mac(dev, ivm->vf,
							  ivm->mac);
			break;
		}
		case IFLA_VF_VLAN: {
			struct ifla_vf_vlan *ivv;
			ivv = nla_data(vf);
			err = -EOPNOTSUPP;
			if (ops->ndo_set_vf_vlan)
				err = ops->ndo_set_vf_vlan(dev, ivv->vf,
							   ivv->vlan,
							   ivv->qos);
			break;
		}
		case IFLA_VF_TX_RATE: {
			struct ifla_vf_tx_rate *ivt;
			ivt = nla_data(vf);
			err = -EOPNOTSUPP;
			if (ops->ndo_set_vf_tx_rate)
				err = ops->ndo_set_vf_tx_rate(dev, ivt->vf,
							      ivt->rate);
			break;
		}
1256
1257
1258
1259
1260
1261
1262
1263
1264
		case IFLA_VF_SPOOFCHK: {
			struct ifla_vf_spoofchk *ivs;
			ivs = nla_data(vf);
			err = -EOPNOTSUPP;
			if (ops->ndo_set_vf_spoofchk)
				err = ops->ndo_set_vf_spoofchk(dev, ivs->vf,
							       ivs->setting);
			break;
		}
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
		default:
			err = -EINVAL;
			break;
		}
		if (err)
			break;
	}
	return err;
}

1275
1276
static int do_set_master(struct net_device *dev, int ifindex)
{
1277
	struct net_device *upper_dev = netdev_master_upper_dev_get(dev);
1278
1279
1280
	const struct net_device_ops *ops;
	int err;

1281
1282
	if (upper_dev) {
		if (upper_dev->ifindex == ifindex)
1283
			return 0;
1284
		ops = upper_dev->netdev_ops;
1285
		if (ops->ndo_del_slave) {
1286
			err = ops->ndo_del_slave(upper_dev, dev);
1287
1288
1289
1290
1291
1292
1293
1294
			if (err)
				return err;
		} else {
			return -EOPNOTSUPP;
		}
	}

	if (ifindex) {
1295
1296
		upper_dev = __dev_get_by_index(dev_net(dev), ifindex);
		if (!upper_dev)
1297
			return -EINVAL;
1298
		ops = upper_dev->netdev_ops;
1299
		if (ops->ndo_add_slave) {
1300
			err = ops->ndo_add_slave(upper_dev, dev);
1301
1302
1303
1304
1305
1306
1307
1308
1309
			if (err)
				return err;
		} else {
			return -EOPNOTSUPP;
		}
	}
	return 0;
}

1310
static int do_setlink(struct net_device *dev, struct ifinfomsg *ifm,
1311
		      struct nlattr **tb, char *ifname, int modified)
Linus Torvalds's avatar
Linus Torvalds committed
1312
{
1313
	const struct net_device_ops *ops = dev->netdev_ops;
1314
	int err;
Linus Torvalds's avatar
Linus Torvalds committed
1315

1316
	if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD]) {
1317
		struct net *net = rtnl_link_get_net(dev_net(dev), tb);
1318
1319
1320
1321
		if (IS_ERR(net)) {
			err = PTR_ERR(net);
			goto errout;
		}
1322
1323
1324
1325
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN)) {
			err = -EPERM;
			goto errout;
		}
1326
1327
1328
1329
1330
1331
1332
		err = dev_change_net_namespace(dev, net, ifname);
		put_net(net);
		if (err)
			goto errout;
		modified = 1;
	}

1333
	if (tb[IFLA_MAP]) {
Linus Torvalds's avatar
Linus Torvalds committed
1334
1335
1336
		struct rtnl_link_ifmap *u_map;
		struct ifmap k_map;

1337
		if (!ops->ndo_set_config) {
Linus Torvalds's avatar
Linus Torvalds committed
1338
			err = -EOPNOTSUPP;
1339
			goto errout;
Linus Torvalds's avatar
Linus Torvalds committed
1340
1341
1342
1343
		}

		if (!netif_device_present(dev)) {
			err = -ENODEV;
1344
			goto errout;