1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * INET		An implementation of the TCP/IP protocol suite for the LINUX
   4 *		operating system.  INET is implemented using the  BSD Socket
   5 *		interface as the means of communication with the user level.
   6 *
   7 *		Routing netlink socket interface: protocol independent part.
   8 *
   9 * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  10 *
 
 
 
 
 
  11 *	Fixes:
  12 *	Vitaly E. Lavrov		RTA_OK arithmetics was wrong.
  13 */
  14
  15#include <linux/bitops.h>
  16#include <linux/errno.h>
  17#include <linux/module.h>
  18#include <linux/types.h>
  19#include <linux/socket.h>
  20#include <linux/kernel.h>
  21#include <linux/timer.h>
  22#include <linux/string.h>
  23#include <linux/sockios.h>
  24#include <linux/net.h>
  25#include <linux/fcntl.h>
  26#include <linux/mm.h>
  27#include <linux/slab.h>
  28#include <linux/interrupt.h>
  29#include <linux/capability.h>
  30#include <linux/skbuff.h>
  31#include <linux/init.h>
  32#include <linux/security.h>
  33#include <linux/mutex.h>
  34#include <linux/if_addr.h>
  35#include <linux/if_bridge.h>
  36#include <linux/if_vlan.h>
  37#include <linux/pci.h>
  38#include <linux/etherdevice.h>
  39#include <linux/bpf.h>
  40
  41#include <linux/uaccess.h>
  42
  43#include <linux/inet.h>
  44#include <linux/netdevice.h>
 
  45#include <net/ip.h>
  46#include <net/protocol.h>
  47#include <net/arp.h>
  48#include <net/route.h>
  49#include <net/udp.h>
  50#include <net/tcp.h>
  51#include <net/sock.h>
  52#include <net/pkt_sched.h>
  53#include <net/fib_rules.h>
  54#include <net/rtnetlink.h>
  55#include <net/net_namespace.h>
  56
  57#define RTNL_MAX_TYPE		50
  58#define RTNL_SLAVE_MAX_TYPE	36
  59
  60struct rtnl_link {
  61	rtnl_doit_func		doit;
  62	rtnl_dumpit_func	dumpit;
  63	struct module		*owner;
  64	unsigned int		flags;
  65	struct rcu_head		rcu;
  66};
  67
  68static DEFINE_MUTEX(rtnl_mutex);
  69
  70void rtnl_lock(void)
  71{
  72	mutex_lock(&rtnl_mutex);
  73}
  74EXPORT_SYMBOL(rtnl_lock);
  75
  76int rtnl_lock_killable(void)
  77{
  78	return mutex_lock_killable(&rtnl_mutex);
  79}
  80EXPORT_SYMBOL(rtnl_lock_killable);
  81
  82static struct sk_buff *defer_kfree_skb_list;
  83void rtnl_kfree_skbs(struct sk_buff *head, struct sk_buff *tail)
  84{
  85	if (head && tail) {
  86		tail->next = defer_kfree_skb_list;
  87		defer_kfree_skb_list = head;
  88	}
  89}
  90EXPORT_SYMBOL(rtnl_kfree_skbs);
  91
  92void __rtnl_unlock(void)
  93{
  94	struct sk_buff *head = defer_kfree_skb_list;
  95
  96	defer_kfree_skb_list = NULL;
  97
  98	mutex_unlock(&rtnl_mutex);
  99
 100	while (head) {
 101		struct sk_buff *next = head->next;
 102
 103		kfree_skb(head);
 104		cond_resched();
 105		head = next;
 106	}
 107}
 108
 109void rtnl_unlock(void)
 110{
 111	/* This fellow will unlock it for us. */
 112	netdev_run_todo();
 113}
 114EXPORT_SYMBOL(rtnl_unlock);
 115
 116int rtnl_trylock(void)
 117{
 118	return mutex_trylock(&rtnl_mutex);
 119}
 120EXPORT_SYMBOL(rtnl_trylock);
 121
 122int rtnl_is_locked(void)
 123{
 124	return mutex_is_locked(&rtnl_mutex);
 125}
 126EXPORT_SYMBOL(rtnl_is_locked);
 127
 128bool refcount_dec_and_rtnl_lock(refcount_t *r)
 129{
 130	return refcount_dec_and_mutex_lock(r, &rtnl_mutex);
 131}
 132EXPORT_SYMBOL(refcount_dec_and_rtnl_lock);
 133
 134#ifdef CONFIG_PROVE_LOCKING
 135bool lockdep_rtnl_is_held(void)
 136{
 137	return lockdep_is_held(&rtnl_mutex);
 138}
 139EXPORT_SYMBOL(lockdep_rtnl_is_held);
 140#endif /* #ifdef CONFIG_PROVE_LOCKING */
 141
 142static struct rtnl_link *__rcu *rtnl_msg_handlers[RTNL_FAMILY_MAX + 1];
 143
 144static inline int rtm_msgindex(int msgtype)
 145{
 146	int msgindex = msgtype - RTM_BASE;
 147
 148	/*
 149	 * msgindex < 0 implies someone tried to register a netlink
 150	 * control code. msgindex >= RTM_NR_MSGTYPES may indicate that
 151	 * the message type has not been added to linux/rtnetlink.h
 152	 */
 153	BUG_ON(msgindex < 0 || msgindex >= RTM_NR_MSGTYPES);
 154
 155	return msgindex;
 156}
 157
 158static struct rtnl_link *rtnl_get_link(int protocol, int msgtype)
 159{
 160	struct rtnl_link **tab;
 161
 162	if (protocol >= ARRAY_SIZE(rtnl_msg_handlers))
 163		protocol = PF_UNSPEC;
 164
 165	tab = rcu_dereference_rtnl(rtnl_msg_handlers[protocol]);
 166	if (!tab)
 167		tab = rcu_dereference_rtnl(rtnl_msg_handlers[PF_UNSPEC]);
 168
 169	return tab[msgtype];
 170}
 171
 172static int rtnl_register_internal(struct module *owner,
 173				  int protocol, int msgtype,
 174				  rtnl_doit_func doit, rtnl_dumpit_func dumpit,
 175				  unsigned int flags)
 176{
 177	struct rtnl_link *link, *old;
 178	struct rtnl_link __rcu **tab;
 179	int msgindex;
 180	int ret = -ENOBUFS;
 181
 182	BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
 183	msgindex = rtm_msgindex(msgtype);
 184
 185	rtnl_lock();
 186	tab = rtnl_msg_handlers[protocol];
 187	if (tab == NULL) {
 188		tab = kcalloc(RTM_NR_MSGTYPES, sizeof(void *), GFP_KERNEL);
 189		if (!tab)
 190			goto unlock;
 191
 192		/* ensures we see the 0 stores */
 193		rcu_assign_pointer(rtnl_msg_handlers[protocol], tab);
 194	}
 195
 196	old = rtnl_dereference(tab[msgindex]);
 197	if (old) {
 198		link = kmemdup(old, sizeof(*old), GFP_KERNEL);
 199		if (!link)
 200			goto unlock;
 201	} else {
 202		link = kzalloc(sizeof(*link), GFP_KERNEL);
 203		if (!link)
 204			goto unlock;
 205	}
 206
 207	WARN_ON(link->owner && link->owner != owner);
 208	link->owner = owner;
 209
 210	WARN_ON(doit && link->doit && link->doit != doit);
 211	if (doit)
 212		link->doit = doit;
 213	WARN_ON(dumpit && link->dumpit && link->dumpit != dumpit);
 214	if (dumpit)
 215		link->dumpit = dumpit;
 216
 217	link->flags |= flags;
 218
 219	/* publish protocol:msgtype */
 220	rcu_assign_pointer(tab[msgindex], link);
 221	ret = 0;
 222	if (old)
 223		kfree_rcu(old, rcu);
 224unlock:
 225	rtnl_unlock();
 226	return ret;
 227}
 228
 229/**
 230 * rtnl_register_module - Register a rtnetlink message type
 231 *
 232 * @owner: module registering the hook (THIS_MODULE)
 233 * @protocol: Protocol family or PF_UNSPEC
 234 * @msgtype: rtnetlink message type
 235 * @doit: Function pointer called for each request message
 236 * @dumpit: Function pointer called for each dump request (NLM_F_DUMP) message
 237 * @flags: rtnl_link_flags to modifiy behaviour of doit/dumpit functions
 238 *
 239 * Like rtnl_register, but for use by removable modules.
 240 */
 241int rtnl_register_module(struct module *owner,
 242			 int protocol, int msgtype,
 243			 rtnl_doit_func doit, rtnl_dumpit_func dumpit,
 244			 unsigned int flags)
 245{
 246	return rtnl_register_internal(owner, protocol, msgtype,
 247				      doit, dumpit, flags);
 248}
 249EXPORT_SYMBOL_GPL(rtnl_register_module);
 250
 251/**
 252 * rtnl_register - Register a rtnetlink message type
 253 * @protocol: Protocol family or PF_UNSPEC
 254 * @msgtype: rtnetlink message type
 255 * @doit: Function pointer called for each request message
 256 * @dumpit: Function pointer called for each dump request (NLM_F_DUMP) message
 257 * @flags: rtnl_link_flags to modifiy behaviour of doit/dumpit functions
 258 *
 259 * Registers the specified function pointers (at least one of them has
 260 * to be non-NULL) to be called whenever a request message for the
 261 * specified protocol family and message type is received.
 262 *
 263 * The special protocol family PF_UNSPEC may be used to define fallback
 264 * function pointers for the case when no entry for the specific protocol
 265 * family exists.
 266 */
 267void rtnl_register(int protocol, int msgtype,
 268		   rtnl_doit_func doit, rtnl_dumpit_func dumpit,
 269		   unsigned int flags)
 270{
 271	int err;
 272
 273	err = rtnl_register_internal(NULL, protocol, msgtype, doit, dumpit,
 274				     flags);
 275	if (err)
 276		pr_err("Unable to register rtnetlink message handler, "
 277		       "protocol = %d, message type = %d\n", protocol, msgtype);
 278}
 279
 280/**
 281 * rtnl_unregister - Unregister a rtnetlink message type
 282 * @protocol: Protocol family or PF_UNSPEC
 283 * @msgtype: rtnetlink message type
 284 *
 285 * Returns 0 on success or a negative error code.
 286 */
 287int rtnl_unregister(int protocol, int msgtype)
 288{
 289	struct rtnl_link **tab, *link;
 290	int msgindex;
 291
 292	BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
 293	msgindex = rtm_msgindex(msgtype);
 294
 295	rtnl_lock();
 296	tab = rtnl_dereference(rtnl_msg_handlers[protocol]);
 297	if (!tab) {
 298		rtnl_unlock();
 299		return -ENOENT;
 300	}
 301
 302	link = tab[msgindex];
 303	rcu_assign_pointer(tab[msgindex], NULL);
 304	rtnl_unlock();
 305
 306	kfree_rcu(link, rcu);
 307
 308	return 0;
 309}
 310EXPORT_SYMBOL_GPL(rtnl_unregister);
 311
 312/**
 313 * rtnl_unregister_all - Unregister all rtnetlink message type of a protocol
 314 * @protocol : Protocol family or PF_UNSPEC
 315 *
 316 * Identical to calling rtnl_unregster() for all registered message types
 317 * of a certain protocol family.
 318 */
 319void rtnl_unregister_all(int protocol)
 320{
 321	struct rtnl_link **tab, *link;
 322	int msgindex;
 323
 324	BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
 325
 326	rtnl_lock();
 327	tab = rtnl_msg_handlers[protocol];
 328	if (!tab) {
 329		rtnl_unlock();
 330		return;
 331	}
 332	RCU_INIT_POINTER(rtnl_msg_handlers[protocol], NULL);
 333	for (msgindex = 0; msgindex < RTM_NR_MSGTYPES; msgindex++) {
 334		link = tab[msgindex];
 335		if (!link)
 336			continue;
 337
 338		rcu_assign_pointer(tab[msgindex], NULL);
 339		kfree_rcu(link, rcu);
 340	}
 341	rtnl_unlock();
 342
 343	synchronize_net();
 344
 345	kfree(tab);
 346}
 347EXPORT_SYMBOL_GPL(rtnl_unregister_all);
 348
 349static LIST_HEAD(link_ops);
 350
 351static const struct rtnl_link_ops *rtnl_link_ops_get(const char *kind)
 352{
 353	const struct rtnl_link_ops *ops;
 354
 355	list_for_each_entry(ops, &link_ops, list) {
 356		if (!strcmp(ops->kind, kind))
 357			return ops;
 358	}
 359	return NULL;
 360}
 361
 362/**
 363 * __rtnl_link_register - Register rtnl_link_ops with rtnetlink.
 364 * @ops: struct rtnl_link_ops * to register
 365 *
 366 * The caller must hold the rtnl_mutex. This function should be used
 367 * by drivers that create devices during module initialization. It
 368 * must be called before registering the devices.
 369 *
 370 * Returns 0 on success or a negative error code.
 371 */
 372int __rtnl_link_register(struct rtnl_link_ops *ops)
 373{
 374	if (rtnl_link_ops_get(ops->kind))
 375		return -EEXIST;
 376
 377	/* The check for setup is here because if ops
 378	 * does not have that filled up, it is not possible
 379	 * to use the ops for creating device. So do not
 380	 * fill up dellink as well. That disables rtnl_dellink.
 381	 */
 382	if (ops->setup && !ops->dellink)
 383		ops->dellink = unregister_netdevice_queue;
 384
 385	list_add_tail(&ops->list, &link_ops);
 386	return 0;
 387}
 388EXPORT_SYMBOL_GPL(__rtnl_link_register);
 389
 390/**
 391 * rtnl_link_register - Register rtnl_link_ops with rtnetlink.
 392 * @ops: struct rtnl_link_ops * to register
 393 *
 394 * Returns 0 on success or a negative error code.
 395 */
 396int rtnl_link_register(struct rtnl_link_ops *ops)
 397{
 398	int err;
 399
 400	/* Sanity-check max sizes to avoid stack buffer overflow. */
 401	if (WARN_ON(ops->maxtype > RTNL_MAX_TYPE ||
 402		    ops->slave_maxtype > RTNL_SLAVE_MAX_TYPE))
 403		return -EINVAL;
 404
 405	rtnl_lock();
 406	err = __rtnl_link_register(ops);
 407	rtnl_unlock();
 408	return err;
 409}
 410EXPORT_SYMBOL_GPL(rtnl_link_register);
 411
 412static void __rtnl_kill_links(struct net *net, struct rtnl_link_ops *ops)
 413{
 414	struct net_device *dev;
 415	LIST_HEAD(list_kill);
 416
 417	for_each_netdev(net, dev) {
 418		if (dev->rtnl_link_ops == ops)
 419			ops->dellink(dev, &list_kill);
 420	}
 421	unregister_netdevice_many(&list_kill);
 422}
 423
 424/**
 425 * __rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink.
 426 * @ops: struct rtnl_link_ops * to unregister
 427 *
 428 * The caller must hold the rtnl_mutex and guarantee net_namespace_list
 429 * integrity (hold pernet_ops_rwsem for writing to close the race
 430 * with setup_net() and cleanup_net()).
 431 */
 432void __rtnl_link_unregister(struct rtnl_link_ops *ops)
 433{
 434	struct net *net;
 435
 436	for_each_net(net) {
 437		__rtnl_kill_links(net, ops);
 438	}
 439	list_del(&ops->list);
 440}
 441EXPORT_SYMBOL_GPL(__rtnl_link_unregister);
 442
 443/* Return with the rtnl_lock held when there are no network
 444 * devices unregistering in any network namespace.
 445 */
 446static void rtnl_lock_unregistering_all(void)
 447{
 448	struct net *net;
 449	bool unregistering;
 450	DEFINE_WAIT_FUNC(wait, woken_wake_function);
 451
 452	add_wait_queue(&netdev_unregistering_wq, &wait);
 453	for (;;) {
 454		unregistering = false;
 455		rtnl_lock();
 456		/* We held write locked pernet_ops_rwsem, and parallel
 457		 * setup_net() and cleanup_net() are not possible.
 458		 */
 459		for_each_net(net) {
 460			if (net->dev_unreg_count > 0) {
 461				unregistering = true;
 462				break;
 463			}
 464		}
 465		if (!unregistering)
 466			break;
 467		__rtnl_unlock();
 468
 469		wait_woken(&wait, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
 470	}
 471	remove_wait_queue(&netdev_unregistering_wq, &wait);
 472}
 473
 474/**
 475 * rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink.
 476 * @ops: struct rtnl_link_ops * to unregister
 477 */
 478void rtnl_link_unregister(struct rtnl_link_ops *ops)
 479{
 480	/* Close the race with setup_net() and cleanup_net() */
 481	down_write(&pernet_ops_rwsem);
 482	rtnl_lock_unregistering_all();
 483	__rtnl_link_unregister(ops);
 484	rtnl_unlock();
 485	up_write(&pernet_ops_rwsem);
 486}
 487EXPORT_SYMBOL_GPL(rtnl_link_unregister);
 488
 489static size_t rtnl_link_get_slave_info_data_size(const struct net_device *dev)
 490{
 491	struct net_device *master_dev;
 492	const struct rtnl_link_ops *ops;
 493	size_t size = 0;
 494
 495	rcu_read_lock();
 496
 497	master_dev = netdev_master_upper_dev_get_rcu((struct net_device *)dev);
 498	if (!master_dev)
 499		goto out;
 500
 501	ops = master_dev->rtnl_link_ops;
 502	if (!ops || !ops->get_slave_size)
 503		goto out;
 504	/* IFLA_INFO_SLAVE_DATA + nested data */
 505	size = nla_total_size(sizeof(struct nlattr)) +
 506	       ops->get_slave_size(master_dev, dev);
 507
 508out:
 509	rcu_read_unlock();
 510	return size;
 511}
 512
 513static size_t rtnl_link_get_size(const struct net_device *dev)
 514{
 515	const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
 516	size_t size;
 517
 518	if (!ops)
 519		return 0;
 520
 521	size = nla_total_size(sizeof(struct nlattr)) + /* IFLA_LINKINFO */
 522	       nla_total_size(strlen(ops->kind) + 1);  /* IFLA_INFO_KIND */
 523
 524	if (ops->get_size)
 525		/* IFLA_INFO_DATA + nested data */
 526		size += nla_total_size(sizeof(struct nlattr)) +
 527			ops->get_size(dev);
 528
 529	if (ops->get_xstats_size)
 530		/* IFLA_INFO_XSTATS */
 531		size += nla_total_size(ops->get_xstats_size(dev));
 532
 533	size += rtnl_link_get_slave_info_data_size(dev);
 534
 535	return size;
 536}
 537
 538static LIST_HEAD(rtnl_af_ops);
 539
 540static const struct rtnl_af_ops *rtnl_af_lookup(const int family)
 541{
 542	const struct rtnl_af_ops *ops;
 543
 544	list_for_each_entry_rcu(ops, &rtnl_af_ops, list) {
 545		if (ops->family == family)
 546			return ops;
 547	}
 548
 549	return NULL;
 550}
 551
 552/**
 553 * rtnl_af_register - Register rtnl_af_ops with rtnetlink.
 554 * @ops: struct rtnl_af_ops * to register
 555 *
 556 * Returns 0 on success or a negative error code.
 557 */
 558void rtnl_af_register(struct rtnl_af_ops *ops)
 559{
 560	rtnl_lock();
 561	list_add_tail_rcu(&ops->list, &rtnl_af_ops);
 562	rtnl_unlock();
 563}
 564EXPORT_SYMBOL_GPL(rtnl_af_register);
 565
 566/**
 567 * rtnl_af_unregister - Unregister rtnl_af_ops from rtnetlink.
 568 * @ops: struct rtnl_af_ops * to unregister
 569 */
 570void rtnl_af_unregister(struct rtnl_af_ops *ops)
 571{
 572	rtnl_lock();
 573	list_del_rcu(&ops->list);
 574	rtnl_unlock();
 575
 576	synchronize_rcu();
 577}
 578EXPORT_SYMBOL_GPL(rtnl_af_unregister);
 579
 580static size_t rtnl_link_get_af_size(const struct net_device *dev,
 581				    u32 ext_filter_mask)
 582{
 583	struct rtnl_af_ops *af_ops;
 584	size_t size;
 585
 586	/* IFLA_AF_SPEC */
 587	size = nla_total_size(sizeof(struct nlattr));
 588
 589	rcu_read_lock();
 590	list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
 591		if (af_ops->get_link_af_size) {
 592			/* AF_* + nested data */
 593			size += nla_total_size(sizeof(struct nlattr)) +
 594				af_ops->get_link_af_size(dev, ext_filter_mask);
 595		}
 596	}
 597	rcu_read_unlock();
 598
 599	return size;
 600}
 601
 602static bool rtnl_have_link_slave_info(const struct net_device *dev)
 603{
 604	struct net_device *master_dev;
 605	bool ret = false;
 606
 607	rcu_read_lock();
 608
 609	master_dev = netdev_master_upper_dev_get_rcu((struct net_device *)dev);
 610	if (master_dev && master_dev->rtnl_link_ops)
 611		ret = true;
 612	rcu_read_unlock();
 613	return ret;
 614}
 615
 616static int rtnl_link_slave_info_fill(struct sk_buff *skb,
 617				     const struct net_device *dev)
 618{
 619	struct net_device *master_dev;
 620	const struct rtnl_link_ops *ops;
 621	struct nlattr *slave_data;
 622	int err;
 623
 624	master_dev = netdev_master_upper_dev_get((struct net_device *) dev);
 625	if (!master_dev)
 626		return 0;
 627	ops = master_dev->rtnl_link_ops;
 628	if (!ops)
 629		return 0;
 630	if (nla_put_string(skb, IFLA_INFO_SLAVE_KIND, ops->kind) < 0)
 631		return -EMSGSIZE;
 632	if (ops->fill_slave_info) {
 633		slave_data = nla_nest_start_noflag(skb, IFLA_INFO_SLAVE_DATA);
 634		if (!slave_data)
 635			return -EMSGSIZE;
 636		err = ops->fill_slave_info(skb, master_dev, dev);
 637		if (err < 0)
 638			goto err_cancel_slave_data;
 639		nla_nest_end(skb, slave_data);
 640	}
 641	return 0;
 642
 643err_cancel_slave_data:
 644	nla_nest_cancel(skb, slave_data);
 645	return err;
 646}
 647
 648static int rtnl_link_info_fill(struct sk_buff *skb,
 649			       const struct net_device *dev)
 650{
 651	const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
 652	struct nlattr *data;
 653	int err;
 654
 655	if (!ops)
 656		return 0;
 657	if (nla_put_string(skb, IFLA_INFO_KIND, ops->kind) < 0)
 658		return -EMSGSIZE;
 659	if (ops->fill_xstats) {
 660		err = ops->fill_xstats(skb, dev);
 661		if (err < 0)
 662			return err;
 663	}
 664	if (ops->fill_info) {
 665		data = nla_nest_start_noflag(skb, IFLA_INFO_DATA);
 666		if (data == NULL)
 667			return -EMSGSIZE;
 668		err = ops->fill_info(skb, dev);
 669		if (err < 0)
 670			goto err_cancel_data;
 671		nla_nest_end(skb, data);
 672	}
 673	return 0;
 674
 675err_cancel_data:
 676	nla_nest_cancel(skb, data);
 677	return err;
 678}
 679
 680static int rtnl_link_fill(struct sk_buff *skb, const struct net_device *dev)
 681{
 682	struct nlattr *linkinfo;
 683	int err = -EMSGSIZE;
 684
 685	linkinfo = nla_nest_start_noflag(skb, IFLA_LINKINFO);
 686	if (linkinfo == NULL)
 687		goto out;
 688
 689	err = rtnl_link_info_fill(skb, dev);
 690	if (err < 0)
 691		goto err_cancel_link;
 692
 693	err = rtnl_link_slave_info_fill(skb, dev);
 694	if (err < 0)
 695		goto err_cancel_link;
 696
 697	nla_nest_end(skb, linkinfo);
 698	return 0;
 699
 700err_cancel_link:
 701	nla_nest_cancel(skb, linkinfo);
 702out:
 703	return err;
 704}
 705
 706int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigned int group, int echo)
 707{
 708	struct sock *rtnl = net->rtnl;
 709	int err = 0;
 710
 711	NETLINK_CB(skb).dst_group = group;
 712	if (echo)
 713		refcount_inc(&skb->users);
 714	netlink_broadcast(rtnl, skb, pid, group, GFP_KERNEL);
 715	if (echo)
 716		err = netlink_unicast(rtnl, skb, pid, MSG_DONTWAIT);
 717	return err;
 718}
 719
 720int rtnl_unicast(struct sk_buff *skb, struct net *net, u32 pid)
 721{
 722	struct sock *rtnl = net->rtnl;
 723
 724	return nlmsg_unicast(rtnl, skb, pid);
 725}
 726EXPORT_SYMBOL(rtnl_unicast);
 727
 728void rtnl_notify(struct sk_buff *skb, struct net *net, u32 pid, u32 group,
 729		 struct nlmsghdr *nlh, gfp_t flags)
 730{
 731	struct sock *rtnl = net->rtnl;
 732	int report = 0;
 733
 734	if (nlh)
 735		report = nlmsg_report(nlh);
 736
 737	nlmsg_notify(rtnl, skb, pid, group, report, flags);
 738}
 739EXPORT_SYMBOL(rtnl_notify);
 740
 741void rtnl_set_sk_err(struct net *net, u32 group, int error)
 742{
 743	struct sock *rtnl = net->rtnl;
 744
 745	netlink_set_err(rtnl, 0, group, error);
 746}
 747EXPORT_SYMBOL(rtnl_set_sk_err);
 748
 749int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics)
 750{
 751	struct nlattr *mx;
 752	int i, valid = 0;
 753
 754	/* nothing is dumped for dst_default_metrics, so just skip the loop */
 755	if (metrics == dst_default_metrics.metrics)
 756		return 0;
 757
 758	mx = nla_nest_start_noflag(skb, RTA_METRICS);
 759	if (mx == NULL)
 760		return -ENOBUFS;
 761
 762	for (i = 0; i < RTAX_MAX; i++) {
 763		if (metrics[i]) {
 764			if (i == RTAX_CC_ALGO - 1) {
 765				char tmp[TCP_CA_NAME_MAX], *name;
 766
 767				name = tcp_ca_get_name_by_key(metrics[i], tmp);
 768				if (!name)
 769					continue;
 770				if (nla_put_string(skb, i + 1, name))
 771					goto nla_put_failure;
 772			} else if (i == RTAX_FEATURES - 1) {
 773				u32 user_features = metrics[i] & RTAX_FEATURE_MASK;
 774
 775				if (!user_features)
 776					continue;
 777				BUILD_BUG_ON(RTAX_FEATURE_MASK & DST_FEATURE_MASK);
 778				if (nla_put_u32(skb, i + 1, user_features))
 779					goto nla_put_failure;
 780			} else {
 781				if (nla_put_u32(skb, i + 1, metrics[i]))
 782					goto nla_put_failure;
 783			}
 784			valid++;
 785		}
 786	}
 787
 788	if (!valid) {
 789		nla_nest_cancel(skb, mx);
 790		return 0;
 791	}
 792
 793	return nla_nest_end(skb, mx);
 794
 795nla_put_failure:
 796	nla_nest_cancel(skb, mx);
 797	return -EMSGSIZE;
 798}
 799EXPORT_SYMBOL(rtnetlink_put_metrics);
 800
 801int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id,
 802		       long expires, u32 error)
 803{
 804	struct rta_cacheinfo ci = {
 
 
 
 805		.rta_error = error,
 806		.rta_id =  id,
 807	};
 808
 809	if (dst) {
 810		ci.rta_lastuse = jiffies_delta_to_clock_t(jiffies - dst->lastuse);
 811		ci.rta_used = dst->__use;
 812		ci.rta_clntref = atomic_read(&dst->__refcnt);
 813	}
 814	if (expires) {
 815		unsigned long clock;
 816
 817		clock = jiffies_to_clock_t(abs(expires));
 818		clock = min_t(unsigned long, clock, INT_MAX);
 819		ci.rta_expires = (expires > 0) ? clock : -clock;
 820	}
 821	return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci);
 822}
 823EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo);
 824
 825static void set_operstate(struct net_device *dev, unsigned char transition)
 826{
 827	unsigned char operstate = dev->operstate;
 828
 829	switch (transition) {
 830	case IF_OPER_UP:
 831		if ((operstate == IF_OPER_DORMANT ||
 832		     operstate == IF_OPER_TESTING ||
 833		     operstate == IF_OPER_UNKNOWN) &&
 834		    !netif_dormant(dev) && !netif_testing(dev))
 835			operstate = IF_OPER_UP;
 836		break;
 837
 838	case IF_OPER_TESTING:
 839		if (operstate == IF_OPER_UP ||
 840		    operstate == IF_OPER_UNKNOWN)
 841			operstate = IF_OPER_TESTING;
 842		break;
 843
 844	case IF_OPER_DORMANT:
 845		if (operstate == IF_OPER_UP ||
 846		    operstate == IF_OPER_UNKNOWN)
 847			operstate = IF_OPER_DORMANT;
 848		break;
 849	}
 850
 851	if (dev->operstate != operstate) {
 852		write_lock_bh(&dev_base_lock);
 853		dev->operstate = operstate;
 854		write_unlock_bh(&dev_base_lock);
 855		netdev_state_change(dev);
 856	}
 857}
 858
 859static unsigned int rtnl_dev_get_flags(const struct net_device *dev)
 860{
 861	return (dev->flags & ~(IFF_PROMISC | IFF_ALLMULTI)) |
 862	       (dev->gflags & (IFF_PROMISC | IFF_ALLMULTI));
 863}
 864
 865static unsigned int rtnl_dev_combine_flags(const struct net_device *dev,
 866					   const struct ifinfomsg *ifm)
 867{
 868	unsigned int flags = ifm->ifi_flags;
 869
 870	/* bugwards compatibility: ifi_change == 0 is treated as ~0 */
 871	if (ifm->ifi_change)
 872		flags = (flags & ifm->ifi_change) |
 873			(rtnl_dev_get_flags(dev) & ~ifm->ifi_change);
 874
 875	return flags;
 876}
 877
 878static void copy_rtnl_link_stats(struct rtnl_link_stats *a,
 879				 const struct rtnl_link_stats64 *b)
 880{
 881	a->rx_packets = b->rx_packets;
 882	a->tx_packets = b->tx_packets;
 883	a->rx_bytes = b->rx_bytes;
 884	a->tx_bytes = b->tx_bytes;
 885	a->rx_errors = b->rx_errors;
 886	a->tx_errors = b->tx_errors;
 887	a->rx_dropped = b->rx_dropped;
 888	a->tx_dropped = b->tx_dropped;
 889
 890	a->multicast = b->multicast;
 891	a->collisions = b->collisions;
 892
 893	a->rx_length_errors = b->rx_length_errors;
 894	a->rx_over_errors = b->rx_over_errors;
 895	a->rx_crc_errors = b->rx_crc_errors;
 896	a->rx_frame_errors = b->rx_frame_errors;
 897	a->rx_fifo_errors = b->rx_fifo_errors;
 898	a->rx_missed_errors = b->rx_missed_errors;
 899
 900	a->tx_aborted_errors = b->tx_aborted_errors;
 901	a->tx_carrier_errors = b->tx_carrier_errors;
 902	a->tx_fifo_errors = b->tx_fifo_errors;
 903	a->tx_heartbeat_errors = b->tx_heartbeat_errors;
 904	a->tx_window_errors = b->tx_window_errors;
 905
 906	a->rx_compressed = b->rx_compressed;
 907	a->tx_compressed = b->tx_compressed;
 908
 909	a->rx_nohandler = b->rx_nohandler;
 910}
 911
 912/* All VF info */
 913static inline int rtnl_vfinfo_size(const struct net_device *dev,
 914				   u32 ext_filter_mask)
 915{
 916	if (dev->dev.parent && (ext_filter_mask & RTEXT_FILTER_VF)) {
 917		int num_vfs = dev_num_vf(dev->dev.parent);
 918		size_t size = nla_total_size(0);
 919		size += num_vfs *
 920			(nla_total_size(0) +
 921			 nla_total_size(sizeof(struct ifla_vf_mac)) +
 922			 nla_total_size(sizeof(struct ifla_vf_broadcast)) +
 923			 nla_total_size(sizeof(struct ifla_vf_vlan)) +
 924			 nla_total_size(0) + /* nest IFLA_VF_VLAN_LIST */
 925			 nla_total_size(MAX_VLAN_LIST_LEN *
 926					sizeof(struct ifla_vf_vlan_info)) +
 927			 nla_total_size(sizeof(struct ifla_vf_spoofchk)) +
 928			 nla_total_size(sizeof(struct ifla_vf_tx_rate)) +
 929			 nla_total_size(sizeof(struct ifla_vf_rate)) +
 930			 nla_total_size(sizeof(struct ifla_vf_link_state)) +
 931			 nla_total_size(sizeof(struct ifla_vf_rss_query_en)) +
 932			 nla_total_size(0) + /* nest IFLA_VF_STATS */
 933			 /* IFLA_VF_STATS_RX_PACKETS */
 934			 nla_total_size_64bit(sizeof(__u64)) +
 935			 /* IFLA_VF_STATS_TX_PACKETS */
 936			 nla_total_size_64bit(sizeof(__u64)) +
 937			 /* IFLA_VF_STATS_RX_BYTES */
 938			 nla_total_size_64bit(sizeof(__u64)) +
 939			 /* IFLA_VF_STATS_TX_BYTES */
 940			 nla_total_size_64bit(sizeof(__u64)) +
 941			 /* IFLA_VF_STATS_BROADCAST */
 942			 nla_total_size_64bit(sizeof(__u64)) +
 943			 /* IFLA_VF_STATS_MULTICAST */
 944			 nla_total_size_64bit(sizeof(__u64)) +
 945			 /* IFLA_VF_STATS_RX_DROPPED */
 946			 nla_total_size_64bit(sizeof(__u64)) +
 947			 /* IFLA_VF_STATS_TX_DROPPED */
 948			 nla_total_size_64bit(sizeof(__u64)) +
 949			 nla_total_size(sizeof(struct ifla_vf_trust)));
 950		return size;
 951	} else
 952		return 0;
 953}
 954
 955static size_t rtnl_port_size(const struct net_device *dev,
 956			     u32 ext_filter_mask)
 957{
 958	size_t port_size = nla_total_size(4)		/* PORT_VF */
 959		+ nla_total_size(PORT_PROFILE_MAX)	/* PORT_PROFILE */
 960		+ nla_total_size(PORT_UUID_MAX)		/* PORT_INSTANCE_UUID */
 961		+ nla_total_size(PORT_UUID_MAX)		/* PORT_HOST_UUID */
 962		+ nla_total_size(1)			/* PROT_VDP_REQUEST */
 963		+ nla_total_size(2);			/* PORT_VDP_RESPONSE */
 964	size_t vf_ports_size = nla_total_size(sizeof(struct nlattr));
 965	size_t vf_port_size = nla_total_size(sizeof(struct nlattr))
 966		+ port_size;
 967	size_t port_self_size = nla_total_size(sizeof(struct nlattr))
 968		+ port_size;
 969
 970	if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
 971	    !(ext_filter_mask & RTEXT_FILTER_VF))
 972		return 0;
 973	if (dev_num_vf(dev->dev.parent))
 974		return port_self_size + vf_ports_size +
 975			vf_port_size * dev_num_vf(dev->dev.parent);
 976	else
 977		return port_self_size;
 978}
 979
 980static size_t rtnl_xdp_size(void)
 981{
 982	size_t xdp_size = nla_total_size(0) +	/* nest IFLA_XDP */
 983			  nla_total_size(1) +	/* XDP_ATTACHED */
 984			  nla_total_size(4) +	/* XDP_PROG_ID (or 1st mode) */
 985			  nla_total_size(4);	/* XDP_<mode>_PROG_ID */
 986
 987	return xdp_size;
 988}
 989
 990static size_t rtnl_prop_list_size(const struct net_device *dev)
 991{
 992	struct netdev_name_node *name_node;
 993	size_t size;
 994
 995	if (list_empty(&dev->name_node->list))
 996		return 0;
 997	size = nla_total_size(0);
 998	list_for_each_entry(name_node, &dev->name_node->list, list)
 999		size += nla_total_size(ALTIFNAMSIZ);
1000	return size;
1001}
1002
1003static size_t rtnl_proto_down_size(const struct net_device *dev)
1004{
1005	size_t size = nla_total_size(1);
1006
1007	if (dev->proto_down_reason)
1008		size += nla_total_size(0) + nla_total_size(4);
1009
1010	return size;
1011}
1012
1013static noinline size_t if_nlmsg_size(const struct net_device *dev,
1014				     u32 ext_filter_mask)
1015{
1016	return NLMSG_ALIGN(sizeof(struct ifinfomsg))
1017	       + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
1018	       + nla_total_size(IFALIASZ) /* IFLA_IFALIAS */
1019	       + nla_total_size(IFNAMSIZ) /* IFLA_QDISC */
1020	       + nla_total_size_64bit(sizeof(struct rtnl_link_ifmap))
1021	       + nla_total_size(sizeof(struct rtnl_link_stats))
1022	       + nla_total_size_64bit(sizeof(struct rtnl_link_stats64))
1023	       + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
1024	       + nla_total_size(MAX_ADDR_LEN) /* IFLA_BROADCAST */
1025	       + nla_total_size(4) /* IFLA_TXQLEN */
1026	       + nla_total_size(4) /* IFLA_WEIGHT */
1027	       + nla_total_size(4) /* IFLA_MTU */
1028	       + nla_total_size(4) /* IFLA_LINK */
1029	       + nla_total_size(4) /* IFLA_MASTER */
1030	       + nla_total_size(1) /* IFLA_CARRIER */
1031	       + nla_total_size(4) /* IFLA_PROMISCUITY */
1032	       + nla_total_size(4) /* IFLA_NUM_TX_QUEUES */
1033	       + nla_total_size(4) /* IFLA_NUM_RX_QUEUES */
1034	       + nla_total_size(4) /* IFLA_GSO_MAX_SEGS */
1035	       + nla_total_size(4) /* IFLA_GSO_MAX_SIZE */
1036	       + nla_total_size(1) /* IFLA_OPERSTATE */
1037	       + nla_total_size(1) /* IFLA_LINKMODE */
1038	       + nla_total_size(4) /* IFLA_CARRIER_CHANGES */
1039	       + nla_total_size(4) /* IFLA_LINK_NETNSID */
1040	       + nla_total_size(4) /* IFLA_GROUP */
1041	       + nla_total_size(ext_filter_mask
1042			        & RTEXT_FILTER_VF ? 4 : 0) /* IFLA_NUM_VF */
1043	       + rtnl_vfinfo_size(dev, ext_filter_mask) /* IFLA_VFINFO_LIST */
1044	       + rtnl_port_size(dev, ext_filter_mask) /* IFLA_VF_PORTS + IFLA_PORT_SELF */
1045	       + rtnl_link_get_size(dev) /* IFLA_LINKINFO */
1046	       + rtnl_link_get_af_size(dev, ext_filter_mask) /* IFLA_AF_SPEC */
1047	       + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_PORT_ID */
1048	       + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_SWITCH_ID */
1049	       + nla_total_size(IFNAMSIZ) /* IFLA_PHYS_PORT_NAME */
1050	       + rtnl_xdp_size() /* IFLA_XDP */
1051	       + nla_total_size(4)  /* IFLA_EVENT */
1052	       + nla_total_size(4)  /* IFLA_NEW_NETNSID */
1053	       + nla_total_size(4)  /* IFLA_NEW_IFINDEX */
1054	       + rtnl_proto_down_size(dev)  /* proto down */
1055	       + nla_total_size(4)  /* IFLA_TARGET_NETNSID */
1056	       + nla_total_size(4)  /* IFLA_CARRIER_UP_COUNT */
1057	       + nla_total_size(4)  /* IFLA_CARRIER_DOWN_COUNT */
1058	       + nla_total_size(4)  /* IFLA_MIN_MTU */
1059	       + nla_total_size(4)  /* IFLA_MAX_MTU */
1060	       + rtnl_prop_list_size(dev)
1061	       + nla_total_size(MAX_ADDR_LEN) /* IFLA_PERM_ADDRESS */
1062	       + 0;
1063}
1064
1065static int rtnl_vf_ports_fill(struct sk_buff *skb, struct net_device *dev)
1066{
1067	struct nlattr *vf_ports;
1068	struct nlattr *vf_port;
1069	int vf;
1070	int err;
1071
1072	vf_ports = nla_nest_start_noflag(skb, IFLA_VF_PORTS);
1073	if (!vf_ports)
1074		return -EMSGSIZE;
1075
1076	for (vf = 0; vf < dev_num_vf(dev->dev.parent); vf++) {
1077		vf_port = nla_nest_start_noflag(skb, IFLA_VF_PORT);
1078		if (!vf_port)
1079			goto nla_put_failure;
1080		if (nla_put_u32(skb, IFLA_PORT_VF, vf))
1081			goto nla_put_failure;
1082		err = dev->netdev_ops->ndo_get_vf_port(dev, vf, skb);
1083		if (err == -EMSGSIZE)
1084			goto nla_put_failure;
1085		if (err) {
1086			nla_nest_cancel(skb, vf_port);
1087			continue;
1088		}
1089		nla_nest_end(skb, vf_port);
1090	}
1091
1092	nla_nest_end(skb, vf_ports);
1093
1094	return 0;
1095
1096nla_put_failure:
1097	nla_nest_cancel(skb, vf_ports);
1098	return -EMSGSIZE;
1099}
1100
1101static int rtnl_port_self_fill(struct sk_buff *skb, struct net_device *dev)
1102{
1103	struct nlattr *port_self;
1104	int err;
1105
1106	port_self = nla_nest_start_noflag(skb, IFLA_PORT_SELF);
1107	if (!port_self)
1108		return -EMSGSIZE;
1109
1110	err = dev->netdev_ops->ndo_get_vf_port(dev, PORT_SELF_VF, skb);
1111	if (err) {
1112		nla_nest_cancel(skb, port_self);
1113		return (err == -EMSGSIZE) ? err : 0;
1114	}
1115
1116	nla_nest_end(skb, port_self);
1117
1118	return 0;
1119}
1120
1121static int rtnl_port_fill(struct sk_buff *skb, struct net_device *dev,
1122			  u32 ext_filter_mask)
1123{
1124	int err;
1125
1126	if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
1127	    !(ext_filter_mask & RTEXT_FILTER_VF))
1128		return 0;
1129
1130	err = rtnl_port_self_fill(skb, dev);
1131	if (err)
1132		return err;
1133
1134	if (dev_num_vf(dev->dev.parent)) {
1135		err = rtnl_vf_ports_fill(skb, dev);
1136		if (err)
1137			return err;
1138	}
1139
1140	return 0;
1141}
1142
1143static int rtnl_phys_port_id_fill(struct sk_buff *skb, struct net_device *dev)
1144{
1145	int err;
1146	struct netdev_phys_item_id ppid;
1147
1148	err = dev_get_phys_port_id(dev, &ppid);
1149	if (err) {
1150		if (err == -EOPNOTSUPP)
1151			return 0;
1152		return err;
1153	}
1154
1155	if (nla_put(skb, IFLA_PHYS_PORT_ID, ppid.id_len, ppid.id))
1156		return -EMSGSIZE;
1157
1158	return 0;
1159}
1160
1161static int rtnl_phys_port_name_fill(struct sk_buff *skb, struct net_device *dev)
1162{
1163	char name[IFNAMSIZ];
1164	int err;
1165
1166	err = dev_get_phys_port_name(dev, name, sizeof(name));
1167	if (err) {
1168		if (err == -EOPNOTSUPP)
1169			return 0;
1170		return err;
1171	}
1172
1173	if (nla_put_string(skb, IFLA_PHYS_PORT_NAME, name))
1174		return -EMSGSIZE;
1175
1176	return 0;
1177}
1178
1179static int rtnl_phys_switch_id_fill(struct sk_buff *skb, struct net_device *dev)
1180{
1181	struct netdev_phys_item_id ppid = { };
1182	int err;
 
 
 
 
 
1183
1184	err = dev_get_port_parent_id(dev, &ppid, false);
1185	if (err) {
1186		if (err == -EOPNOTSUPP)
1187			return 0;
1188		return err;
1189	}
1190
1191	if (nla_put(skb, IFLA_PHYS_SWITCH_ID, ppid.id_len, ppid.id))
 
1192		return -EMSGSIZE;
1193
1194	return 0;
1195}
1196
1197static noinline_for_stack int rtnl_fill_stats(struct sk_buff *skb,
1198					      struct net_device *dev)
1199{
1200	struct rtnl_link_stats64 *sp;
1201	struct nlattr *attr;
1202
1203	attr = nla_reserve_64bit(skb, IFLA_STATS64,
1204				 sizeof(struct rtnl_link_stats64), IFLA_PAD);
1205	if (!attr)
1206		return -EMSGSIZE;
1207
1208	sp = nla_data(attr);
1209	dev_get_stats(dev, sp);
1210
1211	attr = nla_reserve(skb, IFLA_STATS,
1212			   sizeof(struct rtnl_link_stats));
1213	if (!attr)
1214		return -EMSGSIZE;
1215
1216	copy_rtnl_link_stats(nla_data(attr), sp);
1217
1218	return 0;
1219}
1220
1221static noinline_for_stack int rtnl_fill_vfinfo(struct sk_buff *skb,
1222					       struct net_device *dev,
1223					       int vfs_num,
1224					       struct nlattr *vfinfo)
1225{
1226	struct ifla_vf_rss_query_en vf_rss_query_en;
1227	struct nlattr *vf, *vfstats, *vfvlanlist;
1228	struct ifla_vf_link_state vf_linkstate;
1229	struct ifla_vf_vlan_info vf_vlan_info;
1230	struct ifla_vf_spoofchk vf_spoofchk;
1231	struct ifla_vf_tx_rate vf_tx_rate;
1232	struct ifla_vf_stats vf_stats;
1233	struct ifla_vf_trust vf_trust;
1234	struct ifla_vf_vlan vf_vlan;
1235	struct ifla_vf_rate vf_rate;
1236	struct ifla_vf_mac vf_mac;
1237	struct ifla_vf_broadcast vf_broadcast;
1238	struct ifla_vf_info ivi;
1239	struct ifla_vf_guid node_guid;
1240	struct ifla_vf_guid port_guid;
1241
1242	memset(&ivi, 0, sizeof(ivi));
1243
1244	/* Not all SR-IOV capable drivers support the
1245	 * spoofcheck and "RSS query enable" query.  Preset to
1246	 * -1 so the user space tool can detect that the driver
1247	 * didn't report anything.
1248	 */
1249	ivi.spoofchk = -1;
1250	ivi.rss_query_en = -1;
1251	ivi.trusted = -1;
1252	/* The default value for VF link state is "auto"
1253	 * IFLA_VF_LINK_STATE_AUTO which equals zero
1254	 */
1255	ivi.linkstate = 0;
1256	/* VLAN Protocol by default is 802.1Q */
1257	ivi.vlan_proto = htons(ETH_P_8021Q);
1258	if (dev->netdev_ops->ndo_get_vf_config(dev, vfs_num, &ivi))
1259		return 0;
1260
1261	memset(&vf_vlan_info, 0, sizeof(vf_vlan_info));
1262	memset(&node_guid, 0, sizeof(node_guid));
1263	memset(&port_guid, 0, sizeof(port_guid));
1264
1265	vf_mac.vf =
1266		vf_vlan.vf =
1267		vf_vlan_info.vf =
1268		vf_rate.vf =
1269		vf_tx_rate.vf =
1270		vf_spoofchk.vf =
1271		vf_linkstate.vf =
1272		vf_rss_query_en.vf =
1273		vf_trust.vf =
1274		node_guid.vf =
1275		port_guid.vf = ivi.vf;
1276
1277	memcpy(vf_mac.mac, ivi.mac, sizeof(ivi.mac));
1278	memcpy(vf_broadcast.broadcast, dev->broadcast, dev->addr_len);
1279	vf_vlan.vlan = ivi.vlan;
1280	vf_vlan.qos = ivi.qos;
1281	vf_vlan_info.vlan = ivi.vlan;
1282	vf_vlan_info.qos = ivi.qos;
1283	vf_vlan_info.vlan_proto = ivi.vlan_proto;
1284	vf_tx_rate.rate = ivi.max_tx_rate;
1285	vf_rate.min_tx_rate = ivi.min_tx_rate;
1286	vf_rate.max_tx_rate = ivi.max_tx_rate;
1287	vf_spoofchk.setting = ivi.spoofchk;
1288	vf_linkstate.link_state = ivi.linkstate;
1289	vf_rss_query_en.setting = ivi.rss_query_en;
1290	vf_trust.setting = ivi.trusted;
1291	vf = nla_nest_start_noflag(skb, IFLA_VF_INFO);
1292	if (!vf)
1293		goto nla_put_vfinfo_failure;
1294	if (nla_put(skb, IFLA_VF_MAC, sizeof(vf_mac), &vf_mac) ||
1295	    nla_put(skb, IFLA_VF_BROADCAST, sizeof(vf_broadcast), &vf_broadcast) ||
1296	    nla_put(skb, IFLA_VF_VLAN, sizeof(vf_vlan), &vf_vlan) ||
1297	    nla_put(skb, IFLA_VF_RATE, sizeof(vf_rate),
1298		    &vf_rate) ||
1299	    nla_put(skb, IFLA_VF_TX_RATE, sizeof(vf_tx_rate),
1300		    &vf_tx_rate) ||
1301	    nla_put(skb, IFLA_VF_SPOOFCHK, sizeof(vf_spoofchk),
1302		    &vf_spoofchk) ||
1303	    nla_put(skb, IFLA_VF_LINK_STATE, sizeof(vf_linkstate),
1304		    &vf_linkstate) ||
1305	    nla_put(skb, IFLA_VF_RSS_QUERY_EN,
1306		    sizeof(vf_rss_query_en),
1307		    &vf_rss_query_en) ||
1308	    nla_put(skb, IFLA_VF_TRUST,
1309		    sizeof(vf_trust), &vf_trust))
1310		goto nla_put_vf_failure;
1311
1312	if (dev->netdev_ops->ndo_get_vf_guid &&
1313	    !dev->netdev_ops->ndo_get_vf_guid(dev, vfs_num, &node_guid,
1314					      &port_guid)) {
1315		if (nla_put(skb, IFLA_VF_IB_NODE_GUID, sizeof(node_guid),
1316			    &node_guid) ||
1317		    nla_put(skb, IFLA_VF_IB_PORT_GUID, sizeof(port_guid),
1318			    &port_guid))
1319			goto nla_put_vf_failure;
1320	}
1321	vfvlanlist = nla_nest_start_noflag(skb, IFLA_VF_VLAN_LIST);
1322	if (!vfvlanlist)
1323		goto nla_put_vf_failure;
1324	if (nla_put(skb, IFLA_VF_VLAN_INFO, sizeof(vf_vlan_info),
1325		    &vf_vlan_info)) {
1326		nla_nest_cancel(skb, vfvlanlist);
1327		goto nla_put_vf_failure;
1328	}
1329	nla_nest_end(skb, vfvlanlist);
1330	memset(&vf_stats, 0, sizeof(vf_stats));
1331	if (dev->netdev_ops->ndo_get_vf_stats)
1332		dev->netdev_ops->ndo_get_vf_stats(dev, vfs_num,
1333						&vf_stats);
1334	vfstats = nla_nest_start_noflag(skb, IFLA_VF_STATS);
1335	if (!vfstats)
1336		goto nla_put_vf_failure;
1337	if (nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_PACKETS,
1338			      vf_stats.rx_packets, IFLA_VF_STATS_PAD) ||
1339	    nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS,
1340			      vf_stats.tx_packets, IFLA_VF_STATS_PAD) ||
1341	    nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES,
1342			      vf_stats.rx_bytes, IFLA_VF_STATS_PAD) ||
1343	    nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES,
1344			      vf_stats.tx_bytes, IFLA_VF_STATS_PAD) ||
1345	    nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST,
1346			      vf_stats.broadcast, IFLA_VF_STATS_PAD) ||
1347	    nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST,
1348			      vf_stats.multicast, IFLA_VF_STATS_PAD) ||
1349	    nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_DROPPED,
1350			      vf_stats.rx_dropped, IFLA_VF_STATS_PAD) ||
1351	    nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_DROPPED,
1352			      vf_stats.tx_dropped, IFLA_VF_STATS_PAD)) {
1353		nla_nest_cancel(skb, vfstats);
1354		goto nla_put_vf_failure;
1355	}
1356	nla_nest_end(skb, vfstats);
1357	nla_nest_end(skb, vf);
1358	return 0;
1359
1360nla_put_vf_failure:
1361	nla_nest_cancel(skb, vf);
1362nla_put_vfinfo_failure:
1363	nla_nest_cancel(skb, vfinfo);
1364	return -EMSGSIZE;
1365}
1366
1367static noinline_for_stack int rtnl_fill_vf(struct sk_buff *skb,
1368					   struct net_device *dev,
1369					   u32 ext_filter_mask)
1370{
1371	struct nlattr *vfinfo;
1372	int i, num_vfs;
1373
1374	if (!dev->dev.parent || ((ext_filter_mask & RTEXT_FILTER_VF) == 0))
1375		return 0;
1376
1377	num_vfs = dev_num_vf(dev->dev.parent);
1378	if (nla_put_u32(skb, IFLA_NUM_VF, num_vfs))
1379		return -EMSGSIZE;
1380
1381	if (!dev->netdev_ops->ndo_get_vf_config)
1382		return 0;
1383
1384	vfinfo = nla_nest_start_noflag(skb, IFLA_VFINFO_LIST);
1385	if (!vfinfo)
1386		return -EMSGSIZE;
1387
1388	for (i = 0; i < num_vfs; i++) {
1389		if (rtnl_fill_vfinfo(skb, dev, i, vfinfo))
1390			return -EMSGSIZE;
1391	}
1392
1393	nla_nest_end(skb, vfinfo);
1394	return 0;
1395}
1396
1397static int rtnl_fill_link_ifmap(struct sk_buff *skb, struct net_device *dev)
1398{
1399	struct rtnl_link_ifmap map;
1400
1401	memset(&map, 0, sizeof(map));
1402	map.mem_start   = dev->mem_start;
1403	map.mem_end     = dev->mem_end;
1404	map.base_addr   = dev->base_addr;
1405	map.irq         = dev->irq;
1406	map.dma         = dev->dma;
1407	map.port        = dev->if_port;
1408
1409	if (nla_put_64bit(skb, IFLA_MAP, sizeof(map), &map, IFLA_PAD))
1410		return -EMSGSIZE;
1411
1412	return 0;
1413}
1414
1415static u32 rtnl_xdp_prog_skb(struct net_device *dev)
1416{
 
1417	const struct bpf_prog *generic_xdp_prog;
 
1418
1419	ASSERT_RTNL();
1420
 
1421	generic_xdp_prog = rtnl_dereference(dev->xdp_prog);
1422	if (!generic_xdp_prog)
1423		return 0;
1424	return generic_xdp_prog->aux->id;
1425}
1426
1427static u32 rtnl_xdp_prog_drv(struct net_device *dev)
1428{
1429	return dev_xdp_prog_id(dev, XDP_MODE_DRV);
1430}
1431
1432static u32 rtnl_xdp_prog_hw(struct net_device *dev)
1433{
1434	return dev_xdp_prog_id(dev, XDP_MODE_HW);
1435}
1436
1437static int rtnl_xdp_report_one(struct sk_buff *skb, struct net_device *dev,
1438			       u32 *prog_id, u8 *mode, u8 tgt_mode, u32 attr,
1439			       u32 (*get_prog_id)(struct net_device *dev))
1440{
1441	u32 curr_id;
1442	int err;
1443
1444	curr_id = get_prog_id(dev);
1445	if (!curr_id)
1446		return 0;
1447
1448	*prog_id = curr_id;
1449	err = nla_put_u32(skb, attr, curr_id);
1450	if (err)
1451		return err;
1452
1453	if (*mode != XDP_ATTACHED_NONE)
1454		*mode = XDP_ATTACHED_MULTI;
1455	else
1456		*mode = tgt_mode;
1457
1458	return 0;
1459}
1460
1461static int rtnl_xdp_fill(struct sk_buff *skb, struct net_device *dev)
1462{
1463	struct nlattr *xdp;
1464	u32 prog_id;
1465	int err;
1466	u8 mode;
1467
1468	xdp = nla_nest_start_noflag(skb, IFLA_XDP);
1469	if (!xdp)
1470		return -EMSGSIZE;
1471
1472	prog_id = 0;
1473	mode = XDP_ATTACHED_NONE;
1474	err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_SKB,
1475				  IFLA_XDP_SKB_PROG_ID, rtnl_xdp_prog_skb);
1476	if (err)
1477		goto err_cancel;
1478	err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_DRV,
1479				  IFLA_XDP_DRV_PROG_ID, rtnl_xdp_prog_drv);
1480	if (err)
1481		goto err_cancel;
1482	err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_HW,
1483				  IFLA_XDP_HW_PROG_ID, rtnl_xdp_prog_hw);
1484	if (err)
1485		goto err_cancel;
1486
1487	err = nla_put_u8(skb, IFLA_XDP_ATTACHED, mode);
1488	if (err)
1489		goto err_cancel;
1490
1491	if (prog_id && mode != XDP_ATTACHED_MULTI) {
1492		err = nla_put_u32(skb, IFLA_XDP_PROG_ID, prog_id);
1493		if (err)
1494			goto err_cancel;
1495	}
1496
1497	nla_nest_end(skb, xdp);
1498	return 0;
1499
1500err_cancel:
1501	nla_nest_cancel(skb, xdp);
1502	return err;
1503}
1504
1505static u32 rtnl_get_event(unsigned long event)
1506{
1507	u32 rtnl_event_type = IFLA_EVENT_NONE;
1508
1509	switch (event) {
1510	case NETDEV_REBOOT:
1511		rtnl_event_type = IFLA_EVENT_REBOOT;
1512		break;
1513	case NETDEV_FEAT_CHANGE:
1514		rtnl_event_type = IFLA_EVENT_FEATURES;
1515		break;
1516	case NETDEV_BONDING_FAILOVER:
1517		rtnl_event_type = IFLA_EVENT_BONDING_FAILOVER;
1518		break;
1519	case NETDEV_NOTIFY_PEERS:
1520		rtnl_event_type = IFLA_EVENT_NOTIFY_PEERS;
1521		break;
1522	case NETDEV_RESEND_IGMP:
1523		rtnl_event_type = IFLA_EVENT_IGMP_RESEND;
1524		break;
1525	case NETDEV_CHANGEINFODATA:
1526		rtnl_event_type = IFLA_EVENT_BONDING_OPTIONS;
1527		break;
1528	default:
1529		break;
1530	}
1531
1532	return rtnl_event_type;
1533}
1534
1535static int put_master_ifindex(struct sk_buff *skb, struct net_device *dev)
1536{
1537	const struct net_device *upper_dev;
1538	int ret = 0;
1539
1540	rcu_read_lock();
1541
1542	upper_dev = netdev_master_upper_dev_get_rcu(dev);
1543	if (upper_dev)
1544		ret = nla_put_u32(skb, IFLA_MASTER, upper_dev->ifindex);
1545
1546	rcu_read_unlock();
1547	return ret;
1548}
1549
1550static int nla_put_iflink(struct sk_buff *skb, const struct net_device *dev,
1551			  bool force)
1552{
1553	int ifindex = dev_get_iflink(dev);
1554
1555	if (force || dev->ifindex != ifindex)
1556		return nla_put_u32(skb, IFLA_LINK, ifindex);
1557
1558	return 0;
1559}
1560
1561static noinline_for_stack int nla_put_ifalias(struct sk_buff *skb,
1562					      struct net_device *dev)
1563{
1564	char buf[IFALIASZ];
1565	int ret;
1566
1567	ret = dev_get_alias(dev, buf, sizeof(buf));
1568	return ret > 0 ? nla_put_string(skb, IFLA_IFALIAS, buf) : 0;
1569}
1570
1571static int rtnl_fill_link_netnsid(struct sk_buff *skb,
1572				  const struct net_device *dev,
1573				  struct net *src_net, gfp_t gfp)
1574{
1575	bool put_iflink = false;
1576
1577	if (dev->rtnl_link_ops && dev->rtnl_link_ops->get_link_net) {
1578		struct net *link_net = dev->rtnl_link_ops->get_link_net(dev);
1579
1580		if (!net_eq(dev_net(dev), link_net)) {
1581			int id = peernet2id_alloc(src_net, link_net, gfp);
1582
1583			if (nla_put_s32(skb, IFLA_LINK_NETNSID, id))
1584				return -EMSGSIZE;
1585
1586			put_iflink = true;
1587		}
1588	}
1589
1590	return nla_put_iflink(skb, dev, put_iflink);
1591}
1592
1593static int rtnl_fill_link_af(struct sk_buff *skb,
1594			     const struct net_device *dev,
1595			     u32 ext_filter_mask)
1596{
1597	const struct rtnl_af_ops *af_ops;
1598	struct nlattr *af_spec;
1599
1600	af_spec = nla_nest_start_noflag(skb, IFLA_AF_SPEC);
1601	if (!af_spec)
1602		return -EMSGSIZE;
1603
1604	list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
1605		struct nlattr *af;
1606		int err;
1607
1608		if (!af_ops->fill_link_af)
1609			continue;
1610
1611		af = nla_nest_start_noflag(skb, af_ops->family);
1612		if (!af)
1613			return -EMSGSIZE;
1614
1615		err = af_ops->fill_link_af(skb, dev, ext_filter_mask);
1616		/*
1617		 * Caller may return ENODATA to indicate that there
1618		 * was no data to be dumped. This is not an error, it
1619		 * means we should trim the attribute header and
1620		 * continue.
1621		 */
1622		if (err == -ENODATA)
1623			nla_nest_cancel(skb, af);
1624		else if (err < 0)
1625			return -EMSGSIZE;
1626
1627		nla_nest_end(skb, af);
1628	}
1629
1630	nla_nest_end(skb, af_spec);
1631	return 0;
1632}
1633
1634static int rtnl_fill_alt_ifnames(struct sk_buff *skb,
1635				 const struct net_device *dev)
1636{
1637	struct netdev_name_node *name_node;
1638	int count = 0;
1639
1640	list_for_each_entry(name_node, &dev->name_node->list, list) {
1641		if (nla_put_string(skb, IFLA_ALT_IFNAME, name_node->name))
1642			return -EMSGSIZE;
1643		count++;
1644	}
1645	return count;
1646}
1647
1648static int rtnl_fill_prop_list(struct sk_buff *skb,
1649			       const struct net_device *dev)
1650{
1651	struct nlattr *prop_list;
1652	int ret;
1653
1654	prop_list = nla_nest_start(skb, IFLA_PROP_LIST);
1655	if (!prop_list)
1656		return -EMSGSIZE;
1657
1658	ret = rtnl_fill_alt_ifnames(skb, dev);
1659	if (ret <= 0)
1660		goto nest_cancel;
1661
1662	nla_nest_end(skb, prop_list);
1663	return 0;
1664
1665nest_cancel:
1666	nla_nest_cancel(skb, prop_list);
1667	return ret;
1668}
1669
1670static int rtnl_fill_proto_down(struct sk_buff *skb,
1671				const struct net_device *dev)
1672{
1673	struct nlattr *pr;
1674	u32 preason;
1675
1676	if (nla_put_u8(skb, IFLA_PROTO_DOWN, dev->proto_down))
1677		goto nla_put_failure;
1678
1679	preason = dev->proto_down_reason;
1680	if (!preason)
1681		return 0;
1682
1683	pr = nla_nest_start(skb, IFLA_PROTO_DOWN_REASON);
1684	if (!pr)
1685		return -EMSGSIZE;
1686
1687	if (nla_put_u32(skb, IFLA_PROTO_DOWN_REASON_VALUE, preason)) {
1688		nla_nest_cancel(skb, pr);
1689		goto nla_put_failure;
1690	}
1691
1692	nla_nest_end(skb, pr);
1693	return 0;
1694
1695nla_put_failure:
1696	return -EMSGSIZE;
1697}
1698
1699static int rtnl_fill_ifinfo(struct sk_buff *skb,
1700			    struct net_device *dev, struct net *src_net,
1701			    int type, u32 pid, u32 seq, u32 change,
1702			    unsigned int flags, u32 ext_filter_mask,
1703			    u32 event, int *new_nsid, int new_ifindex,
1704			    int tgt_netnsid, gfp_t gfp)
1705{
1706	struct ifinfomsg *ifm;
1707	struct nlmsghdr *nlh;
1708
1709	ASSERT_RTNL();
1710	nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags);
1711	if (nlh == NULL)
1712		return -EMSGSIZE;
1713
1714	ifm = nlmsg_data(nlh);
1715	ifm->ifi_family = AF_UNSPEC;
1716	ifm->__ifi_pad = 0;
1717	ifm->ifi_type = dev->type;
1718	ifm->ifi_index = dev->ifindex;
1719	ifm->ifi_flags = dev_get_flags(dev);
1720	ifm->ifi_change = change;
1721
1722	if (tgt_netnsid >= 0 && nla_put_s32(skb, IFLA_TARGET_NETNSID, tgt_netnsid))
1723		goto nla_put_failure;
1724
1725	if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
1726	    nla_put_u32(skb, IFLA_TXQLEN, dev->tx_queue_len) ||
1727	    nla_put_u8(skb, IFLA_OPERSTATE,
1728		       netif_running(dev) ? dev->operstate : IF_OPER_DOWN) ||
1729	    nla_put_u8(skb, IFLA_LINKMODE, dev->link_mode) ||
1730	    nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
1731	    nla_put_u32(skb, IFLA_MIN_MTU, dev->min_mtu) ||
1732	    nla_put_u32(skb, IFLA_MAX_MTU, dev->max_mtu) ||
1733	    nla_put_u32(skb, IFLA_GROUP, dev->group) ||
1734	    nla_put_u32(skb, IFLA_PROMISCUITY, dev->promiscuity) ||
1735	    nla_put_u32(skb, IFLA_NUM_TX_QUEUES, dev->num_tx_queues) ||
1736	    nla_put_u32(skb, IFLA_GSO_MAX_SEGS, dev->gso_max_segs) ||
1737	    nla_put_u32(skb, IFLA_GSO_MAX_SIZE, dev->gso_max_size) ||
1738#ifdef CONFIG_RPS
1739	    nla_put_u32(skb, IFLA_NUM_RX_QUEUES, dev->num_rx_queues) ||
1740#endif
 
