rtnetlink.c 83.3 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 44 45 46

#include <asm/uaccess.h>

#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
void __rtnl_unlock(void)
L
Linus Torvalds 已提交
75
{
76
	mutex_unlock(&rtnl_mutex);
L
Linus Torvalds 已提交
77
}
78

L
Linus Torvalds 已提交
79 80
void rtnl_unlock(void)
{
H
Herbert Xu 已提交
81
	/* This fellow will unlock it for us. */
L
Linus Torvalds 已提交
82 83
	netdev_run_todo();
}
E
Eric Dumazet 已提交
84
EXPORT_SYMBOL(rtnl_unlock);
L
Linus Torvalds 已提交
85

86 87 88 89
int rtnl_trylock(void)
{
	return mutex_trylock(&rtnl_mutex);
}
E
Eric Dumazet 已提交
90
EXPORT_SYMBOL(rtnl_trylock);
91

92 93 94 95
int rtnl_is_locked(void)
{
	return mutex_is_locked(&rtnl_mutex);
}
E
Eric Dumazet 已提交
96
EXPORT_SYMBOL(rtnl_is_locked);
97

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

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

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;

126
	if (protocol <= RTNL_FAMILY_MAX)
127 128 129 130
		tab = rtnl_msg_handlers[protocol];
	else
		tab = NULL;

131
	if (tab == NULL || tab[msgindex].doit == NULL)
132 133
		tab = rtnl_msg_handlers[PF_UNSPEC];

134
	return tab[msgindex].doit;
135 136 137 138 139 140
}

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

141
	if (protocol <= RTNL_FAMILY_MAX)
142 143 144 145
		tab = rtnl_msg_handlers[protocol];
	else
		tab = NULL;

146
	if (tab == NULL || tab[msgindex].dumpit == NULL)
147 148
		tab = rtnl_msg_handlers[PF_UNSPEC];

149
	return tab[msgindex].dumpit;
150 151
}

152 153 154 155 156 157 158 159 160 161 162 163
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];

164
	return tab[msgindex].calcit;
165 166
}

167 168 169 170 171 172
/**
 * __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
173
 * @calcit: Function pointer to calc size of dump message
174 175 176 177 178 179 180 181 182 183 184 185
 *
 * 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,
186 187
		    rtnl_doit_func doit, rtnl_dumpit_func dumpit,
		    rtnl_calcit_func calcit)
188 189 190 191
{
	struct rtnl_link *tab;
	int msgindex;

192
	BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
	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;

210 211 212
	if (calcit)
		tab[msgindex].calcit = calcit;

213 214 215 216 217 218 219 220 221 222 223
	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 已提交
224
 * of memory implies no sense in continuing.
225 226
 */
void rtnl_register(int protocol, int msgtype,
227 228
		   rtnl_doit_func doit, rtnl_dumpit_func dumpit,
		   rtnl_calcit_func calcit)
229
{
230
	if (__rtnl_register(protocol, msgtype, doit, dumpit, calcit) < 0)
231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
		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;

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

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

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

	return 0;
}
EXPORT_SYMBOL_GPL(rtnl_unregister);

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

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

P
Patrick McHardy 已提交
277 278
static LIST_HEAD(link_ops);

279 280 281 282 283 284 285 286 287 288 289
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 已提交
290 291 292 293 294 295 296 297 298 299 300 301
/**
 * __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)
{
302 303 304
	if (rtnl_link_ops_get(ops->kind))
		return -EEXIST;

305 306 307 308 309 310
	/* 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)
311
		ops->dellink = unregister_netdevice_queue;
312

P
Patrick McHardy 已提交
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
	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);

335 336 337
static void __rtnl_kill_links(struct net *net, struct rtnl_link_ops *ops)
{
	struct net_device *dev;
338 339
	LIST_HEAD(list_kill);

340
	for_each_netdev(net, dev) {
341 342
		if (dev->rtnl_link_ops == ops)
			ops->dellink(dev, &list_kill);
343
	}
344
	unregister_netdevice_many(&list_kill);
345 346
}

P
Patrick McHardy 已提交
347 348 349 350
/**
 * __rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink.
 * @ops: struct rtnl_link_ops * to unregister
 *
351
 * The caller must hold the rtnl_mutex.
P
Patrick McHardy 已提交
352 353 354
 */
void __rtnl_link_unregister(struct rtnl_link_ops *ops)
{
355
	struct net *net;
356

357
	for_each_net(net) {
358
		__rtnl_kill_links(net, ops);
359
	}
P
Patrick McHardy 已提交
360 361 362 363
	list_del(&ops->list);
}
EXPORT_SYMBOL_GPL(__rtnl_link_unregister);

364 365 366 367 368 369 370
/* 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;
371
	DEFINE_WAIT_FUNC(wait, woken_wake_function);
372

373
	add_wait_queue(&netdev_unregistering_wq, &wait);
374 375 376 377 378 379 380 381 382 383 384 385
	for (;;) {
		unregistering = false;
		rtnl_lock();
		for_each_net(net) {
			if (net->dev_unreg_count > 0) {
				unregistering = true;
				break;
			}
		}
		if (!unregistering)
			break;
		__rtnl_unlock();
386 387

		wait_woken(&wait, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
388
	}
389
	remove_wait_queue(&netdev_unregistering_wq, &wait);
390 391
}

P
Patrick McHardy 已提交
392 393 394 395 396 397
/**
 * 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)
{
398 399 400
	/* Close the race with cleanup_net() */
	mutex_lock(&net_mutex);
	rtnl_lock_unregistering_all();
P
Patrick McHardy 已提交
401 402
	__rtnl_link_unregister(ops);
	rtnl_unlock();
403
	mutex_unlock(&net_mutex);
P
Patrick McHardy 已提交
404 405 406
}
EXPORT_SYMBOL_GPL(rtnl_link_unregister);

407 408 409 410 411 412 413 414 415
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;
416
	if (!ops || !ops->get_slave_size)
417 418 419 420 421 422
		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 已提交
423 424 425 426 427 428 429 430
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;

431 432
	size = nla_total_size(sizeof(struct nlattr)) + /* IFLA_LINKINFO */
	       nla_total_size(strlen(ops->kind) + 1);  /* IFLA_INFO_KIND */
P
Patrick McHardy 已提交
433 434 435

	if (ops->get_size)
		/* IFLA_INFO_DATA + nested data */
436
		size += nla_total_size(sizeof(struct nlattr)) +
P
Patrick McHardy 已提交
437 438 439
			ops->get_size(dev);

	if (ops->get_xstats_size)
440 441
		/* IFLA_INFO_XSTATS */
		size += nla_total_size(ops->get_xstats_size(dev));
P
Patrick McHardy 已提交
442

443 444
	size += rtnl_link_get_slave_info_data_size(dev);

P
Patrick McHardy 已提交
445 446 447
	return size;
}

T
Thomas Graf 已提交
448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
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.
 */
468
void rtnl_af_register(struct rtnl_af_ops *ops)
T
Thomas Graf 已提交
469 470
{
	rtnl_lock();
471
	list_add_tail(&ops->list, &rtnl_af_ops);
T
Thomas Graf 已提交
472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518
	rtnl_unlock();
}
EXPORT_SYMBOL_GPL(rtnl_af_register);

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

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

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

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

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

	return size;
}

519
static bool rtnl_have_link_slave_info(const struct net_device *dev)
P
Patrick McHardy 已提交
520
{
521
	struct net_device *master_dev;
P
Patrick McHardy 已提交
522

523
	master_dev = netdev_master_upper_dev_get((struct net_device *) dev);
524
	if (master_dev && master_dev->rtnl_link_ops)
525 526 527 528 529 530 531 532 533 534 535
		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 已提交
536

537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569
	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 已提交
570
	if (nla_put_string(skb, IFLA_INFO_KIND, ops->kind) < 0)
571
		return -EMSGSIZE;
P
Patrick McHardy 已提交
572 573 574
	if (ops->fill_xstats) {
		err = ops->fill_xstats(skb, dev);
		if (err < 0)
575
			return err;
P
Patrick McHardy 已提交
576 577 578
	}
	if (ops->fill_info) {
		data = nla_nest_start(skb, IFLA_INFO_DATA);
579 580
		if (data == NULL)
			return -EMSGSIZE;
P
Patrick McHardy 已提交
581 582 583 584 585 586 587 588 589
		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);
590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612
	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 已提交
613 614 615 616 617 618
err_cancel_link:
	nla_nest_cancel(skb, linkinfo);
out:
	return err;
}

619
int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigned int group, int echo)
L
Linus Torvalds 已提交
620
{
621
	struct sock *rtnl = net->rtnl;
L
Linus Torvalds 已提交
622 623
	int err = 0;

624
	NETLINK_CB(skb).dst_group = group;
L
Linus Torvalds 已提交
625 626 627 628 629 630 631 632
	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;
}

633
int rtnl_unicast(struct sk_buff *skb, struct net *net, u32 pid)
634
{
635 636
	struct sock *rtnl = net->rtnl;

637 638
	return nlmsg_unicast(rtnl, skb, pid);
}
E
Eric Dumazet 已提交
639
EXPORT_SYMBOL(rtnl_unicast);
640

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

	if (nlh)
		report = nlmsg_report(nlh);

650
	nlmsg_notify(rtnl, skb, pid, group, report, flags);
651
}
E
Eric Dumazet 已提交
652
EXPORT_SYMBOL(rtnl_notify);
653

654
void rtnl_set_sk_err(struct net *net, u32 group, int error)
655
{
656 657
	struct sock *rtnl = net->rtnl;

658 659
	netlink_set_err(rtnl, 0, group, error);
}
E
Eric Dumazet 已提交
660
EXPORT_SYMBOL(rtnl_set_sk_err);
661

L
Linus Torvalds 已提交
662 663
int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics)
{
664 665 666 667 668 669 670 671 672
	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]) {
673 674 675 676 677 678 679 680 681 682 683 684
			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;
			} else {
				if (nla_put_u32(skb, i + 1, metrics[i]))
					goto nla_put_failure;
			}
685 686
			valid++;
		}
L
Linus Torvalds 已提交
687 688
	}

689 690 691 692
	if (!valid) {
		nla_nest_cancel(skb, mx);
		return 0;
	}
693 694 695 696

	return nla_nest_end(skb, mx);

nla_put_failure:
697 698
	nla_nest_cancel(skb, mx);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
699
}
E
Eric Dumazet 已提交
700
EXPORT_SYMBOL(rtnetlink_put_metrics);
L
Linus Torvalds 已提交
701

702
int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id,
703
		       long expires, u32 error)
704 705
{
	struct rta_cacheinfo ci = {
706
		.rta_lastuse = jiffies_delta_to_clock_t(jiffies - dst->lastuse),
707 708 709 710 711 712
		.rta_used = dst->__use,
		.rta_clntref = atomic_read(&(dst->__refcnt)),
		.rta_error = error,
		.rta_id =  id,
	};

713 714
	if (expires) {
		unsigned long clock;
715

716 717 718 719
		clock = jiffies_to_clock_t(abs(expires));
		clock = min_t(unsigned long, clock, INT_MAX);
		ci.rta_expires = (expires > 0) ? clock : -clock;
	}
720 721 722
	return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci);
}
EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo);
L
Linus Torvalds 已提交
723

