rtnetlink.c 101.7 KB
Newer Older
L
Linus Torvalds 已提交
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/if_vlan.h>
40
#include <linux/pci.h>
41
#include <linux/etherdevice.h>
L
Linus Torvalds 已提交
42

43
#include <linux/uaccess.h>
L
Linus Torvalds 已提交
44 45 46

#include <linux/inet.h>
#include <linux/netdevice.h>
47
#include <net/switchdev.h>
L
Linus Torvalds 已提交
48 49 50 51 52
#include <net/ip.h>
#include <net/protocol.h>
#include <net/arp.h>
#include <net/route.h>
#include <net/udp.h>
53
#include <net/tcp.h>
L
Linus Torvalds 已提交
54 55
#include <net/sock.h>
#include <net/pkt_sched.h>
56
#include <net/fib_rules.h>
57
#include <net/rtnetlink.h>
58
#include <net/net_namespace.h>
L
Linus Torvalds 已提交
59

E
Eric Dumazet 已提交
60
struct rtnl_link {
61 62
	rtnl_doit_func		doit;
	rtnl_dumpit_func	dumpit;
63
	rtnl_calcit_func 	calcit;
64 65
};

66
static DEFINE_MUTEX(rtnl_mutex);
L
Linus Torvalds 已提交
67 68 69

void rtnl_lock(void)
{
70
	mutex_lock(&rtnl_mutex);
L
Linus Torvalds 已提交
71
}
E
Eric Dumazet 已提交
72
EXPORT_SYMBOL(rtnl_lock);
L
Linus Torvalds 已提交
73

74 75 76 77 78 79 80 81 82 83
static struct sk_buff *defer_kfree_skb_list;
void rtnl_kfree_skbs(struct sk_buff *head, struct sk_buff *tail)
{
	if (head && tail) {
		tail->next = defer_kfree_skb_list;
		defer_kfree_skb_list = head;
	}
}
EXPORT_SYMBOL(rtnl_kfree_skbs);

84
void __rtnl_unlock(void)
L
Linus Torvalds 已提交
85
{
86 87 88 89
	struct sk_buff *head = defer_kfree_skb_list;

	defer_kfree_skb_list = NULL;

90
	mutex_unlock(&rtnl_mutex);
91 92 93 94 95 96 97 98

	while (head) {
		struct sk_buff *next = head->next;

		kfree_skb(head);
		cond_resched();
		head = next;
	}
L
Linus Torvalds 已提交
99
}
100

L
Linus Torvalds 已提交
101 102
void rtnl_unlock(void)
{
H
Herbert Xu 已提交
103
	/* This fellow will unlock it for us. */
L
Linus Torvalds 已提交
104 105
	netdev_run_todo();
}
E
Eric Dumazet 已提交
106
EXPORT_SYMBOL(rtnl_unlock);
L
Linus Torvalds 已提交
107

108 109 110 111
int rtnl_trylock(void)
{
	return mutex_trylock(&rtnl_mutex);
}
E
Eric Dumazet 已提交
112
EXPORT_SYMBOL(rtnl_trylock);
113

114 115 116 117
int rtnl_is_locked(void)
{
	return mutex_is_locked(&rtnl_mutex);
}
E
Eric Dumazet 已提交
118
EXPORT_SYMBOL(rtnl_is_locked);
119

120
#ifdef CONFIG_PROVE_LOCKING
121
bool lockdep_rtnl_is_held(void)
122 123 124 125 126 127
{
	return lockdep_is_held(&rtnl_mutex);
}
EXPORT_SYMBOL(lockdep_rtnl_is_held);
#endif /* #ifdef CONFIG_PROVE_LOCKING */

128
static struct rtnl_link *rtnl_msg_handlers[RTNL_FAMILY_MAX + 1];
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147

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;

148
	if (protocol <= RTNL_FAMILY_MAX)
149 150 151 152
		tab = rtnl_msg_handlers[protocol];
	else
		tab = NULL;

153
	if (tab == NULL || tab[msgindex].doit == NULL)
154 155
		tab = rtnl_msg_handlers[PF_UNSPEC];

156
	return tab[msgindex].doit;
157 158 159 160 161 162
}

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

163
	if (protocol <= RTNL_FAMILY_MAX)
164 165 166 167
		tab = rtnl_msg_handlers[protocol];
	else
		tab = NULL;

168
	if (tab == NULL || tab[msgindex].dumpit == NULL)
169 170
		tab = rtnl_msg_handlers[PF_UNSPEC];

171
	return tab[msgindex].dumpit;
172 173
}

174 175 176 177 178 179 180 181 182 183 184 185
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];

186
	return tab[msgindex].calcit;
187 188
}

189 190 191 192 193 194
/**
 * __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
195
 * @calcit: Function pointer to calc size of dump message
196 197 198 199 200 201 202 203 204 205 206 207
 *
 * 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,
208 209
		    rtnl_doit_func doit, rtnl_dumpit_func dumpit,
		    rtnl_calcit_func calcit)
210 211 212 213
{
	struct rtnl_link *tab;
	int msgindex;

214
	BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
	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;

232 233 234
	if (calcit)
		tab[msgindex].calcit = calcit;

235 236 237 238 239 240 241 242 243 244 245
	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
L
Lucas De Marchi 已提交
246
 * of memory implies no sense in continuing.
247 248
 */
void rtnl_register(int protocol, int msgtype,
249 250
		   rtnl_doit_func doit, rtnl_dumpit_func dumpit,
		   rtnl_calcit_func calcit)
251
{
252
	if (__rtnl_register(protocol, msgtype, doit, dumpit, calcit) < 0)
253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
		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;

270
	BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
271 272 273 274 275 276 277
	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;
278
	rtnl_msg_handlers[protocol][msgindex].calcit = NULL;
279 280 281 282 283 284 285 286 287 288 289 290 291 292

	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)
{
293
	BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
294 295 296 297 298

	kfree(rtnl_msg_handlers[protocol]);
	rtnl_msg_handlers[protocol] = NULL;
}
EXPORT_SYMBOL_GPL(rtnl_unregister_all);
L
Linus Torvalds 已提交
299

P
Patrick McHardy 已提交
300 301
static LIST_HEAD(link_ops);

302 303 304 305 306 307 308 309 310 311 312
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;
}

P
Patrick McHardy 已提交
313 314 315 316 317 318 319 320 321 322 323 324
/**
 * __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)
{
325 326 327
	if (rtnl_link_ops_get(ops->kind))
		return -EEXIST;

328 329 330 331 332 333
	/* 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)
334
		ops->dellink = unregister_netdevice_queue;
335

P
Patrick McHardy 已提交
336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
	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);

358 359 360
static void __rtnl_kill_links(struct net *net, struct rtnl_link_ops *ops)
{
	struct net_device *dev;
361 362
	LIST_HEAD(list_kill);

363
	for_each_netdev(net, dev) {
364 365
		if (dev->rtnl_link_ops == ops)
			ops->dellink(dev, &list_kill);
366
	}
367
	unregister_netdevice_many(&list_kill);
368 369
}

P
Patrick McHardy 已提交
370 371 372 373
/**
 * __rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink.
 * @ops: struct rtnl_link_ops * to unregister
 *
374
 * The caller must hold the rtnl_mutex.
P
Patrick McHardy 已提交
375 376 377
 */
void __rtnl_link_unregister(struct rtnl_link_ops *ops)
{
378
	struct net *net;
379

380
	for_each_net(net) {
381
		__rtnl_kill_links(net, ops);
382
	}
P
Patrick McHardy 已提交
383 384 385 386
	list_del(&ops->list);
}
EXPORT_SYMBOL_GPL(__rtnl_link_unregister);

387 388 389 390 391 392 393
/* 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;
394
	DEFINE_WAIT_FUNC(wait, woken_wake_function);
395

396
	add_wait_queue(&netdev_unregistering_wq, &wait);
397 398 399 400 401 402 403 404 405 406 407 408
	for (;;) {
		unregistering = false;
		rtnl_lock();
		for_each_net(net) {
			if (net->dev_unreg_count > 0) {
				unregistering = true;
				break;
			}
		}
		if (!unregistering)
			break;
		__rtnl_unlock();
409 410

		wait_woken(&wait, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
411
	}
412
	remove_wait_queue(&netdev_unregistering_wq, &wait);
413 414
}

P
Patrick McHardy 已提交
415 416 417 418 419 420
/**
 * 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)
{
421 422 423
	/* Close the race with cleanup_net() */
	mutex_lock(&net_mutex);
	rtnl_lock_unregistering_all();
P
Patrick McHardy 已提交
424 425
	__rtnl_link_unregister(ops);
	rtnl_unlock();
426
	mutex_unlock(&net_mutex);
P
Patrick McHardy 已提交
427 428 429
}
EXPORT_SYMBOL_GPL(rtnl_link_unregister);

430 431 432 433 434 435 436 437 438
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;
439
	if (!ops || !ops->get_slave_size)
440 441 442 443 444 445
		return 0;
	/* IFLA_INFO_SLAVE_DATA + nested data */
	return nla_total_size(sizeof(struct nlattr)) +
	       ops->get_slave_size(master_dev, dev);
}

P
Patrick McHardy 已提交
446 447 448 449 450 451 452 453
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;

454 455
	size = nla_total_size(sizeof(struct nlattr)) + /* IFLA_LINKINFO */
	       nla_total_size(strlen(ops->kind) + 1);  /* IFLA_INFO_KIND */
P
Patrick McHardy 已提交
456 457 458

	if (ops->get_size)
		/* IFLA_INFO_DATA + nested data */
459
		size += nla_total_size(sizeof(struct nlattr)) +
P
Patrick McHardy 已提交
460 461 462
			ops->get_size(dev);

	if (ops->get_xstats_size)
463 464
		/* IFLA_INFO_XSTATS */
		size += nla_total_size(ops->get_xstats_size(dev));
P
Patrick McHardy 已提交
465

466 467
	size += rtnl_link_get_slave_info_data_size(dev);

P
Patrick McHardy 已提交
468 469 470
	return size;
}

T
Thomas Graf 已提交
471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
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.
 */
491
void rtnl_af_register(struct rtnl_af_ops *ops)
T
Thomas Graf 已提交
492 493
{
	rtnl_lock();
494
	list_add_tail(&ops->list, &rtnl_af_ops);
T
Thomas Graf 已提交
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
	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);

523 524
static size_t rtnl_link_get_af_size(const struct net_device *dev,
				    u32 ext_filter_mask)
T
Thomas Graf 已提交
525 526 527 528 529 530 531 532 533 534 535
{
	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)) +
536
				af_ops->get_link_af_size(dev, ext_filter_mask);
T
Thomas Graf 已提交
537 538 539 540 541 542
		}
	}

	return size;
}

543
static bool rtnl_have_link_slave_info(const struct net_device *dev)
P
Patrick McHardy 已提交
544
{
545
	struct net_device *master_dev;
P
Patrick McHardy 已提交
546

547
	master_dev = netdev_master_upper_dev_get((struct net_device *) dev);
548
	if (master_dev && master_dev->rtnl_link_ops)
549 550 551 552 553 554 555 556 557 558 559
		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;
P
Patrick McHardy 已提交
560

561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
	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;
P
Patrick McHardy 已提交
594
	if (nla_put_string(skb, IFLA_INFO_KIND, ops->kind) < 0)
595
		return -EMSGSIZE;
P
Patrick McHardy 已提交
596 597 598
	if (ops->fill_xstats) {
		err = ops->fill_xstats(skb, dev);
		if (err < 0)
599
			return err;
P
Patrick McHardy 已提交
600 601 602
	}
	if (ops->fill_info) {
		data = nla_nest_start(skb, IFLA_INFO_DATA);
603 604
		if (data == NULL)
			return -EMSGSIZE;
P
Patrick McHardy 已提交
605 606 607 608 609 610 611 612 613
		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);
614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
	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;

P
Patrick McHardy 已提交
637 638 639 640 641 642
err_cancel_link:
	nla_nest_cancel(skb, linkinfo);
out:
	return err;
}

643
int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigned int group, int echo)
L
Linus Torvalds 已提交
644
{
645
	struct sock *rtnl = net->rtnl;
L
Linus Torvalds 已提交
646 647
	int err = 0;

648
	NETLINK_CB(skb).dst_group = group;
L
Linus Torvalds 已提交
649 650 651 652 653 654 655 656
	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;
}

657
int rtnl_unicast(struct sk_buff *skb, struct net *net, u32 pid)
658
{
659 660
	struct sock *rtnl = net->rtnl;

661 662
	return nlmsg_unicast(rtnl, skb, pid);
}
E
Eric Dumazet 已提交
663
EXPORT_SYMBOL(rtnl_unicast);
664

665 666
void rtnl_notify(struct sk_buff *skb, struct net *net, u32 pid, u32 group,
		 struct nlmsghdr *nlh, gfp_t flags)
667
{
668
	struct sock *rtnl = net->rtnl;
669 670 671 672 673
	int report = 0;

	if (nlh)
		report = nlmsg_report(nlh);

674
	nlmsg_notify(rtnl, skb, pid, group, report, flags);
675
}
E
Eric Dumazet 已提交
676
EXPORT_SYMBOL(rtnl_notify);
677

678
void rtnl_set_sk_err(struct net *net, u32 group, int error)
679
{
680 681
	struct sock *rtnl = net->rtnl;

682 683
	netlink_set_err(rtnl, 0, group, error);
}
E
Eric Dumazet 已提交
684
EXPORT_SYMBOL(rtnl_set_sk_err);
685

L
Linus Torvalds 已提交
686 687
int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics)
{
688 689 690 691 692 693 694 695 696
	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]) {
697 698 699 700 701 702 703 704
			if (i == RTAX_CC_ALGO - 1) {
				char tmp[TCP_CA_NAME_MAX], *name;

				name = tcp_ca_get_name_by_key(metrics[i], tmp);
				if (!name)
					continue;
				if (nla_put_string(skb, i + 1, name))
					goto nla_put_failure;
705 706 707
			} else if (i == RTAX_FEATURES - 1) {
				u32 user_features = metrics[i] & RTAX_FEATURE_MASK;

708 709
				if (!user_features)
					continue;
710 711 712
				BUILD_BUG_ON(RTAX_FEATURE_MASK & DST_FEATURE_MASK);
				if (nla_put_u32(skb, i + 1, user_features))
					goto nla_put_failure;
713 714 715 716
			} else {
				if (nla_put_u32(skb, i + 1, metrics[i]))
					goto nla_put_failure;
			}
717 718
			valid++;
		}
L
Linus Torvalds 已提交
719 720
	}

721 722 723 724
	if (!valid) {
		nla_nest_cancel(skb, mx);
		return 0;
	}
725 726 727 728

	return nla_nest_end(skb, mx);

nla_put_failure:
729 730
	nla_nest_cancel(skb, mx);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
731
}
E
Eric Dumazet 已提交
732
EXPORT_SYMBOL(rtnetlink_put_metrics);
L
Linus Torvalds 已提交
733

734
int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id,
735
		       long expires, u32 error)
736 737
{
	struct rta_cacheinfo ci = {
738
		.rta_lastuse = jiffies_delta_to_clock_t(jiffies - dst->lastuse),
739 740 741 742 743 744
		.rta_used = dst->__use,
		.rta_clntref = atomic_read(&(dst->__refcnt)),
		.rta_error = error,
		.rta_id =  id,
	};

745 746
	if (expires) {
		unsigned long clock;
747

748 749 750 751
		clock = jiffies_to_clock_t(abs(expires));
		clock = min_t(unsigned long, clock, INT_MAX);
		ci.rta_expires = (expires > 0) ? clock : -clock;
	}
752 753 754
	return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci);
}
EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo);
L
Linus Torvalds 已提交
755

756
static void set_operstate(struct net_device *dev, unsigned char transition)
S
Stefan Rompf 已提交
757 758 759
{
	unsigned char operstate = dev->operstate;

E
Eric Dumazet 已提交
760
	switch (transition) {
S
Stefan Rompf 已提交
761 762 763 764 765 766 767 768 769 770 771 772
	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;
773
	}
S
Stefan Rompf 已提交
774 775 776 777 778

	if (dev->operstate != operstate) {
		write_lock_bh(&dev_base_lock);
		dev->operstate = operstate;
		write_unlock_bh(&dev_base_lock);
779 780
		netdev_state_change(dev);
	}
S
Stefan Rompf 已提交
781 782
}

783 784 785 786 787 788
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));
}

789 790 791 792 793 794 795 796
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) |
797
			(rtnl_dev_get_flags(dev) & ~ifm->ifi_change);
798 799 800 801

	return flags;
}

802
static void copy_rtnl_link_stats(struct rtnl_link_stats *a,
803
				 const struct rtnl_link_stats64 *b)
L
Linus Torvalds 已提交
804
{
805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831
	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;
832 833

	a->rx_nohandler = b->rx_nohandler;
834 835
}

836
/* All VF info */
837 838
static inline int rtnl_vfinfo_size(const struct net_device *dev,
				   u32 ext_filter_mask)