1741	    put_master_ifindex(skb, dev) ||
1742	    nla_put_u8(skb, IFLA_CARRIER, netif_carrier_ok(dev)) ||
1743	    (dev->qdisc &&
1744	     nla_put_string(skb, IFLA_QDISC, dev->qdisc->ops->id)) ||
1745	    nla_put_ifalias(skb, dev) ||
1746	    nla_put_u32(skb, IFLA_CARRIER_CHANGES,
1747			atomic_read(&dev->carrier_up_count) +
1748			atomic_read(&dev->carrier_down_count)) ||
 
1749	    nla_put_u32(skb, IFLA_CARRIER_UP_COUNT,
1750			atomic_read(&dev->carrier_up_count)) ||
1751	    nla_put_u32(skb, IFLA_CARRIER_DOWN_COUNT,
1752			atomic_read(&dev->carrier_down_count)))
1753		goto nla_put_failure;
1754
1755	if (rtnl_fill_proto_down(skb, dev))
1756		goto nla_put_failure;
1757
1758	if (event != IFLA_EVENT_NONE) {
1759		if (nla_put_u32(skb, IFLA_EVENT, event))
1760			goto nla_put_failure;
1761	}
1762
1763	if (rtnl_fill_link_ifmap(skb, dev))
1764		goto nla_put_failure;
1765
1766	if (dev->addr_len) {
1767		if (nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr) ||
1768		    nla_put(skb, IFLA_BROADCAST, dev->addr_len, dev->broadcast))
1769			goto nla_put_failure;
1770	}
1771
1772	if (rtnl_phys_port_id_fill(skb, dev))
1773		goto nla_put_failure;
1774
1775	if (rtnl_phys_port_name_fill(skb, dev))
1776		goto nla_put_failure;
1777
1778	if (rtnl_phys_switch_id_fill(skb, dev))
1779		goto nla_put_failure;
1780
1781	if (rtnl_fill_stats(skb, dev))
1782		goto nla_put_failure;
1783
1784	if (rtnl_fill_vf(skb, dev, ext_filter_mask))
1785		goto nla_put_failure;
1786
1787	if (rtnl_port_fill(skb, dev, ext_filter_mask))
1788		goto nla_put_failure;
1789
1790	if (rtnl_xdp_fill(skb, dev))
1791		goto nla_put_failure;
1792
1793	if (dev->rtnl_link_ops || rtnl_have_link_slave_info(dev)) {
1794		if (rtnl_link_fill(skb, dev) < 0)
1795			goto nla_put_failure;
1796	}
1797
1798	if (rtnl_fill_link_netnsid(skb, dev, src_net, gfp))
1799		goto nla_put_failure;
1800
1801	if (new_nsid &&
1802	    nla_put_s32(skb, IFLA_NEW_NETNSID, *new_nsid) < 0)
1803		goto nla_put_failure;
1804	if (new_ifindex &&
1805	    nla_put_s32(skb, IFLA_NEW_IFINDEX, new_ifindex) < 0)
1806		goto nla_put_failure;
1807
1808	if (memchr_inv(dev->perm_addr, '\0', dev->addr_len) &&
1809	    nla_put(skb, IFLA_PERM_ADDRESS, dev->addr_len, dev->perm_addr))
1810		goto nla_put_failure;
1811
1812	rcu_read_lock();
1813	if (rtnl_fill_link_af(skb, dev, ext_filter_mask))
1814		goto nla_put_failure_rcu;
1815	rcu_read_unlock();
1816
1817	if (rtnl_fill_prop_list(skb, dev))
1818		goto nla_put_failure;
1819
1820	nlmsg_end(skb, nlh);
1821	return 0;
1822
1823nla_put_failure_rcu:
1824	rcu_read_unlock();
1825nla_put_failure:
1826	nlmsg_cancel(skb, nlh);
1827	return -EMSGSIZE;
1828}
1829
1830static const struct nla_policy ifla_policy[IFLA_MAX+1] = {
1831	[IFLA_IFNAME]		= { .type = NLA_STRING, .len = IFNAMSIZ-1 },
1832	[IFLA_ADDRESS]		= { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
1833	[IFLA_BROADCAST]	= { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
1834	[IFLA_MAP]		= { .len = sizeof(struct rtnl_link_ifmap) },
1835	[IFLA_MTU]		= { .type = NLA_U32 },
1836	[IFLA_LINK]		= { .type = NLA_U32 },
1837	[IFLA_MASTER]		= { .type = NLA_U32 },
1838	[IFLA_CARRIER]		= { .type = NLA_U8 },
1839	[IFLA_TXQLEN]		= { .type = NLA_U32 },
1840	[IFLA_WEIGHT]		= { .type = NLA_U32 },
1841	[IFLA_OPERSTATE]	= { .type = NLA_U8 },
1842	[IFLA_LINKMODE]		= { .type = NLA_U8 },
1843	[IFLA_LINKINFO]		= { .type = NLA_NESTED },
1844	[IFLA_NET_NS_PID]	= { .type = NLA_U32 },
1845	[IFLA_NET_NS_FD]	= { .type = NLA_U32 },
1846	/* IFLA_IFALIAS is a string, but policy is set to NLA_BINARY to
1847	 * allow 0-length string (needed to remove an alias).
1848	 */
1849	[IFLA_IFALIAS]	        = { .type = NLA_BINARY, .len = IFALIASZ - 1 },
1850	[IFLA_VFINFO_LIST]	= {. type = NLA_NESTED },
1851	[IFLA_VF_PORTS]		= { .type = NLA_NESTED },
1852	[IFLA_PORT_SELF]	= { .type = NLA_NESTED },
1853	[IFLA_AF_SPEC]		= { .type = NLA_NESTED },
1854	[IFLA_EXT_MASK]		= { .type = NLA_U32 },
1855	[IFLA_PROMISCUITY]	= { .type = NLA_U32 },
1856	[IFLA_NUM_TX_QUEUES]	= { .type = NLA_U32 },
1857	[IFLA_NUM_RX_QUEUES]	= { .type = NLA_U32 },
1858	[IFLA_GSO_MAX_SEGS]	= { .type = NLA_U32 },
1859	[IFLA_GSO_MAX_SIZE]	= { .type = NLA_U32 },
1860	[IFLA_PHYS_PORT_ID]	= { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
1861	[IFLA_CARRIER_CHANGES]	= { .type = NLA_U32 },  /* ignored */
1862	[IFLA_PHYS_SWITCH_ID]	= { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
1863	[IFLA_LINK_NETNSID]	= { .type = NLA_S32 },
1864	[IFLA_PROTO_DOWN]	= { .type = NLA_U8 },
1865	[IFLA_XDP]		= { .type = NLA_NESTED },
1866	[IFLA_EVENT]		= { .type = NLA_U32 },
1867	[IFLA_GROUP]		= { .type = NLA_U32 },
1868	[IFLA_TARGET_NETNSID]	= { .type = NLA_S32 },
1869	[IFLA_CARRIER_UP_COUNT]	= { .type = NLA_U32 },
1870	[IFLA_CARRIER_DOWN_COUNT] = { .type = NLA_U32 },
1871	[IFLA_MIN_MTU]		= { .type = NLA_U32 },
1872	[IFLA_MAX_MTU]		= { .type = NLA_U32 },
1873	[IFLA_PROP_LIST]	= { .type = NLA_NESTED },
1874	[IFLA_ALT_IFNAME]	= { .type = NLA_STRING,
1875				    .len = ALTIFNAMSIZ - 1 },
1876	[IFLA_PERM_ADDRESS]	= { .type = NLA_REJECT },
1877	[IFLA_PROTO_DOWN_REASON] = { .type = NLA_NESTED },
1878};
1879
1880static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = {
1881	[IFLA_INFO_KIND]	= { .type = NLA_STRING },
1882	[IFLA_INFO_DATA]	= { .type = NLA_NESTED },
1883	[IFLA_INFO_SLAVE_KIND]	= { .type = NLA_STRING },
1884	[IFLA_INFO_SLAVE_DATA]	= { .type = NLA_NESTED },
1885};
1886
1887static const struct nla_policy ifla_vf_policy[IFLA_VF_MAX+1] = {
1888	[IFLA_VF_MAC]		= { .len = sizeof(struct ifla_vf_mac) },
1889	[IFLA_VF_BROADCAST]	= { .type = NLA_REJECT },
1890	[IFLA_VF_VLAN]		= { .len = sizeof(struct ifla_vf_vlan) },
1891	[IFLA_VF_VLAN_LIST]     = { .type = NLA_NESTED },
1892	[IFLA_VF_TX_RATE]	= { .len = sizeof(struct ifla_vf_tx_rate) },
1893	[IFLA_VF_SPOOFCHK]	= { .len = sizeof(struct ifla_vf_spoofchk) },
1894	[IFLA_VF_RATE]		= { .len = sizeof(struct ifla_vf_rate) },
1895	[IFLA_VF_LINK_STATE]	= { .len = sizeof(struct ifla_vf_link_state) },
1896	[IFLA_VF_RSS_QUERY_EN]	= { .len = sizeof(struct ifla_vf_rss_query_en) },
1897	[IFLA_VF_STATS]		= { .type = NLA_NESTED },
1898	[IFLA_VF_TRUST]		= { .len = sizeof(struct ifla_vf_trust) },
1899	[IFLA_VF_IB_NODE_GUID]	= { .len = sizeof(struct ifla_vf_guid) },
1900	[IFLA_VF_IB_PORT_GUID]	= { .len = sizeof(struct ifla_vf_guid) },
1901};
1902
1903static const struct nla_policy ifla_port_policy[IFLA_PORT_MAX+1] = {
1904	[IFLA_PORT_VF]		= { .type = NLA_U32 },
1905	[IFLA_PORT_PROFILE]	= { .type = NLA_STRING,
1906				    .len = PORT_PROFILE_MAX },
1907	[IFLA_PORT_INSTANCE_UUID] = { .type = NLA_BINARY,
1908				      .len = PORT_UUID_MAX },
1909	[IFLA_PORT_HOST_UUID]	= { .type = NLA_STRING,
1910				    .len = PORT_UUID_MAX },
1911	[IFLA_PORT_REQUEST]	= { .type = NLA_U8, },
1912	[IFLA_PORT_RESPONSE]	= { .type = NLA_U16, },
1913
1914	/* Unused, but we need to keep it here since user space could
1915	 * fill it. It's also broken with regard to NLA_BINARY use in
1916	 * combination with structs.
1917	 */
1918	[IFLA_PORT_VSI_TYPE]	= { .type = NLA_BINARY,
1919				    .len = sizeof(struct ifla_port_vsi) },
1920};
1921
1922static const struct nla_policy ifla_xdp_policy[IFLA_XDP_MAX + 1] = {
1923	[IFLA_XDP_UNSPEC]	= { .strict_start_type = IFLA_XDP_EXPECTED_FD },
1924	[IFLA_XDP_FD]		= { .type = NLA_S32 },
1925	[IFLA_XDP_EXPECTED_FD]	= { .type = NLA_S32 },
1926	[IFLA_XDP_ATTACHED]	= { .type = NLA_U8 },
1927	[IFLA_XDP_FLAGS]	= { .type = NLA_U32 },
1928	[IFLA_XDP_PROG_ID]	= { .type = NLA_U32 },
1929};
1930
1931static const struct rtnl_link_ops *linkinfo_to_kind_ops(const struct nlattr *nla)
1932{
1933	const struct rtnl_link_ops *ops = NULL;
1934	struct nlattr *linfo[IFLA_INFO_MAX + 1];
1935
1936	if (nla_parse_nested_deprecated(linfo, IFLA_INFO_MAX, nla, ifla_info_policy, NULL) < 0)
 
1937		return NULL;
1938
1939	if (linfo[IFLA_INFO_KIND]) {
1940		char kind[MODULE_NAME_LEN];
1941
1942		nla_strlcpy(kind, linfo[IFLA_INFO_KIND], sizeof(kind));
1943		ops = rtnl_link_ops_get(kind);
1944	}
1945
1946	return ops;
1947}
1948
1949static bool link_master_filtered(struct net_device *dev, int master_idx)
1950{
1951	struct net_device *master;
1952
1953	if (!master_idx)
1954		return false;
1955
1956	master = netdev_master_upper_dev_get(dev);
1957	if (!master || master->ifindex != master_idx)
1958		return true;
1959
1960	return false;
1961}
1962
1963static bool link_kind_filtered(const struct net_device *dev,
1964			       const struct rtnl_link_ops *kind_ops)
1965{
1966	if (kind_ops && dev->rtnl_link_ops != kind_ops)
1967		return true;
1968
1969	return false;
1970}
1971
1972static bool link_dump_filtered(struct net_device *dev,
1973			       int master_idx,
1974			       const struct rtnl_link_ops *kind_ops)
1975{
1976	if (link_master_filtered(dev, master_idx) ||
1977	    link_kind_filtered(dev, kind_ops))
1978		return true;
1979
1980	return false;
1981}
1982
1983/**
1984 * rtnl_get_net_ns_capable - Get netns if sufficiently privileged.
1985 * @sk: netlink socket
1986 * @netnsid: network namespace identifier
1987 *
1988 * Returns the network namespace identified by netnsid on success or an error
1989 * pointer on failure.
1990 */
1991struct net *rtnl_get_net_ns_capable(struct sock *sk, int netnsid)
1992{
1993	struct net *net;
1994
1995	net = get_net_ns_by_id(sock_net(sk), netnsid);
1996	if (!net)
1997		return ERR_PTR(-EINVAL);
1998
1999	/* For now, the caller is required to have CAP_NET_ADMIN in
2000	 * the user namespace owning the target net ns.
2001	 */
2002	if (!sk_ns_capable(sk, net->user_ns, CAP_NET_ADMIN)) {
2003		put_net(net);
2004		return ERR_PTR(-EACCES);
2005	}
2006	return net;
2007}
2008EXPORT_SYMBOL_GPL(rtnl_get_net_ns_capable);
2009
2010static int rtnl_valid_dump_ifinfo_req(const struct nlmsghdr *nlh,
2011				      bool strict_check, struct nlattr **tb,
2012				      struct netlink_ext_ack *extack)
2013{
2014	int hdrlen;
2015
2016	if (strict_check) {
2017		struct ifinfomsg *ifm;
2018
2019		if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
2020			NL_SET_ERR_MSG(extack, "Invalid header for link dump");
2021			return -EINVAL;
2022		}
2023
2024		ifm = nlmsg_data(nlh);
2025		if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
2026		    ifm->ifi_change) {
2027			NL_SET_ERR_MSG(extack, "Invalid values in header for link dump request");
2028			return -EINVAL;
2029		}
2030		if (ifm->ifi_index) {
2031			NL_SET_ERR_MSG(extack, "Filter by device index not supported for link dumps");
2032			return -EINVAL;
2033		}
2034
2035		return nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb,
2036						     IFLA_MAX, ifla_policy,
2037						     extack);
2038	}
2039
2040	/* A hack to preserve kernel<->userspace interface.
2041	 * The correct header is ifinfomsg. It is consistent with rtnl_getlink.
2042	 * However, before Linux v3.9 the code here assumed rtgenmsg and that's
2043	 * what iproute2 < v3.9.0 used.
2044	 * We can detect the old iproute2. Even including the IFLA_EXT_MASK
2045	 * attribute, its netlink message is shorter than struct ifinfomsg.
2046	 */
2047	hdrlen = nlmsg_len(nlh) < sizeof(struct ifinfomsg) ?
2048		 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg);
2049
2050	return nlmsg_parse_deprecated(nlh, hdrlen, tb, IFLA_MAX, ifla_policy,
2051				      extack);
2052}
2053
2054static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
2055{
2056	struct netlink_ext_ack *extack = cb->extack;
2057	const struct nlmsghdr *nlh = cb->nlh;
2058	struct net *net = sock_net(skb->sk);
2059	struct net *tgt_net = net;
2060	int h, s_h;
2061	int idx = 0, s_idx;
2062	struct net_device *dev;
2063	struct hlist_head *head;
2064	struct nlattr *tb[IFLA_MAX+1];
2065	u32 ext_filter_mask = 0;
2066	const struct rtnl_link_ops *kind_ops = NULL;
2067	unsigned int flags = NLM_F_MULTI;
2068	int master_idx = 0;
2069	int netnsid = -1;
2070	int err, i;
 
2071
2072	s_h = cb->args[0];
2073	s_idx = cb->args[1];
2074
2075	err = rtnl_valid_dump_ifinfo_req(nlh, cb->strict_check, tb, extack);
2076	if (err < 0) {
2077		if (cb->strict_check)
2078			return err;
2079
2080		goto walk_entries;
2081	}
2082
2083	for (i = 0; i <= IFLA_MAX; ++i) {
2084		if (!tb[i])
2085			continue;
2086
2087		/* new attributes should only be added with strict checking */
2088		switch (i) {
2089		case IFLA_TARGET_NETNSID:
2090			netnsid = nla_get_s32(tb[i]);
2091			tgt_net = rtnl_get_net_ns_capable(skb->sk, netnsid);
2092			if (IS_ERR(tgt_net)) {
2093				NL_SET_ERR_MSG(extack, "Invalid target network namespace id");
2094				return PTR_ERR(tgt_net);
2095			}
2096			break;
2097		case IFLA_EXT_MASK:
2098			ext_filter_mask = nla_get_u32(tb[i]);
2099			break;
2100		case IFLA_MASTER:
2101			master_idx = nla_get_u32(tb[i]);
2102			break;
2103		case IFLA_LINKINFO:
2104			kind_ops = linkinfo_to_kind_ops(tb[i]);
2105			break;
2106		default:
2107			if (cb->strict_check) {
2108				NL_SET_ERR_MSG(extack, "Unsupported attribute in link dump request");
2109				return -EINVAL;
2110			}
2111		}
2112	}
2113
2114	if (master_idx || kind_ops)
2115		flags |= NLM_F_DUMP_FILTERED;
 
 
 
 
 
 
 
 
 
 
2116
2117walk_entries:
2118	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
2119		idx = 0;
2120		head = &tgt_net->dev_index_head[h];
2121		hlist_for_each_entry(dev, head, index_hlist) {
2122			if (link_dump_filtered(dev, master_idx, kind_ops))
2123				goto cont;
2124			if (idx < s_idx)
2125				goto cont;
2126			err = rtnl_fill_ifinfo(skb, dev, net,
2127					       RTM_NEWLINK,
2128					       NETLINK_CB(cb->skb).portid,
2129					       nlh->nlmsg_seq, 0, flags,
 
2130					       ext_filter_mask, 0, NULL, 0,
2131					       netnsid, GFP_KERNEL);
2132
2133			if (err < 0) {
2134				if (likely(skb->len))
2135					goto out;
2136
2137				goto out_err;
2138			}
2139cont:
2140			idx++;
2141		}
2142	}
2143out:
2144	err = skb->len;
2145out_err:
2146	cb->args[1] = idx;
2147	cb->args[0] = h;
2148	cb->seq = net->dev_base_seq;
2149	nl_dump_check_consistent(cb, nlmsg_hdr(skb));
2150	if (netnsid >= 0)
2151		put_net(tgt_net);
2152
2153	return err;
2154}
2155
2156int rtnl_nla_parse_ifla(struct nlattr **tb, const struct nlattr *head, int len,
2157			struct netlink_ext_ack *exterr)
2158{
2159	return nla_parse_deprecated(tb, IFLA_MAX, head, len, ifla_policy,
2160				    exterr);
2161}
2162EXPORT_SYMBOL(rtnl_nla_parse_ifla);
2163
2164struct net *rtnl_link_get_net(struct net *src_net, struct nlattr *tb[])
2165{
2166	struct net *net;
2167	/* Examine the link attributes and figure out which
2168	 * network namespace we are talking about.
2169	 */
2170	if (tb[IFLA_NET_NS_PID])
2171		net = get_net_ns_by_pid(nla_get_u32(tb[IFLA_NET_NS_PID]));
2172	else if (tb[IFLA_NET_NS_FD])
2173		net = get_net_ns_by_fd(nla_get_u32(tb[IFLA_NET_NS_FD]));
2174	else
2175		net = get_net(src_net);
2176	return net;
2177}
2178EXPORT_SYMBOL(rtnl_link_get_net);
2179
2180/* Figure out which network namespace we are talking about by
2181 * examining the link attributes in the following order:
2182 *
2183 * 1. IFLA_NET_NS_PID
2184 * 2. IFLA_NET_NS_FD
2185 * 3. IFLA_TARGET_NETNSID
2186 */
2187static struct net *rtnl_link_get_net_by_nlattr(struct net *src_net,
2188					       struct nlattr *tb[])
2189{
2190	struct net *net;
2191
2192	if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD])
2193		return rtnl_link_get_net(src_net, tb);
2194
2195	if (!tb[IFLA_TARGET_NETNSID])
2196		return get_net(src_net);
2197
2198	net = get_net_ns_by_id(src_net, nla_get_u32(tb[IFLA_TARGET_NETNSID]));
2199	if (!net)
2200		return ERR_PTR(-EINVAL);
2201
2202	return net;
2203}
2204
2205static struct net *rtnl_link_get_net_capable(const struct sk_buff *skb,
2206					     struct net *src_net,
2207					     struct nlattr *tb[], int cap)
2208{
2209	struct net *net;
2210
2211	net = rtnl_link_get_net_by_nlattr(src_net, tb);
2212	if (IS_ERR(net))
2213		return net;
2214
2215	if (!netlink_ns_capable(skb, net->user_ns, cap)) {
2216		put_net(net);
2217		return ERR_PTR(-EPERM);
2218	}
2219
2220	return net;
2221}
2222
2223/* Verify that rtnetlink requests do not pass additional properties
2224 * potentially referring to different network namespaces.
2225 */
2226static int rtnl_ensure_unique_netns(struct nlattr *tb[],
2227				    struct netlink_ext_ack *extack,
2228				    bool netns_id_only)
2229{
2230
2231	if (netns_id_only) {
2232		if (!tb[IFLA_NET_NS_PID] && !tb[IFLA_NET_NS_FD])
2233			return 0;
2234
2235		NL_SET_ERR_MSG(extack, "specified netns attribute not supported");
2236		return -EOPNOTSUPP;
2237	}
2238
2239	if (tb[IFLA_TARGET_NETNSID] && (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD]))
2240		goto invalid_attr;
2241
2242	if (tb[IFLA_NET_NS_PID] && (tb[IFLA_TARGET_NETNSID] || tb[IFLA_NET_NS_FD]))
2243		goto invalid_attr;
2244
2245	if (tb[IFLA_NET_NS_FD] && (tb[IFLA_TARGET_NETNSID] || tb[IFLA_NET_NS_PID]))
2246		goto invalid_attr;
2247
2248	return 0;
2249
2250invalid_attr:
2251	NL_SET_ERR_MSG(extack, "multiple netns identifying attributes specified");
2252	return -EINVAL;
2253}
2254
2255static int validate_linkmsg(struct net_device *dev, struct nlattr *tb[])
2256{
2257	if (dev) {
2258		if (tb[IFLA_ADDRESS] &&
2259		    nla_len(tb[IFLA_ADDRESS]) < dev->addr_len)
2260			return -EINVAL;
2261
2262		if (tb[IFLA_BROADCAST] &&
2263		    nla_len(tb[IFLA_BROADCAST]) < dev->addr_len)
2264			return -EINVAL;
2265	}
2266
2267	if (tb[IFLA_AF_SPEC]) {
2268		struct nlattr *af;
2269		int rem, err;
2270
2271		nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
2272			const struct rtnl_af_ops *af_ops;
2273
2274			rcu_read_lock();
2275			af_ops = rtnl_af_lookup(nla_type(af));
2276			if (!af_ops) {
2277				rcu_read_unlock();
2278				return -EAFNOSUPPORT;
2279			}
2280
2281			if (!af_ops->set_link_af) {
2282				rcu_read_unlock();
2283				return -EOPNOTSUPP;
2284			}
2285
2286			if (af_ops->validate_link_af) {
2287				err = af_ops->validate_link_af(dev, af);
2288				if (err < 0) {
2289					rcu_read_unlock();
2290					return err;
2291				}
2292			}
2293
2294			rcu_read_unlock();
2295		}
2296	}
2297
2298	return 0;
2299}
2300
2301static int handle_infiniband_guid(struct net_device *dev, struct ifla_vf_guid *ivt,
2302				  int guid_type)
2303{
2304	const struct net_device_ops *ops = dev->netdev_ops;
2305
2306	return ops->ndo_set_vf_guid(dev, ivt->vf, ivt->guid, guid_type);
2307}
2308
2309static int handle_vf_guid(struct net_device *dev, struct ifla_vf_guid *ivt, int guid_type)
2310{
2311	if (dev->type != ARPHRD_INFINIBAND)
2312		return -EOPNOTSUPP;
2313
2314	return handle_infiniband_guid(dev, ivt, guid_type);
2315}
2316
2317static int do_setvfinfo(struct net_device *dev, struct nlattr **tb)
2318{
2319	const struct net_device_ops *ops = dev->netdev_ops;
2320	int err = -EINVAL;
2321
2322	if (tb[IFLA_VF_MAC]) {
2323		struct ifla_vf_mac *ivm = nla_data(tb[IFLA_VF_MAC]);
2324
2325		if (ivm->vf >= INT_MAX)
2326			return -EINVAL;
2327		err = -EOPNOTSUPP;
2328		if (ops->ndo_set_vf_mac)
2329			err = ops->ndo_set_vf_mac(dev, ivm->vf,
2330						  ivm->mac);
2331		if (err < 0)
2332			return err;
2333	}
2334
2335	if (tb[IFLA_VF_VLAN]) {
2336		struct ifla_vf_vlan *ivv = nla_data(tb[IFLA_VF_VLAN]);
2337
2338		if (ivv->vf >= INT_MAX)
2339			return -EINVAL;
2340		err = -EOPNOTSUPP;
2341		if (ops->ndo_set_vf_vlan)
2342			err = ops->ndo_set_vf_vlan(dev, ivv->vf, ivv->vlan,
2343						   ivv->qos,
2344						   htons(ETH_P_8021Q));
2345		if (err < 0)
2346			return err;
2347	}
2348
2349	if (tb[IFLA_VF_VLAN_LIST]) {
2350		struct ifla_vf_vlan_info *ivvl[MAX_VLAN_LIST_LEN];
2351		struct nlattr *attr;
2352		int rem, len = 0;
2353
2354		err = -EOPNOTSUPP;
2355		if (!ops->ndo_set_vf_vlan)
2356			return err;
2357
2358		nla_for_each_nested(attr, tb[IFLA_VF_VLAN_LIST], rem) {
2359			if (nla_type(attr) != IFLA_VF_VLAN_INFO ||
2360			    nla_len(attr) < NLA_HDRLEN) {
2361				return -EINVAL;
2362			}
2363			if (len >= MAX_VLAN_LIST_LEN)
2364				return -EOPNOTSUPP;
2365			ivvl[len] = nla_data(attr);
2366
2367			len++;
2368		}
2369		if (len == 0)
2370			return -EINVAL;
2371
2372		if (ivvl[0]->vf >= INT_MAX)
2373			return -EINVAL;
2374		err = ops->ndo_set_vf_vlan(dev, ivvl[0]->vf, ivvl[0]->vlan,
2375					   ivvl[0]->qos, ivvl[0]->vlan_proto);
2376		if (err < 0)
2377			return err;
2378	}
2379
2380	if (tb[IFLA_VF_TX_RATE]) {
2381		struct ifla_vf_tx_rate *ivt = nla_data(tb[IFLA_VF_TX_RATE]);
2382		struct ifla_vf_info ivf;
2383
2384		if (ivt->vf >= INT_MAX)
2385			return -EINVAL;
2386		err = -EOPNOTSUPP;
2387		if (ops->ndo_get_vf_config)
2388			err = ops->ndo_get_vf_config(dev, ivt->vf, &ivf);
2389		if (err < 0)
2390			return err;
2391
2392		err = -EOPNOTSUPP;
2393		if (ops->ndo_set_vf_rate)
2394			err = ops->ndo_set_vf_rate(dev, ivt->vf,
2395						   ivf.min_tx_rate,
2396						   ivt->rate);
2397		if (err < 0)
2398			return err;
2399	}
2400
2401	if (tb[IFLA_VF_RATE]) {
2402		struct ifla_vf_rate *ivt = nla_data(tb[IFLA_VF_RATE]);
2403
2404		if (ivt->vf >= INT_MAX)
2405			return -EINVAL;
2406		err = -EOPNOTSUPP;
2407		if (ops->ndo_set_vf_rate)
2408			err = ops->ndo_set_vf_rate(dev, ivt->vf,
2409						   ivt->min_tx_rate,
2410						   ivt->max_tx_rate);
2411		if (err < 0)
2412			return err;
2413	}
2414
2415	if (tb[IFLA_VF_SPOOFCHK]) {
2416		struct ifla_vf_spoofchk *ivs = nla_data(tb[IFLA_VF_SPOOFCHK]);
2417
2418		if (ivs->vf >= INT_MAX)
2419			return -EINVAL;
2420		err = -EOPNOTSUPP;
2421		if (ops->ndo_set_vf_spoofchk)
2422			err = ops->ndo_set_vf_spoofchk(dev, ivs->vf,
2423						       ivs->setting);
2424		if (err < 0)
2425			return err;
2426	}
2427
2428	if (tb[IFLA_VF_LINK_STATE]) {
2429		struct ifla_vf_link_state *ivl = nla_data(tb[IFLA_VF_LINK_STATE]);
2430
2431		if (ivl->vf >= INT_MAX)
2432			return -EINVAL;
2433		err = -EOPNOTSUPP;
2434		if (ops->ndo_set_vf_link_state)
2435			err = ops->ndo_set_vf_link_state(dev, ivl->vf,
2436							 ivl->link_state);
2437		if (err < 0)
2438			return err;
2439	}
2440
2441	if (tb[IFLA_VF_RSS_QUERY_EN]) {
2442		struct ifla_vf_rss_query_en *ivrssq_en;
2443
2444		err = -EOPNOTSUPP;
2445		ivrssq_en = nla_data(tb[IFLA_VF_RSS_QUERY_EN]);
2446		if (ivrssq_en->vf >= INT_MAX)
2447			return -EINVAL;
2448		if (ops->ndo_set_vf_rss_query_en)
2449			err = ops->ndo_set_vf_rss_query_en(dev, ivrssq_en->vf,
2450							   ivrssq_en->setting);
2451		if (err < 0)
2452			return err;
2453	}
2454
2455	if (tb[IFLA_VF_TRUST]) {
2456		struct ifla_vf_trust *ivt = nla_data(tb[IFLA_VF_TRUST]);
2457
2458		if (ivt->vf >= INT_MAX)
2459			return -EINVAL;
2460		err = -EOPNOTSUPP;
2461		if (ops->ndo_set_vf_trust)
2462			err = ops->ndo_set_vf_trust(dev, ivt->vf, ivt->setting);
2463		if (err < 0)
2464			return err;
2465	}
2466
2467	if (tb[IFLA_VF_IB_NODE_GUID]) {
2468		struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_NODE_GUID]);
2469
2470		if (ivt->vf >= INT_MAX)
2471			return -EINVAL;
2472		if (!ops->ndo_set_vf_guid)
2473			return -EOPNOTSUPP;
 