724
static void set_operstate(struct net_device *dev, unsigned char transition)
S
Stefan Rompf 已提交
725 726 727
{
	unsigned char operstate = dev->operstate;

E
Eric Dumazet 已提交
728
	switch (transition) {
S
Stefan Rompf 已提交
729 730 731 732 733 734 735 736 737 738 739 740
	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;
741
	}
S
Stefan Rompf 已提交
742 743 744 745 746

	if (dev->operstate != operstate) {
		write_lock_bh(&dev_base_lock);
		dev->operstate = operstate;
		write_unlock_bh(&dev_base_lock);
747 748
		netdev_state_change(dev);
	}
S
Stefan Rompf 已提交
749 750
}

751 752 753 754 755 756
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));
}

757 758 759 760 761 762 763 764
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) |
765
			(rtnl_dev_get_flags(dev) & ~ifm->ifi_change);
766 767 768 769

	return flags;
}

770
static void copy_rtnl_link_stats(struct rtnl_link_stats *a,
771
				 const struct rtnl_link_stats64 *b)
L
Linus Torvalds 已提交
772
{
773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799
	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;
800 801
}

802
static void copy_rtnl_link_stats64(void *v, const struct rtnl_link_stats64 *b)
803
{
804
	memcpy(v, b, sizeof(*b));
805
}
L
Linus Torvalds 已提交
806

807
/* All VF info */
808 809
static inline int rtnl_vfinfo_size(const struct net_device *dev,
				   u32 ext_filter_mask)
810
{
811 812
	if (dev->dev.parent && dev_is_pci(dev->dev.parent) &&
	    (ext_filter_mask & RTEXT_FILTER_VF)) {
813
		int num_vfs = dev_num_vf(dev->dev.parent);
814 815 816 817 818
		size_t size = nla_total_size(sizeof(struct nlattr));
		size += nla_total_size(num_vfs * sizeof(struct nlattr));
		size += num_vfs *
			(nla_total_size(sizeof(struct ifla_vf_mac)) +
			 nla_total_size(sizeof(struct ifla_vf_vlan)) +
819
			 nla_total_size(sizeof(struct ifla_vf_spoofchk)) +
J
Jiri Benc 已提交
820
			 nla_total_size(sizeof(struct ifla_vf_rate)) +
821
			 nla_total_size(sizeof(struct ifla_vf_link_state)) +
822 823 824 825 826 827 828 829 830 831 832 833 834
			 nla_total_size(sizeof(struct ifla_vf_rss_query_en)) +
			 /* IFLA_VF_STATS_RX_PACKETS */
			 nla_total_size(sizeof(__u64)) +
			 /* IFLA_VF_STATS_TX_PACKETS */
			 nla_total_size(sizeof(__u64)) +
			 /* IFLA_VF_STATS_RX_BYTES */
			 nla_total_size(sizeof(__u64)) +
			 /* IFLA_VF_STATS_TX_BYTES */
			 nla_total_size(sizeof(__u64)) +
			 /* IFLA_VF_STATS_BROADCAST */
			 nla_total_size(sizeof(__u64)) +
			 /* IFLA_VF_STATS_MULTICAST */
			 nla_total_size(sizeof(__u64)));
835 836
		return size;
	} else
837 838 839
		return 0;
}

840 841
static size_t rtnl_port_size(const struct net_device *dev,
			     u32 ext_filter_mask)
842 843 844 845 846 847 848 849 850 851 852 853 854 855 856
{
	size_t port_size = nla_total_size(4)		/* PORT_VF */
		+ nla_total_size(PORT_PROFILE_MAX)	/* PORT_PROFILE */
		+ nla_total_size(sizeof(struct ifla_port_vsi))
							/* PORT_VSI_TYPE */
		+ nla_total_size(PORT_UUID_MAX)		/* PORT_INSTANCE_UUID */
		+ nla_total_size(PORT_UUID_MAX)		/* PORT_HOST_UUID */
		+ nla_total_size(1)			/* PROT_VDP_REQUEST */
		+ nla_total_size(2);			/* PORT_VDP_RESPONSE */
	size_t vf_ports_size = nla_total_size(sizeof(struct nlattr));
	size_t vf_port_size = nla_total_size(sizeof(struct nlattr))
		+ port_size;
	size_t port_self_size = nla_total_size(sizeof(struct nlattr))
		+ port_size;

857 858
	if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
	    !(ext_filter_mask & RTEXT_FILTER_VF))
859 860 861 862 863 864 865 866
		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;
}

867 868
static noinline size_t if_nlmsg_size(const struct net_device *dev,
				     u32 ext_filter_mask)
869 870 871
{
	return NLMSG_ALIGN(sizeof(struct ifinfomsg))
	       + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
872
	       + nla_total_size(IFALIASZ) /* IFLA_IFALIAS */
873 874 875
	       + nla_total_size(IFNAMSIZ) /* IFLA_QDISC */
	       + nla_total_size(sizeof(struct rtnl_link_ifmap))
	       + nla_total_size(sizeof(struct rtnl_link_stats))
876
	       + nla_total_size(sizeof(struct rtnl_link_stats64))
877 878 879 880 881 882 883
	       + 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 */
884
	       + nla_total_size(1) /* IFLA_CARRIER */
885
	       + nla_total_size(4) /* IFLA_PROMISCUITY */
886 887
	       + nla_total_size(4) /* IFLA_NUM_TX_QUEUES */
	       + nla_total_size(4) /* IFLA_NUM_RX_QUEUES */
888
	       + nla_total_size(1) /* IFLA_OPERSTATE */
P
Patrick McHardy 已提交
889
	       + nla_total_size(1) /* IFLA_LINKMODE */
890
	       + nla_total_size(4) /* IFLA_CARRIER_CHANGES */
891
	       + nla_total_size(4) /* IFLA_LINK_NETNSID */
892 893 894
	       + nla_total_size(ext_filter_mask
			        & RTEXT_FILTER_VF ? 4 : 0) /* IFLA_NUM_VF */
	       + rtnl_vfinfo_size(dev, ext_filter_mask) /* IFLA_VFINFO_LIST */
895
	       + rtnl_port_size(dev, ext_filter_mask) /* IFLA_VF_PORTS + IFLA_PORT_SELF */
T
Thomas Graf 已提交
896
	       + rtnl_link_get_size(dev) /* IFLA_LINKINFO */
897
	       + rtnl_link_get_af_size(dev) /* IFLA_AF_SPEC */
898
	       + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_PORT_ID */
899 900 901
	       + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_SWITCH_ID */
	       + nla_total_size(1); /* IFLA_PROTO_DOWN */

902 903
}

904 905 906 907 908 909 910 911 912 913 914 915 916
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);
917 918
		if (!vf_port)
			goto nla_put_failure;
919 920
		if (nla_put_u32(skb, IFLA_PORT_VF, vf))
			goto nla_put_failure;
921
		err = dev->netdev_ops->ndo_get_vf_port(dev, vf, skb);
922 923
		if (err == -EMSGSIZE)
			goto nla_put_failure;
924 925 926 927 928 929 930 931 932 933
		if (err) {
			nla_nest_cancel(skb, vf_port);
			continue;
		}
		nla_nest_end(skb, vf_port);
	}

	nla_nest_end(skb, vf_ports);

	return 0;
934 935 936 937

nla_put_failure:
	nla_nest_cancel(skb, vf_ports);
	return -EMSGSIZE;
938 939 940 941 942 943 944 945 946 947 948 949 950 951
}

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);
952
		return (err == -EMSGSIZE) ? err : 0;
953 954 955 956 957 958 959
	}

	nla_nest_end(skb, port_self);

	return 0;
}

960 961
static int rtnl_port_fill(struct sk_buff *skb, struct net_device *dev,
			  u32 ext_filter_mask)
962 963 964
{
	int err;

965 966
	if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
	    !(ext_filter_mask & RTEXT_FILTER_VF))
967 968 969 970 971 972 973 974 975 976 977 978 979 980 981
		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;
}

982 983 984
static int rtnl_phys_port_id_fill(struct sk_buff *skb, struct net_device *dev)
{
	int err;
985
	struct netdev_phys_item_id ppid;
986 987 988 989 990 991 992 993 994 995 996 997 998 999

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

1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017
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;
}

1018 1019 1020
static int rtnl_phys_switch_id_fill(struct sk_buff *skb, struct net_device *dev)
{
	int err;
1021 1022 1023 1024
	struct switchdev_attr attr = {
		.id = SWITCHDEV_ATTR_PORT_PARENT_ID,
		.flags = SWITCHDEV_F_NO_RECURSE,
	};
1025

1026
	err = switchdev_port_attr_get(dev, &attr);
1027 1028 1029 1030 1031 1032
	if (err) {
		if (err == -EOPNOTSUPP)
			return 0;
		return err;
	}

1033 1034
	if (nla_put(skb, IFLA_PHYS_SWITCH_ID, attr.u.ppid.id_len,
		    attr.u.ppid.id))
1035 1036 1037 1038 1039
		return -EMSGSIZE;

	return 0;
}

1040
static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev,
1041
			    int type, u32 pid, u32 seq, u32 change,
1042
			    unsigned int flags, u32 ext_filter_mask)
1043 1044 1045
{
	struct ifinfomsg *ifm;
	struct nlmsghdr *nlh;
1046
	struct rtnl_link_stats64 temp;
1047
	const struct rtnl_link_stats64 *stats;
T
Thomas Graf 已提交
1048 1049
	struct nlattr *attr, *af_spec;
	struct rtnl_af_ops *af_ops;
1050
	struct net_device *upper_dev = netdev_master_upper_dev_get(dev);
L
Linus Torvalds 已提交
1051

1052
	ASSERT_RTNL();
1053 1054
	nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags);
	if (nlh == NULL)
1055
		return -EMSGSIZE;
L
Linus Torvalds 已提交
1056

1057 1058 1059 1060 1061 1062 1063 1064
	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;

1065 1066 1067 1068 1069 1070 1071
	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) ||
1072
	    nla_put_u32(skb, IFLA_PROMISCUITY, dev->promiscuity) ||
1073
	    nla_put_u32(skb, IFLA_NUM_TX_QUEUES, dev->num_tx_queues) ||
1074
#ifdef CONFIG_RPS
1075
	    nla_put_u32(skb, IFLA_NUM_RX_QUEUES, dev->num_rx_queues) ||
1076
#endif
1077 1078
	    (dev->ifindex != dev_get_iflink(dev) &&
	     nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))) ||
1079 1080
	    (upper_dev &&
	     nla_put_u32(skb, IFLA_MASTER, upper_dev->ifindex)) ||