839
{
840
	if (dev->dev.parent && (ext_filter_mask & RTEXT_FILTER_VF)) {
841
		int num_vfs = dev_num_vf(dev->dev.parent);
S
Sabrina Dubroca 已提交
842
		size_t size = nla_total_size(0);
843
		size += num_vfs *
S
Sabrina Dubroca 已提交
844 845 846 847
			(nla_total_size(0) +
			 nla_total_size(sizeof(struct ifla_vf_mac)) +
			 nla_total_size(sizeof(struct ifla_vf_vlan)) +
			 nla_total_size(0) + /* nest IFLA_VF_VLAN_LIST */
848 849
			 nla_total_size(MAX_VLAN_LIST_LEN *
					sizeof(struct ifla_vf_vlan_info)) +
850
			 nla_total_size(sizeof(struct ifla_vf_spoofchk)) +
S
Sabrina Dubroca 已提交
851
			 nla_total_size(sizeof(struct ifla_vf_tx_rate)) +
J
Jiri Benc 已提交
852
			 nla_total_size(sizeof(struct ifla_vf_rate)) +
853
			 nla_total_size(sizeof(struct ifla_vf_link_state)) +
854
			 nla_total_size(sizeof(struct ifla_vf_rss_query_en)) +
S
Sabrina Dubroca 已提交
855
			 nla_total_size(0) + /* nest IFLA_VF_STATS */
856
			 /* IFLA_VF_STATS_RX_PACKETS */
N
Nicolas Dichtel 已提交
857
			 nla_total_size_64bit(sizeof(__u64)) +
858
			 /* IFLA_VF_STATS_TX_PACKETS */
N
Nicolas Dichtel 已提交
859
			 nla_total_size_64bit(sizeof(__u64)) +
860
			 /* IFLA_VF_STATS_RX_BYTES */
N
Nicolas Dichtel 已提交
861
			 nla_total_size_64bit(sizeof(__u64)) +
862
			 /* IFLA_VF_STATS_TX_BYTES */
N
Nicolas Dichtel 已提交
863
			 nla_total_size_64bit(sizeof(__u64)) +
864
			 /* IFLA_VF_STATS_BROADCAST */
N
Nicolas Dichtel 已提交
865
			 nla_total_size_64bit(sizeof(__u64)) +
866
			 /* IFLA_VF_STATS_MULTICAST */
N
Nicolas Dichtel 已提交
867
			 nla_total_size_64bit(sizeof(__u64)) +
H
Hiroshi Shimamoto 已提交
868
			 nla_total_size(sizeof(struct ifla_vf_trust)));
869 870
		return size;
	} else
871 872 873
		return 0;
}

874 875
static size_t rtnl_port_size(const struct net_device *dev,
			     u32 ext_filter_mask)
876 877 878 879 880 881 882 883 884 885 886 887 888
{
	size_t port_size = nla_total_size(4)		/* PORT_VF */
		+ nla_total_size(PORT_PROFILE_MAX)	/* PORT_PROFILE */
		+ 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;

889 890
	if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
	    !(ext_filter_mask & RTEXT_FILTER_VF))
891 892 893 894 895 896 897 898
		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;
}

899 900
static size_t rtnl_xdp_size(const struct net_device *dev)
{
901 902
	size_t xdp_size = nla_total_size(0) +	/* nest IFLA_XDP */
			  nla_total_size(1);	/* XDP_ATTACHED */
903 904 905 906 907 908 909

	if (!dev->netdev_ops->ndo_xdp)
		return 0;
	else
		return xdp_size;
}

910 911
static noinline size_t if_nlmsg_size(const struct net_device *dev,
				     u32 ext_filter_mask)
912 913 914
{
	return NLMSG_ALIGN(sizeof(struct ifinfomsg))
	       + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
915
	       + nla_total_size(IFALIASZ) /* IFLA_IFALIAS */
916
	       + nla_total_size(IFNAMSIZ) /* IFLA_QDISC */
917
	       + nla_total_size_64bit(sizeof(struct rtnl_link_ifmap))
918
	       + nla_total_size(sizeof(struct rtnl_link_stats))
919
	       + nla_total_size_64bit(sizeof(struct rtnl_link_stats64))
920 921 922 923 924 925 926
	       + 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 */
927
	       + nla_total_size(1) /* IFLA_CARRIER */
928
	       + nla_total_size(4) /* IFLA_PROMISCUITY */
929 930
	       + nla_total_size(4) /* IFLA_NUM_TX_QUEUES */
	       + nla_total_size(4) /* IFLA_NUM_RX_QUEUES */
931 932
	       + nla_total_size(4) /* IFLA_GSO_MAX_SEGS */
	       + nla_total_size(4) /* IFLA_GSO_MAX_SIZE */
933
	       + nla_total_size(1) /* IFLA_OPERSTATE */
P
Patrick McHardy 已提交
934
	       + nla_total_size(1) /* IFLA_LINKMODE */
935
	       + nla_total_size(4) /* IFLA_CARRIER_CHANGES */
936
	       + nla_total_size(4) /* IFLA_LINK_NETNSID */
937 938 939
	       + nla_total_size(ext_filter_mask
			        & RTEXT_FILTER_VF ? 4 : 0) /* IFLA_NUM_VF */
	       + rtnl_vfinfo_size(dev, ext_filter_mask) /* IFLA_VFINFO_LIST */
940
	       + rtnl_port_size(dev, ext_filter_mask) /* IFLA_VF_PORTS + IFLA_PORT_SELF */
T
Thomas Graf 已提交
941
	       + rtnl_link_get_size(dev) /* IFLA_LINKINFO */
942
	       + rtnl_link_get_af_size(dev, ext_filter_mask) /* IFLA_AF_SPEC */
943
	       + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_PORT_ID */
944
	       + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_SWITCH_ID */
945
	       + nla_total_size(IFNAMSIZ) /* IFLA_PHYS_PORT_NAME */
946
	       + rtnl_xdp_size(dev) /* IFLA_XDP */
947 948
	       + nla_total_size(1); /* IFLA_PROTO_DOWN */

949 950
}

951 952 953 954 955 956 957 958 959 960 961 962 963
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);
964 965
		if (!vf_port)
			goto nla_put_failure;
966 967
		if (nla_put_u32(skb, IFLA_PORT_VF, vf))
			goto nla_put_failure;
968
		err = dev->netdev_ops->ndo_get_vf_port(dev, vf, skb);
969 970
		if (err == -EMSGSIZE)
			goto nla_put_failure;
971 972 973 974 975 976 977 978 979 980
		if (err) {
			nla_nest_cancel(skb, vf_port);
			continue;
		}
		nla_nest_end(skb, vf_port);
	}

	nla_nest_end(skb, vf_ports);

	return 0;
981 982 983 984

nla_put_failure:
	nla_nest_cancel(skb, vf_ports);
	return -EMSGSIZE;
985 986 987 988 989 990 991 992 993 994 995 996 997 998
}

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);
999
		return (err == -EMSGSIZE) ? err : 0;
1000 1001 1002 1003 1004 1005 1006
	}

	nla_nest_end(skb, port_self);

	return 0;
}

1007 1008
static int rtnl_port_fill(struct sk_buff *skb, struct net_device *dev,
			  u32 ext_filter_mask)
1009 1010 1011
{
	int err;

1012 1013
	if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
	    !(ext_filter_mask & RTEXT_FILTER_VF))
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028
		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;
}

1029 1030 1031
static int rtnl_phys_port_id_fill(struct sk_buff *skb, struct net_device *dev)
{
	int err;
1032
	struct netdev_phys_item_id ppid;
1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046

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

1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
static int rtnl_phys_port_name_fill(struct sk_buff *skb, struct net_device *dev)
{
	char name[IFNAMSIZ];
	int err;

	err = dev_get_phys_port_name(dev, name, sizeof(name));
	if (err) {
		if (err == -EOPNOTSUPP)
			return 0;
		return err;
	}

	if (nla_put(skb, IFLA_PHYS_PORT_NAME, strlen(name), name))
		return -EMSGSIZE;

	return 0;
}

1065 1066 1067
static int rtnl_phys_switch_id_fill(struct sk_buff *skb, struct net_device *dev)
{
	int err;
1068
	struct switchdev_attr attr = {
1069
		.orig_dev = dev,
1070
		.id = SWITCHDEV_ATTR_ID_PORT_PARENT_ID,
1071 1072
		.flags = SWITCHDEV_F_NO_RECURSE,
	};
1073

1074
	err = switchdev_port_attr_get(dev, &attr);
1075 1076 1077 1078 1079 1080
	if (err) {
		if (err == -EOPNOTSUPP)
			return 0;
		return err;
	}

1081 1082
	if (nla_put(skb, IFLA_PHYS_SWITCH_ID, attr.u.ppid.id_len,
		    attr.u.ppid.id))
1083 1084 1085 1086 1087
		return -EMSGSIZE;

	return 0;
}

1088 1089 1090
static noinline_for_stack int rtnl_fill_stats(struct sk_buff *skb,
					      struct net_device *dev)
{
1091
	struct rtnl_link_stats64 *sp;
1092
	struct nlattr *attr;
1093

1094 1095
	attr = nla_reserve_64bit(skb, IFLA_STATS64,
				 sizeof(struct rtnl_link_stats64), IFLA_PAD);
1096 1097 1098
	if (!attr)
		return -EMSGSIZE;

1099 1100
	sp = nla_data(attr);
	dev_get_stats(dev, sp);
1101

1102 1103
	attr = nla_reserve(skb, IFLA_STATS,
			   sizeof(struct rtnl_link_stats));
1104 1105 1106
	if (!attr)
		return -EMSGSIZE;

1107
	copy_rtnl_link_stats(nla_data(attr), sp);
1108 1109 1110 1111 1112 1113 1114 1115 1116 1117

	return 0;
}

static noinline_for_stack int rtnl_fill_vfinfo(struct sk_buff *skb,
					       struct net_device *dev,
					       int vfs_num,
					       struct nlattr *vfinfo)
{
	struct ifla_vf_rss_query_en vf_rss_query_en;
1118
	struct nlattr *vf, *vfstats, *vfvlanlist;
1119
	struct ifla_vf_link_state vf_linkstate;
1120
	struct ifla_vf_vlan_info vf_vlan_info;
1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
	struct ifla_vf_spoofchk vf_spoofchk;
	struct ifla_vf_tx_rate vf_tx_rate;
	struct ifla_vf_stats vf_stats;
	struct ifla_vf_trust vf_trust;
	struct ifla_vf_vlan vf_vlan;
	struct ifla_vf_rate vf_rate;
	struct ifla_vf_mac vf_mac;
	struct ifla_vf_info ivi;

	/* Not all SR-IOV capable drivers support the
	 * spoofcheck and "RSS query enable" query.  Preset to
	 * -1 so the user space tool can detect that the driver
	 * didn't report anything.
	 */
	ivi.spoofchk = -1;
	ivi.rss_query_en = -1;
	ivi.trusted = -1;
	memset(ivi.mac, 0, sizeof(ivi.mac));
	/* The default value for VF link state is "auto"
	 * IFLA_VF_LINK_STATE_AUTO which equals zero
	 */
	ivi.linkstate = 0;
1143 1144
	/* VLAN Protocol by default is 802.1Q */
	ivi.vlan_proto = htons(ETH_P_8021Q);
1145 1146 1147
	if (dev->netdev_ops->ndo_get_vf_config(dev, vfs_num, &ivi))
		return 0;

1148 1149
	memset(&vf_vlan_info, 0, sizeof(vf_vlan_info));

1150 1151
	vf_mac.vf =
		vf_vlan.vf =
1152
		vf_vlan_info.vf =
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
		vf_rate.vf =
		vf_tx_rate.vf =
		vf_spoofchk.vf =
		vf_linkstate.vf =
		vf_rss_query_en.vf =
		vf_trust.vf = ivi.vf;

	memcpy(vf_mac.mac, ivi.mac, sizeof(ivi.mac));
	vf_vlan.vlan = ivi.vlan;
	vf_vlan.qos = ivi.qos;
1163 1164 1165
	vf_vlan_info.vlan = ivi.vlan;
	vf_vlan_info.qos = ivi.qos;
	vf_vlan_info.vlan_proto = ivi.vlan_proto;
1166 1167 1168 1169 1170 1171 1172 1173
	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;
	vf_spoofchk.setting = ivi.spoofchk;
	vf_linkstate.link_state = ivi.linkstate;
	vf_rss_query_en.setting = ivi.rss_query_en;
	vf_trust.setting = ivi.trusted;
	vf = nla_nest_start(skb, IFLA_VF_INFO);
1174 1175
	if (!vf)
		goto nla_put_vfinfo_failure;
1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190
	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_RATE, sizeof(vf_rate),
		    &vf_rate) ||
	    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) ||
	    nla_put(skb, IFLA_VF_LINK_STATE, sizeof(vf_linkstate),
		    &vf_linkstate) ||
	    nla_put(skb, IFLA_VF_RSS_QUERY_EN,
		    sizeof(vf_rss_query_en),
		    &vf_rss_query_en) ||
	    nla_put(skb, IFLA_VF_TRUST,
		    sizeof(vf_trust), &vf_trust))
1191 1192 1193 1194 1195 1196 1197 1198 1199 1200
		goto nla_put_vf_failure;
	vfvlanlist = nla_nest_start(skb, IFLA_VF_VLAN_LIST);
	if (!vfvlanlist)
		goto nla_put_vf_failure;
	if (nla_put(skb, IFLA_VF_VLAN_INFO, sizeof(vf_vlan_info),
		    &vf_vlan_info)) {
		nla_nest_cancel(skb, vfvlanlist);
		goto nla_put_vf_failure;
	}
	nla_nest_end(skb, vfvlanlist);
1201 1202 1203 1204 1205
	memset(&vf_stats, 0, sizeof(vf_stats));
	if (dev->netdev_ops->ndo_get_vf_stats)
		dev->netdev_ops->ndo_get_vf_stats(dev, vfs_num,
						&vf_stats);
	vfstats = nla_nest_start(skb, IFLA_VF_STATS);
1206 1207
	if (!vfstats)
		goto nla_put_vf_failure;
N
Nicolas Dichtel 已提交
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
	if (nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_PACKETS,
			      vf_stats.rx_packets, IFLA_VF_STATS_PAD) ||
	    nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS,
			      vf_stats.tx_packets, IFLA_VF_STATS_PAD) ||
	    nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES,
			      vf_stats.rx_bytes, IFLA_VF_STATS_PAD) ||
	    nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES,
			      vf_stats.tx_bytes, IFLA_VF_STATS_PAD) ||
	    nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST,
			      vf_stats.broadcast, IFLA_VF_STATS_PAD) ||
	    nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST,
1219 1220 1221 1222
			      vf_stats.multicast, IFLA_VF_STATS_PAD)) {
		nla_nest_cancel(skb, vfstats);
		goto nla_put_vf_failure;
	}
1223 1224 1225
	nla_nest_end(skb, vfstats);
	nla_nest_end(skb, vf);
	return 0;
1226 1227 1228 1229 1230 1231

nla_put_vf_failure:
	nla_nest_cancel(skb, vf);
nla_put_vfinfo_failure:
	nla_nest_cancel(skb, vfinfo);
	return -EMSGSIZE;
1232 1233 1234 1235
}

static int rtnl_fill_link_ifmap(struct sk_buff *skb, struct net_device *dev)
{
K
Kangjie Lu 已提交
1236 1237 1238 1239 1240 1241 1242 1243 1244 1245
	struct rtnl_link_ifmap map;

	memset(&map, 0, sizeof(map));
	map.mem_start   = dev->mem_start;
	map.mem_end     = dev->mem_end;
	map.base_addr   = dev->base_addr;
	map.irq         = dev->irq;
	map.dma         = dev->dma;
	map.port        = dev->if_port;

1246
	if (nla_put_64bit(skb, IFLA_MAP, sizeof(map), &map, IFLA_PAD))
1247 1248 1249 1250 1251
		return -EMSGSIZE;

	return 0;
}

1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278
static int rtnl_xdp_fill(struct sk_buff *skb, struct net_device *dev)
{
	struct netdev_xdp xdp_op = {};
	struct nlattr *xdp;
	int err;

	if (!dev->netdev_ops->ndo_xdp)
		return 0;
	xdp = nla_nest_start(skb, IFLA_XDP);
	if (!xdp)
		return -EMSGSIZE;
	xdp_op.command = XDP_QUERY_PROG;
	err = dev->netdev_ops->ndo_xdp(dev, &xdp_op);
	if (err)
		goto err_cancel;
	err = nla_put_u8(skb, IFLA_XDP_ATTACHED, xdp_op.prog_attached);
	if (err)
		goto err_cancel;

	nla_nest_end(skb, xdp);
	return 0;

err_cancel:
	nla_nest_cancel(skb, xdp);
	return err;
}

1279
static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev,
1280
			    int type, u32 pid, u32 seq, u32 change,
1281
			    unsigned int flags, u32 ext_filter_mask)
1282 1283 1284
{
	struct ifinfomsg *ifm;
	struct nlmsghdr *nlh;
1285
	struct nlattr *af_spec;
T
Thomas Graf 已提交
1286
	struct rtnl_af_ops *af_ops;
1287
	struct net_device *upper_dev = netdev_master_upper_dev_get(dev);
L
Linus Torvalds 已提交
1288

1289
	ASSERT_RTNL();
1290 1291
	nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags);
	if (nlh == NULL)
1292
		return -EMSGSIZE;
L
Linus Torvalds 已提交
1293

1294 1295 1296 1297 1298 1299 1300 1301
	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;

1302 1303 1304 1305 1306 1307 1308
	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) ||
1309
	    nla_put_u32(skb, IFLA_PROMISCUITY, dev->promiscuity) ||
1310
	    nla_put_u32(skb, IFLA_NUM_TX_QUEUES, dev->num_tx_queues) ||
1311 1312
	    nla_put_u32(skb, IFLA_GSO_MAX_SEGS, dev->gso_max_segs) ||
	    nla_put_u32(skb, IFLA_GSO_MAX_SIZE, dev->gso_max_size) ||
1313
#ifdef CONFIG_RPS
1314
	    nla_put_u32(skb, IFLA_NUM_RX_QUEUES, dev->num_rx_queues) ||
1315
#endif
1316 1317
	    (dev->ifindex != dev_get_iflink(dev) &&
	     nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))) ||
1318 1319
	    (upper_dev &&
	     nla_put_u32(skb, IFLA_MASTER, upper_dev->ifindex)) ||
1320
	    nla_put_u8(skb, IFLA_CARRIER, netif_carrier_ok(dev)) ||
1321 1322 1323
	    (dev->qdisc &&
	     nla_put_string(skb, IFLA_QDISC, dev->qdisc->ops->id)) ||
	    (dev->ifalias &&
1324 1325
	     nla_put_string(skb, IFLA_IFALIAS, dev->ifalias)) ||
	    nla_put_u32(skb, IFLA_CARRIER_CHANGES,
1326 1327
			atomic_read(&dev->carrier_changes)) ||
	    nla_put_u8(skb, IFLA_PROTO_DOWN, dev->proto_down))