2474		return handle_vf_guid(dev, ivt, IFLA_VF_IB_NODE_GUID);
2475	}
2476
2477	if (tb[IFLA_VF_IB_PORT_GUID]) {
2478		struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_PORT_GUID]);
2479
2480		if (ivt->vf >= INT_MAX)
2481			return -EINVAL;
2482		if (!ops->ndo_set_vf_guid)
2483			return -EOPNOTSUPP;
2484
2485		return handle_vf_guid(dev, ivt, IFLA_VF_IB_PORT_GUID);
2486	}
2487
2488	return err;
2489}
2490
2491static int do_set_master(struct net_device *dev, int ifindex,
2492			 struct netlink_ext_ack *extack)
2493{
2494	struct net_device *upper_dev = netdev_master_upper_dev_get(dev);
2495	const struct net_device_ops *ops;
2496	int err;
2497
2498	if (upper_dev) {
2499		if (upper_dev->ifindex == ifindex)
2500			return 0;
2501		ops = upper_dev->netdev_ops;
2502		if (ops->ndo_del_slave) {
2503			err = ops->ndo_del_slave(upper_dev, dev);
2504			if (err)
2505				return err;
2506		} else {
2507			return -EOPNOTSUPP;
2508		}
2509	}
2510
2511	if (ifindex) {
2512		upper_dev = __dev_get_by_index(dev_net(dev), ifindex);
2513		if (!upper_dev)
2514			return -EINVAL;
2515		ops = upper_dev->netdev_ops;
2516		if (ops->ndo_add_slave) {
2517			err = ops->ndo_add_slave(upper_dev, dev, extack);
2518			if (err)
2519				return err;
2520		} else {
2521			return -EOPNOTSUPP;
2522		}
2523	}
2524	return 0;
2525}
2526
2527static const struct nla_policy ifla_proto_down_reason_policy[IFLA_PROTO_DOWN_REASON_VALUE + 1] = {
2528	[IFLA_PROTO_DOWN_REASON_MASK]	= { .type = NLA_U32 },
2529	[IFLA_PROTO_DOWN_REASON_VALUE]	= { .type = NLA_U32 },
2530};
2531
2532static int do_set_proto_down(struct net_device *dev,
2533			     struct nlattr *nl_proto_down,
2534			     struct nlattr *nl_proto_down_reason,
2535			     struct netlink_ext_ack *extack)
2536{
2537	struct nlattr *pdreason[IFLA_PROTO_DOWN_REASON_MAX + 1];
2538	const struct net_device_ops *ops = dev->netdev_ops;
2539	unsigned long mask = 0;
2540	u32 value;
2541	bool proto_down;
2542	int err;
2543
2544	if (!ops->ndo_change_proto_down) {
2545		NL_SET_ERR_MSG(extack,  "Protodown not supported by device");
2546		return -EOPNOTSUPP;
2547	}
2548
2549	if (nl_proto_down_reason) {
2550		err = nla_parse_nested_deprecated(pdreason,
2551						  IFLA_PROTO_DOWN_REASON_MAX,
2552						  nl_proto_down_reason,
2553						  ifla_proto_down_reason_policy,
2554						  NULL);
2555		if (err < 0)
2556			return err;
2557
2558		if (!pdreason[IFLA_PROTO_DOWN_REASON_VALUE]) {
2559			NL_SET_ERR_MSG(extack, "Invalid protodown reason value");
2560			return -EINVAL;
2561		}
2562
2563		value = nla_get_u32(pdreason[IFLA_PROTO_DOWN_REASON_VALUE]);
2564
2565		if (pdreason[IFLA_PROTO_DOWN_REASON_MASK])
2566			mask = nla_get_u32(pdreason[IFLA_PROTO_DOWN_REASON_MASK]);
2567
2568		dev_change_proto_down_reason(dev, mask, value);
2569	}
2570
2571	if (nl_proto_down) {
2572		proto_down = nla_get_u8(nl_proto_down);
2573
2574		/* Dont turn off protodown if there are active reasons */
2575		if (!proto_down && dev->proto_down_reason) {
2576			NL_SET_ERR_MSG(extack, "Cannot clear protodown, active reasons");
2577			return -EBUSY;
2578		}
2579		err = dev_change_proto_down(dev,
2580					    proto_down);
2581		if (err)
2582			return err;
2583	}
2584
2585	return 0;
2586}
2587
2588#define DO_SETLINK_MODIFIED	0x01
2589/* notify flag means notify + modified. */
2590#define DO_SETLINK_NOTIFY	0x03
2591static int do_setlink(const struct sk_buff *skb,
2592		      struct net_device *dev, struct ifinfomsg *ifm,
2593		      struct netlink_ext_ack *extack,
2594		      struct nlattr **tb, char *ifname, int status)
2595{
2596	const struct net_device_ops *ops = dev->netdev_ops;
2597	int err;
2598
2599	err = validate_linkmsg(dev, tb);
2600	if (err < 0)
2601		return err;
2602
2603	if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD] || tb[IFLA_TARGET_NETNSID]) {
2604		struct net *net = rtnl_link_get_net_capable(skb, dev_net(dev),
2605							    tb, CAP_NET_ADMIN);
2606		if (IS_ERR(net)) {
2607			err = PTR_ERR(net);
2608			goto errout;
2609		}
2610
2611		err = dev_change_net_namespace(dev, net, ifname);
2612		put_net(net);
2613		if (err)
2614			goto errout;
2615		status |= DO_SETLINK_MODIFIED;
2616	}
2617
2618	if (tb[IFLA_MAP]) {
2619		struct rtnl_link_ifmap *u_map;
2620		struct ifmap k_map;
2621
2622		if (!ops->ndo_set_config) {
2623			err = -EOPNOTSUPP;
2624			goto errout;
2625		}
2626
2627		if (!netif_device_present(dev)) {
2628			err = -ENODEV;
2629			goto errout;
2630		}
2631
2632		u_map = nla_data(tb[IFLA_MAP]);
2633		k_map.mem_start = (unsigned long) u_map->mem_start;
2634		k_map.mem_end = (unsigned long) u_map->mem_end;
2635		k_map.base_addr = (unsigned short) u_map->base_addr;
2636		k_map.irq = (unsigned char) u_map->irq;
2637		k_map.dma = (unsigned char) u_map->dma;
2638		k_map.port = (unsigned char) u_map->port;
2639
2640		err = ops->ndo_set_config(dev, &k_map);
2641		if (err < 0)
2642			goto errout;
2643
2644		status |= DO_SETLINK_NOTIFY;
2645	}
2646
2647	if (tb[IFLA_ADDRESS]) {
2648		struct sockaddr *sa;
2649		int len;
2650
2651		len = sizeof(sa_family_t) + max_t(size_t, dev->addr_len,
2652						  sizeof(*sa));
2653		sa = kmalloc(len, GFP_KERNEL);
2654		if (!sa) {
2655			err = -ENOMEM;
2656			goto errout;
2657		}
2658		sa->sa_family = dev->type;
2659		memcpy(sa->sa_data, nla_data(tb[IFLA_ADDRESS]),
2660		       dev->addr_len);
2661		err = dev_set_mac_address(dev, sa, extack);
2662		kfree(sa);
2663		if (err)
2664			goto errout;
2665		status |= DO_SETLINK_MODIFIED;
2666	}
2667
2668	if (tb[IFLA_MTU]) {
2669		err = dev_set_mtu_ext(dev, nla_get_u32(tb[IFLA_MTU]), extack);
2670		if (err < 0)
2671			goto errout;
2672		status |= DO_SETLINK_MODIFIED;
2673	}
2674
2675	if (tb[IFLA_GROUP]) {
2676		dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP]));
2677		status |= DO_SETLINK_NOTIFY;
2678	}
2679
2680	/*
2681	 * Interface selected by interface index but interface
2682	 * name provided implies that a name change has been
2683	 * requested.
2684	 */
2685	if (ifm->ifi_index > 0 && ifname[0]) {
2686		err = dev_change_name(dev, ifname);
2687		if (err < 0)
2688			goto errout;
2689		status |= DO_SETLINK_MODIFIED;
2690	}
2691
2692	if (tb[IFLA_IFALIAS]) {
2693		err = dev_set_alias(dev, nla_data(tb[IFLA_IFALIAS]),
2694				    nla_len(tb[IFLA_IFALIAS]));
2695		if (err < 0)
2696			goto errout;
2697		status |= DO_SETLINK_NOTIFY;
2698	}
2699
2700	if (tb[IFLA_BROADCAST]) {
2701		nla_memcpy(dev->broadcast, tb[IFLA_BROADCAST], dev->addr_len);
2702		call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
2703	}
2704
2705	if (ifm->ifi_flags || ifm->ifi_change) {
2706		err = dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm),
2707				       extack);
2708		if (err < 0)
2709			goto errout;
2710	}
2711
2712	if (tb[IFLA_MASTER]) {
2713		err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), extack);
2714		if (err)
2715			goto errout;
2716		status |= DO_SETLINK_MODIFIED;
2717	}
2718
2719	if (tb[IFLA_CARRIER]) {
2720		err = dev_change_carrier(dev, nla_get_u8(tb[IFLA_CARRIER]));
2721		if (err)
2722			goto errout;
2723		status |= DO_SETLINK_MODIFIED;
2724	}
2725
2726	if (tb[IFLA_TXQLEN]) {
2727		unsigned int value = nla_get_u32(tb[IFLA_TXQLEN]);
2728
2729		err = dev_change_tx_queue_len(dev, value);
2730		if (err)
2731			goto errout;
2732		status |= DO_SETLINK_MODIFIED;
2733	}
2734
2735	if (tb[IFLA_GSO_MAX_SIZE]) {
2736		u32 max_size = nla_get_u32(tb[IFLA_GSO_MAX_SIZE]);
2737
2738		if (max_size > GSO_MAX_SIZE) {
2739			err = -EINVAL;
2740			goto errout;
2741		}
2742
2743		if (dev->gso_max_size ^ max_size) {
2744			netif_set_gso_max_size(dev, max_size);
2745			status |= DO_SETLINK_MODIFIED;
2746		}
2747	}
2748
2749	if (tb[IFLA_GSO_MAX_SEGS]) {
2750		u32 max_segs = nla_get_u32(tb[IFLA_GSO_MAX_SEGS]);
2751
2752		if (max_segs > GSO_MAX_SEGS) {
2753			err = -EINVAL;
2754			goto errout;
2755		}
2756
2757		if (dev->gso_max_segs ^ max_segs) {
2758			dev->gso_max_segs = max_segs;
2759			status |= DO_SETLINK_MODIFIED;
2760		}
2761	}
2762
2763	if (tb[IFLA_OPERSTATE])
2764		set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
2765
2766	if (tb[IFLA_LINKMODE]) {
2767		unsigned char value = nla_get_u8(tb[IFLA_LINKMODE]);
2768
2769		write_lock_bh(&dev_base_lock);
2770		if (dev->link_mode ^ value)
2771			status |= DO_SETLINK_NOTIFY;
2772		dev->link_mode = value;
2773		write_unlock_bh(&dev_base_lock);
2774	}
2775
2776	if (tb[IFLA_VFINFO_LIST]) {
2777		struct nlattr *vfinfo[IFLA_VF_MAX + 1];
2778		struct nlattr *attr;
2779		int rem;
2780
2781		nla_for_each_nested(attr, tb[IFLA_VFINFO_LIST], rem) {
2782			if (nla_type(attr) != IFLA_VF_INFO ||
2783			    nla_len(attr) < NLA_HDRLEN) {
2784				err = -EINVAL;
2785				goto errout;
2786			}
2787			err = nla_parse_nested_deprecated(vfinfo, IFLA_VF_MAX,
2788							  attr,
2789							  ifla_vf_policy,
2790							  NULL);
2791			if (err < 0)
2792				goto errout;
2793			err = do_setvfinfo(dev, vfinfo);
2794			if (err < 0)
2795				goto errout;
2796			status |= DO_SETLINK_NOTIFY;
2797		}
2798	}
2799	err = 0;
2800
2801	if (tb[IFLA_VF_PORTS]) {
2802		struct nlattr *port[IFLA_PORT_MAX+1];
2803		struct nlattr *attr;
2804		int vf;
2805		int rem;
2806
2807		err = -EOPNOTSUPP;
2808		if (!ops->ndo_set_vf_port)
2809			goto errout;
2810
2811		nla_for_each_nested(attr, tb[IFLA_VF_PORTS], rem) {
2812			if (nla_type(attr) != IFLA_VF_PORT ||
2813			    nla_len(attr) < NLA_HDRLEN) {
2814				err = -EINVAL;
2815				goto errout;
2816			}
2817			err = nla_parse_nested_deprecated(port, IFLA_PORT_MAX,
2818							  attr,
2819							  ifla_port_policy,
2820							  NULL);
2821			if (err < 0)
2822				goto errout;
2823			if (!port[IFLA_PORT_VF]) {
2824				err = -EOPNOTSUPP;
2825				goto errout;
2826			}
2827			vf = nla_get_u32(port[IFLA_PORT_VF]);
2828			err = ops->ndo_set_vf_port(dev, vf, port);
2829			if (err < 0)
2830				goto errout;
2831			status |= DO_SETLINK_NOTIFY;
2832		}
2833	}
2834	err = 0;
2835
2836	if (tb[IFLA_PORT_SELF]) {
2837		struct nlattr *port[IFLA_PORT_MAX+1];
2838
2839		err = nla_parse_nested_deprecated(port, IFLA_PORT_MAX,
2840						  tb[IFLA_PORT_SELF],
2841						  ifla_port_policy, NULL);
2842		if (err < 0)
2843			goto errout;
2844
2845		err = -EOPNOTSUPP;
2846		if (ops->ndo_set_vf_port)
2847			err = ops->ndo_set_vf_port(dev, PORT_SELF_VF, port);
2848		if (err < 0)
2849			goto errout;
2850		status |= DO_SETLINK_NOTIFY;
2851	}
2852
2853	if (tb[IFLA_AF_SPEC]) {
2854		struct nlattr *af;
2855		int rem;
2856
2857		nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
2858			const struct rtnl_af_ops *af_ops;
2859
2860			rcu_read_lock();
2861
2862			BUG_ON(!(af_ops = rtnl_af_lookup(nla_type(af))));
2863
2864			err = af_ops->set_link_af(dev, af);
2865			if (err < 0) {
2866				rcu_read_unlock();
2867				goto errout;
2868			}
2869
2870			rcu_read_unlock();
2871			status |= DO_SETLINK_NOTIFY;
2872		}
2873	}
2874	err = 0;
2875
2876	if (tb[IFLA_PROTO_DOWN] || tb[IFLA_PROTO_DOWN_REASON]) {
2877		err = do_set_proto_down(dev, tb[IFLA_PROTO_DOWN],
2878					tb[IFLA_PROTO_DOWN_REASON], extack);
2879		if (err)
2880			goto errout;
2881		status |= DO_SETLINK_NOTIFY;
2882	}
2883
2884	if (tb[IFLA_XDP]) {
2885		struct nlattr *xdp[IFLA_XDP_MAX + 1];
2886		u32 xdp_flags = 0;
2887
2888		err = nla_parse_nested_deprecated(xdp, IFLA_XDP_MAX,
2889						  tb[IFLA_XDP],
2890						  ifla_xdp_policy, NULL);
2891		if (err < 0)
2892			goto errout;
2893
2894		if (xdp[IFLA_XDP_ATTACHED] || xdp[IFLA_XDP_PROG_ID]) {
2895			err = -EINVAL;
2896			goto errout;
2897		}
2898
2899		if (xdp[IFLA_XDP_FLAGS]) {
2900			xdp_flags = nla_get_u32(xdp[IFLA_XDP_FLAGS]);
2901			if (xdp_flags & ~XDP_FLAGS_MASK) {
2902				err = -EINVAL;
2903				goto errout;
2904			}
2905			if (hweight32(xdp_flags & XDP_FLAGS_MODES) > 1) {
2906				err = -EINVAL;
2907				goto errout;
2908			}
2909		}
2910
2911		if (xdp[IFLA_XDP_FD]) {
2912			int expected_fd = -1;
2913
2914			if (xdp_flags & XDP_FLAGS_REPLACE) {
2915				if (!xdp[IFLA_XDP_EXPECTED_FD]) {
2916					err = -EINVAL;
2917					goto errout;
2918				}
2919				expected_fd =
2920					nla_get_s32(xdp[IFLA_XDP_EXPECTED_FD]);
2921			}
2922
2923			err = dev_change_xdp_fd(dev, extack,
2924						nla_get_s32(xdp[IFLA_XDP_FD]),
2925						expected_fd,
2926						xdp_flags);
2927			if (err)
2928				goto errout;
2929			status |= DO_SETLINK_NOTIFY;
2930		}
2931	}
2932
2933errout:
2934	if (status & DO_SETLINK_MODIFIED) {
2935		if ((status & DO_SETLINK_NOTIFY) == DO_SETLINK_NOTIFY)
2936			netdev_state_change(dev);
2937
2938		if (err < 0)
2939			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",
2940					     dev->name);
2941	}
2942
2943	return err;
2944}
2945
2946static struct net_device *rtnl_dev_get(struct net *net,
2947				       struct nlattr *ifname_attr,
2948				       struct nlattr *altifname_attr,
2949				       char *ifname)
2950{
2951	char buffer[ALTIFNAMSIZ];
2952
2953	if (!ifname) {
2954		ifname = buffer;
2955		if (ifname_attr)
2956			nla_strlcpy(ifname, ifname_attr, IFNAMSIZ);
2957		else if (altifname_attr)
2958			nla_strlcpy(ifname, altifname_attr, ALTIFNAMSIZ);
2959		else
2960			return NULL;
2961	}
2962
2963	return __dev_get_by_name(net, ifname);
2964}
2965
2966static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh,
2967			struct netlink_ext_ack *extack)
2968{
2969	struct net *net = sock_net(skb->sk);
2970	struct ifinfomsg *ifm;
2971	struct net_device *dev;
2972	int err;
2973	struct nlattr *tb[IFLA_MAX+1];
2974	char ifname[IFNAMSIZ];
2975
2976	err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
2977				     ifla_policy, extack);
2978	if (err < 0)
2979		goto errout;
2980
2981	err = rtnl_ensure_unique_netns(tb, extack, false);
2982	if (err < 0)
2983		goto errout;
2984
2985	if (tb[IFLA_IFNAME])
2986		nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
2987	else
2988		ifname[0] = '\0';
2989
2990	err = -EINVAL;
2991	ifm = nlmsg_data(nlh);
2992	if (ifm->ifi_index > 0)
2993		dev = __dev_get_by_index(net, ifm->ifi_index);
2994	else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
2995		dev = rtnl_dev_get(net, NULL, tb[IFLA_ALT_IFNAME], ifname);
2996	else
2997		goto errout;
2998
2999	if (dev == NULL) {
3000		err = -ENODEV;
3001		goto errout;
3002	}
3003
 
 
 
 
3004	err = do_setlink(skb, dev, ifm, extack, tb, ifname, 0);
3005errout:
3006	return err;
3007}
3008
3009static int rtnl_group_dellink(const struct net *net, int group)
3010{
3011	struct net_device *dev, *aux;
3012	LIST_HEAD(list_kill);
3013	bool found = false;
3014
3015	if (!group)
3016		return -EPERM;
3017
3018	for_each_netdev(net, dev) {
3019		if (dev->group == group) {
3020			const struct rtnl_link_ops *ops;
3021
3022			found = true;
3023			ops = dev->rtnl_link_ops;
3024			if (!ops || !ops->dellink)
3025				return -EOPNOTSUPP;
3026		}
3027	}
3028
3029	if (!found)
3030		return -ENODEV;
3031
3032	for_each_netdev_safe(net, dev, aux) {
3033		if (dev->group == group) {
3034			const struct rtnl_link_ops *ops;
3035
3036			ops = dev->rtnl_link_ops;
3037			ops->dellink(dev, &list_kill);
3038		}
3039	}
3040	unregister_netdevice_many(&list_kill);
3041
3042	return 0;
3043}
3044
3045int rtnl_delete_link(struct net_device *dev)
3046{
3047	const struct rtnl_link_ops *ops;
3048	LIST_HEAD(list_kill);
3049
3050	ops = dev->rtnl_link_ops;
3051	if (!ops || !ops->dellink)
3052		return -EOPNOTSUPP;
3053
3054	ops->dellink(dev, &list_kill);
3055	unregister_netdevice_many(&list_kill);
3056
3057	return 0;
3058}
3059EXPORT_SYMBOL_GPL(rtnl_delete_link);
3060
3061static int rtnl_dellink(struct sk_buff *skb, struct nlmsghdr *nlh,
3062			struct netlink_ext_ack *extack)
3063{
3064	struct net *net = sock_net(skb->sk);
3065	struct net *tgt_net = net;
3066	struct net_device *dev = NULL;
3067	struct ifinfomsg *ifm;
 
3068	struct nlattr *tb[IFLA_MAX+1];
3069	int err;
3070	int netnsid = -1;
3071
3072	err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
3073				     ifla_policy, extack);
3074	if (err < 0)
3075		return err;
3076
3077	err = rtnl_ensure_unique_netns(tb, extack, true);
3078	if (err < 0)
3079		return err;
3080
3081	if (tb[IFLA_TARGET_NETNSID]) {
3082		netnsid = nla_get_s32(tb[IFLA_TARGET_NETNSID]);
3083		tgt_net = rtnl_get_net_ns_capable(NETLINK_CB(skb).sk, netnsid);
 
 
 
3084		if (IS_ERR(tgt_net))
3085			return PTR_ERR(tgt_net);
3086	}
3087
3088	err = -EINVAL;
3089	ifm = nlmsg_data(nlh);
3090	if (ifm->ifi_index > 0)
3091		dev = __dev_get_by_index(tgt_net, ifm->ifi_index);
3092	else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3093		dev = rtnl_dev_get(net, tb[IFLA_IFNAME],
3094				   tb[IFLA_ALT_IFNAME], NULL);
3095	else if (tb[IFLA_GROUP])
3096		err = rtnl_group_dellink(tgt_net, nla_get_u32(tb[IFLA_GROUP]));
3097	else
3098		goto out;
3099
3100	if (!dev) {
3101		if (tb[IFLA_IFNAME] || ifm->ifi_index > 0)
3102			err = -ENODEV;
3103
3104		goto out;
3105	}
3106
3107	err = rtnl_delete_link(dev);
3108
3109out:
3110	if (netnsid >= 0)
3111		put_net(tgt_net);
3112
3113	return err;
3114}
3115
3116int rtnl_configure_link(struct net_device *dev, const struct ifinfomsg *ifm)
3117{
3118	unsigned int old_flags;
3119	int err;
3120
3121	old_flags = dev->flags;
3122	if (ifm && (ifm->ifi_flags || ifm->ifi_change)) {
3123		err = __dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm),
3124					 NULL);
3125		if (err < 0)
3126			return err;
3127	}
3128
3129	if (dev->rtnl_link_state == RTNL_LINK_INITIALIZED) {
3130		__dev_notify_flags(dev, old_flags, (old_flags ^ dev->flags));
3131	} else {
3132		dev->rtnl_link_state = RTNL_LINK_INITIALIZED;
3133		__dev_notify_flags(dev, old_flags, ~0U);
3134	}
3135	return 0;
3136}
3137EXPORT_SYMBOL(rtnl_configure_link);
3138
3139struct net_device *rtnl_create_link(struct net *net, const char *ifname,
3140				    unsigned char name_assign_type,
3141				    const struct rtnl_link_ops *ops,
3142				    struct nlattr *tb[],
3143				    struct netlink_ext_ack *extack)
3144{
3145	struct net_device *dev;
3146	unsigned int num_tx_queues = 1;
3147	unsigned int num_rx_queues = 1;
3148
3149	if (tb[IFLA_NUM_TX_QUEUES])
3150		num_tx_queues = nla_get_u32(tb[IFLA_NUM_TX_QUEUES]);
3151	else if (ops->get_num_tx_queues)
3152		num_tx_queues = ops->get_num_tx_queues();
3153
3154	if (tb[IFLA_NUM_RX_QUEUES])
3155		num_rx_queues = nla_get_u32(tb[IFLA_NUM_RX_QUEUES]);
3156	else if (ops->get_num_rx_queues)
3157		num_rx_queues = ops->get_num_rx_queues();
3158
3159	if (num_tx_queues < 1 || num_tx_queues > 4096) {
3160		NL_SET_ERR_MSG(extack, "Invalid number of transmit queues");
3161		return ERR_PTR(-EINVAL);
3162	}
3163
3164	if (num_rx_queues < 1 || num_rx_queues > 4096) {
3165		NL_SET_ERR_MSG(extack, "Invalid number of receive queues");
3166		return ERR_PTR(-EINVAL);
3167	}
3168
3169	dev = alloc_netdev_mqs(ops->priv_size, ifname, name_assign_type,
3170			       ops->setup, num_tx_queues, num_rx_queues);
3171	if (!dev)
3172		return ERR_PTR(-ENOMEM);
3173
3174	dev_net_set(dev, net);
3175	dev->rtnl_link_ops = ops;
3176	dev->rtnl_link_state = RTNL_LINK_INITIALIZING;
3177
3178	if (tb[IFLA_MTU]) {
3179		u32 mtu = nla_get_u32(tb[IFLA_MTU]);
3180		int err;
3181
3182		err = dev_validate_mtu(dev, mtu, extack);
3183		if (err) {
3184			free_netdev(dev);
3185			return ERR_PTR(err);
3186		}
3187		dev->mtu = mtu;
3188	}
3189	if (tb[IFLA_ADDRESS]) {
3190		memcpy(dev->dev_addr, nla_data(tb[IFLA_ADDRESS]),
3191				nla_len(tb[IFLA_ADDRESS]));
3192		dev->addr_assign_type = NET_ADDR_SET;
3193	}
3194	if (tb[IFLA_BROADCAST])
3195		memcpy(dev->broadcast, nla_data(tb[IFLA_BROADCAST]),
3196				nla_len(tb[IFLA_BROADCAST]));
3197	if (tb[IFLA_TXQLEN])
3198		dev->tx_queue_len = nla_get_u32(tb[IFLA_TXQLEN]);
3199	if (tb[IFLA_OPERSTATE])
3200		set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
3201	if (tb[IFLA_LINKMODE])
3202		dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]);
3203	if (tb[IFLA_GROUP])
3204		dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP]));
3205	if (tb[IFLA_GSO_MAX_SIZE])
3206		netif_set_gso_max_size(dev, nla_get_u32(tb[IFLA_GSO_MAX_SIZE]));
3207	if (tb[IFLA_GSO_MAX_SEGS])
3208		dev->gso_max_segs = nla_get_u32(tb[IFLA_GSO_MAX_SEGS]);
3209
3210	return dev;
3211}
3212EXPORT_SYMBOL(rtnl_create_link);
3213
3214static int rtnl_group_changelink(const struct sk_buff *skb,
3215		struct net *net, int group,
3216		struct ifinfomsg *ifm,
3217		struct netlink_ext_ack *extack,
3218		struct nlattr **tb)
3219{
3220	struct net_device *dev, *aux;
3221	int err;
3222
3223	for_each_netdev_safe(net, dev, aux) {
3224		if (dev->group == group) {
3225			err = do_setlink(skb, dev, ifm, extack, tb, NULL, 0);
3226			if (err < 0)
3227				return err;
3228		}
3229	}
3230
3231	return 0;
3232}
3233
3234static int __rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3235			  struct nlattr **attr, struct netlink_ext_ack *extack)
3236{
3237	struct nlattr *slave_attr[RTNL_SLAVE_MAX_TYPE + 1];
3238	unsigned char name_assign_type = NET_NAME_USER;
3239	struct nlattr *linkinfo[IFLA_INFO_MAX + 1];
3240	const struct rtnl_link_ops *m_ops = NULL;
3241	struct net_device *master_dev = NULL;
3242	struct net *net = sock_net(skb->sk);
3243	const struct rtnl_link_ops *ops;
3244	struct nlattr *tb[IFLA_MAX + 1];
3245	struct net *dest_net, *link_net;
3246	struct nlattr **slave_data;
3247	char kind[MODULE_NAME_LEN];
3248	struct net_device *dev;
 
3249	struct ifinfomsg *ifm;
 
3250	char ifname[IFNAMSIZ];
3251	struct nlattr **data;
 
 
3252	int err;
3253
3254#ifdef CONFIG_MODULES
3255replay:
3256#endif
3257	err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
3258				     ifla_policy, extack);
3259	if (err < 0)
3260		return err;
3261
3262	err = rtnl_ensure_unique_netns(tb, extack, false);
3263	if (err < 0)
3264		return err;
3265
3266	if (tb[IFLA_IFNAME])
3267		nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
3268	else
3269		ifname[0] = '\0';
3270
3271	ifm = nlmsg_data(nlh);
3272	if (ifm->ifi_index > 0)
3273		dev = __dev_get_by_index(net, ifm->ifi_index);
3274	else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3275		dev = rtnl_dev_get(net, NULL, tb[IFLA_ALT_IFNAME], ifname);
3276	else
3277		dev = NULL;
 
 
3278
3279	if (dev) {
3280		master_dev = netdev_master_upper_dev_get(dev);
3281		if (master_dev)
3282			m_ops = master_dev->rtnl_link_ops;
3283	}
3284
3285	err = validate_linkmsg(dev, tb);
3286	if (err < 0)
3287		return err;
3288
3289	if (tb[IFLA_LINKINFO]) {
3290		err = nla_parse_nested_deprecated(linkinfo, IFLA_INFO_MAX,
3291						  tb[IFLA_LINKINFO],
3292						  ifla_info_policy, NULL);
3293		if (err < 0)
3294			return err;
3295	} else
3296		memset(linkinfo, 0, sizeof(linkinfo));
3297
3298	if (linkinfo[IFLA_INFO_KIND]) {
3299		nla_strlcpy(kind, linkinfo[IFLA_INFO_KIND], sizeof(kind));
3300		ops = rtnl_link_ops_get(kind);
3301	} else {
3302		kind[0] = '\0';
3303		ops = NULL;
3304	}
3305
3306	data = NULL;
3307	if (ops) {
3308		if (ops->maxtype > RTNL_MAX_TYPE)
3309			return -EINVAL;
3310
3311		if (ops->maxtype && linkinfo[IFLA_INFO_DATA]) {
3312			err = nla_parse_nested_deprecated(attr, ops->maxtype,
3313							  linkinfo[IFLA_INFO_DATA],
3314							  ops->policy, extack);
3315			if (err < 0)
3316				return err;
3317			data = attr;
3318		}
3319		if (ops->validate) {
3320			err = ops->validate(tb, data, extack);
3321			if (err < 0)
3322				return err;
 
 
 
 
3323		}
3324	}
3325
3326	slave_data = NULL;
3327	if (m_ops) {
3328		if (m_ops->slave_maxtype > RTNL_SLAVE_MAX_TYPE)
3329			return -EINVAL;
3330
3331		if (m_ops->slave_maxtype &&
3332		    linkinfo[IFLA_INFO_SLAVE_DATA]) {
3333			err = nla_parse_nested_deprecated(slave_attr,
3334							  m_ops->slave_maxtype,
3335							  linkinfo[IFLA_INFO_SLAVE_DATA],
3336							  m_ops->slave_policy,
3337							  extack);
3338			if (err < 0)
3339				return err;
3340			slave_data = slave_attr;
 
 
3341		}
3342	}
3343
3344	if (dev) {
3345		int status = 0;
3346
3347		if (nlh->nlmsg_flags & NLM_F_EXCL)
3348			return -EEXIST;
3349		if (nlh->nlmsg_flags & NLM_F_REPLACE)
3350			return -EOPNOTSUPP;
3351
3352		if (linkinfo[IFLA_INFO_DATA]) {
3353			if (!ops || ops != dev->rtnl_link_ops ||
3354			    !ops->changelink)
3355				return -EOPNOTSUPP;
3356
3357			err = ops->changelink(dev, tb, data, extack);
3358			if (err < 0)
3359				return err;
3360			status |= DO_SETLINK_NOTIFY;
3361		}
3362
3363		if (linkinfo[IFLA_INFO_SLAVE_DATA]) {
3364			if (!m_ops || !m_ops->slave_changelink)
3365				return -EOPNOTSUPP;
 
 
3366
3367			err = m_ops->slave_changelink(master_dev, dev, tb,
3368						      slave_data, extack);
3369			if (err < 0)
3370				return err;
3371			status |= DO_SETLINK_NOTIFY;
3372		}
 
 
 
 
 
3373
3374		return do_setlink(skb, dev, ifm, extack, tb, ifname, status);
3375	}
 