1081
	    nla_put_u8(skb, IFLA_CARRIER, netif_carrier_ok(dev)) ||
1082 1083 1084
	    (dev->qdisc &&
	     nla_put_string(skb, IFLA_QDISC, dev->qdisc->ops->id)) ||
	    (dev->ifalias &&
1085 1086
	     nla_put_string(skb, IFLA_IFALIAS, dev->ifalias)) ||
	    nla_put_u32(skb, IFLA_CARRIER_CHANGES,
1087 1088
			atomic_read(&dev->carrier_changes)) ||
	    nla_put_u8(skb, IFLA_PROTO_DOWN, dev->proto_down))
1089
		goto nla_put_failure;
1090

L
Linus Torvalds 已提交
1091 1092 1093 1094 1095 1096 1097 1098 1099
	if (1) {
		struct rtnl_link_ifmap map = {
			.mem_start   = dev->mem_start,
			.mem_end     = dev->mem_end,
			.base_addr   = dev->base_addr,
			.irq         = dev->irq,
			.dma         = dev->dma,
			.port        = dev->if_port,
		};
1100 1101
		if (nla_put(skb, IFLA_MAP, sizeof(map), &map))
			goto nla_put_failure;
L
Linus Torvalds 已提交
1102 1103 1104
	}

	if (dev->addr_len) {
1105 1106 1107
		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 已提交
1108 1109
	}

1110 1111 1112
	if (rtnl_phys_port_id_fill(skb, dev))
		goto nla_put_failure;

1113 1114 1115
	if (rtnl_phys_port_name_fill(skb, dev))
		goto nla_put_failure;

1116 1117 1118
	if (rtnl_phys_switch_id_fill(skb, dev))
		goto nla_put_failure;

1119 1120 1121 1122
	attr = nla_reserve(skb, IFLA_STATS,
			sizeof(struct rtnl_link_stats));
	if (attr == NULL)
		goto nla_put_failure;
1123

1124
	stats = dev_get_stats(dev, &temp);
1125
	copy_rtnl_link_stats(nla_data(attr), stats);
L
Linus Torvalds 已提交
1126

1127 1128 1129 1130 1131 1132
	attr = nla_reserve(skb, IFLA_STATS64,
			sizeof(struct rtnl_link_stats64));
	if (attr == NULL)
		goto nla_put_failure;
	copy_rtnl_link_stats64(nla_data(attr), stats);

1133 1134 1135
	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;
1136

1137 1138
	if (dev->netdev_ops->ndo_get_vf_config && dev->dev.parent
	    && (ext_filter_mask & RTEXT_FILTER_VF)) {
1139 1140
		int i;

1141
		struct nlattr *vfinfo, *vf, *vfstats;
1142 1143 1144 1145 1146 1147 1148 1149 1150
		int num_vfs = dev_num_vf(dev->dev.parent);

		vfinfo = nla_nest_start(skb, IFLA_VFINFO_LIST);
		if (!vfinfo)
			goto nla_put_failure;
		for (i = 0; i < num_vfs; i++) {
			struct ifla_vf_info ivi;
			struct ifla_vf_mac vf_mac;
			struct ifla_vf_vlan vf_vlan;
1151
			struct ifla_vf_rate vf_rate;
1152
			struct ifla_vf_tx_rate vf_tx_rate;
1153
			struct ifla_vf_spoofchk vf_spoofchk;
1154
			struct ifla_vf_link_state vf_linkstate;
1155
			struct ifla_vf_rss_query_en vf_rss_query_en;
1156
			struct ifla_vf_stats vf_stats;
1157 1158 1159

			/*
			 * Not all SR-IOV capable drivers support the
1160 1161 1162
			 * spoofcheck and "RSS query enable" query.  Preset to
			 * -1 so the user space tool can detect that the driver
			 * didn't report anything.
1163 1164
			 */
			ivi.spoofchk = -1;
1165
			ivi.rss_query_en = -1;
1166
			memset(ivi.mac, 0, sizeof(ivi.mac));
1167 1168 1169 1170
			/* The default value for VF link state is "auto"
			 * IFLA_VF_LINK_STATE_AUTO which equals zero
			 */
			ivi.linkstate = 0;
1171 1172
			if (dev->netdev_ops->ndo_get_vf_config(dev, i, &ivi))
				break;
1173 1174
			vf_mac.vf =
				vf_vlan.vf =
1175
				vf_rate.vf =
1176
				vf_tx_rate.vf =
1177
				vf_spoofchk.vf =
1178 1179
				vf_linkstate.vf =
				vf_rss_query_en.vf = ivi.vf;
1180

1181 1182 1183
			memcpy(vf_mac.mac, ivi.mac, sizeof(ivi.mac));
			vf_vlan.vlan = ivi.vlan;
			vf_vlan.qos = ivi.qos;
1184 1185 1186
			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;
1187
			vf_spoofchk.setting = ivi.spoofchk;
1188
			vf_linkstate.link_state = ivi.linkstate;
1189
			vf_rss_query_en.setting = ivi.rss_query_en;
1190 1191 1192 1193 1194
			vf = nla_nest_start(skb, IFLA_VF_INFO);
			if (!vf) {
				nla_nest_cancel(skb, vfinfo);
				goto nla_put_failure;
			}
1195 1196
			if (nla_put(skb, IFLA_VF_MAC, sizeof(vf_mac), &vf_mac) ||
			    nla_put(skb, IFLA_VF_VLAN, sizeof(vf_vlan), &vf_vlan) ||
1197 1198
			    nla_put(skb, IFLA_VF_RATE, sizeof(vf_rate),
				    &vf_rate) ||
1199 1200 1201
			    nla_put(skb, IFLA_VF_TX_RATE, sizeof(vf_tx_rate),
				    &vf_tx_rate) ||
			    nla_put(skb, IFLA_VF_SPOOFCHK, sizeof(vf_spoofchk),
1202 1203
				    &vf_spoofchk) ||
			    nla_put(skb, IFLA_VF_LINK_STATE, sizeof(vf_linkstate),
1204 1205 1206 1207
				    &vf_linkstate) ||
			    nla_put(skb, IFLA_VF_RSS_QUERY_EN,
				    sizeof(vf_rss_query_en),
				    &vf_rss_query_en))
1208
				goto nla_put_failure;
1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
			memset(&vf_stats, 0, sizeof(vf_stats));
			if (dev->netdev_ops->ndo_get_vf_stats)
				dev->netdev_ops->ndo_get_vf_stats(dev, i,
								  &vf_stats);
			vfstats = nla_nest_start(skb, IFLA_VF_STATS);
			if (!vfstats) {
				nla_nest_cancel(skb, vf);
				nla_nest_cancel(skb, vfinfo);
				goto nla_put_failure;
			}
			if (nla_put_u64(skb, IFLA_VF_STATS_RX_PACKETS,
					vf_stats.rx_packets) ||
			    nla_put_u64(skb, IFLA_VF_STATS_TX_PACKETS,
					vf_stats.tx_packets) ||
			    nla_put_u64(skb, IFLA_VF_STATS_RX_BYTES,
					vf_stats.rx_bytes) ||
			    nla_put_u64(skb, IFLA_VF_STATS_TX_BYTES,
					vf_stats.tx_bytes) ||
			    nla_put_u64(skb, IFLA_VF_STATS_BROADCAST,
					vf_stats.broadcast) ||
			    nla_put_u64(skb, IFLA_VF_STATS_MULTICAST,
					vf_stats.multicast))
				goto nla_put_failure;
			nla_nest_end(skb, vfstats);
1233
			nla_nest_end(skb, vf);
1234
		}
1235
		nla_nest_end(skb, vfinfo);
1236
	}
1237

1238
	if (rtnl_port_fill(skb, dev, ext_filter_mask))
1239 1240
		goto nla_put_failure;

1241
	if (dev->rtnl_link_ops || rtnl_have_link_slave_info(dev)) {
P
Patrick McHardy 已提交
1242 1243 1244 1245
		if (rtnl_link_fill(skb, dev) < 0)
			goto nla_put_failure;
	}

1246 1247 1248 1249 1250
	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)) {
1251
			int id = peernet2id_alloc(dev_net(dev), link_net);
1252 1253 1254 1255 1256 1257

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

T
Thomas Graf 已提交
1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287
	if (!(af_spec = nla_nest_start(skb, IFLA_AF_SPEC)))
		goto nla_put_failure;

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

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

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

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

			nla_nest_end(skb, af);
		}
	}

	nla_nest_end(skb, af_spec);

1288 1289
	nlmsg_end(skb, nlh);
	return 0;
1290 1291

nla_put_failure:
1292 1293
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
1294 1295
}