1328
		goto nla_put_failure;
1329

1330 1331
	if (rtnl_fill_link_ifmap(skb, dev))
		goto nla_put_failure;
L
Linus Torvalds 已提交
1332 1333

	if (dev->addr_len) {
1334 1335 1336
		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;
L
Linus Torvalds 已提交
1337 1338
	}

1339 1340 1341
	if (rtnl_phys_port_id_fill(skb, dev))
		goto nla_put_failure;

1342 1343 1344
	if (rtnl_phys_port_name_fill(skb, dev))
		goto nla_put_failure;

1345 1346 1347
	if (rtnl_phys_switch_id_fill(skb, dev))
		goto nla_put_failure;

1348
	if (rtnl_fill_stats(skb, dev))
1349 1350
		goto nla_put_failure;

1351 1352 1353
	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;
1354

1355 1356
	if (dev->netdev_ops->ndo_get_vf_config && dev->dev.parent &&
	    ext_filter_mask & RTEXT_FILTER_VF) {
1357
		int i;
1358
		struct nlattr *vfinfo;
1359 1360 1361 1362 1363 1364
		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++) {
1365
			if (rtnl_fill_vfinfo(skb, dev, i, vfinfo))
1366
				goto nla_put_failure;
1367
		}
1368

1369
		nla_nest_end(skb, vfinfo);
1370
	}
1371

1372
	if (rtnl_port_fill(skb, dev, ext_filter_mask))
1373 1374
		goto nla_put_failure;

1375 1376 1377
	if (rtnl_xdp_fill(skb, dev))
		goto nla_put_failure;

1378
	if (dev->rtnl_link_ops || rtnl_have_link_slave_info(dev)) {
P
Patrick McHardy 已提交
1379 1380 1381 1382
		if (rtnl_link_fill(skb, dev) < 0)
			goto nla_put_failure;
	}

1383 1384 1385 1386 1387
	if (dev->rtnl_link_ops &&
	    dev->rtnl_link_ops->get_link_net) {
		struct net *link_net = dev->rtnl_link_ops->get_link_net(dev);

		if (!net_eq(dev_net(dev), link_net)) {
1388
			int id = peernet2id_alloc(dev_net(dev), link_net);
1389 1390 1391 1392 1393 1394

			if (nla_put_s32(skb, IFLA_LINK_NETNSID, id))
				goto nla_put_failure;
		}
	}

T
Thomas Graf 已提交
1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405
	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;

1406
			err = af_ops->fill_link_af(skb, dev, ext_filter_mask);
T
Thomas Graf 已提交
1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424

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

1425 1426
	nlmsg_end(skb, nlh);
	return 0;
1427 1428

nla_put_failure:
1429 1430
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
1431 1432
}

J
Jiri Pirko 已提交
1433
static const struct nla_policy ifla_policy[IFLA_MAX+1] = {
1434
	[IFLA_IFNAME]		= { .type = NLA_STRING, .len = IFNAMSIZ-1 },
P
Patrick McHardy 已提交
1435 1436
	[IFLA_ADDRESS]		= { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
	[IFLA_BROADCAST]	= { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
1437
	[IFLA_MAP]		= { .len = sizeof(struct rtnl_link_ifmap) },
1438
	[IFLA_MTU]		= { .type = NLA_U32 },
1439
	[IFLA_LINK]		= { .type = NLA_U32 },
1440
	[IFLA_MASTER]		= { .type = NLA_U32 },
1441
	[IFLA_CARRIER]		= { .type = NLA_U8 },
1442 1443 1444 1445
	[IFLA_TXQLEN]		= { .type = NLA_U32 },
	[IFLA_WEIGHT]		= { .type = NLA_U32 },
	[IFLA_OPERSTATE]	= { .type = NLA_U8 },
	[IFLA_LINKMODE]		= { .type = NLA_U8 },
1446
	[IFLA_LINKINFO]		= { .type = NLA_NESTED },
1447
	[IFLA_NET_NS_PID]	= { .type = NLA_U32 },
1448
	[IFLA_NET_NS_FD]	= { .type = NLA_U32 },
1449
	[IFLA_IFALIAS]	        = { .type = NLA_STRING, .len = IFALIASZ-1 },
1450
	[IFLA_VFINFO_LIST]	= {. type = NLA_NESTED },
1451 1452
	[IFLA_VF_PORTS]		= { .type = NLA_NESTED },
	[IFLA_PORT_SELF]	= { .type = NLA_NESTED },
T
Thomas Graf 已提交
1453
	[IFLA_AF_SPEC]		= { .type = NLA_NESTED },
1454
	[IFLA_EXT_MASK]		= { .type = NLA_U32 },
1455
	[IFLA_PROMISCUITY]	= { .type = NLA_U32 },
1456 1457
	[IFLA_NUM_TX_QUEUES]	= { .type = NLA_U32 },
	[IFLA_NUM_RX_QUEUES]	= { .type = NLA_U32 },
1458
	[IFLA_PHYS_PORT_ID]	= { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
1459
	[IFLA_CARRIER_CHANGES]	= { .type = NLA_U32 },  /* ignored */
1460
	[IFLA_PHYS_SWITCH_ID]	= { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
1461
	[IFLA_LINK_NETNSID]	= { .type = NLA_S32 },
1462
	[IFLA_PROTO_DOWN]	= { .type = NLA_U8 },
1463
	[IFLA_XDP]		= { .type = NLA_NESTED },
1464 1465
};

P
Patrick McHardy 已提交
1466 1467 1468
static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = {
	[IFLA_INFO_KIND]	= { .type = NLA_STRING },
	[IFLA_INFO_DATA]	= { .type = NLA_NESTED },
1469 1470
	[IFLA_INFO_SLAVE_KIND]	= { .type = NLA_STRING },
	[IFLA_INFO_SLAVE_DATA]	= { .type = NLA_NESTED },
P
Patrick McHardy 已提交
1471 1472
};

1473
static const struct nla_policy ifla_vf_policy[IFLA_VF_MAX+1] = {
1474 1475
	[IFLA_VF_MAC]		= { .len = sizeof(struct ifla_vf_mac) },
	[IFLA_VF_VLAN]		= { .len = sizeof(struct ifla_vf_vlan) },
1476
	[IFLA_VF_VLAN_LIST]     = { .type = NLA_NESTED },
1477 1478 1479 1480
	[IFLA_VF_TX_RATE]	= { .len = sizeof(struct ifla_vf_tx_rate) },
	[IFLA_VF_SPOOFCHK]	= { .len = sizeof(struct ifla_vf_spoofchk) },
	[IFLA_VF_RATE]		= { .len = sizeof(struct ifla_vf_rate) },
	[IFLA_VF_LINK_STATE]	= { .len = sizeof(struct ifla_vf_link_state) },
1481
	[IFLA_VF_RSS_QUERY_EN]	= { .len = sizeof(struct ifla_vf_rss_query_en) },
1482
	[IFLA_VF_STATS]		= { .type = NLA_NESTED },
H
Hiroshi Shimamoto 已提交
1483
	[IFLA_VF_TRUST]		= { .len = sizeof(struct ifla_vf_trust) },
1484 1485
	[IFLA_VF_IB_NODE_GUID]	= { .len = sizeof(struct ifla_vf_guid) },
	[IFLA_VF_IB_PORT_GUID]	= { .len = sizeof(struct ifla_vf_guid) },
1486 1487
};

1488 1489 1490 1491 1492 1493 1494 1495 1496 1497
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_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, },
1498 1499 1500 1501 1502 1503 1504

	/* Unused, but we need to keep it here since user space could
	 * fill it. It's also broken with regard to NLA_BINARY use in
	 * combination with structs.
	 */
	[IFLA_PORT_VSI_TYPE]	= { .type = NLA_BINARY,
				    .len = sizeof(struct ifla_port_vsi) },
1505 1506
};

1507 1508 1509
static const struct nla_policy ifla_xdp_policy[IFLA_XDP_MAX + 1] = {
	[IFLA_XDP_FD]		= { .type = NLA_S32 },
	[IFLA_XDP_ATTACHED]	= { .type = NLA_U8 },
1510
	[IFLA_XDP_FLAGS]	= { .type = NLA_U32 },
1511 1512
};

1513 1514 1515 1516 1517
static const struct rtnl_link_ops *linkinfo_to_kind_ops(const struct nlattr *nla)
{
	const struct rtnl_link_ops *ops = NULL;
	struct nlattr *linfo[IFLA_INFO_MAX + 1];

1518 1519
	if (nla_parse_nested(linfo, IFLA_INFO_MAX, nla,
			     ifla_info_policy, NULL) < 0)
1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565
		return NULL;

	if (linfo[IFLA_INFO_KIND]) {
		char kind[MODULE_NAME_LEN];

		nla_strlcpy(kind, linfo[IFLA_INFO_KIND], sizeof(kind));
		ops = rtnl_link_ops_get(kind);
	}

	return ops;
}

static bool link_master_filtered(struct net_device *dev, int master_idx)
{
	struct net_device *master;

	if (!master_idx)
		return false;

	master = netdev_master_upper_dev_get(dev);
	if (!master || master->ifindex != master_idx)
		return true;

	return false;
}

static bool link_kind_filtered(const struct net_device *dev,
			       const struct rtnl_link_ops *kind_ops)
{
	if (kind_ops && dev->rtnl_link_ops != kind_ops)
		return true;

	return false;
}

static bool link_dump_filtered(struct net_device *dev,
			       int master_idx,
			       const struct rtnl_link_ops *kind_ops)
{
	if (link_master_filtered(dev, master_idx) ||
	    link_kind_filtered(dev, kind_ops))
		return true;

	return false;
}

J
Jiri Pirko 已提交
1566 1567 1568 1569 1570 1571 1572 1573 1574
static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
{
	struct net *net = sock_net(skb->sk);
	int h, s_h;
	int idx = 0, s_idx;
	struct net_device *dev;
	struct hlist_head *head;
	struct nlattr *tb[IFLA_MAX+1];
	u32 ext_filter_mask = 0;
1575 1576 1577
	const struct rtnl_link_ops *kind_ops = NULL;
	unsigned int flags = NLM_F_MULTI;
	int master_idx = 0;
1578
	int err;
1579
	int hdrlen;
J
Jiri Pirko 已提交
1580 1581 1582 1583 1584 1585

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

	cb->seq = net->dev_base_seq;

1586 1587 1588 1589 1590 1591 1592 1593 1594 1595
	/* A hack to preserve kernel<->userspace interface.
	 * The correct header is ifinfomsg. It is consistent with rtnl_getlink.
	 * However, before Linux v3.9 the code here assumed rtgenmsg and that's
	 * what iproute2 < v3.9.0 used.
	 * We can detect the old iproute2. Even including the IFLA_EXT_MASK
	 * attribute, its netlink message is shorter than struct ifinfomsg.
	 */
	hdrlen = nlmsg_len(cb->nlh) < sizeof(struct ifinfomsg) ?
		 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg);

1596 1597
	if (nlmsg_parse(cb->nlh, hdrlen, tb, IFLA_MAX,
			ifla_policy, NULL) >= 0) {
J
Jiri Pirko 已提交
1598 1599
		if (tb[IFLA_EXT_MASK])
			ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
1600 1601 1602 1603 1604 1605 1606 1607 1608

		if (tb[IFLA_MASTER])
			master_idx = nla_get_u32(tb[IFLA_MASTER]);

		if (tb[IFLA_LINKINFO])
			kind_ops = linkinfo_to_kind_ops(tb[IFLA_LINKINFO]);

		if (master_idx || kind_ops)
			flags |= NLM_F_DUMP_FILTERED;
J
Jiri Pirko 已提交
1609 1610 1611 1612 1613
	}

	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
		idx = 0;
		head = &net->dev_index_head[h];
1614
		hlist_for_each_entry(dev, head, index_hlist) {
1615
			if (link_dump_filtered(dev, master_idx, kind_ops))
1616
				goto cont;
J
Jiri Pirko 已提交
1617 1618
			if (idx < s_idx)
				goto cont;
1619 1620 1621
			err = rtnl_fill_ifinfo(skb, dev, RTM_NEWLINK,
					       NETLINK_CB(cb->skb).portid,
					       cb->nlh->nlmsg_seq, 0,
1622
					       flags,
1623
					       ext_filter_mask);
1624 1625 1626 1627 1628
			/* If we ran out of room on the first message,
			 * we're in trouble
			 */
			WARN_ON((err == -EMSGSIZE) && (skb->len == 0));

1629
			if (err < 0)
J
Jiri Pirko 已提交
1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643
				goto out;

			nl_dump_check_consistent(cb, nlmsg_hdr(skb));
cont:
			idx++;
		}
	}
out:
	cb->args[1] = idx;
	cb->args[0] = h;

	return skb->len;
}

1644 1645
int rtnl_nla_parse_ifla(struct nlattr **tb, const struct nlattr *head, int len,
			struct netlink_ext_ack *exterr)
J
Jiri Pirko 已提交
1646
{
1647
	return nla_parse(tb, IFLA_MAX, head, len, ifla_policy, exterr);
J
Jiri Pirko 已提交
1648 1649 1650
}
EXPORT_SYMBOL(rtnl_nla_parse_ifla);

1651 1652 1653 1654 1655 1656 1657 1658
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]));
1659 1660
	else if (tb[IFLA_NET_NS_FD])
		net = get_net_ns_by_fd(nla_get_u32(tb[IFLA_NET_NS_FD]));
1661 1662 1663 1664 1665 1666
	else
		net = get_net(src_net);
	return net;
}
EXPORT_SYMBOL(rtnl_link_get_net);

1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678
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;
	}

1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692
	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) {
1693
				err = af_ops->validate_link_af(dev, af);
1694 1695 1696 1697 1698 1699
				if (err < 0)
					return err;
			}
		}
	}

1700 1701 1702
	return 0;
}

1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718
static int handle_infiniband_guid(struct net_device *dev, struct ifla_vf_guid *ivt,
				  int guid_type)
{
	const struct net_device_ops *ops = dev->netdev_ops;

	return ops->ndo_set_vf_guid(dev, ivt->vf, ivt->guid, guid_type);
}

static int handle_vf_guid(struct net_device *dev, struct ifla_vf_guid *ivt, int guid_type)
{
	if (dev->type != ARPHRD_INFINIBAND)
		return -EOPNOTSUPP;

	return handle_infiniband_guid(dev, ivt, guid_type);
}

1719
static int do_setvfinfo(struct net_device *dev, struct nlattr **tb)
1720 1721
{
	const struct net_device_ops *ops = dev->netdev_ops;
1722
	int err = -EINVAL;
1723

1724 1725
	if (tb[IFLA_VF_MAC]) {
		struct ifla_vf_mac *ivm = nla_data(tb[IFLA_VF_MAC]);
1726

1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740
		err = -EOPNOTSUPP;
		if (ops->ndo_set_vf_mac)
			err = ops->ndo_set_vf_mac(dev, ivm->vf,
						  ivm->mac);
		if (err < 0)
			return err;
	}

	if (tb[IFLA_VF_VLAN]) {
		struct ifla_vf_vlan *ivv = nla_data(tb[IFLA_VF_VLAN]);

		err = -EOPNOTSUPP;
		if (ops->ndo_set_vf_vlan)
			err = ops->ndo_set_vf_vlan(dev, ivv->vf, ivv->vlan,
1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766
						   ivv->qos,
						   htons(ETH_P_8021Q));
		if (err < 0)
			return err;
	}

	if (tb[IFLA_VF_VLAN_LIST]) {
		struct ifla_vf_vlan_info *ivvl[MAX_VLAN_LIST_LEN];
		struct nlattr *attr;
		int rem, len = 0;

		err = -EOPNOTSUPP;
		if (!ops->ndo_set_vf_vlan)
			return err;

		nla_for_each_nested(attr, tb[IFLA_VF_VLAN_LIST], rem) {
			if (nla_type(attr) != IFLA_VF_VLAN_INFO ||
			    nla_len(attr) < NLA_HDRLEN) {
				return -EINVAL;
			}
			if (len >= MAX_VLAN_LIST_LEN)
				return -EOPNOTSUPP;
			ivvl[len] = nla_data(attr);

			len++;
		}
1767 1768 1769
		if (len == 0)
			return -EINVAL;

1770 1771
		err = ops->ndo_set_vf_vlan(dev, ivvl[0]->vf, ivvl[0]->vlan,
					   ivvl[0]->qos, ivvl[0]->vlan_proto);
1772 1773
		if (err < 0)
			return err;
1774
	}
1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840

	if (tb[IFLA_VF_TX_RATE]) {
		struct ifla_vf_tx_rate *ivt = nla_data(tb[IFLA_VF_TX_RATE]);
		struct ifla_vf_info ivf;

		err = -EOPNOTSUPP;
		if (ops->ndo_get_vf_config)
			err = ops->ndo_get_vf_config(dev, ivt->vf, &ivf);
		if (err < 0)
			return err;

		err = -EOPNOTSUPP;
		if (ops->ndo_set_vf_rate)
			err = ops->ndo_set_vf_rate(dev, ivt->vf,
						   ivf.min_tx_rate,
						   ivt->rate);
		if (err < 0)
			return err;
	}

	if (tb[IFLA_VF_RATE]) {
		struct ifla_vf_rate *ivt = nla_data(tb[IFLA_VF_RATE]);

		err = -EOPNOTSUPP;
		if (ops->ndo_set_vf_rate)
			err = ops->ndo_set_vf_rate(dev, ivt->vf,
						   ivt->min_tx_rate,
						   ivt->max_tx_rate);
		if (err < 0)
			return err;
	}

	if (tb[IFLA_VF_SPOOFCHK]) {
		struct ifla_vf_spoofchk *ivs = nla_data(tb[IFLA_VF_SPOOFCHK]);

		err = -EOPNOTSUPP;
		if (ops->ndo_set_vf_spoofchk)
			err = ops->ndo_set_vf_spoofchk(dev, ivs->vf,
						       ivs->setting);
		if (err < 0)
			return err;
	}

	if (tb[IFLA_VF_LINK_STATE]) {
		struct ifla_vf_link_state *ivl = nla_data(tb[IFLA_VF_LINK_STATE]);

		err = -EOPNOTSUPP;
		if (ops->ndo_set_vf_link_state)
			err = ops->ndo_set_vf_link_state(dev, ivl->vf,
							 ivl->link_state);
		if (err < 0)
			return err;
	}

	if (tb[IFLA_VF_RSS_QUERY_EN]) {
		struct ifla_vf_rss_query_en *ivrssq_en;

		err = -EOPNOTSUPP;
		ivrssq_en = nla_data(tb[IFLA_VF_RSS_QUERY_EN]);
		if (ops->ndo_set_vf_rss_query_en)
			err = ops->ndo_set_vf_rss_query_en(dev, ivrssq_en->vf,
							   ivrssq_en->setting);
		if (err < 0)
			return err;
	}

H
Hiroshi Shimamoto 已提交
1841 1842 1843 1844 1845 1846 1847 1848 1849 1850
	if (tb[IFLA_VF_TRUST]) {
		struct ifla_vf_trust *ivt = nla_data(tb[IFLA_VF_TRUST]);

		err = -EOPNOTSUPP;
		if (ops->ndo_set_vf_trust)
			err = ops->ndo_set_vf_trust(dev, ivt->vf, ivt->setting);
		if (err < 0)
			return err;
	}

1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868
	if (tb[IFLA_VF_IB_NODE_GUID]) {
		struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_NODE_GUID]);

		if (!ops->ndo_set_vf_guid)
			return -EOPNOTSUPP;

		return handle_vf_guid(dev, ivt, IFLA_VF_IB_NODE_GUID);
	}

	if (tb[IFLA_VF_IB_PORT_GUID]) {
		struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_PORT_GUID]);

		if (!ops->ndo_set_vf_guid)
			return -EOPNOTSUPP;

		return handle_vf_guid(dev, ivt, IFLA_VF_IB_PORT_GUID);
	}