3376
3377	if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
3378		if (ifm->ifi_index == 0 && tb[IFLA_GROUP])
3379			return rtnl_group_changelink(skb, net,
3380						nla_get_u32(tb[IFLA_GROUP]),
3381						ifm, extack, tb);
3382		return -ENODEV;
3383	}
3384
3385	if (tb[IFLA_MAP] || tb[IFLA_PROTINFO])
3386		return -EOPNOTSUPP;
3387
3388	if (!ops) {
3389#ifdef CONFIG_MODULES
3390		if (kind[0]) {
3391			__rtnl_unlock();
3392			request_module("rtnl-link-%s", kind);
3393			rtnl_lock();
3394			ops = rtnl_link_ops_get(kind);
3395			if (ops)
3396				goto replay;
3397		}
3398#endif
3399		NL_SET_ERR_MSG(extack, "Unknown device type");
3400		return -EOPNOTSUPP;
3401	}
3402
3403	if (!ops->setup)
3404		return -EOPNOTSUPP;
3405
3406	if (!ifname[0]) {
3407		snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind);
3408		name_assign_type = NET_NAME_ENUM;
3409	}
3410
3411	dest_net = rtnl_link_get_net_capable(skb, net, tb, CAP_NET_ADMIN);
3412	if (IS_ERR(dest_net))
3413		return PTR_ERR(dest_net);
3414
3415	if (tb[IFLA_LINK_NETNSID]) {
3416		int id = nla_get_s32(tb[IFLA_LINK_NETNSID]);
3417
3418		link_net = get_net_ns_by_id(dest_net, id);
3419		if (!link_net) {
3420			NL_SET_ERR_MSG(extack, "Unknown network namespace id");
3421			err =  -EINVAL;
3422			goto out;
3423		}
3424		err = -EPERM;
3425		if (!netlink_ns_capable(skb, link_net->user_ns, CAP_NET_ADMIN))
3426			goto out;
3427	} else {
3428		link_net = NULL;
3429	}
3430
3431	dev = rtnl_create_link(link_net ? : dest_net, ifname,
3432			       name_assign_type, ops, tb, extack);
3433	if (IS_ERR(dev)) {
3434		err = PTR_ERR(dev);
3435		goto out;
3436	}
3437
3438	dev->ifindex = ifm->ifi_index;
 