J
Jiri Pirko 已提交
1296
static const struct nla_policy ifla_policy[IFLA_MAX+1] = {
1297
	[IFLA_IFNAME]		= { .type = NLA_STRING, .len = IFNAMSIZ-1 },
P
Patrick McHardy 已提交
1298 1299
	[IFLA_ADDRESS]		= { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
	[IFLA_BROADCAST]	= { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
1300
	[IFLA_MAP]		= { .len = sizeof(struct rtnl_link_ifmap) },
1301
	[IFLA_MTU]		= { .type = NLA_U32 },
1302
	[IFLA_LINK]		= { .type = NLA_U32 },
1303
	[IFLA_MASTER]		= { .type = NLA_U32 },
1304
	[IFLA_CARRIER]		= { .type = NLA_U8 },
1305 1306 1307 1308
	[IFLA_TXQLEN]		= { .type = NLA_U32 },
	[IFLA_WEIGHT]		= { .type = NLA_U32 },
	[IFLA_OPERSTATE]	= { .type = NLA_U8 },
	[IFLA_LINKMODE]		= { .type = NLA_U8 },
1309
	[IFLA_LINKINFO]		= { .type = NLA_NESTED },
1310
	[IFLA_NET_NS_PID]	= { .type = NLA_U32 },
1311
	[IFLA_NET_NS_FD]	= { .type = NLA_U32 },
1312
	[IFLA_IFALIAS]	        = { .type = NLA_STRING, .len = IFALIASZ-1 },
1313
	[IFLA_VFINFO_LIST]	= {. type = NLA_NESTED },
1314 1315
	[IFLA_VF_PORTS]		= { .type = NLA_NESTED },
	[IFLA_PORT_SELF]	= { .type = NLA_NESTED },
T
Thomas Graf 已提交
1316
	[IFLA_AF_SPEC]		= { .type = NLA_NESTED },
1317
	[IFLA_EXT_MASK]		= { .type = NLA_U32 },
1318
	[IFLA_PROMISCUITY]	= { .type = NLA_U32 },
1319 1320
	[IFLA_NUM_TX_QUEUES]	= { .type = NLA_U32 },
	[IFLA_NUM_RX_QUEUES]	= { .type = NLA_U32 },
1321
	[IFLA_PHYS_PORT_ID]	= { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
1322
	[IFLA_CARRIER_CHANGES]	= { .type = NLA_U32 },  /* ignored */
1323
	[IFLA_PHYS_SWITCH_ID]	= { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
1324
	[IFLA_LINK_NETNSID]	= { .type = NLA_S32 },
1325
	[IFLA_PROTO_DOWN]	= { .type = NLA_U8 },
1326 1327
};

P
Patrick McHardy 已提交
1328 1329 1330
static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = {
	[IFLA_INFO_KIND]	= { .type = NLA_STRING },
	[IFLA_INFO_DATA]	= { .type = NLA_NESTED },
1331 1332
	[IFLA_INFO_SLAVE_KIND]	= { .type = NLA_STRING },
	[IFLA_INFO_SLAVE_DATA]	= { .type = NLA_NESTED },
P
Patrick McHardy 已提交
1333 1334
};

1335
static const struct nla_policy ifla_vf_policy[IFLA_VF_MAX+1] = {
1336 1337 1338 1339 1340 1341
	[IFLA_VF_MAC]		= { .len = sizeof(struct ifla_vf_mac) },
	[IFLA_VF_VLAN]		= { .len = sizeof(struct ifla_vf_vlan) },
	[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) },
1342
	[IFLA_VF_RSS_QUERY_EN]	= { .len = sizeof(struct ifla_vf_rss_query_en) },
1343 1344 1345 1346 1347 1348 1349 1350 1351 1352
	[IFLA_VF_STATS]		= { .type = NLA_NESTED },
};

static const struct nla_policy ifla_vf_stats_policy[IFLA_VF_STATS_MAX + 1] = {
	[IFLA_VF_STATS_RX_PACKETS]	= { .type = NLA_U64 },
	[IFLA_VF_STATS_TX_PACKETS]	= { .type = NLA_U64 },
	[IFLA_VF_STATS_RX_BYTES]	= { .type = NLA_U64 },
	[IFLA_VF_STATS_TX_BYTES]	= { .type = NLA_U64 },
	[IFLA_VF_STATS_BROADCAST]	= { .type = NLA_U64 },
	[IFLA_VF_STATS_MULTICAST]	= { .type = NLA_U64 },
1353 1354
};

1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368
static const struct nla_policy ifla_port_policy[IFLA_PORT_MAX+1] = {
	[IFLA_PORT_VF]		= { .type = NLA_U32 },
	[IFLA_PORT_PROFILE]	= { .type = NLA_STRING,
				    .len = PORT_PROFILE_MAX },
	[IFLA_PORT_VSI_TYPE]	= { .type = NLA_BINARY,
				    .len = sizeof(struct ifla_port_vsi)},
	[IFLA_PORT_INSTANCE_UUID] = { .type = NLA_BINARY,
				      .len = PORT_UUID_MAX },
	[IFLA_PORT_HOST_UUID]	= { .type = NLA_STRING,
				    .len = PORT_UUID_MAX },
	[IFLA_PORT_REQUEST]	= { .type = NLA_U8, },
	[IFLA_PORT_RESPONSE]	= { .type = NLA_U16, },
};

J
Jiri Pirko 已提交
1369 1370 1371 1372 1373 1374 1375 1376 1377
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;
1378
	int err;
1379
	int hdrlen;
J
Jiri Pirko 已提交
1380 1381 1382 1383 1384 1385

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

	cb->seq = net->dev_base_seq;

1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396
	/* 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);

	if (nlmsg_parse(cb->nlh, hdrlen, tb, IFLA_MAX, ifla_policy) >= 0) {
J
Jiri Pirko 已提交
1397 1398 1399 1400 1401 1402 1403 1404

		if (tb[IFLA_EXT_MASK])
			ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
	}

	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
		idx = 0;
		head = &net->dev_index_head[h];
1405
		hlist_for_each_entry(dev, head, index_hlist) {
J
Jiri Pirko 已提交
1406 1407
			if (idx < s_idx)
				goto cont;
1408 1409 1410 1411 1412 1413 1414 1415 1416 1417
			err = rtnl_fill_ifinfo(skb, dev, RTM_NEWLINK,
					       NETLINK_CB(cb->skb).portid,
					       cb->nlh->nlmsg_seq, 0,
					       NLM_F_MULTI,
					       ext_filter_mask);
			/* If we ran out of room on the first message,
			 * we're in trouble
			 */
			WARN_ON((err == -EMSGSIZE) && (skb->len == 0));

1418
			if (err < 0)
J
Jiri Pirko 已提交
1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438
				goto out;

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

	return skb->len;
}

int rtnl_nla_parse_ifla(struct nlattr **tb, const struct nlattr *head, int len)
{
	return nla_parse(tb, IFLA_MAX, head, len, ifla_policy);
}
EXPORT_SYMBOL(rtnl_nla_parse_ifla);

1439 1440 1441 1442 1443 1444 1445 1446
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]));
1447 1448
	else if (tb[IFLA_NET_NS_FD])
		net = get_net_ns_by_fd(nla_get_u32(tb[IFLA_NET_NS_FD]));
1449 1450 1451 1452 1453 1454
	else
		net = get_net(src_net);
	return net;
}
EXPORT_SYMBOL(rtnl_link_get_net);

1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466
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;
	}

1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480
	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) {
1481
				err = af_ops->validate_link_af(dev, af);
1482 1483 1484 1485 1486 1487
				if (err < 0)
					return err;
			}
		}
	}

1488 1489 1490
	return 0;
}

1491
static int do_setvfinfo(struct net_device *dev, struct nlattr **tb)
1492 1493
{
	const struct net_device_ops *ops = dev->netdev_ops;
1494
	int err = -EINVAL;
1495

1496 1497
	if (tb[IFLA_VF_MAC]) {
		struct ifla_vf_mac *ivm = nla_data(tb[IFLA_VF_MAC]);
1498

1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515
		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,
						   ivv->qos);
		if (err < 0)
			return err;
1516
	}
1517 1518 1519 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 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582

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

1583 1584 1585
	return err;
}

1586 1587
static int do_set_master(struct net_device *dev, int ifindex)
{
1588
	struct net_device *upper_dev = netdev_master_upper_dev_get(dev);
1589 1590 1591
	const struct net_device_ops *ops;
	int err;

1592 1593
	if (upper_dev) {
		if (upper_dev->ifindex == ifindex)
1594
			return 0;
1595
		ops = upper_dev->netdev_ops;
1596
		if (ops->ndo_del_slave) {
1597
			err = ops->ndo_del_slave(upper_dev, dev);
1598 1599 1600 1601 1602 1603 1604 1605
			if (err)
				return err;
		} else {
			return -EOPNOTSUPP;
		}
	}

	if (ifindex) {
1606 1607
		upper_dev = __dev_get_by_index(dev_net(dev), ifindex);
		if (!upper_dev)
1608
			return -EINVAL;
1609
		ops = upper_dev->netdev_ops;
1610
		if (ops->ndo_add_slave) {
1611
			err = ops->ndo_add_slave(upper_dev, dev);
1612 1613 1614 1615 1616 1617 1618 1619 1620
			if (err)
				return err;
		} else {
			return -EOPNOTSUPP;
		}
	}
	return 0;
}

1621
#define DO_SETLINK_MODIFIED	0x01
1622 1623
/* notify flag means notify + modified. */
#define DO_SETLINK_NOTIFY	0x03
1624 1625
static int do_setlink(const struct sk_buff *skb,
		      struct net_device *dev, struct ifinfomsg *ifm,
1626
		      struct nlattr **tb, char *ifname, int status)
L
Linus Torvalds 已提交
1627
{
1628
	const struct net_device_ops *ops = dev->netdev_ops;
1629
	int err;
L
Linus Torvalds 已提交
1630

1631
	if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD]) {
1632
		struct net *net = rtnl_link_get_net(dev_net(dev), tb);
1633 1634 1635 1636
		if (IS_ERR(net)) {
			err = PTR_ERR(net);
			goto errout;
		}
1637
		if (!netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN)) {
1638
			put_net(net);
1639 1640 1641
			err = -EPERM;
			goto errout;
		}
1642 1643 1644 1645
		err = dev_change_net_namespace(dev, net, ifname);
		put_net(net);
		if (err)
			goto errout;
1646
		status |= DO_SETLINK_MODIFIED;
1647 1648
	}

1649
	if (tb[IFLA_MAP]) {
L
Linus Torvalds 已提交
1650 1651 1652
		struct rtnl_link_ifmap *u_map;
		struct ifmap k_map;

1653
		if (!ops->ndo_set_config) {
L
Linus Torvalds 已提交
1654
			err = -EOPNOTSUPP;
1655
			goto errout;
L
Linus Torvalds 已提交
1656 1657 1658 1659
		}

		if (!netif_device_present(dev)) {
			err = -ENODEV;
1660
			goto errout;
L
Linus Torvalds 已提交
1661 1662
		}

1663
		u_map = nla_data(tb[IFLA_MAP]);
L
Linus Torvalds 已提交
1664 1665 1666 1667 1668 1669 1670
		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;

1671
		err = ops->ndo_set_config(dev, &k_map);
1672
		if (err < 0)
1673
			goto errout;
L
Linus Torvalds 已提交
1674

1675
		status |= DO_SETLINK_NOTIFY;
L
Linus Torvalds 已提交
1676 1677
	}

1678
	if (tb[IFLA_ADDRESS]) {
1679 1680 1681 1682 1683 1684 1685
		struct sockaddr *sa;
		int len;

		len = sizeof(sa_family_t) + dev->addr_len;
		sa = kmalloc(len, GFP_KERNEL);
		if (!sa) {
			err = -ENOMEM;
1686
			goto errout;
1687 1688
		}
		sa->sa_family = dev->type;
1689
		memcpy(sa->sa_data, nla_data(tb[IFLA_ADDRESS]),
1690
		       dev->addr_len);
1691
		err = dev_set_mac_address(dev, sa);
1692
		kfree(sa);
L
Linus Torvalds 已提交
1693
		if (err)
1694
			goto errout;
1695
		status |= DO_SETLINK_MODIFIED;
L
Linus Torvalds 已提交
1696 1697
	}

1698 1699 1700
	if (tb[IFLA_MTU]) {
		err = dev_set_mtu(dev, nla_get_u32(tb[IFLA_MTU]));
		if (err < 0)
1701
			goto errout;
1702
		status |= DO_SETLINK_MODIFIED;
L
Linus Torvalds 已提交
1703 1704
	}

1705 1706
	if (tb[IFLA_GROUP]) {
		dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP]));
1707
		status |= DO_SETLINK_NOTIFY;
1708 1709
	}

1710 1711 1712 1713 1714
	/*
	 * Interface selected by interface index but interface
	 * name provided implies that a name change has been
	 * requested.
	 */
1715
	if (ifm->ifi_index > 0 && ifname[0]) {
1716 1717
		err = dev_change_name(dev, ifname);
		if (err < 0)
1718
			goto errout;
1719
		status |= DO_SETLINK_MODIFIED;
L
Linus Torvalds 已提交
1720 1721
	}