1869 1870 1871
	return err;
}

1872 1873
static int do_set_master(struct net_device *dev, int ifindex)
{
1874
	struct net_device *upper_dev = netdev_master_upper_dev_get(dev);
1875 1876 1877
	const struct net_device_ops *ops;
	int err;

1878 1879
	if (upper_dev) {
		if (upper_dev->ifindex == ifindex)
1880
			return 0;
1881
		ops = upper_dev->netdev_ops;
1882
		if (ops->ndo_del_slave) {
1883
			err = ops->ndo_del_slave(upper_dev, dev);
1884 1885 1886 1887 1888 1889 1890 1891
			if (err)
				return err;
		} else {
			return -EOPNOTSUPP;
		}
	}

	if (ifindex) {
1892 1893
		upper_dev = __dev_get_by_index(dev_net(dev), ifindex);
		if (!upper_dev)
1894
			return -EINVAL;
1895
		ops = upper_dev->netdev_ops;
1896
		if (ops->ndo_add_slave) {
1897
			err = ops->ndo_add_slave(upper_dev, dev);
1898 1899 1900 1901 1902 1903 1904 1905 1906
			if (err)
				return err;
		} else {
			return -EOPNOTSUPP;
		}
	}
	return 0;
}

1907
#define DO_SETLINK_MODIFIED	0x01
1908 1909
/* notify flag means notify + modified. */
#define DO_SETLINK_NOTIFY	0x03
1910 1911
static int do_setlink(const struct sk_buff *skb,
		      struct net_device *dev, struct ifinfomsg *ifm,
1912
		      struct nlattr **tb, char *ifname, int status)
L
Linus Torvalds 已提交
1913
{
1914
	const struct net_device_ops *ops = dev->netdev_ops;
1915
	int err;
L
Linus Torvalds 已提交
1916

1917
	if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD]) {
1918
		struct net *net = rtnl_link_get_net(dev_net(dev), tb);
1919 1920 1921 1922
		if (IS_ERR(net)) {
			err = PTR_ERR(net);
			goto errout;
		}
1923
		if (!netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN)) {
1924
			put_net(net);
1925 1926 1927
			err = -EPERM;
			goto errout;
		}
1928 1929 1930 1931
		err = dev_change_net_namespace(dev, net, ifname);
		put_net(net);
		if (err)
			goto errout;
1932
		status |= DO_SETLINK_MODIFIED;
1933 1934
	}

1935
	if (tb[IFLA_MAP]) {
L
Linus Torvalds 已提交
1936 1937 1938
		struct rtnl_link_ifmap *u_map;
		struct ifmap k_map;

1939
		if (!ops->ndo_set_config) {
L
Linus Torvalds 已提交
1940
			err = -EOPNOTSUPP;
1941
			goto errout;
L
Linus Torvalds 已提交
1942 1943 1944 1945
		}

		if (!netif_device_present(dev)) {
			err = -ENODEV;
1946
			goto errout;
L
Linus Torvalds 已提交
1947 1948
		}

1949
		u_map = nla_data(tb[IFLA_MAP]);
L
Linus Torvalds 已提交
1950 1951 1952 1953 1954 1955 1956
		k_map.mem_start = (unsigned long) u_map->mem_start;
		k_map.mem_end = (unsigned long) u_map->mem_end;
		k_map.base_addr = (unsigned short) u_map->base_addr;
		k_map.irq = (unsigned char) u_map->irq;
		k_map.dma = (unsigned char) u_map->dma;
		k_map.port = (unsigned char) u_map->port;

1957
		err = ops->ndo_set_config(dev, &k_map);
1958
		if (err < 0)
1959
			goto errout;
L
Linus Torvalds 已提交
1960

1961
		status |= DO_SETLINK_NOTIFY;
L
Linus Torvalds 已提交
1962 1963
	}

1964
	if (tb[IFLA_ADDRESS]) {
1965 1966 1967 1968 1969 1970 1971
		struct sockaddr *sa;
		int len;

		len = sizeof(sa_family_t) + dev->addr_len;
		sa = kmalloc(len, GFP_KERNEL);
		if (!sa) {
			err = -ENOMEM;
1972
			goto errout;
1973 1974
		}
		sa->sa_family = dev->type;
1975
		memcpy(sa->sa_data, nla_data(tb[IFLA_ADDRESS]),
1976
		       dev->addr_len);
1977
		err = dev_set_mac_address(dev, sa);
1978
		kfree(sa);
L
Linus Torvalds 已提交
1979
		if (err)
1980
			goto errout;
1981
		status |= DO_SETLINK_MODIFIED;
L
Linus Torvalds 已提交
1982 1983
	}

1984 1985 1986
	if (tb[IFLA_MTU]) {
		err = dev_set_mtu(dev, nla_get_u32(tb[IFLA_MTU]));
		if (err < 0)
1987
			goto errout;
1988
		status |= DO_SETLINK_MODIFIED;
L
Linus Torvalds 已提交
1989 1990
	}

1991 1992
	if (tb[IFLA_GROUP]) {
		dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP]));
1993
		status |= DO_SETLINK_NOTIFY;
1994 1995
	}

1996 1997 1998 1999 2000
	/*
	 * Interface selected by interface index but interface
	 * name provided implies that a name change has been
	 * requested.
	 */
2001
	if (ifm->ifi_index > 0 && ifname[0]) {
2002 2003
		err = dev_change_name(dev, ifname);
		if (err < 0)
2004
			goto errout;
2005
		status |= DO_SETLINK_MODIFIED;
L
Linus Torvalds 已提交
2006 2007
	}

2008 2009 2010 2011 2012
	if (tb[IFLA_IFALIAS]) {
		err = dev_set_alias(dev, nla_data(tb[IFLA_IFALIAS]),
				    nla_len(tb[IFLA_IFALIAS]));
		if (err < 0)
			goto errout;
2013
		status |= DO_SETLINK_NOTIFY;
2014 2015
	}

2016 2017
	if (tb[IFLA_BROADCAST]) {
		nla_memcpy(dev->broadcast, tb[IFLA_BROADCAST], dev->addr_len);
2018
		call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
L
Linus Torvalds 已提交
2019 2020
	}

2021
	if (ifm->ifi_flags || ifm->ifi_change) {
2022
		err = dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm));
2023 2024
		if (err < 0)
			goto errout;
2025
	}
L
Linus Torvalds 已提交
2026

2027 2028 2029 2030
	if (tb[IFLA_MASTER]) {
		err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]));
		if (err)
			goto errout;
2031
		status |= DO_SETLINK_MODIFIED;
2032 2033
	}

2034 2035 2036 2037
	if (tb[IFLA_CARRIER]) {
		err = dev_change_carrier(dev, nla_get_u8(tb[IFLA_CARRIER]));
		if (err)
			goto errout;
2038
		status |= DO_SETLINK_MODIFIED;
2039 2040
	}

2041 2042
	if (tb[IFLA_TXQLEN]) {
		unsigned long value = nla_get_u32(tb[IFLA_TXQLEN]);
2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053
		unsigned long orig_len = dev->tx_queue_len;

		if (dev->tx_queue_len ^ value) {
			dev->tx_queue_len = value;
			err = call_netdevice_notifiers(
			      NETDEV_CHANGE_TX_QUEUE_LEN, dev);
			err = notifier_to_errno(err);
			if (err) {
				dev->tx_queue_len = orig_len;
				goto errout;
			}
2054
			status |= DO_SETLINK_NOTIFY;
2055
		}
2056
	}
S
Stefan Rompf 已提交
2057

2058
	if (tb[IFLA_OPERSTATE])
2059
		set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
S
Stefan Rompf 已提交
2060

2061
	if (tb[IFLA_LINKMODE]) {
2062 2063
		unsigned char value = nla_get_u8(tb[IFLA_LINKMODE]);

2064
		write_lock_bh(&dev_base_lock);
2065
		if (dev->link_mode ^ value)
2066
			status |= DO_SETLINK_NOTIFY;
2067
		dev->link_mode = value;
2068
		write_unlock_bh(&dev_base_lock);
S
Stefan Rompf 已提交
2069 2070
	}

2071
	if (tb[IFLA_VFINFO_LIST]) {
2072
		struct nlattr *vfinfo[IFLA_VF_MAX + 1];
2073 2074
		struct nlattr *attr;
		int rem;
2075

2076
		nla_for_each_nested(attr, tb[IFLA_VFINFO_LIST], rem) {
2077 2078
			if (nla_type(attr) != IFLA_VF_INFO ||
			    nla_len(attr) < NLA_HDRLEN) {
2079
				err = -EINVAL;
2080
				goto errout;
2081
			}
2082
			err = nla_parse_nested(vfinfo, IFLA_VF_MAX, attr,
2083
					       ifla_vf_policy, NULL);
2084 2085 2086
			if (err < 0)
				goto errout;
			err = do_setvfinfo(dev, vfinfo);
2087 2088
			if (err < 0)
				goto errout;
2089
			status |= DO_SETLINK_NOTIFY;
2090
		}
2091
	}
L
Linus Torvalds 已提交
2092 2093
	err = 0;

2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104
	if (tb[IFLA_VF_PORTS]) {
		struct nlattr *port[IFLA_PORT_MAX+1];
		struct nlattr *attr;
		int vf;
		int rem;

		err = -EOPNOTSUPP;
		if (!ops->ndo_set_vf_port)
			goto errout;

		nla_for_each_nested(attr, tb[IFLA_VF_PORTS], rem) {
2105 2106 2107 2108 2109 2110
			if (nla_type(attr) != IFLA_VF_PORT ||
			    nla_len(attr) < NLA_HDRLEN) {
				err = -EINVAL;
				goto errout;
			}
			err = nla_parse_nested(port, IFLA_PORT_MAX, attr,
2111
					       ifla_port_policy, NULL);
2112 2113 2114 2115 2116 2117 2118 2119 2120 2121
			if (err < 0)
				goto errout;
			if (!port[IFLA_PORT_VF]) {
				err = -EOPNOTSUPP;
				goto errout;
			}
			vf = nla_get_u32(port[IFLA_PORT_VF]);
			err = ops->ndo_set_vf_port(dev, vf, port);
			if (err < 0)
				goto errout;
2122
			status |= DO_SETLINK_NOTIFY;
2123 2124 2125 2126 2127 2128 2129 2130
		}
	}
	err = 0;

	if (tb[IFLA_PORT_SELF]) {
		struct nlattr *port[IFLA_PORT_MAX+1];

		err = nla_parse_nested(port, IFLA_PORT_MAX,
2131 2132
				       tb[IFLA_PORT_SELF], ifla_port_policy,
				       NULL);
2133 2134 2135 2136 2137 2138 2139 2140
		if (err < 0)
			goto errout;

		err = -EOPNOTSUPP;
		if (ops->ndo_set_vf_port)
			err = ops->ndo_set_vf_port(dev, PORT_SELF_VF, port);
		if (err < 0)
			goto errout;
2141
		status |= DO_SETLINK_NOTIFY;
2142
	}
T
Thomas Graf 已提交
2143 2144 2145 2146 2147 2148 2149 2150 2151

	if (tb[IFLA_AF_SPEC]) {
		struct nlattr *af;
		int rem;

		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))))
2152
				BUG();
T
Thomas Graf 已提交
2153

2154
			err = af_ops->set_link_af(dev, af);
T
Thomas Graf 已提交
2155 2156 2157
			if (err < 0)
				goto errout;

2158
			status |= DO_SETLINK_NOTIFY;
T
Thomas Graf 已提交
2159 2160
		}
	}
2161 2162
	err = 0;

2163 2164 2165 2166 2167 2168 2169 2170
	if (tb[IFLA_PROTO_DOWN]) {
		err = dev_change_proto_down(dev,
					    nla_get_u8(tb[IFLA_PROTO_DOWN]));
		if (err)
			goto errout;
		status |= DO_SETLINK_NOTIFY;
	}

2171 2172
	if (tb[IFLA_XDP]) {
		struct nlattr *xdp[IFLA_XDP_MAX + 1];
2173
		u32 xdp_flags = 0;
2174 2175

		err = nla_parse_nested(xdp, IFLA_XDP_MAX, tb[IFLA_XDP],
2176
				       ifla_xdp_policy, NULL);
2177 2178 2179
		if (err < 0)
			goto errout;

2180 2181 2182 2183
		if (xdp[IFLA_XDP_ATTACHED]) {
			err = -EINVAL;
			goto errout;
		}
2184 2185 2186 2187 2188 2189 2190 2191 2192

		if (xdp[IFLA_XDP_FLAGS]) {
			xdp_flags = nla_get_u32(xdp[IFLA_XDP_FLAGS]);
			if (xdp_flags & ~XDP_FLAGS_MASK) {
				err = -EINVAL;
				goto errout;
			}
		}

2193 2194
		if (xdp[IFLA_XDP_FD]) {
			err = dev_change_xdp_fd(dev,
2195 2196
						nla_get_s32(xdp[IFLA_XDP_FD]),
						xdp_flags);
2197 2198 2199 2200 2201 2202
			if (err)
				goto errout;
			status |= DO_SETLINK_NOTIFY;
		}
	}

2203
errout:
2204 2205 2206 2207 2208 2209 2210 2211
	if (status & DO_SETLINK_MODIFIED) {
		if (status & DO_SETLINK_NOTIFY)
			netdev_state_change(dev);

		if (err < 0)
			net_warn_ratelimited("A link change request failed with some changes committed already. Interface %s may have been left with an inconsistent configuration, please check.\n",
					     dev->name);
	}
2212

2213 2214
	return err;
}
L
Linus Torvalds 已提交
2215

2216 2217
static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh,
			struct netlink_ext_ack *extack)
2218
{
2219
	struct net *net = sock_net(skb->sk);
2220 2221 2222 2223 2224 2225
	struct ifinfomsg *ifm;
	struct net_device *dev;
	int err;
	struct nlattr *tb[IFLA_MAX+1];
	char ifname[IFNAMSIZ];

2226 2227
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy,
			  extack);
2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238
	if (err < 0)
		goto errout;

	if (tb[IFLA_IFNAME])
		nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
	else
		ifname[0] = '\0';

	err = -EINVAL;
	ifm = nlmsg_data(nlh);
	if (ifm->ifi_index > 0)
2239
		dev = __dev_get_by_index(net, ifm->ifi_index);
2240
	else if (tb[IFLA_IFNAME])
2241
		dev = __dev_get_by_name(net, ifname);
2242 2243 2244 2245 2246 2247 2248 2249
	else
		goto errout;

	if (dev == NULL) {
		err = -ENODEV;
		goto errout;
	}

E
Eric Dumazet 已提交
2250 2251
	err = validate_linkmsg(dev, tb);
	if (err < 0)
2252
		goto errout;
2253

2254
	err = do_setlink(skb, dev, ifm, tb, ifname, 0);
2255
errout:
L
Linus Torvalds 已提交
2256 2257 2258
	return err;
}

2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294
static int rtnl_group_dellink(const struct net *net, int group)
{
	struct net_device *dev, *aux;
	LIST_HEAD(list_kill);
	bool found = false;

	if (!group)
		return -EPERM;

	for_each_netdev(net, dev) {
		if (dev->group == group) {
			const struct rtnl_link_ops *ops;

			found = true;
			ops = dev->rtnl_link_ops;
			if (!ops || !ops->dellink)
				return -EOPNOTSUPP;
		}
	}

	if (!found)
		return -ENODEV;

	for_each_netdev_safe(net, dev, aux) {
		if (dev->group == group) {
			const struct rtnl_link_ops *ops;

			ops = dev->rtnl_link_ops;
			ops->dellink(dev, &list_kill);
		}
	}
	unregister_netdevice_many(&list_kill);

	return 0;
}

2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310
int rtnl_delete_link(struct net_device *dev)
{
	const struct rtnl_link_ops *ops;
	LIST_HEAD(list_kill);

	ops = dev->rtnl_link_ops;
	if (!ops || !ops->dellink)
		return -EOPNOTSUPP;

	ops->dellink(dev, &list_kill);
	unregister_netdevice_many(&list_kill);

	return 0;
}
EXPORT_SYMBOL_GPL(rtnl_delete_link);