3439
3440	if (ops->newlink) {
3441		err = ops->newlink(link_net ? : net, dev, tb, data, extack);
3442		/* Drivers should call free_netdev() in ->destructor
3443		 * and unregister it on failure after registration
3444		 * so that device could be finally freed in rtnl_unlock.
3445		 */
3446		if (err < 0) {
3447			/* If device is not registered at all, free it now */
3448			if (dev->reg_state == NETREG_UNINITIALIZED ||
3449			    dev->reg_state == NETREG_UNREGISTERED)
3450				free_netdev(dev);
3451			goto out;
3452		}
3453	} else {
3454		err = register_netdevice(dev);
3455		if (err < 0) {
3456			free_netdev(dev);
 
3457			goto out;
3458		}
3459	}
3460	err = rtnl_configure_link(dev, ifm);
3461	if (err < 0)
3462		goto out_unregister;
3463	if (link_net) {
3464		err = dev_change_net_namespace(dev, dest_net, ifname);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3465		if (err < 0)
3466			goto out_unregister;
3467	}
3468	if (tb[IFLA_MASTER]) {
3469		err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), extack);
3470		if (err)
3471			goto out_unregister;
3472	}
 
 
 
 
 
3473out:
3474	if (link_net)
3475		put_net(link_net);
3476	put_net(dest_net);
3477	return err;
3478out_unregister:
3479	if (ops->newlink) {
3480		LIST_HEAD(list_kill);
3481
3482		ops->dellink(dev, &list_kill);
3483		unregister_netdevice_many(&list_kill);
3484	} else {
3485		unregister_netdevice(dev);
3486	}
3487	goto out;
3488}
3489
3490static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3491			struct netlink_ext_ack *extack)
3492{
3493	struct nlattr **attr;
3494	int ret;
3495
3496	attr = kmalloc_array(RTNL_MAX_TYPE + 1, sizeof(*attr), GFP_KERNEL);
3497	if (!attr)
3498		return -ENOMEM;
3499
3500	ret = __rtnl_newlink(skb, nlh, attr, extack);
3501	kfree(attr);
3502	return ret;
3503}
3504
3505static int rtnl_valid_getlink_req(struct sk_buff *skb,
3506				  const struct nlmsghdr *nlh,
3507				  struct nlattr **tb,
3508				  struct netlink_ext_ack *extack)
3509{
3510	struct ifinfomsg *ifm;
3511	int i, err;
3512
3513	if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
3514		NL_SET_ERR_MSG(extack, "Invalid header for get link");
3515		return -EINVAL;
3516	}
3517
3518	if (!netlink_strict_get_check(skb))
3519		return nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
3520					      ifla_policy, extack);
3521
3522	ifm = nlmsg_data(nlh);
3523	if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
3524	    ifm->ifi_change) {
3525		NL_SET_ERR_MSG(extack, "Invalid values in header for get link request");
3526		return -EINVAL;
3527	}
3528
3529	err = nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb, IFLA_MAX,
3530					    ifla_policy, extack);
3531	if (err)
3532		return err;
 
 
 