1722 1723 1724 1725 1726
	if (tb[IFLA_IFALIAS]) {
		err = dev_set_alias(dev, nla_data(tb[IFLA_IFALIAS]),
				    nla_len(tb[IFLA_IFALIAS]));
		if (err < 0)
			goto errout;
1727
		status |= DO_SETLINK_NOTIFY;
1728 1729
	}

1730 1731
	if (tb[IFLA_BROADCAST]) {
		nla_memcpy(dev->broadcast, tb[IFLA_BROADCAST], dev->addr_len);
1732
		call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
L
Linus Torvalds 已提交
1733 1734
	}

1735
	if (ifm->ifi_flags || ifm->ifi_change) {
1736
		err = dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm));
1737 1738
		if (err < 0)
			goto errout;
1739
	}
L
Linus Torvalds 已提交
1740

1741 1742 1743 1744
	if (tb[IFLA_MASTER]) {
		err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]));
		if (err)
			goto errout;
1745
		status |= DO_SETLINK_MODIFIED;
1746 1747
	}

1748 1749 1750 1751
	if (tb[IFLA_CARRIER]) {
		err = dev_change_carrier(dev, nla_get_u8(tb[IFLA_CARRIER]));
		if (err)
			goto errout;
1752
		status |= DO_SETLINK_MODIFIED;
1753 1754
	}

1755 1756 1757 1758
	if (tb[IFLA_TXQLEN]) {
		unsigned long value = nla_get_u32(tb[IFLA_TXQLEN]);

		if (dev->tx_queue_len ^ value)
1759
			status |= DO_SETLINK_NOTIFY;
1760 1761 1762

		dev->tx_queue_len = value;
	}
S
Stefan Rompf 已提交
1763

1764
	if (tb[IFLA_OPERSTATE])
1765
		set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
S
Stefan Rompf 已提交
1766

1767
	if (tb[IFLA_LINKMODE]) {
1768 1769
		unsigned char value = nla_get_u8(tb[IFLA_LINKMODE]);

1770
		write_lock_bh(&dev_base_lock);
1771
		if (dev->link_mode ^ value)
1772
			status |= DO_SETLINK_NOTIFY;
1773
		dev->link_mode = value;
1774
		write_unlock_bh(&dev_base_lock);
S
Stefan Rompf 已提交
1775 1776
	}

1777
	if (tb[IFLA_VFINFO_LIST]) {
1778
		struct nlattr *vfinfo[IFLA_VF_MAX + 1];
1779 1780
		struct nlattr *attr;
		int rem;
1781

1782
		nla_for_each_nested(attr, tb[IFLA_VFINFO_LIST], rem) {
1783 1784
			if (nla_type(attr) != IFLA_VF_INFO ||
			    nla_len(attr) < NLA_HDRLEN) {
1785
				err = -EINVAL;
1786
				goto errout;
1787
			}
1788 1789 1790 1791 1792
			err = nla_parse_nested(vfinfo, IFLA_VF_MAX, attr,
					       ifla_vf_policy);
			if (err < 0)
				goto errout;
			err = do_setvfinfo(dev, vfinfo);
1793 1794
			if (err < 0)
				goto errout;
1795
			status |= DO_SETLINK_NOTIFY;
1796
		}
1797
	}
L
Linus Torvalds 已提交
1798 1799
	err = 0;

1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810
	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) {
1811 1812 1813 1814 1815 1816 1817
			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,
					       ifla_port_policy);
1818 1819 1820 1821 1822 1823 1824 1825 1826 1827
			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;
1828
			status |= DO_SETLINK_NOTIFY;
1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845
		}
	}
	err = 0;

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

		err = nla_parse_nested(port, IFLA_PORT_MAX,
			tb[IFLA_PORT_SELF], ifla_port_policy);
		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;
1846
		status |= DO_SETLINK_NOTIFY;
1847
	}
T
Thomas Graf 已提交
1848 1849 1850 1851 1852 1853 1854 1855 1856

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

1859
			err = af_ops->set_link_af(dev, af);
T
Thomas Graf 已提交
1860 1861 1862
			if (err < 0)
				goto errout;

1863
			status |= DO_SETLINK_NOTIFY;
T
Thomas Graf 已提交
1864 1865
		}
	}
1866 1867
	err = 0;

1868 1869 1870 1871 1872 1873 1874 1875
	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;
	}

1876
errout:
1877 1878 1879 1880 1881 1882 1883 1884
	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);
	}
1885

1886 1887
	return err;
}
L
Linus Torvalds 已提交
1888

1889
static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh)
1890
{
1891
	struct net *net = sock_net(skb->sk);
1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909
	struct ifinfomsg *ifm;
	struct net_device *dev;
	int err;
	struct nlattr *tb[IFLA_MAX+1];
	char ifname[IFNAMSIZ];

	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy);
	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)
1910
		dev = __dev_get_by_index(net, ifm->ifi_index);
1911
	else if (tb[IFLA_IFNAME])
1912
		dev = __dev_get_by_name(net, ifname);
1913 1914 1915 1916 1917 1918 1919 1920
	else
		goto errout;

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

E
Eric Dumazet 已提交
1921 1922
	err = validate_linkmsg(dev, tb);
	if (err < 0)
1923
		goto errout;
1924

1925
	err = do_setlink(skb, dev, ifm, tb, ifname, 0);
1926
errout:
L
Linus Torvalds 已提交
1927 1928 1929
	return err;
}

1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965
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;
}

1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981
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);

1982
static int rtnl_dellink(struct sk_buff *skb, struct nlmsghdr *nlh)
P
Patrick McHardy 已提交
1983
{
1984
	struct net *net = sock_net(skb->sk);
P
Patrick McHardy 已提交
1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999
	struct net_device *dev;
	struct ifinfomsg *ifm;
	char ifname[IFNAMSIZ];
	struct nlattr *tb[IFLA_MAX+1];
	int err;

	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy);
	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)
2000
		dev = __dev_get_by_index(net, ifm->ifi_index);
P
Patrick McHardy 已提交
2001
	else if (tb[IFLA_IFNAME])
2002
		dev = __dev_get_by_name(net, ifname);
2003 2004
	else if (tb[IFLA_GROUP])
		return rtnl_group_dellink(net, nla_get_u32(tb[IFLA_GROUP]));
P
Patrick McHardy 已提交
2005 2006 2007 2008 2009 2010
	else
		return -EINVAL;

	if (!dev)
		return -ENODEV;

2011
	return rtnl_delete_link(dev);
P
Patrick McHardy 已提交
2012 2013
}

2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027
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;

2028
	__dev_notify_flags(dev, old_flags, ~0U);
2029 2030 2031 2032
	return 0;
}
EXPORT_SYMBOL(rtnl_configure_link);

2033
struct net_device *rtnl_create_link(struct net *net,
2034
	const char *ifname, unsigned char name_assign_type,
2035
	const struct rtnl_link_ops *ops, struct nlattr *tb[])
2036 2037 2038
{
	int err;
	struct net_device *dev;
2039 2040
	unsigned int num_tx_queues = 1;
	unsigned int num_rx_queues = 1;
2041

2042 2043 2044
	if (tb[IFLA_NUM_TX_QUEUES])
		num_tx_queues = nla_get_u32(tb[IFLA_NUM_TX_QUEUES]);
	else if (ops->get_num_tx_queues)
2045
		num_tx_queues = ops->get_num_tx_queues();
2046 2047 2048 2049

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

2052
	err = -ENOMEM;
2053
	dev = alloc_netdev_mqs(ops->priv_size, ifname, name_assign_type,
2054
			       ops->setup, num_tx_queues, num_rx_queues);
2055 2056 2057
	if (!dev)
		goto err;

2058 2059
	dev_net_set(dev, net);
	dev->rtnl_link_ops = ops;
2060
	dev->rtnl_link_state = RTNL_LINK_INITIALIZING;
2061

2062 2063
	if (tb[IFLA_MTU])
		dev->mtu = nla_get_u32(tb[IFLA_MTU]);
2064
	if (tb[IFLA_ADDRESS]) {
2065 2066
		memcpy(dev->dev_addr, nla_data(tb[IFLA_ADDRESS]),
				nla_len(tb[IFLA_ADDRESS]));
2067 2068
		dev->addr_assign_type = NET_ADDR_SET;
	}
2069 2070 2071 2072 2073 2074
	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])
2075
		set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
2076 2077
	if (tb[IFLA_LINKMODE])
		dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]);
2078 2079
	if (tb[IFLA_GROUP])
		dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP]));
2080 2081 2082 2083 2084 2085

	return dev;

err:
	return ERR_PTR(err);
}
E
Eric Dumazet 已提交
2086
EXPORT_SYMBOL(rtnl_create_link);
2087

2088 2089
static int rtnl_group_changelink(const struct sk_buff *skb,
		struct net *net, int group,
2090 2091 2092
		struct ifinfomsg *ifm,
		struct nlattr **tb)
{
2093
	struct net_device *dev, *aux;
2094 2095
	int err;

2096
	for_each_netdev_safe(net, dev, aux) {
2097
		if (dev->group == group) {
2098
			err = do_setlink(skb, dev, ifm, tb, NULL, 0);
2099 2100 2101 2102 2103 2104 2105 2106
			if (err < 0)
				return err;
		}
	}

	return 0;
}

2107
static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh)
P
Patrick McHardy 已提交
2108
{
2109
	struct net *net = sock_net(skb->sk);
P
Patrick McHardy 已提交
2110
	const struct rtnl_link_ops *ops;
2111
	const struct rtnl_link_ops *m_ops = NULL;
P
Patrick McHardy 已提交
2112
	struct net_device *dev;
2113
	struct net_device *master_dev = NULL;
P
Patrick McHardy 已提交
2114 2115 2116 2117 2118
	struct ifinfomsg *ifm;
	char kind[MODULE_NAME_LEN];
	char ifname[IFNAMSIZ];
	struct nlattr *tb[IFLA_MAX+1];
	struct nlattr *linkinfo[IFLA_INFO_MAX+1];
2119
	unsigned char name_assign_type = NET_NAME_USER;
P
Patrick McHardy 已提交
2120 2121
	int err;

2122
#ifdef CONFIG_MODULES
P
Patrick McHardy 已提交
2123
replay:
2124
#endif
P
Patrick McHardy 已提交
2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy);
	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)
2136
		dev = __dev_get_by_index(net, ifm->ifi_index);
2137 2138 2139 2140 2141 2142
	else {
		if (ifname[0])
			dev = __dev_get_by_name(net, ifname);
		else
			dev = NULL;
	}
P
Patrick McHardy 已提交
2143

2144 2145 2146 2147 2148 2149
	if (dev) {
		master_dev = netdev_master_upper_dev_get(dev);
		if (master_dev)
			m_ops = master_dev->rtnl_link_ops;
	}

E
Eric Dumazet 已提交
2150 2151
	err = validate_linkmsg(dev, tb);
	if (err < 0)
2152 2153
		return err;