2311 2312
static int rtnl_dellink(struct sk_buff *skb, struct nlmsghdr *nlh,
			struct netlink_ext_ack *extack)
P
Patrick McHardy 已提交
2313
{
2314
	struct net *net = sock_net(skb->sk);
P
Patrick McHardy 已提交
2315 2316 2317 2318 2319 2320
	struct net_device *dev;
	struct ifinfomsg *ifm;
	char ifname[IFNAMSIZ];
	struct nlattr *tb[IFLA_MAX+1];
	int err;

2321
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy, extack);
P
Patrick McHardy 已提交
2322 2323 2324 2325 2326 2327 2328 2329
	if (err < 0)
		return err;

	if (tb[IFLA_IFNAME])
		nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);

	ifm = nlmsg_data(nlh);
	if (ifm->ifi_index > 0)
2330
		dev = __dev_get_by_index(net, ifm->ifi_index);
P
Patrick McHardy 已提交
2331
	else if (tb[IFLA_IFNAME])
2332
		dev = __dev_get_by_name(net, ifname);
2333 2334
	else if (tb[IFLA_GROUP])
		return rtnl_group_dellink(net, nla_get_u32(tb[IFLA_GROUP]));
P
Patrick McHardy 已提交
2335 2336 2337 2338 2339 2340
	else
		return -EINVAL;

	if (!dev)
		return -ENODEV;

2341
	return rtnl_delete_link(dev);
P
Patrick McHardy 已提交
2342 2343
}

2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357
int rtnl_configure_link(struct net_device *dev, const struct ifinfomsg *ifm)
{
	unsigned int old_flags;
	int err;

	old_flags = dev->flags;
	if (ifm && (ifm->ifi_flags || ifm->ifi_change)) {
		err = __dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm));
		if (err < 0)
			return err;
	}

	dev->rtnl_link_state = RTNL_LINK_INITIALIZED;

2358
	__dev_notify_flags(dev, old_flags, ~0U);
2359 2360 2361 2362
	return 0;
}
EXPORT_SYMBOL(rtnl_configure_link);

2363
struct net_device *rtnl_create_link(struct net *net,
2364
	const char *ifname, unsigned char name_assign_type,
2365
	const struct rtnl_link_ops *ops, struct nlattr *tb[])
2366 2367
{
	struct net_device *dev;
2368 2369
	unsigned int num_tx_queues = 1;
	unsigned int num_rx_queues = 1;
2370

2371 2372 2373
	if (tb[IFLA_NUM_TX_QUEUES])
		num_tx_queues = nla_get_u32(tb[IFLA_NUM_TX_QUEUES]);
	else if (ops->get_num_tx_queues)
2374
		num_tx_queues = ops->get_num_tx_queues();
2375 2376 2377 2378

	if (tb[IFLA_NUM_RX_QUEUES])
		num_rx_queues = nla_get_u32(tb[IFLA_NUM_RX_QUEUES]);
	else if (ops->get_num_rx_queues)
2379
		num_rx_queues = ops->get_num_rx_queues();
2380

2381
	dev = alloc_netdev_mqs(ops->priv_size, ifname, name_assign_type,
2382
			       ops->setup, num_tx_queues, num_rx_queues);
2383
	if (!dev)
2384
		return ERR_PTR(-ENOMEM);
2385

2386 2387
	dev_net_set(dev, net);
	dev->rtnl_link_ops = ops;
2388
	dev->rtnl_link_state = RTNL_LINK_INITIALIZING;
2389

2390 2391
	if (tb[IFLA_MTU])
		dev->mtu = nla_get_u32(tb[IFLA_MTU]);
2392
	if (tb[IFLA_ADDRESS]) {
2393 2394
		memcpy(dev->dev_addr, nla_data(tb[IFLA_ADDRESS]),
				nla_len(tb[IFLA_ADDRESS]));
2395 2396
		dev->addr_assign_type = NET_ADDR_SET;
	}
2397 2398 2399 2400 2401 2402
	if (tb[IFLA_BROADCAST])
		memcpy(dev->broadcast, nla_data(tb[IFLA_BROADCAST]),
				nla_len(tb[IFLA_BROADCAST]));
	if (tb[IFLA_TXQLEN])
		dev->tx_queue_len = nla_get_u32(tb[IFLA_TXQLEN]);
	if (tb[IFLA_OPERSTATE])
2403
		set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
2404 2405
	if (tb[IFLA_LINKMODE])
		dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]);
2406 2407
	if (tb[IFLA_GROUP])
		dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP]));
2408 2409 2410

	return dev;
}
E
Eric Dumazet 已提交
2411
EXPORT_SYMBOL(rtnl_create_link);
2412

2413 2414
static int rtnl_group_changelink(const struct sk_buff *skb,
		struct net *net, int group,
2415 2416 2417
		struct ifinfomsg *ifm,
		struct nlattr **tb)
{
2418
	struct net_device *dev, *aux;
2419 2420
	int err;

2421
	for_each_netdev_safe(net, dev, aux) {
2422
		if (dev->group == group) {
2423
			err = do_setlink(skb, dev, ifm, tb, NULL, 0);
2424 2425 2426 2427 2428 2429 2430 2431
			if (err < 0)
				return err;
		}
	}

	return 0;
}

2432 2433
static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
			struct netlink_ext_ack *extack)
P
Patrick McHardy 已提交
2434
{
2435
	struct net *net = sock_net(skb->sk);
P
Patrick McHardy 已提交
2436
	const struct rtnl_link_ops *ops;
2437
	const struct rtnl_link_ops *m_ops = NULL;
P
Patrick McHardy 已提交
2438
	struct net_device *dev;
2439
	struct net_device *master_dev = NULL;
P
Patrick McHardy 已提交
2440 2441 2442 2443 2444
	struct ifinfomsg *ifm;
	char kind[MODULE_NAME_LEN];
	char ifname[IFNAMSIZ];
	struct nlattr *tb[IFLA_MAX+1];
	struct nlattr *linkinfo[IFLA_INFO_MAX+1];
2445
	unsigned char name_assign_type = NET_NAME_USER;
P
Patrick McHardy 已提交
2446 2447
	int err;

2448
#ifdef CONFIG_MODULES
P
Patrick McHardy 已提交
2449
replay:
2450
#endif
2451
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy, extack);
P
Patrick McHardy 已提交
2452 2453 2454 2455 2456 2457 2458 2459 2460 2461
	if (err < 0)
		return err;

	if (tb[IFLA_IFNAME])
		nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
	else
		ifname[0] = '\0';

	ifm = nlmsg_data(nlh);
	if (ifm->ifi_index > 0)
2462
		dev = __dev_get_by_index(net, ifm->ifi_index);
2463 2464 2465 2466 2467 2468
	else {
		if (ifname[0])
			dev = __dev_get_by_name(net, ifname);
		else
			dev = NULL;
	}
P
Patrick McHardy 已提交
2469

2470 2471 2472 2473 2474 2475
	if (dev) {
		master_dev = netdev_master_upper_dev_get(dev);
		if (master_dev)
			m_ops = master_dev->rtnl_link_ops;
	}

E
Eric Dumazet 已提交
2476 2477
	err = validate_linkmsg(dev, tb);
	if (err < 0)
2478 2479
		return err;

P
Patrick McHardy 已提交
2480 2481
	if (tb[IFLA_LINKINFO]) {
		err = nla_parse_nested(linkinfo, IFLA_INFO_MAX,
2482 2483
				       tb[IFLA_LINKINFO], ifla_info_policy,
				       NULL);
P
Patrick McHardy 已提交
2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497
		if (err < 0)
			return err;
	} else
		memset(linkinfo, 0, sizeof(linkinfo));

	if (linkinfo[IFLA_INFO_KIND]) {
		nla_strlcpy(kind, linkinfo[IFLA_INFO_KIND], sizeof(kind));
		ops = rtnl_link_ops_get(kind);
	} else {
		kind[0] = '\0';
		ops = NULL;
	}

	if (1) {
S
Sasha Levin 已提交
2498 2499
		struct nlattr *attr[ops ? ops->maxtype + 1 : 1];
		struct nlattr *slave_attr[m_ops ? m_ops->slave_maxtype + 1 : 1];
2500 2501
		struct nlattr **data = NULL;
		struct nlattr **slave_data = NULL;
2502
		struct net *dest_net, *link_net = NULL;
P
Patrick McHardy 已提交
2503 2504 2505 2506 2507

		if (ops) {
			if (ops->maxtype && linkinfo[IFLA_INFO_DATA]) {
				err = nla_parse_nested(attr, ops->maxtype,
						       linkinfo[IFLA_INFO_DATA],
2508
						       ops->policy, NULL);
P
Patrick McHardy 已提交
2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519
				if (err < 0)
					return err;
				data = attr;
			}
			if (ops->validate) {
				err = ops->validate(tb, data);
				if (err < 0)
					return err;
			}
		}

2520 2521 2522 2523 2524 2525
		if (m_ops) {
			if (m_ops->slave_maxtype &&
			    linkinfo[IFLA_INFO_SLAVE_DATA]) {
				err = nla_parse_nested(slave_attr,
						       m_ops->slave_maxtype,
						       linkinfo[IFLA_INFO_SLAVE_DATA],
2526 2527
						       m_ops->slave_policy,
						       NULL);
2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538
				if (err < 0)
					return err;
				slave_data = slave_attr;
			}
			if (m_ops->slave_validate) {
				err = m_ops->slave_validate(tb, slave_data);
				if (err < 0)
					return err;
			}
		}

P
Patrick McHardy 已提交
2539
		if (dev) {
2540
			int status = 0;
P
Patrick McHardy 已提交
2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554

			if (nlh->nlmsg_flags & NLM_F_EXCL)
				return -EEXIST;
			if (nlh->nlmsg_flags & NLM_F_REPLACE)
				return -EOPNOTSUPP;

			if (linkinfo[IFLA_INFO_DATA]) {
				if (!ops || ops != dev->rtnl_link_ops ||
				    !ops->changelink)
					return -EOPNOTSUPP;

				err = ops->changelink(dev, tb, data);
				if (err < 0)
					return err;
2555
				status |= DO_SETLINK_NOTIFY;
P
Patrick McHardy 已提交
2556 2557
			}

2558 2559 2560 2561 2562 2563 2564 2565
			if (linkinfo[IFLA_INFO_SLAVE_DATA]) {
				if (!m_ops || !m_ops->slave_changelink)
					return -EOPNOTSUPP;

				err = m_ops->slave_changelink(master_dev, dev,
							      tb, slave_data);
				if (err < 0)
					return err;
2566
				status |= DO_SETLINK_NOTIFY;
2567 2568
			}

2569
			return do_setlink(skb, dev, ifm, tb, ifname, status);
P
Patrick McHardy 已提交
2570 2571
		}

2572 2573
		if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
			if (ifm->ifi_index == 0 && tb[IFLA_GROUP])
2574
				return rtnl_group_changelink(skb, net,
2575 2576
						nla_get_u32(tb[IFLA_GROUP]),
						ifm, tb);
P
Patrick McHardy 已提交
2577
			return -ENODEV;
2578
		}
P
Patrick McHardy 已提交
2579

2580
		if (tb[IFLA_MAP] || tb[IFLA_PROTINFO])
P
Patrick McHardy 已提交
2581 2582 2583
			return -EOPNOTSUPP;

		if (!ops) {
2584
#ifdef CONFIG_MODULES
P
Patrick McHardy 已提交
2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596
			if (kind[0]) {
				__rtnl_unlock();
				request_module("rtnl-link-%s", kind);
				rtnl_lock();
				ops = rtnl_link_ops_get(kind);
				if (ops)
					goto replay;
			}
#endif
			return -EOPNOTSUPP;
		}

2597 2598 2599
		if (!ops->setup)
			return -EOPNOTSUPP;

2600
		if (!ifname[0]) {
P
Patrick McHardy 已提交
2601
			snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind);
2602 2603
			name_assign_type = NET_NAME_ENUM;
		}
2604

2605
		dest_net = rtnl_link_get_net(net, tb);
2606 2607 2608
		if (IS_ERR(dest_net))
			return PTR_ERR(dest_net);

2609 2610 2611 2612
		err = -EPERM;
		if (!netlink_ns_capable(skb, dest_net->user_ns, CAP_NET_ADMIN))
			goto out;

2613 2614 2615 2616 2617 2618 2619 2620
		if (tb[IFLA_LINK_NETNSID]) {
			int id = nla_get_s32(tb[IFLA_LINK_NETNSID]);

			link_net = get_net_ns_by_id(dest_net, id);
			if (!link_net) {
				err =  -EINVAL;
				goto out;
			}
2621 2622 2623
			err = -EPERM;
			if (!netlink_ns_capable(skb, link_net->user_ns, CAP_NET_ADMIN))
				goto out;
2624 2625 2626 2627
		}

		dev = rtnl_create_link(link_net ? : dest_net, ifname,
				       name_assign_type, ops, tb);
2628
		if (IS_ERR(dev)) {
2629
			err = PTR_ERR(dev);
2630 2631 2632 2633 2634
			goto out;
		}

		dev->ifindex = ifm->ifi_index;

2635
		if (ops->newlink) {
2636
			err = ops->newlink(link_net ? : net, dev, tb, data);
2637
			/* Drivers should call free_netdev() in ->destructor
2638 2639
			 * and unregister it on failure after registration
			 * so that device could be finally freed in rtnl_unlock.
2640
			 */
2641 2642 2643 2644
			if (err < 0) {
				/* If device is not registered at all, free it now */
				if (dev->reg_state == NETREG_UNINITIALIZED)
					free_netdev(dev);
2645
				goto out;
2646
			}
2647
		} else {
2648
			err = register_netdevice(dev);
2649 2650 2651 2652
			if (err < 0) {
				free_netdev(dev);
				goto out;
			}
2653
		}
2654
		err = rtnl_configure_link(dev, ifm);
2655 2656
		if (err < 0)
			goto out_unregister;
2657
		if (link_net) {
2658
			err = dev_change_net_namespace(dev, dest_net, ifname);
2659
			if (err < 0)
2660
				goto out_unregister;
2661
		}
2662 2663 2664 2665 2666
		if (tb[IFLA_MASTER]) {
			err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]));
			if (err)
				goto out_unregister;
		}
2667
out:
2668 2669
		if (link_net)
			put_net(link_net);
2670
		put_net(dest_net);
P
Patrick McHardy 已提交
2671
		return err;
2672 2673 2674 2675 2676 2677 2678 2679 2680 2681
out_unregister:
		if (ops->newlink) {
			LIST_HEAD(list_kill);

			ops->dellink(dev, &list_kill);
			unregister_netdevice_many(&list_kill);
		} else {
			unregister_netdevice(dev);
		}
		goto out;
P
Patrick McHardy 已提交
2682 2683 2684
	}
}

2685 2686
static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr *nlh,
			struct netlink_ext_ack *extack)
2687
{
2688
	struct net *net = sock_net(skb->sk);
2689
	struct ifinfomsg *ifm;
2690
	char ifname[IFNAMSIZ];
2691 2692 2693
	struct nlattr *tb[IFLA_MAX+1];
	struct net_device *dev = NULL;
	struct sk_buff *nskb;
2694
	int err;
2695
	u32 ext_filter_mask = 0;
2696

2697
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy, extack);
2698
	if (err < 0)
2699
		return err;
2700

2701 2702 2703
	if (tb[IFLA_IFNAME])
		nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);

2704 2705 2706
	if (tb[IFLA_EXT_MASK])
		ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);

2707
	ifm = nlmsg_data(nlh);
2708 2709 2710 2711 2712
	if (ifm->ifi_index > 0)
		dev = __dev_get_by_index(net, ifm->ifi_index);
	else if (tb[IFLA_IFNAME])
		dev = __dev_get_by_name(net, ifname);
	else
2713 2714
		return -EINVAL;

2715 2716 2717
	if (dev == NULL)
		return -ENODEV;

2718
	nskb = nlmsg_new(if_nlmsg_size(dev, ext_filter_mask), GFP_KERNEL);
2719 2720
	if (nskb == NULL)
		return -ENOBUFS;
2721

2722
	err = rtnl_fill_ifinfo(nskb, dev, RTM_NEWLINK, NETLINK_CB(skb).portid,
2723
			       nlh->nlmsg_seq, 0, 0, ext_filter_mask);
2724 2725 2726 2727
	if (err < 0) {
		/* -EMSGSIZE implies BUG in if_nlmsg_size */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(nskb);
2728
	} else
2729
		err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid);
2730

2731
	return err;
2732 2733
}

2734
static u16 rtnl_calcit(struct sk_buff *skb, struct nlmsghdr *nlh)
2735
{
2736 2737 2738 2739 2740
	struct net *net = sock_net(skb->sk);
	struct net_device *dev;
	struct nlattr *tb[IFLA_MAX+1];
	u32 ext_filter_mask = 0;
	u16 min_ifinfo_dump_size = 0;
2741 2742 2743 2744 2745
	int hdrlen;

	/* Same kernel<->userspace interface hack as in rtnl_dump_ifinfo. */
	hdrlen = nlmsg_len(nlh) < sizeof(struct ifinfomsg) ?
		 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg);
2746

2747
	if (nlmsg_parse(nlh, hdrlen, tb, IFLA_MAX, ifla_policy, NULL) >= 0) {
2748 2749 2750
		if (tb[IFLA_EXT_MASK])
			ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
	}
2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763

	if (!ext_filter_mask)
		return NLMSG_GOODSIZE;
	/*
	 * traverse the list of net devices and compute the minimum
	 * buffer size based upon the filter mask.
	 */
	list_for_each_entry(dev, &net->dev_base_head, dev_list) {
		min_ifinfo_dump_size = max_t(u16, min_ifinfo_dump_size,
					     if_nlmsg_size(dev,
						           ext_filter_mask));
	}

2764
	return nlmsg_total_size(min_ifinfo_dump_size);
2765 2766
}