3533
3534	for (i = 0; i <= IFLA_MAX; i++) {
3535		if (!tb[i])
3536			continue;
3537
3538		switch (i) {
3539		case IFLA_IFNAME:
3540		case IFLA_ALT_IFNAME:
3541		case IFLA_EXT_MASK:
3542		case IFLA_TARGET_NETNSID:
3543			break;
3544		default:
3545			NL_SET_ERR_MSG(extack, "Unsupported attribute in get link request");
3546			return -EINVAL;
3547		}
 
3548	}
3549
3550	return 0;
3551}
3552
3553static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3554			struct netlink_ext_ack *extack)
3555{
3556	struct net *net = sock_net(skb->sk);
3557	struct net *tgt_net = net;
3558	struct ifinfomsg *ifm;
 
3559	struct nlattr *tb[IFLA_MAX+1];
3560	struct net_device *dev = NULL;
3561	struct sk_buff *nskb;
3562	int netnsid = -1;
3563	int err;
3564	u32 ext_filter_mask = 0;
3565
3566	err = rtnl_valid_getlink_req(skb, nlh, tb, extack);
3567	if (err < 0)
3568		return err;
3569
3570	err = rtnl_ensure_unique_netns(tb, extack, true);
3571	if (err < 0)
3572		return err;
3573
3574	if (tb[IFLA_TARGET_NETNSID]) {
3575		netnsid = nla_get_s32(tb[IFLA_TARGET_NETNSID]);
3576		tgt_net = rtnl_get_net_ns_capable(NETLINK_CB(skb).sk, netnsid);
3577		if (IS_ERR(tgt_net))
3578			return PTR_ERR(tgt_net);
3579	}
3580
 
 
 
3581	if (tb[IFLA_EXT_MASK])
3582		ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
3583
3584	err = -EINVAL;
3585	ifm = nlmsg_data(nlh);
3586	if (ifm->ifi_index > 0)
3587		dev = __dev_get_by_index(tgt_net, ifm->ifi_index);
3588	else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3589		dev = rtnl_dev_get(tgt_net, tb[IFLA_IFNAME],
3590				   tb[IFLA_ALT_IFNAME], NULL);
3591	else
3592		goto out;
3593
3594	err = -ENODEV;
3595	if (dev == NULL)
3596		goto out;
3597
3598	err = -ENOBUFS;
3599	nskb = nlmsg_new(if_nlmsg_size(dev, ext_filter_mask), GFP_KERNEL);
3600	if (nskb == NULL)
3601		goto out;
3602
3603	err = rtnl_fill_ifinfo(nskb, dev, net,
3604			       RTM_NEWLINK, NETLINK_CB(skb).portid,
3605			       nlh->nlmsg_seq, 0, 0, ext_filter_mask,
3606			       0, NULL, 0, netnsid, GFP_KERNEL);
3607	if (err < 0) {
3608		/* -EMSGSIZE implies BUG in if_nlmsg_size */
3609		WARN_ON(err == -EMSGSIZE);
3610		kfree_skb(nskb);
3611	} else
3612		err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid);
3613out:
3614	if (netnsid >= 0)
3615		put_net(tgt_net);
3616
3617	return err;
3618}
3619
3620static int rtnl_alt_ifname(int cmd, struct net_device *dev, struct nlattr *attr,
3621			   bool *changed, struct netlink_ext_ack *extack)
3622{
3623	char *alt_ifname;
3624	int err;
3625
3626	err = nla_validate(attr, attr->nla_len, IFLA_MAX, ifla_policy, extack);
3627	if (err)
3628		return err;
3629
3630	alt_ifname = nla_strdup(attr, GFP_KERNEL);
3631	if (!alt_ifname)
3632		return -ENOMEM;
3633
3634	if (cmd == RTM_NEWLINKPROP) {
3635		err = netdev_name_node_alt_create(dev, alt_ifname);
3636		if (!err)
3637			alt_ifname = NULL;
3638	} else if (cmd == RTM_DELLINKPROP) {
3639		err = netdev_name_node_alt_destroy(dev, alt_ifname);
3640	} else {
3641		WARN_ON_ONCE(1);
3642		err = -EINVAL;
3643	}
3644
3645	kfree(alt_ifname);
3646	if (!err)
3647		*changed = true;
3648	return err;
3649}
3650
3651static int rtnl_linkprop(int cmd, struct sk_buff *skb, struct nlmsghdr *nlh,
3652			 struct netlink_ext_ack *extack)
3653{
3654	struct net *net = sock_net(skb->sk);
3655	struct nlattr *tb[IFLA_MAX + 1];
3656	struct net_device *dev;
3657	struct ifinfomsg *ifm;
3658	bool changed = false;
3659	struct nlattr *attr;
3660	int err, rem;
3661
3662	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy, extack);
3663	if (err)
3664		return err;
3665
3666	err = rtnl_ensure_unique_netns(tb, extack, true);
3667	if (err)
3668		return err;
3669
3670	ifm = nlmsg_data(nlh);
3671	if (ifm->ifi_index > 0)
3672		dev = __dev_get_by_index(net, ifm->ifi_index);
3673	else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3674		dev = rtnl_dev_get(net, tb[IFLA_IFNAME],
3675				   tb[IFLA_ALT_IFNAME], NULL);
3676	else
3677		return -EINVAL;
3678
3679	if (!dev)
3680		return -ENODEV;
3681
3682	if (!tb[IFLA_PROP_LIST])
3683		return 0;
3684
3685	nla_for_each_nested(attr, tb[IFLA_PROP_LIST], rem) {
3686		switch (nla_type(attr)) {
3687		case IFLA_ALT_IFNAME:
3688			err = rtnl_alt_ifname(cmd, dev, attr, &changed, extack);
3689			if (err)
3690				return err;
3691			break;
3692		}
3693	}
3694
3695	if (changed)
3696		netdev_state_change(dev);
3697	return 0;
3698}
3699
3700static int rtnl_newlinkprop(struct sk_buff *skb, struct nlmsghdr *nlh,
3701			    struct netlink_ext_ack *extack)
3702{
3703	return rtnl_linkprop(RTM_NEWLINKPROP, skb, nlh, extack);
3704}
3705
3706static int rtnl_dellinkprop(struct sk_buff *skb, struct nlmsghdr *nlh,
3707			    struct netlink_ext_ack *extack)
3708{
3709	return rtnl_linkprop(RTM_DELLINKPROP, skb, nlh, extack);
3710}
3711
3712static u16 rtnl_calcit(struct sk_buff *skb, struct nlmsghdr *nlh)
3713{
3714	struct net *net = sock_net(skb->sk);
3715	struct net_device *dev;
3716	struct nlattr *tb[IFLA_MAX+1];
3717	u32 ext_filter_mask = 0;
3718	u16 min_ifinfo_dump_size = 0;
3719	int hdrlen;
3720
3721	/* Same kernel<->userspace interface hack as in rtnl_dump_ifinfo. */
3722	hdrlen = nlmsg_len(nlh) < sizeof(struct ifinfomsg) ?
3723		 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg);
3724
3725	if (nlmsg_parse_deprecated(nlh, hdrlen, tb, IFLA_MAX, ifla_policy, NULL) >= 0) {
3726		if (tb[IFLA_EXT_MASK])
3727			ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
3728	}
3729
3730	if (!ext_filter_mask)
3731		return NLMSG_GOODSIZE;
3732	/*
3733	 * traverse the list of net devices and compute the minimum
3734	 * buffer size based upon the filter mask.
3735	 */
3736	rcu_read_lock();
3737	for_each_netdev_rcu(net, dev) {
3738		min_ifinfo_dump_size = max_t(u16, min_ifinfo_dump_size,
3739					     if_nlmsg_size(dev,
3740						           ext_filter_mask));
3741	}
3742	rcu_read_unlock();
3743
3744	return nlmsg_total_size(min_ifinfo_dump_size);
3745}
3746
3747static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb)
3748{
3749	int idx;
3750	int s_idx = cb->family;
3751	int type = cb->nlh->nlmsg_type - RTM_BASE;
3752	int ret = 0;
3753
3754	if (s_idx == 0)
3755		s_idx = 1;
3756
3757	for (idx = 1; idx <= RTNL_FAMILY_MAX; idx++) {
3758		struct rtnl_link **tab;
 
3759		struct rtnl_link *link;
3760		rtnl_dumpit_func dumpit;
3761
3762		if (idx < s_idx || idx == PF_PACKET)
3763			continue;
3764
3765		if (type < 0 || type >= RTM_NR_MSGTYPES)
3766			continue;
3767
3768		tab = rcu_dereference_rtnl(rtnl_msg_handlers[idx]);
3769		if (!tab)
3770			continue;
3771
3772		link = tab[type];
3773		if (!link)
3774			continue;
3775
3776		dumpit = link->dumpit;
3777		if (!dumpit)
3778			continue;
3779
3780		if (idx > s_idx) {
3781			memset(&cb->args[0], 0, sizeof(cb->args));
3782			cb->prev_seq = 0;
3783			cb->seq = 0;
3784		}
3785		ret = dumpit(skb, cb);
3786		if (ret)
3787			break;
3788	}
3789	cb->family = idx;
3790
3791	return skb->len ? : ret;
3792}
3793
3794struct sk_buff *rtmsg_ifinfo_build_skb(int type, struct net_device *dev,
3795				       unsigned int change,
3796				       u32 event, gfp_t flags, int *new_nsid,
3797				       int new_ifindex)
3798{
3799	struct net *net = dev_net(dev);
3800	struct sk_buff *skb;
3801	int err = -ENOBUFS;
3802	size_t if_info_size;
3803
3804	skb = nlmsg_new((if_info_size = if_nlmsg_size(dev, 0)), flags);
3805	if (skb == NULL)
3806		goto errout;
3807
3808	err = rtnl_fill_ifinfo(skb, dev, dev_net(dev),
3809			       type, 0, 0, change, 0, 0, event,
3810			       new_nsid, new_ifindex, -1, flags);
3811	if (err < 0) {
3812		/* -EMSGSIZE implies BUG in if_nlmsg_size() */
3813		WARN_ON(err == -EMSGSIZE);
3814		kfree_skb(skb);
3815		goto errout;
3816	}
3817	return skb;
3818errout:
3819	if (err < 0)
3820		rtnl_set_sk_err(net, RTNLGRP_LINK, err);
3821	return NULL;
3822}
3823
3824void rtmsg_ifinfo_send(struct sk_buff *skb, struct net_device *dev, gfp_t flags)
3825{
3826	struct net *net = dev_net(dev);
3827
3828	rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, flags);
3829}
3830
3831static void rtmsg_ifinfo_event(int type, struct net_device *dev,
3832			       unsigned int change, u32 event,
3833			       gfp_t flags, int *new_nsid, int new_ifindex)
3834{
3835	struct sk_buff *skb;
3836
3837	if (dev->reg_state != NETREG_REGISTERED)
3838		return;
3839
3840	skb = rtmsg_ifinfo_build_skb(type, dev, change, event, flags, new_nsid,
3841				     new_ifindex);
3842	if (skb)
3843		rtmsg_ifinfo_send(skb, dev, flags);
3844}
3845
3846void rtmsg_ifinfo(int type, struct net_device *dev, unsigned int change,
3847		  gfp_t flags)
3848{
3849	rtmsg_ifinfo_event(type, dev, change, rtnl_get_event(0), flags,
3850			   NULL, 0);
3851}
3852
3853void rtmsg_ifinfo_newnet(int type, struct net_device *dev, unsigned int change,
3854			 gfp_t flags, int *new_nsid, int new_ifindex)
3855{
3856	rtmsg_ifinfo_event(type, dev, change, rtnl_get_event(0), flags,
3857			   new_nsid, new_ifindex);
3858}
3859
3860static int nlmsg_populate_fdb_fill(struct sk_buff *skb,
3861				   struct net_device *dev,
3862				   u8 *addr, u16 vid, u32 pid, u32 seq,
3863				   int type, unsigned int flags,
3864				   int nlflags, u16 ndm_state)
3865{
3866	struct nlmsghdr *nlh;
3867	struct ndmsg *ndm;
3868
3869	nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), nlflags);
3870	if (!nlh)
3871		return -EMSGSIZE;
3872
3873	ndm = nlmsg_data(nlh);
3874	ndm->ndm_family  = AF_BRIDGE;
3875	ndm->ndm_pad1	 = 0;
3876	ndm->ndm_pad2    = 0;
3877	ndm->ndm_flags	 = flags;
3878	ndm->ndm_type	 = 0;
3879	ndm->ndm_ifindex = dev->ifindex;
3880	ndm->ndm_state   = ndm_state;
3881
3882	if (nla_put(skb, NDA_LLADDR, ETH_ALEN, addr))
3883		goto nla_put_failure;
3884	if (vid)
3885		if (nla_put(skb, NDA_VLAN, sizeof(u16), &vid))
3886			goto nla_put_failure;
3887
3888	nlmsg_end(skb, nlh);
3889	return 0;
3890
3891nla_put_failure:
3892	nlmsg_cancel(skb, nlh);
3893	return -EMSGSIZE;
3894}
3895
3896static inline size_t rtnl_fdb_nlmsg_size(void)
3897{
3898	return NLMSG_ALIGN(sizeof(struct ndmsg)) +
3899	       nla_total_size(ETH_ALEN) +	/* NDA_LLADDR */
3900	       nla_total_size(sizeof(u16)) +	/* NDA_VLAN */
3901	       0;
3902}
3903
3904static void rtnl_fdb_notify(struct net_device *dev, u8 *addr, u16 vid, int type,
3905			    u16 ndm_state)
3906{
3907	struct net *net = dev_net(dev);
3908	struct sk_buff *skb;
3909	int err = -ENOBUFS;
3910
3911	skb = nlmsg_new(rtnl_fdb_nlmsg_size(), GFP_ATOMIC);
3912	if (!skb)
3913		goto errout;
3914
3915	err = nlmsg_populate_fdb_fill(skb, dev, addr, vid,
3916				      0, 0, type, NTF_SELF, 0, ndm_state);
3917	if (err < 0) {
3918		kfree_skb(skb);
3919		goto errout;
3920	}
3921
3922	rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
3923	return;
3924errout:
3925	rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
3926}
3927
3928/*
3929 * ndo_dflt_fdb_add - default netdevice operation to add an FDB entry
3930 */
3931int ndo_dflt_fdb_add(struct ndmsg *ndm,
3932		     struct nlattr *tb[],
3933		     struct net_device *dev,
3934		     const unsigned char *addr, u16 vid,
3935		     u16 flags)
3936{
3937	int err = -EINVAL;
3938
3939	/* If aging addresses are supported device will need to
3940	 * implement its own handler for this.
3941	 */
3942	if (ndm->ndm_state && !(ndm->ndm_state & NUD_PERMANENT)) {
3943		pr_info("%s: FDB only supports static addresses\n", dev->name);
3944		return err;
3945	}
3946
3947	if (vid) {
3948		pr_info("%s: vlans aren't supported yet for dev_uc|mc_add()\n", dev->name);
3949		return err;
3950	}
3951
3952	if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr))
3953		err = dev_uc_add_excl(dev, addr);
3954	else if (is_multicast_ether_addr(addr))
3955		err = dev_mc_add_excl(dev, addr);
3956
3957	/* Only return duplicate errors if NLM_F_EXCL is set */
3958	if (err == -EEXIST && !(flags & NLM_F_EXCL))
3959		err = 0;
3960
3961	return err;
3962}
3963EXPORT_SYMBOL(ndo_dflt_fdb_add);
3964
3965static int fdb_vid_parse(struct nlattr *vlan_attr, u16 *p_vid,
3966			 struct netlink_ext_ack *extack)
3967{
3968	u16 vid = 0;
3969
3970	if (vlan_attr) {
3971		if (nla_len(vlan_attr) != sizeof(u16)) {
3972			NL_SET_ERR_MSG(extack, "invalid vlan attribute size");
3973			return -EINVAL;
3974		}
3975
3976		vid = nla_get_u16(vlan_attr);
3977
3978		if (!vid || vid >= VLAN_VID_MASK) {
3979			NL_SET_ERR_MSG(extack, "invalid vlan id");
3980			return -EINVAL;
3981		}
3982	}
3983	*p_vid = vid;
3984	return 0;
3985}
3986
3987static int rtnl_fdb_add(struct sk_buff *skb, struct nlmsghdr *nlh,
3988			struct netlink_ext_ack *extack)
3989{
3990	struct net *net = sock_net(skb->sk);
3991	struct ndmsg *ndm;
3992	struct nlattr *tb[NDA_MAX+1];
3993	struct net_device *dev;
3994	u8 *addr;
3995	u16 vid;
3996	int err;
3997
3998	err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX, NULL,
3999				     extack);
4000	if (err < 0)
4001		return err;
4002
4003	ndm = nlmsg_data(nlh);
4004	if (ndm->ndm_ifindex == 0) {
4005		NL_SET_ERR_MSG(extack, "invalid ifindex");
4006		return -EINVAL;
4007	}
4008
4009	dev = __dev_get_by_index(net, ndm->ndm_ifindex);
4010	if (dev == NULL) {
4011		NL_SET_ERR_MSG(extack, "unknown ifindex");
4012		return -ENODEV;
4013	}
4014
4015	if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
4016		NL_SET_ERR_MSG(extack, "invalid address");
4017		return -EINVAL;
4018	}
4019
4020	if (dev->type != ARPHRD_ETHER) {
4021		NL_SET_ERR_MSG(extack, "FDB add only supported for Ethernet devices");
4022		return -EINVAL;
4023	}
4024
4025	addr = nla_data(tb[NDA_LLADDR]);
4026
4027	err = fdb_vid_parse(tb[NDA_VLAN], &vid, extack);
4028	if (err)
4029		return err;
4030
4031	err = -EOPNOTSUPP;
4032
4033	/* Support fdb on master device the net/bridge default case */
4034	if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) &&
4035	    netif_is_bridge_port(dev)) {
4036		struct net_device *br_dev = netdev_master_upper_dev_get(dev);
4037		const struct net_device_ops *ops = br_dev->netdev_ops;
4038
4039		err = ops->ndo_fdb_add(ndm, tb, dev, addr, vid,
4040				       nlh->nlmsg_flags, extack);
4041		if (err)
4042			goto out;
4043		else
4044			ndm->ndm_flags &= ~NTF_MASTER;
4045	}
4046
4047	/* Embedded bridge, macvlan, and any other device support */
4048	if ((ndm->ndm_flags & NTF_SELF)) {
4049		if (dev->netdev_ops->ndo_fdb_add)
4050			err = dev->netdev_ops->ndo_fdb_add(ndm, tb, dev, addr,
4051							   vid,
4052							   nlh->nlmsg_flags,
4053							   extack);
4054		else
4055			err = ndo_dflt_fdb_add(ndm, tb, dev, addr, vid,
4056					       nlh->nlmsg_flags);
4057
4058		if (!err) {
4059			rtnl_fdb_notify(dev, addr, vid, RTM_NEWNEIGH,
4060					ndm->ndm_state);
4061			ndm->ndm_flags &= ~NTF_SELF;
4062		}
4063	}
4064out:
4065	return err;
4066}
4067
4068/*
4069 * ndo_dflt_fdb_del - default netdevice operation to delete an FDB entry
4070 */
4071int ndo_dflt_fdb_del(struct ndmsg *ndm,
4072		     struct nlattr *tb[],
4073		     struct net_device *dev,
4074		     const unsigned char *addr, u16 vid)
4075{
4076	int err = -EINVAL;
4077
4078	/* If aging addresses are supported device will need to
4079	 * implement its own handler for this.
4080	 */
4081	if (!(ndm->ndm_state & NUD_PERMANENT)) {
4082		pr_info("%s: FDB only supports static addresses\n", dev->name);
4083		return err;
4084	}
4085
4086	if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr))
4087		err = dev_uc_del(dev, addr);
4088	else if (is_multicast_ether_addr(addr))
4089		err = dev_mc_del(dev, addr);
4090
4091	return err;
4092}
4093EXPORT_SYMBOL(ndo_dflt_fdb_del);
4094
4095static int rtnl_fdb_del(struct sk_buff *skb, struct nlmsghdr *nlh,
4096			struct netlink_ext_ack *extack)
4097{
4098	struct net *net = sock_net(skb->sk);
4099	struct ndmsg *ndm;
4100	struct nlattr *tb[NDA_MAX+1];
4101	struct net_device *dev;
 
4102	__u8 *addr;
4103	int err;
4104	u16 vid;
4105
4106	if (!netlink_capable(skb, CAP_NET_ADMIN))
4107		return -EPERM;
4108
4109	err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX, NULL,
4110				     extack);
4111	if (err < 0)
4112		return err;
4113
4114	ndm = nlmsg_data(nlh);
4115	if (ndm->ndm_ifindex == 0) {
4116		NL_SET_ERR_MSG(extack, "invalid ifindex");
4117		return -EINVAL;
4118	}
4119
4120	dev = __dev_get_by_index(net, ndm->ndm_ifindex);
4121	if (dev == NULL) {
4122		NL_SET_ERR_MSG(extack, "unknown ifindex");
4123		return -ENODEV;
4124	}
4125
4126	if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
4127		NL_SET_ERR_MSG(extack, "invalid address");
4128		return -EINVAL;
4129	}
4130
4131	if (dev->type != ARPHRD_ETHER) {
4132		NL_SET_ERR_MSG(extack, "FDB delete only supported for Ethernet devices");
4133		return -EINVAL;
4134	}
4135
4136	addr = nla_data(tb[NDA_LLADDR]);
4137
4138	err = fdb_vid_parse(tb[NDA_VLAN], &vid, extack);
4139	if (err)
4140		return err;
4141
4142	err = -EOPNOTSUPP;
4143
4144	/* Support fdb on master device the net/bridge default case */
4145	if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) &&
4146	    netif_is_bridge_port(dev)) {
4147		struct net_device *br_dev = netdev_master_upper_dev_get(dev);
4148		const struct net_device_ops *ops = br_dev->netdev_ops;
4149
4150		if (ops->ndo_fdb_del)
4151			err = ops->ndo_fdb_del(ndm, tb, dev, addr, vid);
4152
4153		if (err)
4154			goto out;
4155		else
4156			ndm->ndm_flags &= ~NTF_MASTER;
4157	}
4158
4159	/* Embedded bridge, macvlan, and any other device support */
4160	if (ndm->ndm_flags & NTF_SELF) {
4161		if (dev->netdev_ops->ndo_fdb_del)
4162			err = dev->netdev_ops->ndo_fdb_del(ndm, tb, dev, addr,
4163							   vid);
4164		else
4165			err = ndo_dflt_fdb_del(ndm, tb, dev, addr, vid);
4166
4167		if (!err) {
4168			rtnl_fdb_notify(dev, addr, vid, RTM_DELNEIGH,
4169					ndm->ndm_state);
4170			ndm->ndm_flags &= ~NTF_SELF;
4171		}
4172	}
4173out:
4174	return err;
4175}
4176
4177static int nlmsg_populate_fdb(struct sk_buff *skb,
4178			      struct netlink_callback *cb,
4179			      struct net_device *dev,
4180			      int *idx,
4181			      struct netdev_hw_addr_list *list)
4182{
4183	struct netdev_hw_addr *ha;
4184	int err;
4185	u32 portid, seq;
4186
4187	portid = NETLINK_CB(cb->skb).portid;
4188	seq = cb->nlh->nlmsg_seq;
4189
4190	list_for_each_entry(ha, &list->list, list) {
4191		if (*idx < cb->args[2])
4192			goto skip;
4193
4194		err = nlmsg_populate_fdb_fill(skb, dev, ha->addr, 0,
4195					      portid, seq,
4196					      RTM_NEWNEIGH, NTF_SELF,
4197					      NLM_F_MULTI, NUD_PERMANENT);
4198		if (err < 0)
4199			return err;
4200skip:
4201		*idx += 1;
4202	}
4203	return 0;
4204}
4205
4206/**
4207 * ndo_dflt_fdb_dump - default netdevice operation to dump an FDB table.
4208 * @skb: socket buffer to store message in
4209 * @cb: netlink callback
4210 * @dev: netdevice
4211 * @filter_dev: ignored
4212 * @idx: the number of FDB table entries dumped is added to *@idx
4213 *
4214 * Default netdevice operation to dump the existing unicast address list.
4215 * Returns number of addresses from list put in skb.
4216 */
4217int ndo_dflt_fdb_dump(struct sk_buff *skb,
4218		      struct netlink_callback *cb,
4219		      struct net_device *dev,
4220		      struct net_device *filter_dev,
4221		      int *idx)
4222{
4223	int err;
4224
4225	if (dev->type != ARPHRD_ETHER)
4226		return -EINVAL;
4227
4228	netif_addr_lock_bh(dev);
4229	err = nlmsg_populate_fdb(skb, cb, dev, idx, &dev->uc);
4230	if (err)
4231		goto out;
4232	err = nlmsg_populate_fdb(skb, cb, dev, idx, &dev->mc);
4233out:
4234	netif_addr_unlock_bh(dev);
4235	return err;
4236}
4237EXPORT_SYMBOL(ndo_dflt_fdb_dump);
4238
4239static int valid_fdb_dump_strict(const struct nlmsghdr *nlh,
4240				 int *br_idx, int *brport_idx,
4241				 struct netlink_ext_ack *extack)
4242{
4243	struct nlattr *tb[NDA_MAX + 1];
4244	struct ndmsg *ndm;
4245	int err, i;
4246
4247	if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ndm))) {
4248		NL_SET_ERR_MSG(extack, "Invalid header for fdb dump request");
4249		return -EINVAL;
4250	}
4251
4252	ndm = nlmsg_data(nlh);
4253	if (ndm->ndm_pad1  || ndm->ndm_pad2  || ndm->ndm_state ||
4254	    ndm->ndm_flags || ndm->ndm_type) {
4255		NL_SET_ERR_MSG(extack, "Invalid values in header for fdb dump request");
4256		return -EINVAL;
4257	}
4258
4259	err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct ndmsg), tb,
4260					    NDA_MAX, NULL, extack);
4261	if (err < 0)
4262		return err;
4263
4264	*brport_idx = ndm->ndm_ifindex;
4265	for (i = 0; i <= NDA_MAX; ++i) {
4266		if (!tb[i])
4267			continue;
4268
4269		switch (i) {
4270		case NDA_IFINDEX:
4271			if (nla_len(tb[i]) != sizeof(u32)) {
4272				NL_SET_ERR_MSG(extack, "Invalid IFINDEX attribute in fdb dump request");
4273				return -EINVAL;
4274			}
4275			*brport_idx = nla_get_u32(tb[NDA_IFINDEX]);
4276			break;
4277		case NDA_MASTER:
4278			if (nla_len(tb[i]) != sizeof(u32)) {
4279				NL_SET_ERR_MSG(extack, "Invalid MASTER attribute in fdb dump request");
4280				return -EINVAL;
4281			}
4282			*br_idx = nla_get_u32(tb[NDA_MASTER]);
4283			break;
4284		default:
4285			NL_SET_ERR_MSG(extack, "Unsupported attribute in fdb dump request");
4286			return -EINVAL;
4287		}
4288	}
4289
4290	return 0;
4291}
4292
4293static int valid_fdb_dump_legacy(const struct nlmsghdr *nlh,
4294				 int *br_idx, int *brport_idx,
4295				 struct netlink_ext_ack *extack)
4296{
4297	struct nlattr *tb[IFLA_MAX+1];
4298	int err;
4299
4300	/* A hack to preserve kernel<->userspace interface.
4301	 * Before Linux v4.12 this code accepted ndmsg since iproute2 v3.3.0.
4302	 * However, ndmsg is shorter than ifinfomsg thus nlmsg_parse() bails.
4303	 * So, check for ndmsg with an optional u32 attribute (not used here).
4304	 * Fortunately these sizes don't conflict with the size of ifinfomsg
4305	 * with an optional attribute.
4306	 */
4307	if (nlmsg_len(nlh) != sizeof(struct ndmsg) &&
4308	    (nlmsg_len(nlh) != sizeof(struct ndmsg) +
4309	     nla_attr_size(sizeof(u32)))) {
4310		struct ifinfomsg *ifm;
4311
4312		err = nlmsg_parse_deprecated(nlh, sizeof(struct ifinfomsg),
4313					     tb, IFLA_MAX, ifla_policy,
4314					     extack);
4315		if (err < 0) {
4316			return -EINVAL;
4317		} else if (err == 0) {
4318			if (tb[IFLA_MASTER])
4319				*br_idx = nla_get_u32(tb[IFLA_MASTER]);
4320		}
4321
4322		ifm = nlmsg_data(nlh);
4323		*brport_idx = ifm->ifi_index;
4324	}
4325	return 0;
4326}
4327
4328static int rtnl_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb)
4329{
4330	struct net_device *dev;
 
4331	struct net_device *br_dev = NULL;
4332	const struct net_device_ops *ops = NULL;
4333	const struct net_device_ops *cops = NULL;
 
4334	struct net *net = sock_net(skb->sk);
4335	struct hlist_head *head;
4336	int brport_idx = 0;
4337	int br_idx = 0;
4338	int h, s_h;
4339	int idx = 0, s_idx;
4340	int err = 0;
4341	int fidx = 0;
4342
4343	if (cb->strict_check)
4344		err = valid_fdb_dump_strict(cb->nlh, &br_idx, &brport_idx,
4345					    cb->extack);
4346	else
4347		err = valid_fdb_dump_legacy(cb->nlh, &br_idx, &brport_idx,
4348					    cb->extack);
4349	if (err < 0)
4350		return err;
 
 
4351
4352	if (br_idx) {
4353		br_dev = __dev_get_by_index(net, br_idx);
4354		if (!br_dev)
4355			return -ENODEV;
4356
4357		ops = br_dev->netdev_ops;
4358	}
4359
4360	s_h = cb->args[0];
4361	s_idx = cb->args[1];
4362
4363	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
4364		idx = 0;
4365		head = &net->dev_index_head[h];
4366		hlist_for_each_entry(dev, head, index_hlist) {
4367
4368			if (brport_idx && (dev->ifindex != brport_idx))
4369				continue;
4370
4371			if (!br_idx) { /* user did not specify a specific bridge */
4372				if (netif_is_bridge_port(dev)) {
4373					br_dev = netdev_master_upper_dev_get(dev);
4374					cops = br_dev->netdev_ops;
4375				}
4376			} else {
4377				if (dev != br_dev &&
4378				    !netif_is_bridge_port(dev))
4379					continue;
4380
4381				if (br_dev != netdev_master_upper_dev_get(dev) &&
4382				    !(dev->priv_flags & IFF_EBRIDGE))
4383					continue;
4384				cops = ops;
4385			}
4386
4387			if (idx < s_idx)
4388				goto cont;
4389
4390			if (netif_is_bridge_port(dev)) {
4391				if (cops && cops->ndo_fdb_dump) {
4392					err = cops->ndo_fdb_dump(skb, cb,
4393								br_dev, dev,
4394								&fidx);
4395					if (err == -EMSGSIZE)
4396						goto out;
4397				}
4398			}
4399
4400			if (dev->netdev_ops->ndo_fdb_dump)
4401				err = dev->netdev_ops->ndo_fdb_dump(skb, cb,
4402								    dev, NULL,
4403								    &fidx);
4404			else
4405				err = ndo_dflt_fdb_dump(skb, cb, dev, NULL,
4406							&fidx);
4407			if (err == -EMSGSIZE)
4408				goto out;
4409
4410			cops = NULL;
4411
4412			/* reset fdb offset to 0 for rest of the interfaces */
4413			cb->args[2] = 0;
4414			fidx = 0;
4415cont:
4416			idx++;
4417		}
4418	}
4419
4420out:
4421	cb->args[0] = h;
4422	cb->args[1] = idx;
4423	cb->args[2] = fidx;
4424
4425	return skb->len;
4426}
4427
4428static int valid_fdb_get_strict(const struct nlmsghdr *nlh,
4429				struct nlattr **tb, u8 *ndm_flags,
4430				int *br_idx, int *brport_idx, u8 **addr,
4431				u16 *vid, struct netlink_ext_ack *extack)
4432{
4433	struct ndmsg *ndm;
4434	int err, i;
4435
4436	if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ndm))) {
4437		NL_SET_ERR_MSG(extack, "Invalid header for fdb get request");
4438		return -EINVAL;
4439	}
4440
4441	ndm = nlmsg_data(nlh);
4442	if (ndm->ndm_pad1  || ndm->ndm_pad2  || ndm->ndm_state ||
4443	    ndm->ndm_type) {
4444		NL_SET_ERR_MSG(extack, "Invalid values in header for fdb get request");
4445		return -EINVAL;
4446	}
4447
4448	if (ndm->ndm_flags & ~(NTF_MASTER | NTF_SELF)) {
4449		NL_SET_ERR_MSG(extack, "Invalid flags in header for fdb get request");
4450		return -EINVAL;
4451	}
4452
4453	err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct ndmsg), tb,
4454					    NDA_MAX, nda_policy, extack);
4455	if (err < 0)
4456		return err;
4457
4458	*ndm_flags = ndm->ndm_flags;
4459	*brport_idx = ndm->ndm_ifindex;
4460	for (i = 0; i <= NDA_MAX; ++i) {
4461		if (!tb[i])
4462			continue;
4463
4464		switch (i) {
4465		case NDA_MASTER:
4466			*br_idx = nla_get_u32(tb[i]);
4467			break;
4468		case NDA_LLADDR:
4469			if (nla_len(tb[i]) != ETH_ALEN) {
4470				NL_SET_ERR_MSG(extack, "Invalid address in fdb get request");
4471				return -EINVAL;
4472			}
4473			*addr = nla_data(tb[i]);
4474			break;
4475		case NDA_VLAN:
4476			err = fdb_vid_parse(tb[i], vid, extack);
4477			if (err)
4478				return err;
4479			break;
4480		case NDA_VNI:
4481			break;
4482		default:
4483			NL_SET_ERR_MSG(extack, "Unsupported attribute in fdb get request");
4484			return -EINVAL;
4485		}
4486	}
4487
4488	return 0;
4489}
4490
4491static int rtnl_fdb_get(struct sk_buff *in_skb, struct nlmsghdr *nlh,
4492			struct netlink_ext_ack *extack)
4493{
4494	struct net_device *dev = NULL, *br_dev = NULL;
4495	const struct net_device_ops *ops = NULL;
4496	struct net *net = sock_net(in_skb->sk);
4497	struct nlattr *tb[NDA_MAX + 1];
4498	struct sk_buff *skb;
4499	int brport_idx = 0;
4500	u8 ndm_flags = 0;
4501	int br_idx = 0;
4502	u8 *addr = NULL;
4503	u16 vid = 0;
4504	int err;
4505
4506	err = valid_fdb_get_strict(nlh, tb, &ndm_flags, &br_idx,
4507				   &brport_idx, &addr, &vid, extack);
4508	if (err < 0)
4509		return err;
4510
4511	if (!addr) {
4512		NL_SET_ERR_MSG(extack, "Missing lookup address for fdb get request");
4513		return -EINVAL;
4514	}
4515
4516	if (brport_idx) {
4517		dev = __dev_get_by_index(net, brport_idx);
4518		if (!dev) {
4519			NL_SET_ERR_MSG(extack, "Unknown device ifindex");
4520			return -ENODEV;
4521		}
4522	}
4523
4524	if (br_idx) {
4525		if (dev) {
4526			NL_SET_ERR_MSG(extack, "Master and device are mutually exclusive");
4527			return -EINVAL;
4528		}
4529
4530		br_dev = __dev_get_by_index(net, br_idx);
4531		if (!br_dev) {
4532			NL_SET_ERR_MSG(extack, "Invalid master ifindex");
4533			return -EINVAL;
4534		}
4535		ops = br_dev->netdev_ops;
4536	}
4537
4538	if (dev) {
4539		if (!ndm_flags || (ndm_flags & NTF_MASTER)) {
4540			if (!netif_is_bridge_port(dev)) {
4541				NL_SET_ERR_MSG(extack, "Device is not a bridge port");
4542				return -EINVAL;
4543			}
4544			br_dev = netdev_master_upper_dev_get(dev);
4545			if (!br_dev) {
4546				NL_SET_ERR_MSG(extack, "Master of device not found");
4547				return -EINVAL;
4548			}
4549			ops = br_dev->netdev_ops;
4550		} else {
4551			if (!(ndm_flags & NTF_SELF)) {
4552				NL_SET_ERR_MSG(extack, "Missing NTF_SELF");
4553				return -EINVAL;
4554			}
4555			ops = dev->netdev_ops;
4556		}
4557	}
4558
4559	if (!br_dev && !dev) {
4560		NL_SET_ERR_MSG(extack, "No device specified");
4561		return -ENODEV;
4562	}
4563
4564	if (!ops || !ops->ndo_fdb_get) {
4565		NL_SET_ERR_MSG(extack, "Fdb get operation not supported by device");
4566		return -EOPNOTSUPP;
4567	}
4568
4569	skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
4570	if (!skb)
4571		return -ENOBUFS;
4572
4573	if (br_dev)
4574		dev = br_dev;
4575	err = ops->ndo_fdb_get(skb, tb, dev, addr, vid,
4576			       NETLINK_CB(in_skb).portid,
4577			       nlh->nlmsg_seq, extack);
4578	if (err)
4579		goto out;
4580
4581	return rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
4582out:
4583	kfree_skb(skb);
4584	return err;
4585}
4586
4587static int brport_nla_put_flag(struct sk_buff *skb, u32 flags, u32 mask,
4588			       unsigned int attrnum, unsigned int flag)
4589{
4590	if (mask & flag)
4591		return nla_put_u8(skb, attrnum, !!(flags & flag));
4592	return 0;
4593}
4594
4595int ndo_dflt_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
4596			    struct net_device *dev, u16 mode,
4597			    u32 flags, u32 mask, int nlflags,
4598			    u32 filter_mask,
4599			    int (*vlan_fill)(struct sk_buff *skb,
4600					     struct net_device *dev,
4601					     u32 filter_mask))
4602{
4603	struct nlmsghdr *nlh;
4604	struct ifinfomsg *ifm;
4605	struct nlattr *br_afspec;
4606	struct nlattr *protinfo;
4607	u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN;
4608	struct net_device *br_dev = netdev_master_upper_dev_get(dev);
4609	int err = 0;
4610
4611	nlh = nlmsg_put(skb, pid, seq, RTM_NEWLINK, sizeof(*ifm), nlflags);
4612	if (nlh == NULL)
4613		return -EMSGSIZE;
4614
4615	ifm = nlmsg_data(nlh);
4616	ifm->ifi_family = AF_BRIDGE;
4617	ifm->__ifi_pad = 0;
4618	ifm->ifi_type = dev->type;
4619	ifm->ifi_index = dev->ifindex;
4620	ifm->ifi_flags = dev_get_flags(dev);
4621	ifm->ifi_change = 0;
4622
4623
4624	if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
4625	    nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
4626	    nla_put_u8(skb, IFLA_OPERSTATE, operstate) ||
4627	    (br_dev &&
4628	     nla_put_u32(skb, IFLA_MASTER, br_dev->ifindex)) ||
4629	    (dev->addr_len &&
4630	     nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
4631	    (dev->ifindex != dev_get_iflink(dev) &&
4632	     nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))))
4633		goto nla_put_failure;
4634
4635	br_afspec = nla_nest_start_noflag(skb, IFLA_AF_SPEC);
4636	if (!br_afspec)
4637		goto nla_put_failure;
4638
4639	if (nla_put_u16(skb, IFLA_BRIDGE_FLAGS, BRIDGE_FLAGS_SELF)) {
4640		nla_nest_cancel(skb, br_afspec);
4641		goto nla_put_failure;
4642	}
4643
4644	if (mode != BRIDGE_MODE_UNDEF) {
4645		if (nla_put_u16(skb, IFLA_BRIDGE_MODE, mode)) {
4646			nla_nest_cancel(skb, br_afspec);
4647			goto nla_put_failure;
4648		}
4649	}
4650	if (vlan_fill) {
4651		err = vlan_fill(skb, dev, filter_mask);
4652		if (err) {
4653			nla_nest_cancel(skb, br_afspec);
4654			goto nla_put_failure;
4655		}
4656	}
4657	nla_nest_end(skb, br_afspec);
4658
4659	protinfo = nla_nest_start(skb, IFLA_PROTINFO);
4660	if (!protinfo)
4661		goto nla_put_failure;
4662
4663	if (brport_nla_put_flag(skb, flags, mask,
4664				IFLA_BRPORT_MODE, BR_HAIRPIN_MODE) ||
4665	    brport_nla_put_flag(skb, flags, mask,
4666				IFLA_BRPORT_GUARD, BR_BPDU_GUARD) ||
4667	    brport_nla_put_flag(skb, flags, mask,
4668				IFLA_BRPORT_FAST_LEAVE,
4669				BR_MULTICAST_FAST_LEAVE) ||
4670	    brport_nla_put_flag(skb, flags, mask,
4671				IFLA_BRPORT_PROTECT, BR_ROOT_BLOCK) ||
4672	    brport_nla_put_flag(skb, flags, mask,
4673				IFLA_BRPORT_LEARNING, BR_LEARNING) ||
4674	    brport_nla_put_flag(skb, flags, mask,
4675				IFLA_BRPORT_LEARNING_SYNC, BR_LEARNING_SYNC) ||
4676	    brport_nla_put_flag(skb, flags, mask,
4677				IFLA_BRPORT_UNICAST_FLOOD, BR_FLOOD) ||
4678	    brport_nla_put_flag(skb, flags, mask,
4679				IFLA_BRPORT_PROXYARP, BR_PROXYARP) ||
4680	    brport_nla_put_flag(skb, flags, mask,
4681				IFLA_BRPORT_MCAST_FLOOD, BR_MCAST_FLOOD) ||
4682	    brport_nla_put_flag(skb, flags, mask,
4683				IFLA_BRPORT_BCAST_FLOOD, BR_BCAST_FLOOD)) {
4684		nla_nest_cancel(skb, protinfo);
4685		goto nla_put_failure;
4686	}
4687
4688	nla_nest_end(skb, protinfo);
4689
4690	nlmsg_end(skb, nlh);
4691	return 0;
4692nla_put_failure:
4693	nlmsg_cancel(skb, nlh);
4694	return err ? err : -EMSGSIZE;
4695}
4696EXPORT_SYMBOL_GPL(ndo_dflt_bridge_getlink);
4697
4698static int valid_bridge_getlink_req(const struct nlmsghdr *nlh,
4699				    bool strict_check, u32 *filter_mask,
4700				    struct netlink_ext_ack *extack)
4701{
4702	struct nlattr *tb[IFLA_MAX+1];
4703	int err, i;
4704
4705	if (strict_check) {
4706		struct ifinfomsg *ifm;
4707
4708		if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
4709			NL_SET_ERR_MSG(extack, "Invalid header for bridge link dump");
4710			return -EINVAL;
4711		}
4712
4713		ifm = nlmsg_data(nlh);
4714		if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
4715		    ifm->ifi_change || ifm->ifi_index) {
4716			NL_SET_ERR_MSG(extack, "Invalid values in header for bridge link dump request");
4717			return -EINVAL;
4718		}
4719
4720		err = nlmsg_parse_deprecated_strict(nlh,
4721						    sizeof(struct ifinfomsg),
4722						    tb, IFLA_MAX, ifla_policy,
4723						    extack);
4724	} else {
4725		err = nlmsg_parse_deprecated(nlh, sizeof(struct ifinfomsg),
4726					     tb, IFLA_MAX, ifla_policy,
4727					     extack);
4728	}
4729	if (err < 0)
4730		return err;
4731
4732	/* new attributes should only be added with strict checking */
4733	for (i = 0; i <= IFLA_MAX; ++i) {
4734		if (!tb[i])
4735			continue;
4736
4737		switch (i) {
4738		case IFLA_EXT_MASK:
4739			*filter_mask = nla_get_u32(tb[i]);
4740			break;
4741		default:
4742			if (strict_check) {
4743				NL_SET_ERR_MSG(extack, "Unsupported attribute in bridge link dump request");
4744				return -EINVAL;
4745			}
4746		}
4747	}
4748
4749	return 0;
4750}
4751
4752static int rtnl_bridge_getlink(struct sk_buff *skb, struct netlink_callback *cb)
4753{
4754	const struct nlmsghdr *nlh = cb->nlh;
4755	struct net *net = sock_net(skb->sk);
4756	struct net_device *dev;
4757	int idx = 0;
4758	u32 portid = NETLINK_CB(cb->skb).portid;
4759	u32 seq = nlh->nlmsg_seq;
4760	u32 filter_mask = 0;
4761	int err;
4762
4763	err = valid_bridge_getlink_req(nlh, cb->strict_check, &filter_mask,
4764				       cb->extack);
4765	if (err < 0 && cb->strict_check)
4766		return err;
 
 
 
 
 
 
 
 
4767
4768	rcu_read_lock();
4769	for_each_netdev_rcu(net, dev) {
4770		const struct net_device_ops *ops = dev->netdev_ops;
4771		struct net_device *br_dev = netdev_master_upper_dev_get(dev);
4772
4773		if (br_dev && br_dev->netdev_ops->ndo_bridge_getlink) {
4774			if (idx >= cb->args[0]) {
4775				err = br_dev->netdev_ops->ndo_bridge_getlink(
4776						skb, portid, seq, dev,
4777						filter_mask, NLM_F_MULTI);
4778				if (err < 0 && err != -EOPNOTSUPP) {
4779					if (likely(skb->len))
4780						break;
4781
4782					goto out_err;
4783				}
4784			}
4785			idx++;
4786		}
4787
4788		if (ops->ndo_bridge_getlink) {
4789			if (idx >= cb->args[0]) {
4790				err = ops->ndo_bridge_getlink(skb, portid,
4791							      seq, dev,
4792							      filter_mask,
4793							      NLM_F_MULTI);
4794				if (err < 0 && err != -EOPNOTSUPP) {
4795					if (likely(skb->len))
4796						break;
4797
4798					goto out_err;
4799				}
4800			}
4801			idx++;
4802		}
4803	}
4804	err = skb->len;
4805out_err:
4806	rcu_read_unlock();
4807	cb->args[0] = idx;
4808
4809	return err;
4810}
4811
4812static inline size_t bridge_nlmsg_size(void)
4813{
4814	return NLMSG_ALIGN(sizeof(struct ifinfomsg))
4815		+ nla_total_size(IFNAMSIZ)	/* IFLA_IFNAME */
4816		+ nla_total_size(MAX_ADDR_LEN)	/* IFLA_ADDRESS */
4817		+ nla_total_size(sizeof(u32))	/* IFLA_MASTER */
4818		+ nla_total_size(sizeof(u32))	/* IFLA_MTU */
4819		+ nla_total_size(sizeof(u32))	/* IFLA_LINK */
4820		+ nla_total_size(sizeof(u32))	/* IFLA_OPERSTATE */
4821		+ nla_total_size(sizeof(u8))	/* IFLA_PROTINFO */
4822		+ nla_total_size(sizeof(struct nlattr))	/* IFLA_AF_SPEC */
4823		+ nla_total_size(sizeof(u16))	/* IFLA_BRIDGE_FLAGS */
4824		+ nla_total_size(sizeof(u16));	/* IFLA_BRIDGE_MODE */
4825}
4826
4827static int rtnl_bridge_notify(struct net_device *dev)
4828{
4829	struct net *net = dev_net(dev);
4830	struct sk_buff *skb;
4831	int err = -EOPNOTSUPP;
4832
4833	if (!dev->netdev_ops->ndo_bridge_getlink)
4834		return 0;
4835
4836	skb = nlmsg_new(bridge_nlmsg_size(), GFP_ATOMIC);
4837	if (!skb) {
4838		err = -ENOMEM;
4839		goto errout;
4840	}
4841
4842	err = dev->netdev_ops->ndo_bridge_getlink(skb, 0, 0, dev, 0, 0);
4843	if (err < 0)
4844		goto errout;
4845
4846	if (!skb->len)
4847		goto errout;
4848
4849	rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
4850	return 0;
4851errout:
4852	WARN_ON(err == -EMSGSIZE);
4853	kfree_skb(skb);
4854	if (err)
4855		rtnl_set_sk_err(net, RTNLGRP_LINK, err);
4856	return err;
4857}
4858
4859static int rtnl_bridge_setlink(struct sk_buff *skb, struct nlmsghdr *nlh,
4860			       struct netlink_ext_ack *extack)
4861{
4862	struct net *net = sock_net(skb->sk);
4863	struct ifinfomsg *ifm;
4864	struct net_device *dev;
4865	struct nlattr *br_spec, *attr = NULL;
4866	int rem, err = -EOPNOTSUPP;
4867	u16 flags = 0;
4868	bool have_flags = false;
4869
4870	if (nlmsg_len(nlh) < sizeof(*ifm))
4871		return -EINVAL;
4872
4873	ifm = nlmsg_data(nlh);
4874	if (ifm->ifi_family != AF_BRIDGE)
4875		return -EPFNOSUPPORT;
4876
4877	dev = __dev_get_by_index(net, ifm->ifi_index);
4878	if (!dev) {
4879		NL_SET_ERR_MSG(extack, "unknown ifindex");
4880		return -ENODEV;
4881	}
4882
4883	br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
4884	if (br_spec) {
4885		nla_for_each_nested(attr, br_spec, rem) {
4886			if (nla_type(attr) == IFLA_BRIDGE_FLAGS) {
4887				if (nla_len(attr) < sizeof(flags))
4888					return -EINVAL;
4889
4890				have_flags = true;
4891				flags = nla_get_u16(attr);
4892				break;
4893			}
4894		}
4895	}
4896
4897	if (!flags || (flags & BRIDGE_FLAGS_MASTER)) {
4898		struct net_device *br_dev = netdev_master_upper_dev_get(dev);
4899
4900		if (!br_dev || !br_dev->netdev_ops->ndo_bridge_setlink) {
4901			err = -EOPNOTSUPP;
4902			goto out;
4903		}
4904
4905		err = br_dev->netdev_ops->ndo_bridge_setlink(dev, nlh, flags,
4906							     extack);
4907		if (err)
4908			goto out;
4909
4910		flags &= ~BRIDGE_FLAGS_MASTER;
4911	}
4912
4913	if ((flags & BRIDGE_FLAGS_SELF)) {
4914		if (!dev->netdev_ops->ndo_bridge_setlink)
4915			err = -EOPNOTSUPP;
4916		else
4917			err = dev->netdev_ops->ndo_bridge_setlink(dev, nlh,
4918								  flags,
4919								  extack);
4920		if (!err) {
4921			flags &= ~BRIDGE_FLAGS_SELF;
4922
4923			/* Generate event to notify upper layer of bridge
4924			 * change
4925			 */
4926			err = rtnl_bridge_notify(dev);
4927		}
4928	}
4929
4930	if (have_flags)
4931		memcpy(nla_data(attr), &flags, sizeof(flags));
4932out:
4933	return err;
4934}
4935
4936static int rtnl_bridge_dellink(struct sk_buff *skb, struct nlmsghdr *nlh,
4937			       struct netlink_ext_ack *extack)
4938{
4939	struct net *net = sock_net(skb->sk);
4940	struct ifinfomsg *ifm;
4941	struct net_device *dev;
4942	struct nlattr *br_spec, *attr = NULL;
4943	int rem, err = -EOPNOTSUPP;
4944	u16 flags = 0;
4945	bool have_flags = false;
4946
4947	if (nlmsg_len(nlh) < sizeof(*ifm))
4948		return -EINVAL;
4949
4950	ifm = nlmsg_data(nlh);
4951	if (ifm->ifi_family != AF_BRIDGE)
4952		return -EPFNOSUPPORT;
4953
4954	dev = __dev_get_by_index(net, ifm->ifi_index);
4955	if (!dev) {
4956		NL_SET_ERR_MSG(extack, "unknown ifindex");
4957		return -ENODEV;
4958	}
4959
4960	br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
4961	if (br_spec) {
4962		nla_for_each_nested(attr, br_spec, rem) {
4963			if (nla_type(attr) == IFLA_BRIDGE_FLAGS) {
4964				if (nla_len(attr) < sizeof(flags))
4965					return -EINVAL;
4966
4967				have_flags = true;
4968				flags = nla_get_u16(attr);
4969				break;
4970			}
4971		}
4972	}
4973
4974	if (!flags || (flags & BRIDGE_FLAGS_MASTER)) {
4975		struct net_device *br_dev = netdev_master_upper_dev_get(dev);
4976
4977		if (!br_dev || !br_dev->netdev_ops->ndo_bridge_dellink) {
4978			err = -EOPNOTSUPP;
4979			goto out;
4980		}
4981
4982		err = br_dev->netdev_ops->ndo_bridge_dellink(dev, nlh, flags);
4983		if (err)
4984			goto out;
4985
4986		flags &= ~BRIDGE_FLAGS_MASTER;
4987	}
4988
4989	if ((flags & BRIDGE_FLAGS_SELF)) {
4990		if (!dev->netdev_ops->ndo_bridge_dellink)
4991			err = -EOPNOTSUPP;
4992		else
4993			err = dev->netdev_ops->ndo_bridge_dellink(dev, nlh,
4994								  flags);
4995
4996		if (!err) {
4997			flags &= ~BRIDGE_FLAGS_SELF;
4998
4999			/* Generate event to notify upper layer of bridge
5000			 * change
5001			 */
5002			err = rtnl_bridge_notify(dev);
5003		}
5004	}
5005
5006	if (have_flags)
5007		memcpy(nla_data(attr), &flags, sizeof(flags));
5008out:
5009	return err;
5010}
5011
5012static bool stats_attr_valid(unsigned int mask, int attrid, int idxattr)
5013{
5014	return (mask & IFLA_STATS_FILTER_BIT(attrid)) &&
5015	       (!idxattr || idxattr == attrid);
5016}
5017
5018#define IFLA_OFFLOAD_XSTATS_FIRST (IFLA_OFFLOAD_XSTATS_UNSPEC + 1)
5019static int rtnl_get_offload_stats_attr_size(int attr_id)
5020{
5021	switch (attr_id) {
5022	case IFLA_OFFLOAD_XSTATS_CPU_HIT:
5023		return sizeof(struct rtnl_link_stats64);
5024	}
5025
5026	return 0;
5027}
5028
5029static int rtnl_get_offload_stats(struct sk_buff *skb, struct net_device *dev,
5030				  int *prividx)
5031{
5032	struct nlattr *attr = NULL;
5033	int attr_id, size;
5034	void *attr_data;
5035	int err;
5036
5037	if (!(dev->netdev_ops && dev->netdev_ops->ndo_has_offload_stats &&
5038	      dev->netdev_ops->ndo_get_offload_stats))
5039		return -ENODATA;
5040
5041	for (attr_id = IFLA_OFFLOAD_XSTATS_FIRST;
5042	     attr_id <= IFLA_OFFLOAD_XSTATS_MAX; attr_id++) {
5043		if (attr_id < *prividx)
5044			continue;
5045
5046		size = rtnl_get_offload_stats_attr_size(attr_id);
5047		if (!size)
5048			continue;
5049
5050		if (!dev->netdev_ops->ndo_has_offload_stats(dev, attr_id))
5051			continue;
5052
5053		attr = nla_reserve_64bit(skb, attr_id, size,
5054					 IFLA_OFFLOAD_XSTATS_UNSPEC);
5055		if (!attr)
5056			goto nla_put_failure;
5057
5058		attr_data = nla_data(attr);
5059		memset(attr_data, 0, size);
5060		err = dev->netdev_ops->ndo_get_offload_stats(attr_id, dev,
5061							     attr_data);
5062		if (err)
5063			goto get_offload_stats_failure;
5064	}
5065
5066	if (!attr)
5067		return -ENODATA;
5068
5069	*prividx = 0;
5070	return 0;
5071
5072nla_put_failure:
5073	err = -EMSGSIZE;
5074get_offload_stats_failure:
5075	*prividx = attr_id;
5076	return err;
5077}
5078
5079static int rtnl_get_offload_stats_size(const struct net_device *dev)
5080{
5081	int nla_size = 0;
5082	int attr_id;
5083	int size;
5084
5085	if (!(dev->netdev_ops && dev->netdev_ops->ndo_has_offload_stats &&
5086	      dev->netdev_ops->ndo_get_offload_stats))
5087		return 0;
5088
5089	for (attr_id = IFLA_OFFLOAD_XSTATS_FIRST;
5090	     attr_id <= IFLA_OFFLOAD_XSTATS_MAX; attr_id++) {
5091		if (!dev->netdev_ops->ndo_has_offload_stats(dev, attr_id))
5092			continue;
5093		size = rtnl_get_offload_stats_attr_size(attr_id);
5094		nla_size += nla_total_size_64bit(size);
5095	}
5096
5097	if (nla_size != 0)
5098		nla_size += nla_total_size(0);
5099
5100	return nla_size;
5101}
5102
5103static int rtnl_fill_statsinfo(struct sk_buff *skb, struct net_device *dev,
5104			       int type, u32 pid, u32 seq, u32 change,
5105			       unsigned int flags, unsigned int filter_mask,
5106			       int *idxattr, int *prividx)
5107{
5108	struct if_stats_msg *ifsm;
5109	struct nlmsghdr *nlh;
5110	struct nlattr *attr;
5111	int s_prividx = *prividx;
5112	int err;
5113
5114	ASSERT_RTNL();
5115
5116	nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifsm), flags);
5117	if (!nlh)
5118		return -EMSGSIZE;
5119
5120	ifsm = nlmsg_data(nlh);
5121	ifsm->family = PF_UNSPEC;
5122	ifsm->pad1 = 0;
5123	ifsm->pad2 = 0;
5124	ifsm->ifindex = dev->ifindex;
5125	ifsm->filter_mask = filter_mask;
5126
5127	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_64, *idxattr)) {
5128		struct rtnl_link_stats64 *sp;
5129
5130		attr = nla_reserve_64bit(skb, IFLA_STATS_LINK_64,
5131					 sizeof(struct rtnl_link_stats64),
5132					 IFLA_STATS_UNSPEC);
5133		if (!attr)
5134			goto nla_put_failure;
5135
5136		sp = nla_data(attr);
5137		dev_get_stats(dev, sp);
5138	}
5139
5140	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS, *idxattr)) {
5141		const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
5142
5143		if (ops && ops->fill_linkxstats) {
5144			*idxattr = IFLA_STATS_LINK_XSTATS;
5145			attr = nla_nest_start_noflag(skb,
5146						     IFLA_STATS_LINK_XSTATS);
5147			if (!attr)
5148				goto nla_put_failure;
5149
5150			err = ops->fill_linkxstats(skb, dev, prividx, *idxattr);
5151			nla_nest_end(skb, attr);
5152			if (err)
5153				goto nla_put_failure;
5154			*idxattr = 0;
5155		}
5156	}
5157
5158	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS_SLAVE,
5159			     *idxattr)) {
5160		const struct rtnl_link_ops *ops = NULL;
5161		const struct net_device *master;
5162
5163		master = netdev_master_upper_dev_get(dev);
5164		if (master)
5165			ops = master->rtnl_link_ops;
5166		if (ops && ops->fill_linkxstats) {
5167			*idxattr = IFLA_STATS_LINK_XSTATS_SLAVE;
5168			attr = nla_nest_start_noflag(skb,
5169						     IFLA_STATS_LINK_XSTATS_SLAVE);
5170			if (!attr)
5171				goto nla_put_failure;
5172
5173			err = ops->fill_linkxstats(skb, dev, prividx, *idxattr);
5174			nla_nest_end(skb, attr);
5175			if (err)
5176				goto nla_put_failure;
5177			*idxattr = 0;
5178		}
5179	}
5180
5181	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_OFFLOAD_XSTATS,
5182			     *idxattr)) {
5183		*idxattr = IFLA_STATS_LINK_OFFLOAD_XSTATS;
5184		attr = nla_nest_start_noflag(skb,
5185					     IFLA_STATS_LINK_OFFLOAD_XSTATS);
5186		if (!attr)
5187			goto nla_put_failure;
5188
5189		err = rtnl_get_offload_stats(skb, dev, prividx);
5190		if (err == -ENODATA)
5191			nla_nest_cancel(skb, attr);
5192		else
5193			nla_nest_end(skb, attr);
5194
5195		if (err && err != -ENODATA)
5196			goto nla_put_failure;
5197		*idxattr = 0;
5198	}
5199
5200	if (stats_attr_valid(filter_mask, IFLA_STATS_AF_SPEC, *idxattr)) {
5201		struct rtnl_af_ops *af_ops;
5202
5203		*idxattr = IFLA_STATS_AF_SPEC;
5204		attr = nla_nest_start_noflag(skb, IFLA_STATS_AF_SPEC);
5205		if (!attr)
5206			goto nla_put_failure;
5207
5208		rcu_read_lock();
5209		list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
5210			if (af_ops->fill_stats_af) {
5211				struct nlattr *af;
5212				int err;
5213
5214				af = nla_nest_start_noflag(skb,
5215							   af_ops->family);
5216				if (!af) {
5217					rcu_read_unlock();
5218					goto nla_put_failure;
5219				}
5220				err = af_ops->fill_stats_af(skb, dev);
5221
5222				if (err == -ENODATA) {
5223					nla_nest_cancel(skb, af);
5224				} else if (err < 0) {
5225					rcu_read_unlock();
5226					goto nla_put_failure;
5227				}
5228
5229				nla_nest_end(skb, af);
5230			}
5231		}
5232		rcu_read_unlock();
5233
5234		nla_nest_end(skb, attr);
5235
5236		*idxattr = 0;
5237	}
5238
5239	nlmsg_end(skb, nlh);
5240
5241	return 0;
5242
5243nla_put_failure:
5244	/* not a multi message or no progress mean a real error */
5245	if (!(flags & NLM_F_MULTI) || s_prividx == *prividx)
5246		nlmsg_cancel(skb, nlh);
5247	else
5248		nlmsg_end(skb, nlh);
5249
5250	return -EMSGSIZE;
5251}
5252
5253static size_t if_nlmsg_stats_size(const struct net_device *dev,
5254				  u32 filter_mask)
5255{
5256	size_t size = 0;
5257
5258	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_64, 0))
5259		size += nla_total_size_64bit(sizeof(struct rtnl_link_stats64));
5260
5261	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS, 0)) {
5262		const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
5263		int attr = IFLA_STATS_LINK_XSTATS;
5264
5265		if (ops && ops->get_linkxstats_size) {
5266			size += nla_total_size(ops->get_linkxstats_size(dev,
5267									attr));
5268			/* for IFLA_STATS_LINK_XSTATS */
5269			size += nla_total_size(0);
5270		}
5271	}
5272
5273	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS_SLAVE, 0)) {
5274		struct net_device *_dev = (struct net_device *)dev;
5275		const struct rtnl_link_ops *ops = NULL;
5276		const struct net_device *master;
5277
5278		/* netdev_master_upper_dev_get can't take const */
5279		master = netdev_master_upper_dev_get(_dev);
5280		if (master)
5281			ops = master->rtnl_link_ops;
5282		if (ops && ops->get_linkxstats_size) {
5283			int attr = IFLA_STATS_LINK_XSTATS_SLAVE;
5284
5285			size += nla_total_size(ops->get_linkxstats_size(dev,
5286									attr));
5287			/* for IFLA_STATS_LINK_XSTATS_SLAVE */
5288			size += nla_total_size(0);
5289		}
5290	}
5291
5292	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_OFFLOAD_XSTATS, 0))
5293		size += rtnl_get_offload_stats_size(dev);
5294
5295	if (stats_attr_valid(filter_mask, IFLA_STATS_AF_SPEC, 0)) {
5296		struct rtnl_af_ops *af_ops;
5297
5298		/* for IFLA_STATS_AF_SPEC */
5299		size += nla_total_size(0);
5300
5301		rcu_read_lock();
5302		list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
5303			if (af_ops->get_stats_af_size) {
5304				size += nla_total_size(
5305					af_ops->get_stats_af_size(dev));
5306
5307				/* for AF_* */
5308				size += nla_total_size(0);
5309			}
5310		}
5311		rcu_read_unlock();
5312	}
5313
5314	return size;
5315}
5316
5317static int rtnl_valid_stats_req(const struct nlmsghdr *nlh, bool strict_check,
5318				bool is_dump, struct netlink_ext_ack *extack)
5319{
5320	struct if_stats_msg *ifsm;
5321
5322	if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifsm))) {
5323		NL_SET_ERR_MSG(extack, "Invalid header for stats dump");
5324		return -EINVAL;
5325	}
5326
5327	if (!strict_check)
5328		return 0;
5329
5330	ifsm = nlmsg_data(nlh);
5331
5332	/* only requests using strict checks can pass data to influence
5333	 * the dump. The legacy exception is filter_mask.
5334	 */
5335	if (ifsm->pad1 || ifsm->pad2 || (is_dump && ifsm->ifindex)) {
5336		NL_SET_ERR_MSG(extack, "Invalid values in header for stats dump request");
5337		return -EINVAL;
5338	}
5339	if (nlmsg_attrlen(nlh, sizeof(*ifsm))) {
5340		NL_SET_ERR_MSG(extack, "Invalid attributes after stats header");
5341		return -EINVAL;
5342	}
5343	if (ifsm->filter_mask >= IFLA_STATS_FILTER_BIT(IFLA_STATS_MAX + 1)) {
5344		NL_SET_ERR_MSG(extack, "Invalid stats requested through filter mask");
5345		return -EINVAL;
5346	}
5347
5348	return 0;
5349}
5350
5351static int rtnl_stats_get(struct sk_buff *skb, struct nlmsghdr *nlh,
5352			  struct netlink_ext_ack *extack)
5353{
5354	struct net *net = sock_net(skb->sk);
5355	struct net_device *dev = NULL;
5356	int idxattr = 0, prividx = 0;
5357	struct if_stats_msg *ifsm;
5358	struct sk_buff *nskb;
5359	u32 filter_mask;
5360	int err;
5361
5362	err = rtnl_valid_stats_req(nlh, netlink_strict_get_check(skb),
5363				   false, extack);
5364	if (err)
5365		return err;
5366
5367	ifsm = nlmsg_data(nlh);
5368	if (ifsm->ifindex > 0)
5369		dev = __dev_get_by_index(net, ifsm->ifindex);
5370	else
5371		return -EINVAL;
5372
5373	if (!dev)
5374		return -ENODEV;
5375
5376	filter_mask = ifsm->filter_mask;
5377	if (!filter_mask)
5378		return -EINVAL;
5379
5380	nskb = nlmsg_new(if_nlmsg_stats_size(dev, filter_mask), GFP_KERNEL);
5381	if (!nskb)
5382		return -ENOBUFS;
5383
5384	err = rtnl_fill_statsinfo(nskb, dev, RTM_NEWSTATS,
5385				  NETLINK_CB(skb).portid, nlh->nlmsg_seq, 0,
5386				  0, filter_mask, &idxattr, &prividx);
5387	if (err < 0) {
5388		/* -EMSGSIZE implies BUG in if_nlmsg_stats_size */
5389		WARN_ON(err == -EMSGSIZE);
5390		kfree_skb(nskb);
5391	} else {
5392		err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid);
5393	}
5394
5395	return err;
5396}
5397
5398static int rtnl_stats_dump(struct sk_buff *skb, struct netlink_callback *cb)
5399{
5400	struct netlink_ext_ack *extack = cb->extack;
5401	int h, s_h, err, s_idx, s_idxattr, s_prividx;
5402	struct net *net = sock_net(skb->sk);
5403	unsigned int flags = NLM_F_MULTI;
5404	struct if_stats_msg *ifsm;
5405	struct hlist_head *head;
5406	struct net_device *dev;
5407	u32 filter_mask = 0;
5408	int idx = 0;
5409
5410	s_h = cb->args[0];
5411	s_idx = cb->args[1];
5412	s_idxattr = cb->args[2];
5413	s_prividx = cb->args[3];
5414
5415	cb->seq = net->dev_base_seq;
5416
5417	err = rtnl_valid_stats_req(cb->nlh, cb->strict_check, true, extack);
5418	if (err)
5419		return err;
5420
5421	ifsm = nlmsg_data(cb->nlh);
5422	filter_mask = ifsm->filter_mask;
5423	if (!filter_mask) {
5424		NL_SET_ERR_MSG(extack, "Filter mask must be set for stats dump");
5425		return -EINVAL;
5426	}
5427
5428	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
5429		idx = 0;
5430		head = &net->dev_index_head[h];
5431		hlist_for_each_entry(dev, head, index_hlist) {
5432			if (idx < s_idx)
5433				goto cont;
5434			err = rtnl_fill_statsinfo(skb, dev, RTM_NEWSTATS,
5435						  NETLINK_CB(cb->skb).portid,
5436						  cb->nlh->nlmsg_seq, 0,
5437						  flags, filter_mask,
5438						  &s_idxattr, &s_prividx);
5439			/* If we ran out of room on the first message,
5440			 * we're in trouble
5441			 */
5442			WARN_ON((err == -EMSGSIZE) && (skb->len == 0));
5443
5444			if (err < 0)
5445				goto out;
5446			s_prividx = 0;
5447			s_idxattr = 0;
5448			nl_dump_check_consistent(cb, nlmsg_hdr(skb));
5449cont:
5450			idx++;
5451		}
5452	}
5453out:
5454	cb->args[3] = s_prividx;
5455	cb->args[2] = s_idxattr;
5456	cb->args[1] = idx;
5457	cb->args[0] = h;
5458
5459	return skb->len;
5460}
5461
5462/* Process one rtnetlink message. */
5463
5464static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
5465			     struct netlink_ext_ack *extack)
5466{
5467	struct net *net = sock_net(skb->sk);
5468	struct rtnl_link *link;
5469	struct module *owner;
5470	int err = -EOPNOTSUPP;
5471	rtnl_doit_func doit;
5472	unsigned int flags;
5473	int kind;
5474	int family;
5475	int type;
5476
5477	type = nlh->nlmsg_type;
5478	if (type > RTM_MAX)
5479		return -EOPNOTSUPP;
5480
5481	type -= RTM_BASE;
5482
5483	/* All the messages must have at least 1 byte length */
5484	if (nlmsg_len(nlh) < sizeof(struct rtgenmsg))
5485		return 0;
5486
5487	family = ((struct rtgenmsg *)nlmsg_data(nlh))->rtgen_family;
5488	kind = type&3;
5489
5490	if (kind != 2 && !netlink_net_capable(skb, CAP_NET_ADMIN))
5491		return -EPERM;
5492
5493	rcu_read_lock();
5494	if (kind == 2 && nlh->nlmsg_flags&NLM_F_DUMP) {
5495		struct sock *rtnl;
5496		rtnl_dumpit_func dumpit;
5497		u16 min_dump_alloc = 0;
5498
5499		link = rtnl_get_link(family, type);
5500		if (!link || !link->dumpit) {
5501			family = PF_UNSPEC;
5502			link = rtnl_get_link(family, type);
5503			if (!link || !link->dumpit)
5504				goto err_unlock;
5505		}
5506		owner = link->owner;
5507		dumpit = link->dumpit;
5508
5509		if (type == RTM_GETLINK - RTM_BASE)
5510			min_dump_alloc = rtnl_calcit(skb, nlh);
5511
5512		err = 0;
5513		/* need to do this before rcu_read_unlock() */
5514		if (!try_module_get(owner))
5515			err = -EPROTONOSUPPORT;
5516
5517		rcu_read_unlock();
5518
5519		rtnl = net->rtnl;
5520		if (err == 0) {
5521			struct netlink_dump_control c = {
5522				.dump		= dumpit,
5523				.min_dump_alloc	= min_dump_alloc,
5524				.module		= owner,
5525			};
5526			err = netlink_dump_start(rtnl, skb, nlh, &c);
5527			/* netlink_dump_start() will keep a reference on
5528			 * module if dump is still in progress.
5529			 */
5530			module_put(owner);
5531		}
5532		return err;
5533	}
5534
5535	link = rtnl_get_link(family, type);
5536	if (!link || !link->doit) {
5537		family = PF_UNSPEC;
5538		link = rtnl_get_link(PF_UNSPEC, type);
5539		if (!link || !link->doit)
5540			goto out_unlock;
5541	}
5542
5543	owner = link->owner;
5544	if (!try_module_get(owner)) {
5545		err = -EPROTONOSUPPORT;
5546		goto out_unlock;
5547	}
5548
5549	flags = link->flags;
5550	if (flags & RTNL_FLAG_DOIT_UNLOCKED) {
5551		doit = link->doit;
5552		rcu_read_unlock();
5553		if (doit)
5554			err = doit(skb, nlh, extack);
5555		module_put(owner);
5556		return err;
5557	}
5558	rcu_read_unlock();
5559
5560	rtnl_lock();
5561	link = rtnl_get_link(family, type);
5562	if (link && link->doit)
5563		err = link->doit(skb, nlh, extack);
5564	rtnl_unlock();
5565
5566	module_put(owner);
5567
5568	return err;
5569
5570out_unlock:
5571	rcu_read_unlock();
5572	return err;
5573
5574err_unlock:
5575	rcu_read_unlock();
5576	return -EOPNOTSUPP;
5577}
5578
5579static void rtnetlink_rcv(struct sk_buff *skb)
5580{
5581	netlink_rcv_skb(skb, &rtnetlink_rcv_msg);
5582}
5583
5584static int rtnetlink_bind(struct net *net, int group)
5585{
5586	switch (group) {
5587	case RTNLGRP_IPV4_MROUTE_R:
5588	case RTNLGRP_IPV6_MROUTE_R:
5589		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
5590			return -EPERM;
5591		break;
5592	}
5593	return 0;
5594}
5595
5596static int rtnetlink_event(struct notifier_block *this, unsigned long event, void *ptr)
5597{
5598	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
5599
5600	switch (event) {
5601	case NETDEV_REBOOT:
5602	case NETDEV_CHANGEMTU:
5603	case NETDEV_CHANGEADDR:
5604	case NETDEV_CHANGENAME:
5605	case NETDEV_FEAT_CHANGE:
5606	case NETDEV_BONDING_FAILOVER:
5607	case NETDEV_POST_TYPE_CHANGE:
5608	case NETDEV_NOTIFY_PEERS:
5609	case NETDEV_CHANGEUPPER:
5610	case NETDEV_RESEND_IGMP:
5611	case NETDEV_CHANGEINFODATA:
5612	case NETDEV_CHANGELOWERSTATE:
5613	case NETDEV_CHANGE_TX_QUEUE_LEN:
5614		rtmsg_ifinfo_event(RTM_NEWLINK, dev, 0, rtnl_get_event(event),
5615				   GFP_KERNEL, NULL, 0);
5616		break;
5617	default:
5618		break;
5619	}
5620	return NOTIFY_DONE;
5621}
5622
5623static struct notifier_block rtnetlink_dev_notifier = {
5624	.notifier_call	= rtnetlink_event,
5625};
5626
5627
5628static int __net_init rtnetlink_net_init(struct net *net)
5629{
5630	struct sock *sk;
5631	struct netlink_kernel_cfg cfg = {
5632		.groups		= RTNLGRP_MAX,
5633		.input		= rtnetlink_rcv,
5634		.cb_mutex	= &rtnl_mutex,
5635		.flags		= NL_CFG_F_NONROOT_RECV,
5636		.bind		= rtnetlink_bind,
5637	};
5638
5639	sk = netlink_kernel_create(net, NETLINK_ROUTE, &cfg);
5640	if (!sk)
5641		return -ENOMEM;
5642	net->rtnl = sk;
5643	return 0;
5644}
5645
5646static void __net_exit rtnetlink_net_exit(struct net *net)
5647{
5648	netlink_kernel_release(net->rtnl);
5649	net->rtnl = NULL;
5650}
5651
5652static struct pernet_operations rtnetlink_net_ops = {
5653	.init = rtnetlink_net_init,
5654	.exit = rtnetlink_net_exit,
5655};
5656
5657void __init rtnetlink_init(void)
5658{
5659	if (register_pernet_subsys(&rtnetlink_net_ops))
5660		panic("rtnetlink_init: cannot initialize rtnetlink\n");
5661
5662	register_netdevice_notifier(&rtnetlink_dev_notifier);
5663
5664	rtnl_register(PF_UNSPEC, RTM_GETLINK, rtnl_getlink,
5665		      rtnl_dump_ifinfo, 0);
5666	rtnl_register(PF_UNSPEC, RTM_SETLINK, rtnl_setlink, NULL, 0);
5667	rtnl_register(PF_UNSPEC, RTM_NEWLINK, rtnl_newlink, NULL, 0);
5668	rtnl_register(PF_UNSPEC, RTM_DELLINK, rtnl_dellink, NULL, 0);
5669
5670	rtnl_register(PF_UNSPEC, RTM_GETADDR, NULL, rtnl_dump_all, 0);
5671	rtnl_register(PF_UNSPEC, RTM_GETROUTE, NULL, rtnl_dump_all, 0);
5672	rtnl_register(PF_UNSPEC, RTM_GETNETCONF, NULL, rtnl_dump_all, 0);
5673
5674	rtnl_register(PF_UNSPEC, RTM_NEWLINKPROP, rtnl_newlinkprop, NULL, 0);
5675	rtnl_register(PF_UNSPEC, RTM_DELLINKPROP, rtnl_dellinkprop, NULL, 0);
5676
5677	rtnl_register(PF_BRIDGE, RTM_NEWNEIGH, rtnl_fdb_add, NULL, 0);
5678	rtnl_register(PF_BRIDGE, RTM_DELNEIGH, rtnl_fdb_del, NULL, 0);
5679	rtnl_register(PF_BRIDGE, RTM_GETNEIGH, rtnl_fdb_get, rtnl_fdb_dump, 0);
5680
5681	rtnl_register(PF_BRIDGE, RTM_GETLINK, NULL, rtnl_bridge_getlink, 0);
5682	rtnl_register(PF_BRIDGE, RTM_DELLINK, rtnl_bridge_dellink, NULL, 0);
5683	rtnl_register(PF_BRIDGE, RTM_SETLINK, rtnl_bridge_setlink, NULL, 0);
5684
5685	rtnl_register(PF_UNSPEC, RTM_GETSTATS, rtnl_stats_get, rtnl_stats_dump,
5686		      0);
5687}