rtnetlink.c 73.8 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 303 304 305 306 307
	/* The check for setup is here because if ops
	 * does not have that filled up, it is not possible
	 * to use the ops for creating device. So do not
	 * fill up dellink as well. That disables rtnl_dellink.
	 */
	if (ops->setup && !ops->dellink)
308
		ops->dellink = unregister_netdevice_queue;
309

310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
	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);

332 333 334
static void __rtnl_kill_links(struct net *net, struct rtnl_link_ops *ops)
{
	struct net_device *dev;
335 336
	LIST_HEAD(list_kill);

337
	for_each_netdev(net, dev) {
338 339
		if (dev->rtnl_link_ops == ops)
			ops->dellink(dev, &list_kill);
340
	}
341
	unregister_netdevice_many(&list_kill);
342 343
}

344 345 346 347
/**
 * __rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink.
 * @ops: struct rtnl_link_ops * to unregister
 *
348
 * The caller must hold the rtnl_mutex.
349 350 351
 */
void __rtnl_link_unregister(struct rtnl_link_ops *ops)
{
352
	struct net *net;
353

354
	for_each_net(net) {
355
		__rtnl_kill_links(net, ops);
356
	}
357 358 359 360
	list_del(&ops->list);
}
EXPORT_SYMBOL_GPL(__rtnl_link_unregister);

361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388
/* Return with the rtnl_lock held when there are no network
 * devices unregistering in any network namespace.
 */
static void rtnl_lock_unregistering_all(void)
{
	struct net *net;
	bool unregistering;
	DEFINE_WAIT(wait);

	for (;;) {
		prepare_to_wait(&netdev_unregistering_wq, &wait,
				TASK_UNINTERRUPTIBLE);
		unregistering = false;
		rtnl_lock();
		for_each_net(net) {
			if (net->dev_unreg_count > 0) {
				unregistering = true;
				break;
			}
		}
		if (!unregistering)
			break;
		__rtnl_unlock();
		schedule();
	}
	finish_wait(&netdev_unregistering_wq, &wait);
}

389 390 391 392 393 394
/**
 * 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)
{
395 396 397
	/* Close the race with cleanup_net() */
	mutex_lock(&net_mutex);
	rtnl_lock_unregistering_all();
398 399
	__rtnl_link_unregister(ops);
	rtnl_unlock();
400
	mutex_unlock(&net_mutex);
401 402 403
}
EXPORT_SYMBOL_GPL(rtnl_link_unregister);

404 405 406 407 408 409 410 411 412
static size_t rtnl_link_get_slave_info_data_size(const struct net_device *dev)
{
	struct net_device *master_dev;
	const struct rtnl_link_ops *ops;

	master_dev = netdev_master_upper_dev_get((struct net_device *) dev);
	if (!master_dev)
		return 0;
	ops = master_dev->rtnl_link_ops;
413
	if (!ops || !ops->get_slave_size)
414 415 416 417 418 419
		return 0;
	/* IFLA_INFO_SLAVE_DATA + nested data */
	return nla_total_size(sizeof(struct nlattr)) +
	       ops->get_slave_size(master_dev, dev);
}

420 421 422 423 424 425 426 427
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;

428 429
	size = nla_total_size(sizeof(struct nlattr)) + /* IFLA_LINKINFO */
	       nla_total_size(strlen(ops->kind) + 1);  /* IFLA_INFO_KIND */
430 431 432

	if (ops->get_size)
		/* IFLA_INFO_DATA + nested data */
433
		size += nla_total_size(sizeof(struct nlattr)) +
434 435 436
			ops->get_size(dev);

	if (ops->get_xstats_size)
437 438
		/* IFLA_INFO_XSTATS */
		size += nla_total_size(ops->get_xstats_size(dev));
439

440 441
	size += rtnl_link_get_slave_info_data_size(dev);

442 443 444
	return size;
}

445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464
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
 *
 * Returns 0 on success or a negative error code.
 */