P
Patrick McHardy 已提交
2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170
	if (tb[IFLA_LINKINFO]) {
		err = nla_parse_nested(linkinfo, IFLA_INFO_MAX,
				       tb[IFLA_LINKINFO], ifla_info_policy);
		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 已提交
2171 2172
		struct nlattr *attr[ops ? ops->maxtype + 1 : 1];
		struct nlattr *slave_attr[m_ops ? m_ops->slave_maxtype + 1 : 1];
2173 2174
		struct nlattr **data = NULL;
		struct nlattr **slave_data = NULL;
2175
		struct net *dest_net, *link_net = NULL;
P
Patrick McHardy 已提交
2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192

		if (ops) {
			if (ops->maxtype && linkinfo[IFLA_INFO_DATA]) {
				err = nla_parse_nested(attr, ops->maxtype,
						       linkinfo[IFLA_INFO_DATA],
						       ops->policy);
				if (err < 0)
					return err;
				data = attr;
			}
			if (ops->validate) {
				err = ops->validate(tb, data);
				if (err < 0)
					return err;
			}
		}

2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210
		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],
						       m_ops->slave_policy);
				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 已提交
2211
		if (dev) {
2212
			int status = 0;
P
Patrick McHardy 已提交
2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226

			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;
2227
				status |= DO_SETLINK_NOTIFY;
P
Patrick McHardy 已提交
2228 2229
			}

2230 2231 2232 2233 2234 2235 2236 2237
			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;
2238
				status |= DO_SETLINK_NOTIFY;
2239 2240
			}

2241
			return do_setlink(skb, dev, ifm, tb, ifname, status);
P
Patrick McHardy 已提交
2242 2243
		}

2244 2245
		if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
			if (ifm->ifi_index == 0 && tb[IFLA_GROUP])
2246
				return rtnl_group_changelink(skb, net,
2247 2248
						nla_get_u32(tb[IFLA_GROUP]),
						ifm, tb);
P
Patrick McHardy 已提交
2249
			return -ENODEV;
2250
		}
P
Patrick McHardy 已提交
2251

2252
		if (tb[IFLA_MAP] || tb[IFLA_MASTER] || tb[IFLA_PROTINFO])
P
Patrick McHardy 已提交
2253 2254 2255
			return -EOPNOTSUPP;

		if (!ops) {
2256
#ifdef CONFIG_MODULES
P
Patrick McHardy 已提交
2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268
			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;
		}

2269 2270 2271
		if (!ops->setup)
			return -EOPNOTSUPP;

2272
		if (!ifname[0]) {
P
Patrick McHardy 已提交
2273
			snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind);
2274 2275
			name_assign_type = NET_NAME_ENUM;
		}
2276

2277
		dest_net = rtnl_link_get_net(net, tb);
2278 2279 2280
		if (IS_ERR(dest_net))
			return PTR_ERR(dest_net);

2281 2282 2283 2284
		err = -EPERM;
		if (!netlink_ns_capable(skb, dest_net->user_ns, CAP_NET_ADMIN))
			goto out;

2285 2286 2287 2288 2289 2290 2291 2292
		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;
			}
2293 2294 2295
			err = -EPERM;
			if (!netlink_ns_capable(skb, link_net->user_ns, CAP_NET_ADMIN))
				goto out;
2296 2297 2298 2299
		}

		dev = rtnl_create_link(link_net ? : dest_net, ifname,
				       name_assign_type, ops, tb);
2300
		if (IS_ERR(dev)) {
2301
			err = PTR_ERR(dev);
2302 2303 2304 2305 2306
			goto out;
		}

		dev->ifindex = ifm->ifi_index;

2307
		if (ops->newlink) {
2308
			err = ops->newlink(link_net ? : net, dev, tb, data);
2309
			/* Drivers should call free_netdev() in ->destructor
2310 2311
			 * and unregister it on failure after registration
			 * so that device could be finally freed in rtnl_unlock.
2312
			 */
2313 2314 2315 2316
			if (err < 0) {
				/* If device is not registered at all, free it now */
				if (dev->reg_state == NETREG_UNINITIALIZED)
					free_netdev(dev);
2317
				goto out;
2318
			}
2319
		} else {
2320
			err = register_netdevice(dev);
2321 2322 2323 2324
			if (err < 0) {
				free_netdev(dev);
				goto out;
			}
2325
		}
2326
		err = rtnl_configure_link(dev, ifm);
2327 2328
		if (err < 0)
			goto out_unregister;
2329
		if (link_net) {
2330
			err = dev_change_net_namespace(dev, dest_net, ifname);
2331
			if (err < 0)
2332
				goto out_unregister;
2333
		}
2334
out:
2335 2336
		if (link_net)
			put_net(link_net);
2337
		put_net(dest_net);
P
Patrick McHardy 已提交
2338
		return err;
2339 2340 2341 2342 2343 2344 2345 2346 2347 2348
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 已提交
2349 2350 2351
	}
}

2352
static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr* nlh)
2353
{
2354
	struct net *net = sock_net(skb->sk);
2355
	struct ifinfomsg *ifm;
2356
	char ifname[IFNAMSIZ];
2357 2358 2359
	struct nlattr *tb[IFLA_MAX+1];
	struct net_device *dev = NULL;
	struct sk_buff *nskb;
2360
	int err;
2361
	u32 ext_filter_mask = 0;
2362

2363 2364
	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy);
	if (err < 0)
2365
		return err;
2366

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

2370 2371 2372
	if (tb[IFLA_EXT_MASK])
		ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);

2373
	ifm = nlmsg_data(nlh);
2374 2375 2376 2377 2378
	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
2379 2380
		return -EINVAL;

2381 2382 2383
	if (dev == NULL)
		return -ENODEV;

2384
	nskb = nlmsg_new(if_nlmsg_size(dev, ext_filter_mask), GFP_KERNEL);
2385 2386
	if (nskb == NULL)
		return -ENOBUFS;
2387

2388
	err = rtnl_fill_ifinfo(nskb, dev, RTM_NEWLINK, NETLINK_CB(skb).portid,
2389
			       nlh->nlmsg_seq, 0, 0, ext_filter_mask);
2390 2391 2392 2393
	if (err < 0) {
		/* -EMSGSIZE implies BUG in if_nlmsg_size */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(nskb);
2394
	} else
2395
		err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid);
2396

2397
	return err;
2398 2399
}

2400
static u16 rtnl_calcit(struct sk_buff *skb, struct nlmsghdr *nlh)
2401
{
2402 2403 2404 2405 2406
	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;
2407 2408 2409 2410 2411
	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);
2412

2413
	if (nlmsg_parse(nlh, hdrlen, tb, IFLA_MAX, ifla_policy) >= 0) {
2414 2415 2416
		if (tb[IFLA_EXT_MASK])
			ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
	}
2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429

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

2430 2431 2432
	return min_ifinfo_dump_size;
}

A
Adrian Bunk 已提交
2433
static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb)
L
Linus Torvalds 已提交
2434 2435 2436 2437 2438 2439
{
	int idx;
	int s_idx = cb->family;

	if (s_idx == 0)
		s_idx = 1;
2440
	for (idx = 1; idx <= RTNL_FAMILY_MAX; idx++) {
L
Linus Torvalds 已提交
2441 2442 2443
		int type = cb->nlh->nlmsg_type-RTM_BASE;
		if (idx < s_idx || idx == PF_PACKET)
			continue;
2444 2445
		if (rtnl_msg_handlers[idx] == NULL ||
		    rtnl_msg_handlers[idx][type].dumpit == NULL)
L
Linus Torvalds 已提交
2446
			continue;
2447
		if (idx > s_idx) {
L
Linus Torvalds 已提交
2448
			memset(&cb->args[0], 0, sizeof(cb->args));
2449 2450 2451
			cb->prev_seq = 0;
			cb->seq = 0;
		}
2452
		if (rtnl_msg_handlers[idx][type].dumpit(skb, cb))
L
Linus Torvalds 已提交
2453 2454 2455 2456 2457 2458 2459
			break;
	}
	cb->family = idx;

	return skb->len;
}

2460 2461
struct sk_buff *rtmsg_ifinfo_build_skb(int type, struct net_device *dev,
				       unsigned int change, gfp_t flags)