A
Adrian Bunk 已提交
2767
static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb)
L
Linus Torvalds 已提交
2768 2769 2770 2771 2772 2773
{
	int idx;
	int s_idx = cb->family;

	if (s_idx == 0)
		s_idx = 1;
2774
	for (idx = 1; idx <= RTNL_FAMILY_MAX; idx++) {
L
Linus Torvalds 已提交
2775 2776 2777
		int type = cb->nlh->nlmsg_type-RTM_BASE;
		if (idx < s_idx || idx == PF_PACKET)
			continue;
2778 2779
		if (rtnl_msg_handlers[idx] == NULL ||
		    rtnl_msg_handlers[idx][type].dumpit == NULL)
L
Linus Torvalds 已提交
2780
			continue;
2781
		if (idx > s_idx) {
L
Linus Torvalds 已提交
2782
			memset(&cb->args[0], 0, sizeof(cb->args));
2783 2784 2785
			cb->prev_seq = 0;
			cb->seq = 0;
		}
2786
		if (rtnl_msg_handlers[idx][type].dumpit(skb, cb))
L
Linus Torvalds 已提交
2787 2788 2789 2790 2791 2792 2793
			break;
	}
	cb->family = idx;

	return skb->len;
}

2794
struct sk_buff *rtmsg_ifinfo_build_skb(int type, struct net_device *dev,
2795
				       unsigned int change, gfp_t flags)
L
Linus Torvalds 已提交
2796
{
2797
	struct net *net = dev_net(dev);
L
Linus Torvalds 已提交
2798
	struct sk_buff *skb;
2799
	int err = -ENOBUFS;
2800
	size_t if_info_size;
L
Linus Torvalds 已提交
2801

2802
	skb = nlmsg_new((if_info_size = if_nlmsg_size(dev, 0)), flags);
2803 2804
	if (skb == NULL)
		goto errout;
L
Linus Torvalds 已提交
2805

2806
	err = rtnl_fill_ifinfo(skb, dev, type, 0, 0, change, 0, 0);
2807 2808 2809 2810 2811 2812
	if (err < 0) {
		/* -EMSGSIZE implies BUG in if_nlmsg_size() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
2813
	return skb;
2814 2815
errout:
	if (err < 0)
2816
		rtnl_set_sk_err(net, RTNLGRP_LINK, err);
2817 2818 2819 2820 2821 2822 2823 2824 2825 2826
	return NULL;
}

void rtmsg_ifinfo_send(struct sk_buff *skb, struct net_device *dev, gfp_t flags)
{
	struct net *net = dev_net(dev);

	rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, flags);
}

2827 2828
void rtmsg_ifinfo(int type, struct net_device *dev, unsigned int change,
		  gfp_t flags)
2829 2830 2831
{
	struct sk_buff *skb;

2832 2833 2834
	if (dev->reg_state != NETREG_REGISTERED)
		return;

2835
	skb = rtmsg_ifinfo_build_skb(type, dev, change, flags);
2836 2837
	if (skb)
		rtmsg_ifinfo_send(skb, dev, flags);
L
Linus Torvalds 已提交
2838
}
2839
EXPORT_SYMBOL(rtmsg_ifinfo);
L
Linus Torvalds 已提交
2840

2841 2842
static int nlmsg_populate_fdb_fill(struct sk_buff *skb,
				   struct net_device *dev,
2843
				   u8 *addr, u16 vid, u32 pid, u32 seq,
2844
				   int type, unsigned int flags,
2845
				   int nlflags, u16 ndm_state)
2846 2847 2848 2849
{
	struct nlmsghdr *nlh;
	struct ndmsg *ndm;

2850
	nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), nlflags);
2851 2852 2853 2854 2855 2856 2857 2858 2859 2860
	if (!nlh)
		return -EMSGSIZE;

	ndm = nlmsg_data(nlh);
	ndm->ndm_family  = AF_BRIDGE;
	ndm->ndm_pad1	 = 0;
	ndm->ndm_pad2    = 0;
	ndm->ndm_flags	 = flags;
	ndm->ndm_type	 = 0;
	ndm->ndm_ifindex = dev->ifindex;
2861
	ndm->ndm_state   = ndm_state;
2862 2863 2864

	if (nla_put(skb, NDA_LLADDR, ETH_ALEN, addr))
		goto nla_put_failure;
2865 2866 2867
	if (vid)
		if (nla_put(skb, NDA_VLAN, sizeof(u16), &vid))
			goto nla_put_failure;
2868

2869 2870
	nlmsg_end(skb, nlh);
	return 0;
2871 2872 2873 2874 2875 2876

nla_put_failure:
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
}

2877 2878
static inline size_t rtnl_fdb_nlmsg_size(void)
{
2879 2880 2881 2882
	return NLMSG_ALIGN(sizeof(struct ndmsg)) +
	       nla_total_size(ETH_ALEN) +	/* NDA_LLADDR */
	       nla_total_size(sizeof(u16)) +	/* NDA_VLAN */
	       0;
2883 2884
}

2885 2886
static void rtnl_fdb_notify(struct net_device *dev, u8 *addr, u16 vid, int type,
			    u16 ndm_state)
2887 2888 2889 2890 2891 2892 2893 2894 2895
{
	struct net *net = dev_net(dev);
	struct sk_buff *skb;
	int err = -ENOBUFS;

	skb = nlmsg_new(rtnl_fdb_nlmsg_size(), GFP_ATOMIC);
	if (!skb)
		goto errout;

2896
	err = nlmsg_populate_fdb_fill(skb, dev, addr, vid,
2897
				      0, 0, type, NTF_SELF, 0, ndm_state);
2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908
	if (err < 0) {
		kfree_skb(skb);
		goto errout;
	}

	rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
	return;
errout:
	rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
}

2909 2910 2911 2912 2913 2914
/**
 * ndo_dflt_fdb_add - default netdevice operation to add an FDB entry
 */
int ndo_dflt_fdb_add(struct ndmsg *ndm,
		     struct nlattr *tb[],
		     struct net_device *dev,
2915
		     const unsigned char *addr, u16 vid,
2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927
		     u16 flags)
{
	int err = -EINVAL;

	/* If aging addresses are supported device will need to
	 * implement its own handler for this.
	 */
	if (ndm->ndm_state && !(ndm->ndm_state & NUD_PERMANENT)) {
		pr_info("%s: FDB only supports static addresses\n", dev->name);
		return err;
	}

2928 2929 2930 2931 2932
	if (vid) {
		pr_info("%s: vlans aren't supported yet for dev_uc|mc_add()\n", dev->name);
		return err;
	}

2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945
	if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr))
		err = dev_uc_add_excl(dev, addr);
	else if (is_multicast_ether_addr(addr))
		err = dev_mc_add_excl(dev, addr);

	/* Only return duplicate errors if NLM_F_EXCL is set */
	if (err == -EEXIST && !(flags & NLM_F_EXCL))
		err = 0;

	return err;
}
EXPORT_SYMBOL(ndo_dflt_fdb_add);

2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967
static int fdb_vid_parse(struct nlattr *vlan_attr, u16 *p_vid)
{
	u16 vid = 0;

	if (vlan_attr) {
		if (nla_len(vlan_attr) != sizeof(u16)) {
			pr_info("PF_BRIDGE: RTM_NEWNEIGH with invalid vlan\n");
			return -EINVAL;
		}

		vid = nla_get_u16(vlan_attr);

		if (!vid || vid >= VLAN_VID_MASK) {
			pr_info("PF_BRIDGE: RTM_NEWNEIGH with invalid vlan id %d\n",
				vid);
			return -EINVAL;
		}
	}
	*p_vid = vid;
	return 0;
}

2968 2969
static int rtnl_fdb_add(struct sk_buff *skb, struct nlmsghdr *nlh,
			struct netlink_ext_ack *extack)
2970 2971 2972 2973 2974 2975
{
	struct net *net = sock_net(skb->sk);
	struct ndmsg *ndm;
	struct nlattr *tb[NDA_MAX+1];
	struct net_device *dev;
	u8 *addr;
2976
	u16 vid;
2977 2978
	int err;

2979
	err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL, extack);
2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001
	if (err < 0)
		return err;

	ndm = nlmsg_data(nlh);
	if (ndm->ndm_ifindex == 0) {
		pr_info("PF_BRIDGE: RTM_NEWNEIGH with invalid ifindex\n");
		return -EINVAL;
	}

	dev = __dev_get_by_index(net, ndm->ndm_ifindex);
	if (dev == NULL) {
		pr_info("PF_BRIDGE: RTM_NEWNEIGH with unknown ifindex\n");
		return -ENODEV;
	}

	if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
		pr_info("PF_BRIDGE: RTM_NEWNEIGH with invalid address\n");
		return -EINVAL;
	}

	addr = nla_data(tb[NDA_LLADDR]);

3002 3003 3004 3005
	err = fdb_vid_parse(tb[NDA_VLAN], &vid);
	if (err)
		return err;

3006 3007 3008 3009 3010
	err = -EOPNOTSUPP;

	/* Support fdb on master device the net/bridge default case */
	if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) &&
	    (dev->priv_flags & IFF_BRIDGE_PORT)) {
3011 3012 3013
		struct net_device *br_dev = netdev_master_upper_dev_get(dev);
		const struct net_device_ops *ops = br_dev->netdev_ops;

3014 3015
		err = ops->ndo_fdb_add(ndm, tb, dev, addr, vid,
				       nlh->nlmsg_flags);
3016 3017 3018 3019 3020 3021 3022
		if (err)
			goto out;
		else
			ndm->ndm_flags &= ~NTF_MASTER;
	}

	/* Embedded bridge, macvlan, and any other device support */
3023 3024 3025
	if ((ndm->ndm_flags & NTF_SELF)) {
		if (dev->netdev_ops->ndo_fdb_add)
			err = dev->netdev_ops->ndo_fdb_add(ndm, tb, dev, addr,
3026
							   vid,
3027 3028
							   nlh->nlmsg_flags);
		else
3029
			err = ndo_dflt_fdb_add(ndm, tb, dev, addr, vid,
3030
					       nlh->nlmsg_flags);
3031

3032
		if (!err) {
3033 3034
			rtnl_fdb_notify(dev, addr, vid, RTM_NEWNEIGH,
					ndm->ndm_state);
3035
			ndm->ndm_flags &= ~NTF_SELF;
3036
		}
3037 3038 3039 3040 3041
	}
out:
	return err;
}

3042 3043 3044 3045 3046 3047
/**
 * ndo_dflt_fdb_del - default netdevice operation to delete an FDB entry
 */
int ndo_dflt_fdb_del(struct ndmsg *ndm,
		     struct nlattr *tb[],
		     struct net_device *dev,
3048
		     const unsigned char *addr, u16 vid)
3049
{
3050
	int err = -EINVAL;
3051 3052 3053 3054

	/* If aging addresses are supported device will need to
	 * implement its own handler for this.
	 */
3055
	if (!(ndm->ndm_state & NUD_PERMANENT)) {
3056
		pr_info("%s: FDB only supports static addresses\n", dev->name);
3057
		return err;
3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068
	}

	if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr))
		err = dev_uc_del(dev, addr);
	else if (is_multicast_ether_addr(addr))
		err = dev_mc_del(dev, addr);

	return err;
}
EXPORT_SYMBOL(ndo_dflt_fdb_del);

3069 3070
static int rtnl_fdb_del(struct sk_buff *skb, struct nlmsghdr *nlh,
			struct netlink_ext_ack *extack)
3071 3072 3073
{
	struct net *net = sock_net(skb->sk);
	struct ndmsg *ndm;
3074
	struct nlattr *tb[NDA_MAX+1];
3075 3076 3077
	struct net_device *dev;
	int err = -EINVAL;
	__u8 *addr;
3078
	u16 vid;
3079

3080
	if (!netlink_capable(skb, CAP_NET_ADMIN))
3081 3082
		return -EPERM;

3083
	err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL, extack);
3084 3085
	if (err < 0)
		return err;
3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098

	ndm = nlmsg_data(nlh);
	if (ndm->ndm_ifindex == 0) {
		pr_info("PF_BRIDGE: RTM_DELNEIGH with invalid ifindex\n");
		return -EINVAL;
	}

	dev = __dev_get_by_index(net, ndm->ndm_ifindex);
	if (dev == NULL) {
		pr_info("PF_BRIDGE: RTM_DELNEIGH with unknown ifindex\n");
		return -ENODEV;
	}

3099 3100 3101 3102 3103 3104
	if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
		pr_info("PF_BRIDGE: RTM_DELNEIGH with invalid address\n");
		return -EINVAL;
	}

	addr = nla_data(tb[NDA_LLADDR]);
3105

3106 3107 3108 3109
	err = fdb_vid_parse(tb[NDA_VLAN], &vid);
	if (err)
		return err;

3110 3111 3112 3113 3114
	err = -EOPNOTSUPP;

	/* Support fdb on master device the net/bridge default case */
	if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) &&
	    (dev->priv_flags & IFF_BRIDGE_PORT)) {
3115 3116
		struct net_device *br_dev = netdev_master_upper_dev_get(dev);
		const struct net_device_ops *ops = br_dev->netdev_ops;
3117

3118
		if (ops->ndo_fdb_del)
3119
			err = ops->ndo_fdb_del(ndm, tb, dev, addr, vid);
3120 3121 3122 3123 3124 3125 3126 3127

		if (err)
			goto out;
		else
			ndm->ndm_flags &= ~NTF_MASTER;
	}

	/* Embedded bridge, macvlan, and any other device support */
3128 3129
	if (ndm->ndm_flags & NTF_SELF) {
		if (dev->netdev_ops->ndo_fdb_del)
3130 3131
			err = dev->netdev_ops->ndo_fdb_del(ndm, tb, dev, addr,
							   vid);
3132
		else
3133
			err = ndo_dflt_fdb_del(ndm, tb, dev, addr, vid);
3134

3135
		if (!err) {
3136 3137
			rtnl_fdb_notify(dev, addr, vid, RTM_DELNEIGH,
					ndm->ndm_state);
3138
			ndm->ndm_flags &= ~NTF_SELF;
3139
		}
3140 3141 3142 3143 3144
	}
out:
	return err;
}

3145 3146 3147 3148 3149 3150 3151 3152
static int nlmsg_populate_fdb(struct sk_buff *skb,
			      struct netlink_callback *cb,
			      struct net_device *dev,
			      int *idx,
			      struct netdev_hw_addr_list *list)
{
	struct netdev_hw_addr *ha;
	int err;
3153
	u32 portid, seq;
3154

3155
	portid = NETLINK_CB(cb->skb).portid;
3156 3157 3158
	seq = cb->nlh->nlmsg_seq;

	list_for_each_entry(ha, &list->list, list) {
3159
		if (*idx < cb->args[2])
3160 3161
			goto skip;

3162
		err = nlmsg_populate_fdb_fill(skb, dev, ha->addr, 0,
3163
					      portid, seq,
3164
					      RTM_NEWNEIGH, NTF_SELF,
3165
					      NLM_F_MULTI, NUD_PERMANENT);
3166 3167 3168 3169 3170 3171 3172 3173 3174
		if (err < 0)
			return err;
skip:
		*idx += 1;
	}
	return 0;
}

/**
3175
 * ndo_dflt_fdb_dump - default netdevice operation to dump an FDB table.
3176 3177 3178 3179
 * @nlh: netlink message header
 * @dev: netdevice
 *
 * Default netdevice operation to dump the existing unicast address list.
3180
 * Returns number of addresses from list put in skb.
3181 3182 3183 3184
 */
int ndo_dflt_fdb_dump(struct sk_buff *skb,
		      struct netlink_callback *cb,
		      struct net_device *dev,
3185
		      struct net_device *filter_dev,
3186
		      int *idx)
3187 3188 3189 3190
{
	int err;

	netif_addr_lock_bh(dev);
3191
	err = nlmsg_populate_fdb(skb, cb, dev, idx, &dev->uc);
3192 3193
	if (err)
		goto out;
3194
	err = nlmsg_populate_fdb(skb, cb, dev, idx, &dev->mc);
3195 3196
out:
	netif_addr_unlock_bh(dev);
3197
	return err;
3198 3199 3200
}
EXPORT_SYMBOL(ndo_dflt_fdb_dump);

3201 3202 3203
static int rtnl_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb)
{
	struct net_device *dev;
3204 3205 3206 3207 3208 3209
	struct nlattr *tb[IFLA_MAX+1];
	struct net_device *br_dev = NULL;
	const struct net_device_ops *ops = NULL;
	const struct net_device_ops *cops = NULL;
	struct ifinfomsg *ifm = nlmsg_data(cb->nlh);
	struct net *net = sock_net(skb->sk);
3210
	struct hlist_head *head;
3211 3212
	int brport_idx = 0;
	int br_idx = 0;
3213 3214 3215 3216
	int h, s_h;
	int idx = 0, s_idx;
	int err = 0;
	int fidx = 0;
3217

3218 3219
	if (nlmsg_parse(cb->nlh, sizeof(struct ifinfomsg), tb,
			IFLA_MAX, ifla_policy, NULL) == 0) {
3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233
		if (tb[IFLA_MASTER])
			br_idx = nla_get_u32(tb[IFLA_MASTER]);
	}

	brport_idx = ifm->ifi_index;

	if (br_idx) {
		br_dev = __dev_get_by_index(net, br_idx);
		if (!br_dev)
			return -ENODEV;

		ops = br_dev->netdev_ops;
	}

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

3237 3238 3239 3240
	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
		idx = 0;
		head = &net->dev_index_head[h];
		hlist_for_each_entry(dev, head, index_hlist) {
3241

3242
			if (brport_idx && (dev->ifindex != brport_idx))
3243 3244
				continue;

3245 3246 3247 3248 3249 3250 3251 3252 3253
			if (!br_idx) { /* user did not specify a specific bridge */
				if (dev->priv_flags & IFF_BRIDGE_PORT) {
					br_dev = netdev_master_upper_dev_get(dev);
					cops = br_dev->netdev_ops;
				}
			} else {
				if (dev != br_dev &&
				    !(dev->priv_flags & IFF_BRIDGE_PORT))
					continue;
3254

3255 3256 3257 3258 3259
				if (br_dev != netdev_master_upper_dev_get(dev) &&
				    !(dev->priv_flags & IFF_EBRIDGE))
					continue;
				cops = ops;
			}
3260

3261 3262
			if (idx < s_idx)
				goto cont;
3263

3264 3265 3266 3267 3268 3269 3270 3271 3272
			if (dev->priv_flags & IFF_BRIDGE_PORT) {
				if (cops && cops->ndo_fdb_dump) {
					err = cops->ndo_fdb_dump(skb, cb,
								br_dev, dev,
								&fidx);
					if (err == -EMSGSIZE)
						goto out;
				}
			}
3273

3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291
			if (dev->netdev_ops->ndo_fdb_dump)
				err = dev->netdev_ops->ndo_fdb_dump(skb, cb,
								    dev, NULL,
								    &fidx);
			else
				err = ndo_dflt_fdb_dump(skb, cb, dev, NULL,
							&fidx);
			if (err == -EMSGSIZE)
				goto out;

			cops = NULL;

			/* reset fdb offset to 0 for rest of the interfaces */
			cb->args[2] = 0;
			fidx = 0;
cont:
			idx++;
		}
3292 3293
	}