465
void rtnl_af_register(struct rtnl_af_ops *ops)
466 467
{
	rtnl_lock();
468
	list_add_tail(&ops->list, &rtnl_af_ops);
469 470 471 472 473 474 475 476 477 478 479 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
	rtnl_unlock();
}
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;
}

516
static bool rtnl_have_link_slave_info(const struct net_device *dev)
517
{
518
	struct net_device *master_dev;
519

520
	master_dev = netdev_master_upper_dev_get((struct net_device *) dev);
521
	if (master_dev && master_dev->rtnl_link_ops)
522 523 524 525 526 527 528 529 530 531 532
		return true;
	return false;
}

static int rtnl_link_slave_info_fill(struct sk_buff *skb,
				     const struct net_device *dev)
{
	struct net_device *master_dev;
	const struct rtnl_link_ops *ops;
	struct nlattr *slave_data;
	int err;
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
	master_dev = netdev_master_upper_dev_get((struct net_device *) dev);
	if (!master_dev)
		return 0;
	ops = master_dev->rtnl_link_ops;
	if (!ops)
		return 0;
	if (nla_put_string(skb, IFLA_INFO_SLAVE_KIND, ops->kind) < 0)
		return -EMSGSIZE;
	if (ops->fill_slave_info) {
		slave_data = nla_nest_start(skb, IFLA_INFO_SLAVE_DATA);
		if (!slave_data)
			return -EMSGSIZE;
		err = ops->fill_slave_info(skb, master_dev, dev);
		if (err < 0)
			goto err_cancel_slave_data;
		nla_nest_end(skb, slave_data);
	}
	return 0;

err_cancel_slave_data:
	nla_nest_cancel(skb, slave_data);
	return err;
}

static int rtnl_link_info_fill(struct sk_buff *skb,
			       const struct net_device *dev)
{
	const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
	struct nlattr *data;
	int err;

	if (!ops)
		return 0;
567
	if (nla_put_string(skb, IFLA_INFO_KIND, ops->kind) < 0)
568
		return -EMSGSIZE;
569 570 571
	if (ops->fill_xstats) {
		err = ops->fill_xstats(skb, dev);
		if (err < 0)
572
			return err;
573 574 575
	}
	if (ops->fill_info) {
		data = nla_nest_start(skb, IFLA_INFO_DATA);
576 577
		if (data == NULL)
			return -EMSGSIZE;
578 579 580 581 582 583 584 585 586
		err = ops->fill_info(skb, dev);
		if (err < 0)
			goto err_cancel_data;
		nla_nest_end(skb, data);
	}
	return 0;

err_cancel_data:
	nla_nest_cancel(skb, data);
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609
	return err;
}

static int rtnl_link_fill(struct sk_buff *skb, const struct net_device *dev)
{
	struct nlattr *linkinfo;
	int err = -EMSGSIZE;

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

	err = rtnl_link_info_fill(skb, dev);
	if (err < 0)
		goto err_cancel_link;

	err = rtnl_link_slave_info_fill(skb, dev);
	if (err < 0)
		goto err_cancel_link;

	nla_nest_end(skb, linkinfo);
	return 0;

610 611 612 613 614 615
err_cancel_link:
	nla_nest_cancel(skb, linkinfo);
out:
	return err;
}

616
int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigned int group, int echo)
Linus Torvalds's avatar
Linus Torvalds committed
617
{
618
	struct sock *rtnl = net->rtnl;
Linus Torvalds's avatar
Linus Torvalds committed
619 620
	int err = 0;

621
	NETLINK_CB(skb).dst_group = group;
Linus Torvalds's avatar
Linus Torvalds committed
622 623 624 625 626 627 628 629
	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;
}

630
int rtnl_unicast(struct sk_buff *skb, struct net *net, u32 pid)
631
{
632 633
	struct sock *rtnl = net->rtnl;

634 635
	return nlmsg_unicast(rtnl, skb, pid);
}
Eric Dumazet's avatar
Eric Dumazet committed
636
EXPORT_SYMBOL(rtnl_unicast);
637