L
Linus Torvalds 已提交
2462
{
2463
	struct net *net = dev_net(dev);
L
Linus Torvalds 已提交
2464
	struct sk_buff *skb;
2465
	int err = -ENOBUFS;
2466
	size_t if_info_size;
L
Linus Torvalds 已提交
2467

2468
	skb = nlmsg_new((if_info_size = if_nlmsg_size(dev, 0)), flags);
2469 2470
	if (skb == NULL)
		goto errout;
L
Linus Torvalds 已提交
2471

2472
	err = rtnl_fill_ifinfo(skb, dev, type, 0, 0, change, 0, 0);
2473 2474 2475 2476 2477 2478
	if (err < 0) {
		/* -EMSGSIZE implies BUG in if_nlmsg_size() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
2479
	return skb;
2480 2481
errout:
	if (err < 0)
2482
		rtnl_set_sk_err(net, RTNLGRP_LINK, err);
2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497
	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);
}

void rtmsg_ifinfo(int type, struct net_device *dev, unsigned int change,
		  gfp_t flags)
{
	struct sk_buff *skb;

2498 2499 2500
	if (dev->reg_state != NETREG_REGISTERED)
		return;

2501 2502 2503
	skb = rtmsg_ifinfo_build_skb(type, dev, change, flags);
	if (skb)
		rtmsg_ifinfo_send(skb, dev, flags);
L
Linus Torvalds 已提交
2504
}
2505
EXPORT_SYMBOL(rtmsg_ifinfo);
L
Linus Torvalds 已提交
2506

2507 2508
static int nlmsg_populate_fdb_fill(struct sk_buff *skb,
				   struct net_device *dev,
2509
				   u8 *addr, u16 vid, u32 pid, u32 seq,
2510 2511
				   int type, unsigned int flags,
				   int nlflags)
2512 2513 2514 2515
{
	struct nlmsghdr *nlh;
	struct ndmsg *ndm;

2516
	nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), nlflags);
2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530
	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;
	ndm->ndm_state   = NUD_PERMANENT;

	if (nla_put(skb, NDA_LLADDR, ETH_ALEN, addr))
		goto nla_put_failure;
2531 2532 2533
	if (vid)
		if (nla_put(skb, NDA_VLAN, sizeof(u16), &vid))
			goto nla_put_failure;
2534

2535 2536
	nlmsg_end(skb, nlh);
	return 0;
2537 2538 2539 2540 2541 2542

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

2543 2544 2545 2546 2547
static inline size_t rtnl_fdb_nlmsg_size(void)
{
	return NLMSG_ALIGN(sizeof(struct ndmsg)) + nla_total_size(ETH_ALEN);
}

2548
static void rtnl_fdb_notify(struct net_device *dev, u8 *addr, u16 vid, int type)
2549 2550 2551 2552 2553 2554 2555 2556 2557
{
	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;

2558 2559
	err = nlmsg_populate_fdb_fill(skb, dev, addr, vid,
				      0, 0, type, NTF_SELF, 0);
2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570
	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);
}

2571 2572 2573 2574 2575 2576
/**
 * 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,
2577
		     const unsigned char *addr, u16 vid,
2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589
		     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;
	}

2590 2591 2592 2593 2594
	if (vid) {
		pr_info("%s: vlans aren't supported yet for dev_uc|mc_add()\n", dev->name);
		return err;
	}

2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607
	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);

2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629
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;
}

2630
static int rtnl_fdb_add(struct sk_buff *skb, struct nlmsghdr *nlh)
2631 2632 2633 2634 2635 2636
{
	struct net *net = sock_net(skb->sk);
	struct ndmsg *ndm;
	struct nlattr *tb[NDA_MAX+1];
	struct net_device *dev;
	u8 *addr;
2637
	u16 vid;
2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662
	int err;

	err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL);
	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]);

2663 2664 2665 2666
	err = fdb_vid_parse(tb[NDA_VLAN], &vid);
	if (err)
		return err;

2667 2668 2669 2670 2671
	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)) {
2672 2673 2674
		struct net_device *br_dev = netdev_master_upper_dev_get(dev);
		const struct net_device_ops *ops = br_dev->netdev_ops;

2675 2676
		err = ops->ndo_fdb_add(ndm, tb, dev, addr, vid,
				       nlh->nlmsg_flags);
2677 2678 2679 2680 2681 2682 2683
		if (err)
			goto out;
		else
			ndm->ndm_flags &= ~NTF_MASTER;
	}

	/* Embedded bridge, macvlan, and any other device support */
2684 2685 2686
	if ((ndm->ndm_flags & NTF_SELF)) {
		if (dev->netdev_ops->ndo_fdb_add)
			err = dev->netdev_ops->ndo_fdb_add(ndm, tb, dev, addr,
2687
							   vid,
2688 2689
							   nlh->nlmsg_flags);
		else
2690
			err = ndo_dflt_fdb_add(ndm, tb, dev, addr, vid,
2691
					       nlh->nlmsg_flags);
2692

2693
		if (!err) {
2694
			rtnl_fdb_notify(dev, addr, vid, RTM_NEWNEIGH);
2695
			ndm->ndm_flags &= ~NTF_SELF;
2696
		}
2697 2698 2699 2700 2701
	}
out:
	return err;
}

2702 2703 2704 2705 2706 2707
/**
 * 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,
2708
		     const unsigned char *addr, u16 vid)
2709
{
2710
	int err = -EINVAL;
2711 2712 2713 2714

	/* If aging addresses are supported device will need to
	 * implement its own handler for this.
	 */
2715
	if (!(ndm->ndm_state & NUD_PERMANENT)) {
2716
		pr_info("%s: FDB only supports static addresses\n", dev->name);
2717
		return err;
2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728
	}

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

2729
static int rtnl_fdb_del(struct sk_buff *skb, struct nlmsghdr *nlh)
2730 2731 2732
{
	struct net *net = sock_net(skb->sk);
	struct ndmsg *ndm;
2733
	struct nlattr *tb[NDA_MAX+1];
2734 2735 2736
	struct net_device *dev;
	int err = -EINVAL;
	__u8 *addr;
2737
	u16 vid;
2738

2739
	if (!netlink_capable(skb, CAP_NET_ADMIN))
2740 2741 2742 2743 2744
		return -EPERM;

	err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL);
	if (err < 0)
		return err;
2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757

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

2758 2759 2760 2761 2762 2763
	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]);
2764

2765 2766 2767 2768
	err = fdb_vid_parse(tb[NDA_VLAN], &vid);
	if (err)
		return err;

2769 2770 2771 2772 2773
	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)) {
2774 2775
		struct net_device *br_dev = netdev_master_upper_dev_get(dev);
		const struct net_device_ops *ops = br_dev->netdev_ops;
2776

2777
		if (ops->ndo_fdb_del)
2778
			err = ops->ndo_fdb_del(ndm, tb, dev, addr, vid);
2779 2780 2781 2782 2783 2784 2785 2786

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

	/* Embedded bridge, macvlan, and any other device support */
2787 2788
	if (ndm->ndm_flags & NTF_SELF) {
		if (dev->netdev_ops->ndo_fdb_del)
2789 2790
			err = dev->netdev_ops->ndo_fdb_del(ndm, tb, dev, addr,
							   vid);
2791
		else
2792
			err = ndo_dflt_fdb_del(ndm, tb, dev, addr, vid);
2793

2794
		if (!err) {
2795
			rtnl_fdb_notify(dev, addr, vid, RTM_DELNEIGH);
2796
			ndm->ndm_flags &= ~NTF_SELF;
2797
		}
2798 2799 2800 2801 2802
	}
out:
	return err;
}

2803 2804 2805 2806 2807 2808 2809 2810
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;
2811
	u32 portid, seq;
2812

2813
	portid = NETLINK_CB(cb->skb).portid;
2814 2815 2816 2817 2818 2819
	seq = cb->nlh->nlmsg_seq;

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

2820
		err = nlmsg_populate_fdb_fill(skb, dev, ha->addr, 0,
2821
					      portid, seq,
2822 2823
					      RTM_NEWNEIGH, NTF_SELF,
					      NLM_F_MULTI);
2824 2825 2826 2827 2828 2829 2830 2831 2832
		if (err < 0)
			return err;
skip:
		*idx += 1;
	}
	return 0;
}

/**
2833
 * ndo_dflt_fdb_dump - default netdevice operation to dump an FDB table.
2834 2835 2836 2837
 * @nlh: netlink message header
 * @dev: netdevice
 *
 * Default netdevice operation to dump the existing unicast address list.
2838
 * Returns number of addresses from list put in skb.
2839 2840 2841 2842
 */
int ndo_dflt_fdb_dump(struct sk_buff *skb,
		      struct netlink_callback *cb,
		      struct net_device *dev,
2843
		      struct net_device *filter_dev,
2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858
		      int idx)
{
	int err;

	netif_addr_lock_bh(dev);
	err = nlmsg_populate_fdb(skb, cb, dev, &idx, &dev->uc);
	if (err)
		goto out;
	nlmsg_populate_fdb(skb, cb, dev, &idx, &dev->mc);
out:
	netif_addr_unlock_bh(dev);
	return idx;
}
EXPORT_SYMBOL(ndo_dflt_fdb_dump);

2859 2860 2861
static int rtnl_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb)
{
	struct net_device *dev;
2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908
	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);
	int brport_idx = 0;
	int br_idx = 0;
	int idx = 0;

	if (nlmsg_parse(cb->nlh, sizeof(struct ifinfomsg), tb, IFLA_MAX,
			ifla_policy) == 0) {
		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;
	}

	for_each_netdev(net, dev) {
		if (brport_idx && (dev->ifindex != brport_idx))
			continue;

		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;

			if (br_dev != netdev_master_upper_dev_get(dev) &&
			    !(dev->priv_flags & IFF_EBRIDGE))
				continue;

			cops = ops;
		}
2909 2910

		if (dev->priv_flags & IFF_BRIDGE_PORT) {
2911 2912 2913
			if (cops && cops->ndo_fdb_dump)
				idx = cops->ndo_fdb_dump(skb, cb, br_dev, dev,
							 idx);
2914 2915 2916
		}

		if (dev->netdev_ops->ndo_fdb_dump)
2917
			idx = dev->netdev_ops->ndo_fdb_dump(skb, cb, dev, NULL,
2918
							    idx);
2919 2920
		else
			idx = ndo_dflt_fdb_dump(skb, cb, dev, NULL, idx);
2921 2922

		cops = NULL;
2923 2924 2925 2926 2927 2928
	}

	cb->args[0] = idx;
	return skb->len;
}

2929 2930 2931 2932 2933 2934 2935 2936
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;
}

2937
int ndo_dflt_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
2938
			    struct net_device *dev, u16 mode,
2939 2940 2941 2942 2943
			    u32 flags, u32 mask, int nlflags,
			    u32 filter_mask,
			    int (*vlan_fill)(struct sk_buff *skb,
					     struct net_device *dev,
					     u32 filter_mask))
2944 2945 2946 2947
{
	struct nlmsghdr *nlh;
	struct ifinfomsg *ifm;
	struct nlattr *br_afspec;
2948
	struct nlattr *protinfo;
2949
	u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN;
2950
	struct net_device *br_dev = netdev_master_upper_dev_get(dev);
2951
	int err = 0;
2952

2953
	nlh = nlmsg_put(skb, pid, seq, RTM_NEWLINK, sizeof(*ifm), nlflags);
2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968
	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) ||
2969 2970
	    (br_dev &&
	     nla_put_u32(skb, IFLA_MASTER, br_dev->ifindex)) ||
2971 2972
	    (dev->addr_len &&
	     nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
2973 2974
	    (dev->ifindex != dev_get_iflink(dev) &&
	     nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))))
2975 2976 2977 2978 2979 2980
		goto nla_put_failure;

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

R
Roopa Prabhu 已提交
2981
	if (nla_put_u16(skb, IFLA_BRIDGE_FLAGS, BRIDGE_FLAGS_SELF)) {
2982 2983 2984
		nla_nest_cancel(skb, br_afspec);
		goto nla_put_failure;
	}
R
Roopa Prabhu 已提交
2985 2986 2987 2988 2989 2990 2991

	if (mode != BRIDGE_MODE_UNDEF) {
		if (nla_put_u16(skb, IFLA_BRIDGE_MODE, mode)) {
			nla_nest_cancel(skb, br_afspec);
			goto nla_put_failure;
		}
	}
2992 2993 2994 2995 2996 2997 2998
	if (vlan_fill) {
		err = vlan_fill(skb, dev, filter_mask);
		if (err) {
			nla_nest_cancel(skb, br_afspec);
			goto nla_put_failure;
		}
	}
2999 3000
	nla_nest_end(skb, br_afspec);

3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027
	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);

3028 3029
	nlmsg_end(skb, nlh);
	return 0;
3030 3031
nla_put_failure:
	nlmsg_cancel(skb, nlh);
3032
	return err ? err : -EMSGSIZE;
3033
}
3034
EXPORT_SYMBOL_GPL(ndo_dflt_bridge_getlink);
3035

J
John Fastabend 已提交
3036 3037 3038 3039 3040 3041 3042
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;
3043 3044
	u32 filter_mask = 0;

3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056
	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 已提交
3057 3058 3059 3060

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

3063
		if (br_dev && br_dev->netdev_ops->ndo_bridge_getlink) {
3064
			if (idx >= cb->args[0] &&
3065
			    br_dev->netdev_ops->ndo_bridge_getlink(
3066 3067
				    skb, portid, seq, dev, filter_mask,
				    NLM_F_MULTI) < 0)
J
John Fastabend 已提交
3068
				break;
3069
			idx++;
J
John Fastabend 已提交
3070 3071 3072
		}

		if (ops->ndo_bridge_getlink) {
3073
			if (idx >= cb->args[0] &&
3074
			    ops->ndo_bridge_getlink(skb, portid, seq, dev,
3075 3076
						    filter_mask,
						    NLM_F_MULTI) < 0)
J
John Fastabend 已提交
3077
				break;
3078
			idx++;
J
John Fastabend 已提交
3079 3080 3081 3082 3083 3084 3085 3086
		}
	}
	rcu_read_unlock();
	cb->args[0] = idx;

	return skb->len;
}