3294 3295 3296 3297 3298
out:
	cb->args[0] = h;
	cb->args[1] = idx;
	cb->args[2] = fidx;

3299 3300 3301
	return skb->len;
}

3302 3303 3304 3305 3306 3307 3308 3309
static int brport_nla_put_flag(struct sk_buff *skb, u32 flags, u32 mask,
			       unsigned int attrnum, unsigned int flag)
{
	if (mask & flag)
		return nla_put_u8(skb, attrnum, !!(flags & flag));
	return 0;
}

3310
int ndo_dflt_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
3311
			    struct net_device *dev, u16 mode,
3312 3313 3314 3315 3316
			    u32 flags, u32 mask, int nlflags,
			    u32 filter_mask,
			    int (*vlan_fill)(struct sk_buff *skb,
					     struct net_device *dev,
					     u32 filter_mask))
3317 3318 3319 3320
{
	struct nlmsghdr *nlh;
	struct ifinfomsg *ifm;
	struct nlattr *br_afspec;
3321
	struct nlattr *protinfo;
3322
	u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN;
3323
	struct net_device *br_dev = netdev_master_upper_dev_get(dev);
3324
	int err = 0;
3325

3326
	nlh = nlmsg_put(skb, pid, seq, RTM_NEWLINK, sizeof(*ifm), nlflags);
3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341
	if (nlh == NULL)
		return -EMSGSIZE;

	ifm = nlmsg_data(nlh);
	ifm->ifi_family = AF_BRIDGE;
	ifm->__ifi_pad = 0;
	ifm->ifi_type = dev->type;
	ifm->ifi_index = dev->ifindex;
	ifm->ifi_flags = dev_get_flags(dev);
	ifm->ifi_change = 0;


	if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
	    nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
	    nla_put_u8(skb, IFLA_OPERSTATE, operstate) ||
3342 3343
	    (br_dev &&
	     nla_put_u32(skb, IFLA_MASTER, br_dev->ifindex)) ||
3344 3345
	    (dev->addr_len &&
	     nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
3346 3347
	    (dev->ifindex != dev_get_iflink(dev) &&
	     nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))))
3348 3349 3350 3351 3352 3353
		goto nla_put_failure;

	br_afspec = nla_nest_start(skb, IFLA_AF_SPEC);
	if (!br_afspec)
		goto nla_put_failure;

R
Roopa Prabhu 已提交
3354
	if (nla_put_u16(skb, IFLA_BRIDGE_FLAGS, BRIDGE_FLAGS_SELF)) {
3355 3356 3357
		nla_nest_cancel(skb, br_afspec);
		goto nla_put_failure;
	}
R
Roopa Prabhu 已提交
3358 3359 3360 3361 3362 3363 3364

	if (mode != BRIDGE_MODE_UNDEF) {
		if (nla_put_u16(skb, IFLA_BRIDGE_MODE, mode)) {
			nla_nest_cancel(skb, br_afspec);
			goto nla_put_failure;
		}
	}
3365 3366 3367 3368 3369 3370 3371
	if (vlan_fill) {
		err = vlan_fill(skb, dev, filter_mask);
		if (err) {
			nla_nest_cancel(skb, br_afspec);
			goto nla_put_failure;
		}
	}
3372 3373
	nla_nest_end(skb, br_afspec);

3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400
	protinfo = nla_nest_start(skb, IFLA_PROTINFO | NLA_F_NESTED);
	if (!protinfo)
		goto nla_put_failure;

	if (brport_nla_put_flag(skb, flags, mask,
				IFLA_BRPORT_MODE, BR_HAIRPIN_MODE) ||
	    brport_nla_put_flag(skb, flags, mask,
				IFLA_BRPORT_GUARD, BR_BPDU_GUARD) ||
	    brport_nla_put_flag(skb, flags, mask,
				IFLA_BRPORT_FAST_LEAVE,
				BR_MULTICAST_FAST_LEAVE) ||
	    brport_nla_put_flag(skb, flags, mask,
				IFLA_BRPORT_PROTECT, BR_ROOT_BLOCK) ||
	    brport_nla_put_flag(skb, flags, mask,
				IFLA_BRPORT_LEARNING, BR_LEARNING) ||
	    brport_nla_put_flag(skb, flags, mask,
				IFLA_BRPORT_LEARNING_SYNC, BR_LEARNING_SYNC) ||
	    brport_nla_put_flag(skb, flags, mask,
				IFLA_BRPORT_UNICAST_FLOOD, BR_FLOOD) ||
	    brport_nla_put_flag(skb, flags, mask,
				IFLA_BRPORT_PROXYARP, BR_PROXYARP)) {
		nla_nest_cancel(skb, protinfo);
		goto nla_put_failure;
	}

	nla_nest_end(skb, protinfo);

3401 3402
	nlmsg_end(skb, nlh);
	return 0;
3403 3404
nla_put_failure:
	nlmsg_cancel(skb, nlh);
3405
	return err ? err : -EMSGSIZE;
3406
}
3407
EXPORT_SYMBOL_GPL(ndo_dflt_bridge_getlink);
3408

J
John Fastabend 已提交
3409 3410 3411 3412 3413 3414 3415
static int rtnl_bridge_getlink(struct sk_buff *skb, struct netlink_callback *cb)
{
	struct net *net = sock_net(skb->sk);
	struct net_device *dev;
	int idx = 0;
	u32 portid = NETLINK_CB(cb->skb).portid;
	u32 seq = cb->nlh->nlmsg_seq;
3416
	u32 filter_mask = 0;
3417
	int err;
3418

3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430
	if (nlmsg_len(cb->nlh) > sizeof(struct ifinfomsg)) {
		struct nlattr *extfilt;

		extfilt = nlmsg_find_attr(cb->nlh, sizeof(struct ifinfomsg),
					  IFLA_EXT_MASK);
		if (extfilt) {
			if (nla_len(extfilt) < sizeof(filter_mask))
				return -EINVAL;

			filter_mask = nla_get_u32(extfilt);
		}
	}
J
John Fastabend 已提交
3431 3432 3433 3434

	rcu_read_lock();
	for_each_netdev_rcu(net, dev) {
		const struct net_device_ops *ops = dev->netdev_ops;
3435
		struct net_device *br_dev = netdev_master_upper_dev_get(dev);
J
John Fastabend 已提交
3436

3437
		if (br_dev && br_dev->netdev_ops->ndo_bridge_getlink) {
3438 3439 3440 3441 3442 3443 3444
			if (idx >= cb->args[0]) {
				err = br_dev->netdev_ops->ndo_bridge_getlink(
						skb, portid, seq, dev,
						filter_mask, NLM_F_MULTI);
				if (err < 0 && err != -EOPNOTSUPP)
					break;
			}
3445
			idx++;
J
John Fastabend 已提交
3446 3447 3448
		}

		if (ops->ndo_bridge_getlink) {
3449 3450 3451 3452 3453 3454 3455 3456
			if (idx >= cb->args[0]) {
				err = ops->ndo_bridge_getlink(skb, portid,
							      seq, dev,
							      filter_mask,
							      NLM_F_MULTI);
				if (err < 0 && err != -EOPNOTSUPP)
					break;
			}
3457
			idx++;
J
John Fastabend 已提交
3458 3459 3460 3461 3462 3463 3464 3465
		}
	}
	rcu_read_unlock();
	cb->args[0] = idx;

	return skb->len;
}

3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480
static inline size_t bridge_nlmsg_size(void)
{
	return NLMSG_ALIGN(sizeof(struct ifinfomsg))
		+ nla_total_size(IFNAMSIZ)	/* IFLA_IFNAME */
		+ nla_total_size(MAX_ADDR_LEN)	/* IFLA_ADDRESS */
		+ nla_total_size(sizeof(u32))	/* IFLA_MASTER */
		+ nla_total_size(sizeof(u32))	/* IFLA_MTU */
		+ nla_total_size(sizeof(u32))	/* IFLA_LINK */
		+ nla_total_size(sizeof(u32))	/* IFLA_OPERSTATE */
		+ nla_total_size(sizeof(u8))	/* IFLA_PROTINFO */
		+ nla_total_size(sizeof(struct nlattr))	/* IFLA_AF_SPEC */
		+ nla_total_size(sizeof(u16))	/* IFLA_BRIDGE_FLAGS */
		+ nla_total_size(sizeof(u16));	/* IFLA_BRIDGE_MODE */
}

3481
static int rtnl_bridge_notify(struct net_device *dev)
3482 3483 3484 3485 3486
{
	struct net *net = dev_net(dev);
	struct sk_buff *skb;
	int err = -EOPNOTSUPP;

3487 3488 3489
	if (!dev->netdev_ops->ndo_bridge_getlink)
		return 0;

3490 3491 3492 3493 3494 3495
	skb = nlmsg_new(bridge_nlmsg_size(), GFP_ATOMIC);
	if (!skb) {
		err = -ENOMEM;
		goto errout;
	}

3496
	err = dev->netdev_ops->ndo_bridge_getlink(skb, 0, 0, dev, 0, 0);
3497 3498
	if (err < 0)
		goto errout;
3499

3500 3501 3502
	if (!skb->len)
		goto errout;

3503 3504 3505 3506 3507
	rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
	return 0;
errout:
	WARN_ON(err == -EMSGSIZE);
	kfree_skb(skb);
3508 3509
	if (err)
		rtnl_set_sk_err(net, RTNLGRP_LINK, err);
3510 3511 3512
	return err;
}

3513 3514
static int rtnl_bridge_setlink(struct sk_buff *skb, struct nlmsghdr *nlh,
			       struct netlink_ext_ack *extack)
J
John Fastabend 已提交
3515 3516 3517 3518
{
	struct net *net = sock_net(skb->sk);
	struct ifinfomsg *ifm;
	struct net_device *dev;
3519 3520
	struct nlattr *br_spec, *attr = NULL;
	int rem, err = -EOPNOTSUPP;
3521
	u16 flags = 0;
3522
	bool have_flags = false;
J
John Fastabend 已提交
3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536

	if (nlmsg_len(nlh) < sizeof(*ifm))
		return -EINVAL;

	ifm = nlmsg_data(nlh);
	if (ifm->ifi_family != AF_BRIDGE)
		return -EPFNOSUPPORT;

	dev = __dev_get_by_index(net, ifm->ifi_index);
	if (!dev) {
		pr_info("PF_BRIDGE: RTM_SETLINK with unknown ifindex\n");
		return -ENODEV;
	}

3537 3538 3539 3540
	br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
	if (br_spec) {
		nla_for_each_nested(attr, br_spec, rem) {
			if (nla_type(attr) == IFLA_BRIDGE_FLAGS) {
3541 3542 3543
				if (nla_len(attr) < sizeof(flags))
					return -EINVAL;

3544
				have_flags = true;
3545 3546 3547 3548 3549 3550 3551
				flags = nla_get_u16(attr);
				break;
			}
		}
	}

	if (!flags || (flags & BRIDGE_FLAGS_MASTER)) {
3552 3553 3554
		struct net_device *br_dev = netdev_master_upper_dev_get(dev);

		if (!br_dev || !br_dev->netdev_ops->ndo_bridge_setlink) {
3555 3556 3557 3558
			err = -EOPNOTSUPP;
			goto out;
		}

3559
		err = br_dev->netdev_ops->ndo_bridge_setlink(dev, nlh, flags);
J
John Fastabend 已提交
3560 3561
		if (err)
			goto out;
3562 3563

		flags &= ~BRIDGE_FLAGS_MASTER;
J
John Fastabend 已提交
3564 3565
	}

3566 3567 3568 3569
	if ((flags & BRIDGE_FLAGS_SELF)) {
		if (!dev->netdev_ops->ndo_bridge_setlink)
			err = -EOPNOTSUPP;
		else
3570 3571
			err = dev->netdev_ops->ndo_bridge_setlink(dev, nlh,
								  flags);
3572
		if (!err) {
3573
			flags &= ~BRIDGE_FLAGS_SELF;
3574 3575 3576 3577 3578 3579

			/* Generate event to notify upper layer of bridge
			 * change
			 */
			err = rtnl_bridge_notify(dev);
		}
3580
	}
J
John Fastabend 已提交
3581

3582
	if (have_flags)
3583
		memcpy(nla_data(attr), &flags, sizeof(flags));
J
John Fastabend 已提交
3584 3585 3586 3587
out:
	return err;
}

3588 3589
static int rtnl_bridge_dellink(struct sk_buff *skb, struct nlmsghdr *nlh,
			       struct netlink_ext_ack *extack)
3590 3591 3592 3593 3594 3595
{
	struct net *net = sock_net(skb->sk);
	struct ifinfomsg *ifm;
	struct net_device *dev;
	struct nlattr *br_spec, *attr = NULL;
	int rem, err = -EOPNOTSUPP;
3596
	u16 flags = 0;
3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615
	bool have_flags = false;

	if (nlmsg_len(nlh) < sizeof(*ifm))
		return -EINVAL;

	ifm = nlmsg_data(nlh);
	if (ifm->ifi_family != AF_BRIDGE)
		return -EPFNOSUPPORT;

	dev = __dev_get_by_index(net, ifm->ifi_index);
	if (!dev) {
		pr_info("PF_BRIDGE: RTM_SETLINK with unknown ifindex\n");
		return -ENODEV;
	}

	br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
	if (br_spec) {
		nla_for_each_nested(attr, br_spec, rem) {
			if (nla_type(attr) == IFLA_BRIDGE_FLAGS) {
3616 3617 3618
				if (nla_len(attr) < sizeof(flags))
					return -EINVAL;

3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633
				have_flags = true;
				flags = nla_get_u16(attr);
				break;
			}
		}
	}

	if (!flags || (flags & BRIDGE_FLAGS_MASTER)) {
		struct net_device *br_dev = netdev_master_upper_dev_get(dev);

		if (!br_dev || !br_dev->netdev_ops->ndo_bridge_dellink) {
			err = -EOPNOTSUPP;
			goto out;
		}

3634
		err = br_dev->netdev_ops->ndo_bridge_dellink(dev, nlh, flags);
3635 3636 3637 3638 3639 3640 3641 3642 3643 3644
		if (err)
			goto out;

		flags &= ~BRIDGE_FLAGS_MASTER;
	}

	if ((flags & BRIDGE_FLAGS_SELF)) {
		if (!dev->netdev_ops->ndo_bridge_dellink)
			err = -EOPNOTSUPP;
		else
3645 3646
			err = dev->netdev_ops->ndo_bridge_dellink(dev, nlh,
								  flags);
3647

3648
		if (!err) {
3649
			flags &= ~BRIDGE_FLAGS_SELF;
3650 3651 3652 3653 3654 3655

			/* Generate event to notify upper layer of bridge
			 * change
			 */
			err = rtnl_bridge_notify(dev);
		}
3656 3657 3658 3659 3660 3661 3662 3663
	}

	if (have_flags)
		memcpy(nla_data(attr), &flags, sizeof(flags));
out:
	return err;
}

3664 3665 3666 3667 3668 3669
static bool stats_attr_valid(unsigned int mask, int attrid, int idxattr)
{
	return (mask & IFLA_STATS_FILTER_BIT(attrid)) &&
	       (!idxattr || idxattr == attrid);
}

3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701
#define IFLA_OFFLOAD_XSTATS_FIRST (IFLA_OFFLOAD_XSTATS_UNSPEC + 1)
static int rtnl_get_offload_stats_attr_size(int attr_id)
{
	switch (attr_id) {
	case IFLA_OFFLOAD_XSTATS_CPU_HIT:
		return sizeof(struct rtnl_link_stats64);
	}

	return 0;
}

static int rtnl_get_offload_stats(struct sk_buff *skb, struct net_device *dev,
				  int *prividx)
{
	struct nlattr *attr = NULL;
	int attr_id, size;
	void *attr_data;
	int err;

	if (!(dev->netdev_ops && dev->netdev_ops->ndo_has_offload_stats &&
	      dev->netdev_ops->ndo_get_offload_stats))
		return -ENODATA;

	for (attr_id = IFLA_OFFLOAD_XSTATS_FIRST;
	     attr_id <= IFLA_OFFLOAD_XSTATS_MAX; attr_id++) {
		if (attr_id < *prividx)
			continue;

		size = rtnl_get_offload_stats_attr_size(attr_id);
		if (!size)
			continue;

3702
		if (!dev->netdev_ops->ndo_has_offload_stats(dev, attr_id))
3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742
			continue;

		attr = nla_reserve_64bit(skb, attr_id, size,
					 IFLA_OFFLOAD_XSTATS_UNSPEC);
		if (!attr)
			goto nla_put_failure;

		attr_data = nla_data(attr);
		memset(attr_data, 0, size);
		err = dev->netdev_ops->ndo_get_offload_stats(attr_id, dev,
							     attr_data);
		if (err)
			goto get_offload_stats_failure;
	}

	if (!attr)
		return -ENODATA;

	*prividx = 0;
	return 0;

nla_put_failure:
	err = -EMSGSIZE;
get_offload_stats_failure:
	*prividx = attr_id;
	return err;
}