638 639
void rtnl_notify(struct sk_buff *skb, struct net *net, u32 pid, u32 group,
		 struct nlmsghdr *nlh, gfp_t flags)
640
{
641
	struct sock *rtnl = net->rtnl;
642 643 644 645 646
	int report = 0;

	if (nlh)
		report = nlmsg_report(nlh);

647
	nlmsg_notify(rtnl, skb, pid, group, report, flags);
648
}
Eric Dumazet's avatar
Eric Dumazet committed
649
EXPORT_SYMBOL(rtnl_notify);
650

651
void rtnl_set_sk_err(struct net *net, u32 group, int error)
652
{
653 654
	struct sock *rtnl = net->rtnl;

655 656
	netlink_set_err(rtnl, 0, group, error);
}
Eric Dumazet's avatar
Eric Dumazet committed
657
EXPORT_SYMBOL(rtnl_set_sk_err);
658

Linus Torvalds's avatar
Linus Torvalds committed
659 660
int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics)
{
661 662 663 664 665 666 667 668 669 670
	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++;
671 672
			if (nla_put_u32(skb, i+1, metrics[i]))
				goto nla_put_failure;
673
		}
Linus Torvalds's avatar
Linus Torvalds committed
674 675
	}

676 677 678 679
	if (!valid) {
		nla_nest_cancel(skb, mx);
		return 0;
	}
680 681 682 683

	return nla_nest_end(skb, mx);

nla_put_failure:
684 685
	nla_nest_cancel(skb, mx);
	return -EMSGSIZE;
Linus Torvalds's avatar
Linus Torvalds committed
686
}
Eric Dumazet's avatar
Eric Dumazet committed
687
EXPORT_SYMBOL(rtnetlink_put_metrics);
Linus Torvalds's avatar
Linus Torvalds committed
688

689
int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id,
690
		       long expires, u32 error)
691 692
{
	struct rta_cacheinfo ci = {
693
		.rta_lastuse = jiffies_delta_to_clock_t(jiffies - dst->lastuse),
694 695 696 697 698 699
		.rta_used = dst->__use,
		.rta_clntref = atomic_read(&(dst->__refcnt)),
		.rta_error = error,
		.rta_id =  id,
	};

700 701
	if (expires) {
		unsigned long clock;
702

703 704 705 706
		clock = jiffies_to_clock_t(abs(expires));
		clock = min_t(unsigned long, clock, INT_MAX);
		ci.rta_expires = (expires > 0) ? clock : -clock;
	}
707 708 709
	return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci);
}
EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo);
Linus Torvalds's avatar
Linus Torvalds committed
710

711
static void set_operstate(struct net_device *dev, unsigned char transition)
712 713 714
{
	unsigned char operstate = dev->operstate;

Eric Dumazet's avatar
Eric Dumazet committed
715
	switch (transition) {
716 717 718 719 720 721 722 723 724 725 726 727
	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;
728
	}
729 730 731 732 733

	if (dev->operstate != operstate) {
		write_lock_bh(&dev_base_lock);
		dev->operstate = operstate;
		write_unlock_bh(&dev_base_lock);
734 735
		netdev_state_change(dev);
	}
736 737
}

738 739 740 741 742 743
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));
}

744 745 746 747 748 749 750 751
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) |
752
			(rtnl_dev_get_flags(dev) & ~ifm->ifi_change);
753 754 755 756

	return flags;
}

757
static void copy_rtnl_link_stats(struct rtnl_link_stats *a,
758
				 const struct rtnl_link_stats64 *b)
Linus Torvalds's avatar
Linus Torvalds committed
759
{
760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786
	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;
787 788
}

789
static void copy_rtnl_link_stats64(void *v, const struct rtnl_link_stats64 *b)
790
{
791
	memcpy(v, b, sizeof(*b));
792
}
Linus Torvalds's avatar
Linus Torvalds committed
793