3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101
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 */
}

3102
static int rtnl_bridge_notify(struct net_device *dev)
3103 3104 3105 3106 3107
{
	struct net *net = dev_net(dev);
	struct sk_buff *skb;
	int err = -EOPNOTSUPP;

3108 3109 3110
	if (!dev->netdev_ops->ndo_bridge_getlink)
		return 0;

3111 3112 3113 3114 3115 3116
	skb = nlmsg_new(bridge_nlmsg_size(), GFP_ATOMIC);
	if (!skb) {
		err = -ENOMEM;
		goto errout;
	}

3117
	err = dev->netdev_ops->ndo_bridge_getlink(skb, 0, 0, dev, 0, 0);
3118 3119
	if (err < 0)
		goto errout;
3120

3121 3122 3123
	if (!skb->len)
		goto errout;

3124 3125 3126 3127 3128
	rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
	return 0;
errout:
	WARN_ON(err == -EMSGSIZE);
	kfree_skb(skb);
3129 3130
	if (err)
		rtnl_set_sk_err(net, RTNLGRP_LINK, err);
3131 3132 3133
	return err;
}

3134
static int rtnl_bridge_setlink(struct sk_buff *skb, struct nlmsghdr *nlh)
J
John Fastabend 已提交
3135 3136 3137 3138
{
	struct net *net = sock_net(skb->sk);
	struct ifinfomsg *ifm;
	struct net_device *dev;
3139 3140
	struct nlattr *br_spec, *attr = NULL;
	int rem, err = -EOPNOTSUPP;
3141
	u16 flags = 0;
3142
	bool have_flags = false;
J
John Fastabend 已提交
3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156

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

3157 3158 3159 3160
	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) {
3161 3162 3163
				if (nla_len(attr) < sizeof(flags))
					return -EINVAL;

3164
				have_flags = true;
3165 3166 3167 3168 3169 3170 3171
				flags = nla_get_u16(attr);
				break;
			}
		}
	}

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

		if (!br_dev || !br_dev->netdev_ops->ndo_bridge_setlink) {
3175 3176 3177 3178
			err = -EOPNOTSUPP;
			goto out;
		}

3179
		err = br_dev->netdev_ops->ndo_bridge_setlink(dev, nlh, flags);
J
John Fastabend 已提交
3180 3181
		if (err)
			goto out;
3182 3183

		flags &= ~BRIDGE_FLAGS_MASTER;
J
John Fastabend 已提交
3184 3185
	}

3186 3187 3188 3189
	if ((flags & BRIDGE_FLAGS_SELF)) {
		if (!dev->netdev_ops->ndo_bridge_setlink)
			err = -EOPNOTSUPP;
		else
3190 3191
			err = dev->netdev_ops->ndo_bridge_setlink(dev, nlh,
								  flags);
3192
		if (!err) {
3193
			flags &= ~BRIDGE_FLAGS_SELF;
3194 3195 3196 3197 3198 3199

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

3202
	if (have_flags)
3203
		memcpy(nla_data(attr), &flags, sizeof(flags));
J
John Fastabend 已提交
3204 3205 3206 3207
out:
	return err;
}

3208
static int rtnl_bridge_dellink(struct sk_buff *skb, struct nlmsghdr *nlh)
3209 3210 3211 3212 3213 3214
{
	struct net *net = sock_net(skb->sk);
	struct ifinfomsg *ifm;
	struct net_device *dev;
	struct nlattr *br_spec, *attr = NULL;
	int rem, err = -EOPNOTSUPP;
3215
	u16 flags = 0;
3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234
	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) {
3235 3236 3237
				if (nla_len(attr) < sizeof(flags))
					return -EINVAL;

3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252
				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;
		}

3253
		err = br_dev->netdev_ops->ndo_bridge_dellink(dev, nlh, flags);
3254 3255 3256 3257 3258 3259 3260 3261 3262 3263
		if (err)
			goto out;

		flags &= ~BRIDGE_FLAGS_MASTER;
	}

	if ((flags & BRIDGE_FLAGS_SELF)) {
		if (!dev->netdev_ops->ndo_bridge_dellink)
			err = -EOPNOTSUPP;
		else
3264 3265
			err = dev->netdev_ops->ndo_bridge_dellink(dev, nlh,
								  flags);
3266

3267
		if (!err) {
3268
			flags &= ~BRIDGE_FLAGS_SELF;
3269 3270 3271 3272 3273 3274

			/* Generate event to notify upper layer of bridge
			 * change
			 */
			err = rtnl_bridge_notify(dev);
		}
3275 3276 3277 3278 3279 3280 3281 3282
	}

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

L
Linus Torvalds 已提交
3283 3284
/* Process one rtnetlink message. */

3285
static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
L
Linus Torvalds 已提交
3286
{
3287
	struct net *net = sock_net(skb->sk);
3288
	rtnl_doit_func doit;
L
Linus Torvalds 已提交
3289 3290 3291
	int sz_idx, kind;
	int family;
	int type;
3292
	int err;
L
Linus Torvalds 已提交
3293 3294 3295

	type = nlh->nlmsg_type;
	if (type > RTM_MAX)
3296
		return -EOPNOTSUPP;
L
Linus Torvalds 已提交
3297 3298 3299 3300

	type -= RTM_BASE;

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

3304
	family = ((struct rtgenmsg *)nlmsg_data(nlh))->rtgen_family;
L
Linus Torvalds 已提交
3305 3306 3307
	sz_idx = type>>2;
	kind = type&3;

3308
	if (kind != 2 && !netlink_net_capable(skb, CAP_NET_ADMIN))
3309
		return -EPERM;
L
Linus Torvalds 已提交
3310

3311
	if (kind == 2 && nlh->nlmsg_flags&NLM_F_DUMP) {
3312
		struct sock *rtnl;
3313
		rtnl_dumpit_func dumpit;
3314 3315
		rtnl_calcit_func calcit;
		u16 min_dump_alloc = 0;
L
Linus Torvalds 已提交
3316

3317 3318
		dumpit = rtnl_get_dumpit(family, type);
		if (dumpit == NULL)
3319
			return -EOPNOTSUPP;
3320 3321
		calcit = rtnl_get_calcit(family, type);
		if (calcit)
3322
			min_dump_alloc = calcit(skb, nlh);
3323

3324
		__rtnl_unlock();
3325
		rtnl = net->rtnl;
3326 3327 3328 3329 3330 3331 3332
		{
			struct netlink_dump_control c = {
				.dump		= dumpit,
				.min_dump_alloc	= min_dump_alloc,
			};
			err = netlink_dump_start(rtnl, skb, nlh, &c);
		}
3333 3334
		rtnl_lock();
		return err;
L
Linus Torvalds 已提交
3335 3336
	}

3337 3338
	doit = rtnl_get_doit(family, type);
	if (doit == NULL)
3339
		return -EOPNOTSUPP;
L
Linus Torvalds 已提交
3340

3341
	return doit(skb, nlh);
L
Linus Torvalds 已提交
3342 3343
}

3344
static void rtnetlink_rcv(struct sk_buff *skb)
L
Linus Torvalds 已提交
3345
{
3346 3347 3348
	rtnl_lock();
	netlink_rcv_skb(skb, &rtnetlink_rcv_msg);
	rtnl_unlock();
L
Linus Torvalds 已提交
3349 3350 3351 3352
}

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

L
Linus Torvalds 已提交
3355 3356 3357
	switch (event) {
	case NETDEV_UP:
	case NETDEV_DOWN:
3358
	case NETDEV_PRE_UP:
3359 3360
	case NETDEV_POST_INIT:
	case NETDEV_REGISTER:
L
Linus Torvalds 已提交
3361
	case NETDEV_CHANGE:
3362
	case NETDEV_PRE_TYPE_CHANGE:
L
Linus Torvalds 已提交
3363
	case NETDEV_GOING_DOWN:
3364
	case NETDEV_UNREGISTER:
3365
	case NETDEV_UNREGISTER_FINAL:
3366 3367
	case NETDEV_RELEASE:
	case NETDEV_JOIN:
3368
	case NETDEV_BONDING_INFO:
L
Linus Torvalds 已提交
3369 3370
		break;
	default:
3371
		rtmsg_ifinfo(RTM_NEWLINK, dev, 0, GFP_KERNEL);
L
Linus Torvalds 已提交
3372 3373 3374 3375 3376 3377 3378 3379 3380
		break;
	}
	return NOTIFY_DONE;
}

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

3381

3382
static int __net_init rtnetlink_net_init(struct net *net)
3383 3384
{
	struct sock *sk;
3385 3386 3387 3388
	struct netlink_kernel_cfg cfg = {
		.groups		= RTNLGRP_MAX,
		.input		= rtnetlink_rcv,
		.cb_mutex	= &rtnl_mutex,
3389
		.flags		= NL_CFG_F_NONROOT_RECV,
3390 3391
	};

3392
	sk = netlink_kernel_create(net, NETLINK_ROUTE, &cfg);
3393 3394 3395 3396 3397 3398
	if (!sk)
		return -ENOMEM;
	net->rtnl = sk;
	return 0;
}

3399
static void __net_exit rtnetlink_net_exit(struct net *net)
3400
{
3401 3402
	netlink_kernel_release(net->rtnl);
	net->rtnl = NULL;
3403 3404 3405 3406 3407 3408 3409
}

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

L
Linus Torvalds 已提交
3410 3411
void __init rtnetlink_init(void)
{
3412
	if (register_pernet_subsys(&rtnetlink_net_ops))
L
Linus Torvalds 已提交
3413
		panic("rtnetlink_init: cannot initialize rtnetlink\n");
3414

L
Linus Torvalds 已提交
3415
	register_netdevice_notifier(&rtnetlink_dev_notifier);
3416

3417 3418 3419 3420 3421
	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);
3422

3423 3424
	rtnl_register(PF_UNSPEC, RTM_GETADDR, NULL, rtnl_dump_all, NULL);
	rtnl_register(PF_UNSPEC, RTM_GETROUTE, NULL, rtnl_dump_all, NULL);
3425 3426 3427 3428

	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 已提交
3429 3430

	rtnl_register(PF_BRIDGE, RTM_GETLINK, NULL, rtnl_bridge_getlink, NULL);
3431
	rtnl_register(PF_BRIDGE, RTM_DELLINK, rtnl_bridge_dellink, NULL, NULL);
J
John Fastabend 已提交
3432
	rtnl_register(PF_BRIDGE, RTM_SETLINK, rtnl_bridge_setlink, NULL, NULL);
L
Linus Torvalds 已提交
3433 3434
}