static int rtnl_get_offload_stats_size(const struct net_device *dev)
{
	int nla_size = 0;
	int attr_id;
	int size;

	if (!(dev->netdev_ops && dev->netdev_ops->ndo_has_offload_stats &&
	      dev->netdev_ops->ndo_get_offload_stats))
		return 0;

	for (attr_id = IFLA_OFFLOAD_XSTATS_FIRST;
	     attr_id <= IFLA_OFFLOAD_XSTATS_MAX; attr_id++) {
3743
		if (!dev->netdev_ops->ndo_has_offload_stats(dev, attr_id))
3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754
			continue;
		size = rtnl_get_offload_stats_attr_size(attr_id);
		nla_size += nla_total_size_64bit(size);
	}

	if (nla_size != 0)
		nla_size += nla_total_size(0);

	return nla_size;
}

3755 3756
static int rtnl_fill_statsinfo(struct sk_buff *skb, struct net_device *dev,
			       int type, u32 pid, u32 seq, u32 change,
3757 3758
			       unsigned int flags, unsigned int filter_mask,
			       int *idxattr, int *prividx)
3759 3760 3761 3762
{
	struct if_stats_msg *ifsm;
	struct nlmsghdr *nlh;
	struct nlattr *attr;
3763
	int s_prividx = *prividx;
3764
	int err;
3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775

	ASSERT_RTNL();

	nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifsm), flags);
	if (!nlh)
		return -EMSGSIZE;

	ifsm = nlmsg_data(nlh);
	ifsm->ifindex = dev->ifindex;
	ifsm->filter_mask = filter_mask;

3776
	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_64, *idxattr)) {
3777 3778
		struct rtnl_link_stats64 *sp;

3779 3780 3781
		attr = nla_reserve_64bit(skb, IFLA_STATS_LINK_64,
					 sizeof(struct rtnl_link_stats64),
					 IFLA_STATS_UNSPEC);
3782 3783 3784 3785 3786 3787 3788
		if (!attr)
			goto nla_put_failure;

		sp = nla_data(attr);
		dev_get_stats(dev, sp);
	}

3789 3790 3791 3792 3793 3794 3795 3796 3797 3798
	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS, *idxattr)) {
		const struct rtnl_link_ops *ops = dev->rtnl_link_ops;

		if (ops && ops->fill_linkxstats) {
			*idxattr = IFLA_STATS_LINK_XSTATS;
			attr = nla_nest_start(skb,
					      IFLA_STATS_LINK_XSTATS);
			if (!attr)
				goto nla_put_failure;

3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822
			err = ops->fill_linkxstats(skb, dev, prividx, *idxattr);
			nla_nest_end(skb, attr);
			if (err)
				goto nla_put_failure;
			*idxattr = 0;
		}
	}

	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS_SLAVE,
			     *idxattr)) {
		const struct rtnl_link_ops *ops = NULL;
		const struct net_device *master;

		master = netdev_master_upper_dev_get(dev);
		if (master)
			ops = master->rtnl_link_ops;
		if (ops && ops->fill_linkxstats) {
			*idxattr = IFLA_STATS_LINK_XSTATS_SLAVE;
			attr = nla_nest_start(skb,
					      IFLA_STATS_LINK_XSTATS_SLAVE);
			if (!attr)
				goto nla_put_failure;

			err = ops->fill_linkxstats(skb, dev, prividx, *idxattr);
3823 3824 3825 3826 3827 3828 3829
			nla_nest_end(skb, attr);
			if (err)
				goto nla_put_failure;
			*idxattr = 0;
		}
	}

3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847
	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_OFFLOAD_XSTATS,
			     *idxattr)) {
		*idxattr = IFLA_STATS_LINK_OFFLOAD_XSTATS;
		attr = nla_nest_start(skb, IFLA_STATS_LINK_OFFLOAD_XSTATS);
		if (!attr)
			goto nla_put_failure;

		err = rtnl_get_offload_stats(skb, dev, prividx);
		if (err == -ENODATA)
			nla_nest_cancel(skb, attr);
		else
			nla_nest_end(skb, attr);

		if (err && err != -ENODATA)
			goto nla_put_failure;
		*idxattr = 0;
	}

3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880
	if (stats_attr_valid(filter_mask, IFLA_STATS_AF_SPEC, *idxattr)) {
		struct rtnl_af_ops *af_ops;

		*idxattr = IFLA_STATS_AF_SPEC;
		attr = nla_nest_start(skb, IFLA_STATS_AF_SPEC);
		if (!attr)
			goto nla_put_failure;

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

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

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

				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, attr);

		*idxattr = 0;
	}

3881 3882 3883 3884 3885
	nlmsg_end(skb, nlh);

	return 0;

nla_put_failure:
3886 3887 3888 3889 3890
	/* not a multi message or no progress mean a real error */
	if (!(flags & NLM_F_MULTI) || s_prividx == *prividx)
		nlmsg_cancel(skb, nlh);
	else
		nlmsg_end(skb, nlh);
3891 3892 3893 3894 3895 3896 3897 3898 3899

	return -EMSGSIZE;
}

static size_t if_nlmsg_stats_size(const struct net_device *dev,
				  u32 filter_mask)
{
	size_t size = 0;

3900
	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_64, 0))
3901 3902
		size += nla_total_size_64bit(sizeof(struct rtnl_link_stats64));

3903 3904
	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS, 0)) {
		const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
3905
		int attr = IFLA_STATS_LINK_XSTATS;
3906 3907

		if (ops && ops->get_linkxstats_size) {
3908 3909
			size += nla_total_size(ops->get_linkxstats_size(dev,
									attr));
3910 3911 3912 3913 3914
			/* for IFLA_STATS_LINK_XSTATS */
			size += nla_total_size(0);
		}
	}

3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933
	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS_SLAVE, 0)) {
		struct net_device *_dev = (struct net_device *)dev;
		const struct rtnl_link_ops *ops = NULL;
		const struct net_device *master;

		/* netdev_master_upper_dev_get can't take const */
		master = netdev_master_upper_dev_get(_dev);
		if (master)
			ops = master->rtnl_link_ops;
		if (ops && ops->get_linkxstats_size) {
			int attr = IFLA_STATS_LINK_XSTATS_SLAVE;

			size += nla_total_size(ops->get_linkxstats_size(dev,
									attr));
			/* for IFLA_STATS_LINK_XSTATS_SLAVE */
			size += nla_total_size(0);
		}
	}

3934 3935 3936
	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_OFFLOAD_XSTATS, 0))
		size += rtnl_get_offload_stats_size(dev);

3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953
	if (stats_attr_valid(filter_mask, IFLA_STATS_AF_SPEC, 0)) {
		struct rtnl_af_ops *af_ops;

		/* for IFLA_STATS_AF_SPEC */
		size += nla_total_size(0);

		list_for_each_entry(af_ops, &rtnl_af_ops, list) {
			if (af_ops->get_stats_af_size) {
				size += nla_total_size(
					af_ops->get_stats_af_size(dev));

				/* for AF_* */
				size += nla_total_size(0);
			}
		}
	}

3954 3955 3956
	return size;
}

3957 3958
static int rtnl_stats_get(struct sk_buff *skb, struct nlmsghdr *nlh,
			  struct netlink_ext_ack *extack)
3959 3960 3961
{
	struct net *net = sock_net(skb->sk);
	struct net_device *dev = NULL;
3962 3963
	int idxattr = 0, prividx = 0;
	struct if_stats_msg *ifsm;
3964 3965 3966 3967
	struct sk_buff *nskb;
	u32 filter_mask;
	int err;

3968 3969 3970
	if (nlmsg_len(nlh) < sizeof(*ifsm))
		return -EINVAL;

3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989
	ifsm = nlmsg_data(nlh);
	if (ifsm->ifindex > 0)
		dev = __dev_get_by_index(net, ifsm->ifindex);
	else
		return -EINVAL;

	if (!dev)
		return -ENODEV;

	filter_mask = ifsm->filter_mask;
	if (!filter_mask)
		return -EINVAL;

	nskb = nlmsg_new(if_nlmsg_stats_size(dev, filter_mask), GFP_KERNEL);
	if (!nskb)
		return -ENOBUFS;

	err = rtnl_fill_statsinfo(nskb, dev, RTM_NEWSTATS,
				  NETLINK_CB(skb).portid, nlh->nlmsg_seq, 0,
3990
				  0, filter_mask, &idxattr, &prividx);
3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003
	if (err < 0) {
		/* -EMSGSIZE implies BUG in if_nlmsg_stats_size */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(nskb);
	} else {
		err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid);
	}

	return err;
}

static int rtnl_stats_dump(struct sk_buff *skb, struct netlink_callback *cb)
{
4004
	int h, s_h, err, s_idx, s_idxattr, s_prividx;
4005
	struct net *net = sock_net(skb->sk);
4006
	unsigned int flags = NLM_F_MULTI;
4007 4008
	struct if_stats_msg *ifsm;
	struct hlist_head *head;
4009
	struct net_device *dev;
4010
	u32 filter_mask = 0;
4011
	int idx = 0;
4012 4013 4014

	s_h = cb->args[0];
	s_idx = cb->args[1];
4015 4016
	s_idxattr = cb->args[2];
	s_prividx = cb->args[3];
4017 4018 4019

	cb->seq = net->dev_base_seq;

4020 4021 4022
	if (nlmsg_len(cb->nlh) < sizeof(*ifsm))
		return -EINVAL;

4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036
	ifsm = nlmsg_data(cb->nlh);
	filter_mask = ifsm->filter_mask;
	if (!filter_mask)
		return -EINVAL;

	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
		idx = 0;
		head = &net->dev_index_head[h];
		hlist_for_each_entry(dev, head, index_hlist) {
			if (idx < s_idx)
				goto cont;
			err = rtnl_fill_statsinfo(skb, dev, RTM_NEWSTATS,
						  NETLINK_CB(cb->skb).portid,
						  cb->nlh->nlmsg_seq, 0,
4037 4038
						  flags, filter_mask,
						  &s_idxattr, &s_prividx);
4039 4040 4041 4042 4043 4044 4045
			/* If we ran out of room on the first message,
			 * we're in trouble
			 */
			WARN_ON((err == -EMSGSIZE) && (skb->len == 0));

			if (err < 0)
				goto out;
4046 4047
			s_prividx = 0;
			s_idxattr = 0;
4048 4049 4050 4051 4052 4053
			nl_dump_check_consistent(cb, nlmsg_hdr(skb));
cont:
			idx++;
		}
	}
out:
4054 4055
	cb->args[3] = s_prividx;
	cb->args[2] = s_idxattr;
4056 4057 4058 4059 4060 4061
	cb->args[1] = idx;
	cb->args[0] = h;

	return skb->len;
}

L
Linus Torvalds 已提交
4062 4063
/* Process one rtnetlink message. */

J
Johannes Berg 已提交
4064 4065
static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
			     struct netlink_ext_ack *extack)
L
Linus Torvalds 已提交
4066
{
4067
	struct net *net = sock_net(skb->sk);
4068
	rtnl_doit_func doit;
4069
	int kind;
L
Linus Torvalds 已提交
4070 4071
	int family;
	int type;
4072
	int err;
L
Linus Torvalds 已提交
4073 4074 4075

	type = nlh->nlmsg_type;
	if (type > RTM_MAX)
4076
		return -EOPNOTSUPP;
L
Linus Torvalds 已提交
4077 4078 4079 4080

	type -= RTM_BASE;

	/* All the messages must have at least 1 byte length */
4081
	if (nlmsg_len(nlh) < sizeof(struct rtgenmsg))
L
Linus Torvalds 已提交
4082 4083
		return 0;

4084
	family = ((struct rtgenmsg *)nlmsg_data(nlh))->rtgen_family;
L
Linus Torvalds 已提交
4085 4086
	kind = type&3;

4087
	if (kind != 2 && !netlink_net_capable(skb, CAP_NET_ADMIN))
4088
		return -EPERM;
L
Linus Torvalds 已提交
4089

4090
	if (kind == 2 && nlh->nlmsg_flags&NLM_F_DUMP) {
4091
		struct sock *rtnl;
4092
		rtnl_dumpit_func dumpit;
4093 4094
		rtnl_calcit_func calcit;
		u16 min_dump_alloc = 0;
L
Linus Torvalds 已提交
4095

4096 4097
		dumpit = rtnl_get_dumpit(family, type);
		if (dumpit == NULL)
4098
			return -EOPNOTSUPP;
4099 4100
		calcit = rtnl_get_calcit(family, type);
		if (calcit)
4101
			min_dump_alloc = calcit(skb, nlh);
4102

4103
		__rtnl_unlock();
4104
		rtnl = net->rtnl;
4105 4106 4107 4108 4109 4110 4111
		{
			struct netlink_dump_control c = {
				.dump		= dumpit,
				.min_dump_alloc	= min_dump_alloc,
			};
			err = netlink_dump_start(rtnl, skb, nlh, &c);
		}
4112 4113
		rtnl_lock();
		return err;
L
Linus Torvalds 已提交
4114 4115
	}

4116 4117
	doit = rtnl_get_doit(family, type);
	if (doit == NULL)
4118
		return -EOPNOTSUPP;
L
Linus Torvalds 已提交
4119

4120
	return doit(skb, nlh, extack);
L
Linus Torvalds 已提交
4121 4122
}

4123
static void rtnetlink_rcv(struct sk_buff *skb)
L
Linus Torvalds 已提交
4124
{
4125 4126 4127
	rtnl_lock();
	netlink_rcv_skb(skb, &rtnetlink_rcv_msg);
	rtnl_unlock();
L
Linus Torvalds 已提交
4128 4129 4130 4131
}

static int rtnetlink_event(struct notifier_block *this, unsigned long event, void *ptr)
{
4132
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
4133

L
Linus Torvalds 已提交
4134
	switch (event) {
4135 4136 4137 4138 4139 4140 4141
	case NETDEV_REBOOT:
	case NETDEV_CHANGENAME:
	case NETDEV_FEAT_CHANGE:
	case NETDEV_BONDING_FAILOVER:
	case NETDEV_NOTIFY_PEERS:
	case NETDEV_RESEND_IGMP:
	case NETDEV_CHANGEINFODATA:
4142
		rtmsg_ifinfo(RTM_NEWLINK, dev, 0, GFP_KERNEL);
L
Linus Torvalds 已提交
4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153
		break;
	default:
		break;
	}
	return NOTIFY_DONE;
}

static struct notifier_block rtnetlink_dev_notifier = {
	.notifier_call	= rtnetlink_event,
};

4154

4155
static int __net_init rtnetlink_net_init(struct net *net)
4156 4157
{
	struct sock *sk;
4158 4159 4160 4161
	struct netlink_kernel_cfg cfg = {
		.groups		= RTNLGRP_MAX,
		.input		= rtnetlink_rcv,
		.cb_mutex	= &rtnl_mutex,
4162
		.flags		= NL_CFG_F_NONROOT_RECV,
4163 4164
	};

4165
	sk = netlink_kernel_create(net, NETLINK_ROUTE, &cfg);
4166 4167 4168 4169 4170 4171
	if (!sk)
		return -ENOMEM;
	net->rtnl = sk;
	return 0;
}

4172
static void __net_exit rtnetlink_net_exit(struct net *net)
4173
{
4174 4175
	netlink_kernel_release(net->rtnl);
	net->rtnl = NULL;
4176 4177 4178 4179 4180 4181 4182
}

static struct pernet_operations rtnetlink_net_ops = {
	.init = rtnetlink_net_init,
	.exit = rtnetlink_net_exit,
};

L
Linus Torvalds 已提交
4183 4184
void __init rtnetlink_init(void)
{
4185
	if (register_pernet_subsys(&rtnetlink_net_ops))
L
Linus Torvalds 已提交
4186
		panic("rtnetlink_init: cannot initialize rtnetlink\n");
4187

L
Linus Torvalds 已提交
4188
	register_netdevice_notifier(&rtnetlink_dev_notifier);
4189

4190 4191 4192 4193 4194
	rtnl_register(PF_UNSPEC, RTM_GETLINK, rtnl_getlink,
		      rtnl_dump_ifinfo, rtnl_calcit);
	rtnl_register(PF_UNSPEC, RTM_SETLINK, rtnl_setlink, NULL, NULL);
	rtnl_register(PF_UNSPEC, RTM_NEWLINK, rtnl_newlink, NULL, NULL);
	rtnl_register(PF_UNSPEC, RTM_DELLINK, rtnl_dellink, NULL, NULL);
4195

4196 4197
	rtnl_register(PF_UNSPEC, RTM_GETADDR, NULL, rtnl_dump_all, NULL);
	rtnl_register(PF_UNSPEC, RTM_GETROUTE, NULL, rtnl_dump_all, NULL);
4198
	rtnl_register(PF_UNSPEC, RTM_GETNETCONF, NULL, rtnl_dump_all, NULL);
4199 4200 4201 4202

	rtnl_register(PF_BRIDGE, RTM_NEWNEIGH, rtnl_fdb_add, NULL, NULL);
	rtnl_register(PF_BRIDGE, RTM_DELNEIGH, rtnl_fdb_del, NULL, NULL);
	rtnl_register(PF_BRIDGE, RTM_GETNEIGH, NULL, rtnl_fdb_dump, NULL);
J
John Fastabend 已提交
4203 4204

	rtnl_register(PF_BRIDGE, RTM_GETLINK, NULL, rtnl_bridge_getlink, NULL);
4205
	rtnl_register(PF_BRIDGE, RTM_DELLINK, rtnl_bridge_dellink, NULL, NULL);
J
John Fastabend 已提交
4206
	rtnl_register(PF_BRIDGE, RTM_SETLINK, rtnl_bridge_setlink, NULL, NULL);
4207 4208 4209

	rtnl_register(PF_UNSPEC, RTM_GETSTATS, rtnl_stats_get, rtnl_stats_dump,
		      NULL);
L
Linus Torvalds 已提交
4210
}