794
/* All VF info */
795 796
static inline int rtnl_vfinfo_size(const struct net_device *dev,
				   u32 ext_filter_mask)
797
{
798 799
	if (dev->dev.parent && dev_is_pci(dev->dev.parent) &&
	    (ext_filter_mask & RTEXT_FILTER_VF)) {
800
		int num_vfs = dev_num_vf(dev->dev.parent);
801 802 803 804 805
		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)) +
806 807
			 nla_total_size(sizeof(struct ifla_vf_spoofchk)) +
			 nla_total_size(sizeof(struct ifla_vf_rate)));
808 809
		return size;
	} else
810 811 812
		return 0;
}

813 814
static size_t rtnl_port_size(const struct net_device *dev,
			     u32 ext_filter_mask)
815 816 817 818 819 820 821 822 823 824 825 826 827 828 829
{
	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;

830 831
	if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
	    !(ext_filter_mask & RTEXT_FILTER_VF))
832 833 834 835 836 837 838 839
		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;
}

840 841
static noinline size_t if_nlmsg_size(const struct net_device *dev,
				     u32 ext_filter_mask)
842 843 844
{
	return NLMSG_ALIGN(sizeof(struct ifinfomsg))
	       + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
845
	       + nla_total_size(IFALIASZ) /* IFLA_IFALIAS */
846 847 848
	       + nla_total_size(IFNAMSIZ) /* IFLA_QDISC */
	       + nla_total_size(sizeof(struct rtnl_link_ifmap))
	       + nla_total_size(sizeof(struct rtnl_link_stats))
849
	       + nla_total_size(sizeof(struct rtnl_link_stats64))
850 851 852 853 854 855 856
	       + 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 */
857
	       + nla_total_size(1) /* IFLA_CARRIER */
858
	       + nla_total_size(4) /* IFLA_PROMISCUITY */
859 860
	       + nla_total_size(4) /* IFLA_NUM_TX_QUEUES */
	       + nla_total_size(4) /* IFLA_NUM_RX_QUEUES */
861
	       + nla_total_size(1) /* IFLA_OPERSTATE */
862
	       + nla_total_size(1) /* IFLA_LINKMODE */
863
	       + nla_total_size(4) /* IFLA_CARRIER_CHANGES */
864 865 866
	       + nla_total_size(ext_filter_mask
			        & RTEXT_FILTER_VF ? 4 : 0) /* IFLA_NUM_VF */
	       + rtnl_vfinfo_size(dev, ext_filter_mask) /* IFLA_VFINFO_LIST */
867
	       + rtnl_port_size(dev, ext_filter_mask) /* IFLA_VF_PORTS + IFLA_PORT_SELF */
868
	       + rtnl_link_get_size(dev) /* IFLA_LINKINFO */
869 870
	       + rtnl_link_get_af_size(dev) /* IFLA_AF_SPEC */
	       + nla_total_size(MAX_PHYS_PORT_ID_LEN); /* IFLA_PHYS_PORT_ID */
871 872
}

873 874 875 876 877 878 879 880 881 882 883 884 885
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);
886 887
		if (!vf_port)
			goto nla_put_failure;
888 889
		if (nla_put_u32(skb, IFLA_PORT_VF, vf))
			goto nla_put_failure;
890
		err = dev->netdev_ops->ndo_get_vf_port(dev, vf, skb);
891 892
		if (err == -EMSGSIZE)
			goto nla_put_failure;
893 894 895 896 897 898 899 900 901 902
		if (err) {
			nla_nest_cancel(skb, vf_port);
			continue;
		}
		nla_nest_end(skb, vf_port);
	}

	nla_nest_end(skb, vf_ports);

	return 0;
903 904 905 906

nla_put_failure:
	nla_nest_cancel(skb, vf_ports);
	return -EMSGSIZE;
907 908 909 910 911 912 913 914 915 916 917 918 919 920
}

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);
921
		return (err == -EMSGSIZE) ? err : 0;
922 923 924 925 926 927 928
	}

	nla_nest_end(skb, port_self);

	return 0;
}

929 930
static int rtnl_port_fill(struct sk_buff *skb, struct net_device *dev,
			  u32 ext_filter_mask)
931 932 933
{
	int err;

934 935
	if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
	    !(ext_filter_mask & RTEXT_FILTER_VF))
936 937 938 939 940 941 942 943 944 945 946 947 948 949 950
		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;
}

951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968
static int rtnl_phys_port_id_fill(struct sk_buff *skb, struct net_device *dev)
{
	int err;
	struct netdev_phys_port_id ppid;

	err = dev_get_phys_port_id(dev, &ppid);
	if (err) {
		if (err == -EOPNOTSUPP)
			return 0;
		return err;
	}

	if (nla_put(skb, IFLA_PHYS_PORT_ID, ppid.id_len, ppid.id))
		return -EMSGSIZE;

	return 0;
}

969
static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev,
970
			    int type, u32 pid, u32 seq, u32 change,
971
			    unsigned int flags, u32 ext_filter_mask)
972 973 974
{
	struct ifinfomsg *ifm;
	struct nlmsghdr *nlh;
975
	struct rtnl_link_stats64 temp;
976
	const struct rtnl_link_stats64 *stats;
977 978
	struct nlattr *attr, *af_spec;
	struct rtnl_af_ops *af_ops;
979
	struct net_device *upper_dev = netdev_master_upper_dev_get(dev);
Linus Torvalds's avatar
Linus Torvalds committed
980

981
	ASSERT_RTNL();
982 983
	nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags);
	if (nlh == NULL)
984
		return -EMSGSIZE;
Linus Torvalds's avatar
Linus Torvalds committed
985

986 987 988 989 990 991 992 993
	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;

994 995 996 997 998 999 1000
	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) ||
1001
	    nla_put_u32(skb, IFLA_PROMISCUITY, dev->promiscuity) ||
1002
	    nla_put_u32(skb, IFLA_NUM_TX_QUEUES, dev->num_tx_queues) ||
1003
#ifdef CONFIG_RPS
1004
	    nla_put_u32(skb, IFLA_NUM_RX_QUEUES, dev->num_rx_queues) ||
1005
#endif
1006 1007
	    (dev->ifindex != dev->iflink &&
	     nla_put_u32(skb, IFLA_LINK, dev->iflink)) ||
1008 1009
	    (upper_dev &&
	     nla_put_u32(skb, IFLA_MASTER, upper_dev->ifindex)) ||
1010
	    nla_put_u8(skb, IFLA_CARRIER, netif_carrier_ok(dev)) ||
1011 1012 1013
	    (dev->qdisc &&
	     nla_put_string(skb, IFLA_QDISC, dev->qdisc->ops->id)) ||
	    (dev->ifalias &&
1014 1015 1016
	     nla_put_string(skb, IFLA_IFALIAS, dev->ifalias)) ||
	    nla_put_u32(skb, IFLA_CARRIER_CHANGES,
			atomic_read(&dev->carrier_changes)))
1017
		goto nla_put_failure;
1018

Linus Torvalds's avatar
Linus Torvalds committed
1019 1020 1021 1022 1023 1024 1025 1026 1027
	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,
		};
1028 1029
		if (nla_put(skb, IFLA_MAP, sizeof(map), &map))
			goto nla_put_failure;
Linus Torvalds's avatar
Linus Torvalds committed
1030 1031 1032
	}

	if (dev->addr_len) {
1033 1034 1035
		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
1036 1037
	}

1038 1039 1040
	if (rtnl_phys_port_id_fill(skb, dev))
		goto nla_put_failure;

1041 1042 1043 1044
	attr = nla_reserve(skb, IFLA_STATS,
			sizeof(struct rtnl_link_stats));
	if (attr == NULL)
		goto nla_put_failure;
1045

1046
	stats = dev_get_stats(dev, &temp);
1047
	copy_rtnl_link_stats(nla_data(attr), stats);
Linus Torvalds's avatar
Linus Torvalds committed
1048

1049 1050 1051 1052 1053 1054
	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);

1055 1056 1057
	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;
1058

1059 1060
	if (dev->netdev_ops->ndo_get_vf_config && dev->dev.parent
	    && (ext_filter_mask & RTEXT_FILTER_VF)) {
1061 1062
		int i;

1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
		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;
1073
			struct ifla_vf_rate vf_rate;
1074
			struct ifla_vf_tx_rate vf_tx_rate;
1075
			struct ifla_vf_spoofchk vf_spoofchk;
1076
			struct ifla_vf_link_state vf_linkstate;
1077 1078 1079 1080 1081 1082 1083 1084

			/*
			 * 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;
1085
			memset(ivi.mac, 0, sizeof(ivi.mac));
1086 1087 1088 1089
			/* The default value for VF link state is "auto"
			 * IFLA_VF_LINK_STATE_AUTO which equals zero
			 */
			ivi.linkstate = 0;
1090 1091
			if (dev->netdev_ops->ndo_get_vf_config(dev, i, &ivi))
				break;
1092 1093
			vf_mac.vf =
				vf_vlan.vf =
1094
				vf_rate.vf =
1095
				vf_tx_rate.vf =
1096 1097
				vf_spoofchk.vf =
				vf_linkstate.vf = ivi.vf;
1098

1099 1100 1101
			memcpy(vf_mac.mac, ivi.mac, sizeof(ivi.mac));
			vf_vlan.vlan = ivi.vlan;
			vf_vlan.qos = ivi.qos;
1102 1103 1104
			vf_tx_rate.rate = ivi.max_tx_rate;
			vf_rate.min_tx_rate = ivi.min_tx_rate;
			vf_rate.max_tx_rate = ivi.max_tx_rate;
1105
			vf_spoofchk.setting = ivi.spoofchk;
1106
			vf_linkstate.link_state = ivi.linkstate;
1107 1108 1109 1110 1111
			vf = nla_nest_start(skb, IFLA_VF_INFO);
			if (!vf) {
				nla_nest_cancel(skb, vfinfo);
				goto nla_put_failure;
			}
1112 1113
			if (nla_put(skb, IFLA_VF_MAC, sizeof(vf_mac), &vf_mac) ||
			    nla_put(skb, IFLA_VF_VLAN, sizeof(vf_vlan), &vf_vlan) ||
1114 1115
			    nla_put(skb, IFLA_VF_RATE, sizeof(vf_rate),
				    &vf_rate) ||
1116 1117 1118
			    nla_put(skb, IFLA_VF_TX_RATE, sizeof(vf_tx_rate),
				    &vf_tx_rate) ||
			    nla_put(skb, IFLA_VF_SPOOFCHK, sizeof(vf_spoofchk),
1119 1120 1121
				    &vf_spoofchk) ||
			    nla_put(skb, IFLA_VF_LINK_STATE, sizeof(vf_linkstate),
				    &vf_linkstate))
1122
				goto nla_put_failure;
1123
			nla_nest_end(skb, vf);
1124
		}
1125
		nla_nest_end(skb, vfinfo);
1126
	}
1127

1128
	if (rtnl_port_fill(skb, dev, ext_filter_mask))
1129 1130
		goto nla_put_failure;

1131
	if (dev->rtnl_link_ops || rtnl_have_link_slave_info(dev)) {
1132 1133 1134 1135
		if (rtnl_link_fill(skb, dev) < 0)
			goto nla_put_failure;
	}

1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165
	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);

1166 1167 1168
	return nlmsg_end(skb, nlh);

nla_put_failure:
1169 1170
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
Linus Torvalds's avatar
Linus Torvalds committed
1171 1172
}

Jiri Pirko's avatar
Jiri Pirko committed
1173
static const struct nla_policy ifla_policy[IFLA_MAX+1] = {
1174
	[IFLA_IFNAME]		= { .type = NLA_STRING, .len = IFNAMSIZ-1 },