rtnetlink.c

   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 arithmetic 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#include <net/netdev_lock.h>
  57#include <net/devlink.h>
  58#if IS_ENABLED(CONFIG_IPV6)
  59#include <net/addrconf.h>
  60#endif
  61#include <linux/dpll.h>
  62
  63#include "dev.h"
  64
  65#define RTNL_MAX_TYPE		50
  66#define RTNL_SLAVE_MAX_TYPE	44
  67
  68struct rtnl_link {
  69	rtnl_doit_func		doit;
  70	rtnl_dumpit_func	dumpit;
  71	struct module		*owner;
  72	unsigned int		flags;
  73	struct rcu_head		rcu;
  74};
  75
  76static DEFINE_MUTEX(rtnl_mutex);
  77
  78void rtnl_lock(void)
  79{
  80	mutex_lock(&rtnl_mutex);
  81}
  82EXPORT_SYMBOL(rtnl_lock);
  83
  84int rtnl_lock_interruptible(void)
  85{
  86	return mutex_lock_interruptible(&rtnl_mutex);
  87}
  88
  89int rtnl_lock_killable(void)
  90{
  91	return mutex_lock_killable(&rtnl_mutex);
  92}
  93
  94static struct sk_buff *defer_kfree_skb_list;
  95void rtnl_kfree_skbs(struct sk_buff *head, struct sk_buff *tail)
  96{
  97	if (head && tail) {
  98		tail->next = defer_kfree_skb_list;
  99		defer_kfree_skb_list = head;
 100	}
 101}
 102EXPORT_SYMBOL(rtnl_kfree_skbs);
 103
 104void __rtnl_unlock(void)
 105{
 106	struct sk_buff *head = defer_kfree_skb_list;
 107
 108	defer_kfree_skb_list = NULL;
 109
 110	/* Ensure that we didn't actually add any TODO item when __rtnl_unlock()
 111	 * is used. In some places, e.g. in cfg80211, we have code that will do
 112	 * something like
 113	 *   rtnl_lock()
 114	 *   wiphy_lock()
 115	 *   ...
 116	 *   rtnl_unlock()
 117	 *
 118	 * and because netdev_run_todo() acquires the RTNL for items on the list
 119	 * we could cause a situation such as this:
 120	 * Thread 1			Thread 2
 121	 *				  rtnl_lock()
 122	 *				  unregister_netdevice()
 123	 *				  __rtnl_unlock()
 124	 * rtnl_lock()
 125	 * wiphy_lock()
 126	 * rtnl_unlock()
 127	 *   netdev_run_todo()
 128	 *     __rtnl_unlock()
 129	 *
 130	 *     // list not empty now
 131	 *     // because of thread 2
 132	 *				  rtnl_lock()
 133	 *     while (!list_empty(...))
 134	 *       rtnl_lock()
 135	 *				  wiphy_lock()
 136	 * **** DEADLOCK ****
 137	 *
 138	 * However, usage of __rtnl_unlock() is rare, and so we can ensure that
 139	 * it's not used in cases where something is added to do the list.
 140	 */
 141	WARN_ON(!list_empty(&net_todo_list));
 142
 143	mutex_unlock(&rtnl_mutex);
 144
 145	while (head) {
 146		struct sk_buff *next = head->next;
 147
 148		kfree_skb(head);
 149		cond_resched();
 150		head = next;
 151	}
 152}
 153
 154void rtnl_unlock(void)
 155{
 156	/* This fellow will unlock it for us. */
 157	netdev_run_todo();
 158}
 159EXPORT_SYMBOL(rtnl_unlock);
 160
 161int rtnl_trylock(void)
 162{
 163	return mutex_trylock(&rtnl_mutex);
 164}
 165EXPORT_SYMBOL(rtnl_trylock);
 166
 167int rtnl_is_locked(void)
 168{
 169	return mutex_is_locked(&rtnl_mutex);
 170}
 171EXPORT_SYMBOL(rtnl_is_locked);
 172
 173bool refcount_dec_and_rtnl_lock(refcount_t *r)
 174{
 175	return refcount_dec_and_mutex_lock(r, &rtnl_mutex);
 176}
 177EXPORT_SYMBOL(refcount_dec_and_rtnl_lock);
 178
 179#ifdef CONFIG_PROVE_LOCKING
 180bool lockdep_rtnl_is_held(void)
 181{
 182	return lockdep_is_held(&rtnl_mutex);
 183}
 184EXPORT_SYMBOL(lockdep_rtnl_is_held);
 185#endif /* #ifdef CONFIG_PROVE_LOCKING */
 186
 187#ifdef CONFIG_DEBUG_NET_SMALL_RTNL
 188void __rtnl_net_lock(struct net *net)
 189{
 190	ASSERT_RTNL();
 191
 192	mutex_lock(&net->rtnl_mutex);
 193}
 194EXPORT_SYMBOL(__rtnl_net_lock);
 195
 196void __rtnl_net_unlock(struct net *net)
 197{
 198	ASSERT_RTNL();
 199
 200	mutex_unlock(&net->rtnl_mutex);
 201}
 202EXPORT_SYMBOL(__rtnl_net_unlock);
 203
 204void rtnl_net_lock(struct net *net)
 205{
 206	rtnl_lock();
 207	__rtnl_net_lock(net);
 208}
 209EXPORT_SYMBOL(rtnl_net_lock);
 210
 211void rtnl_net_unlock(struct net *net)
 212{
 213	__rtnl_net_unlock(net);
 214	rtnl_unlock();
 215}
 216EXPORT_SYMBOL(rtnl_net_unlock);
 217
 218int rtnl_net_trylock(struct net *net)
 219{
 220	int ret = rtnl_trylock();
 221
 222	if (ret)
 223		__rtnl_net_lock(net);
 224
 225	return ret;
 226}
 227EXPORT_SYMBOL(rtnl_net_trylock);
 228
 229int rtnl_net_lock_killable(struct net *net)
 230{
 231	int ret = rtnl_lock_killable();
 232
 233	if (!ret)
 234		__rtnl_net_lock(net);
 235
 236	return ret;
 237}
 238
 239static int rtnl_net_cmp_locks(const struct net *net_a, const struct net *net_b)
 240{
 241	if (net_eq(net_a, net_b))
 242		return 0;
 243
 244	/* always init_net first */
 245	if (net_eq(net_a, &init_net))
 246		return -1;
 247
 248	if (net_eq(net_b, &init_net))
 249		return 1;
 250
 251	/* otherwise lock in ascending order */
 252	return net_a < net_b ? -1 : 1;
 253}
 254
 255int rtnl_net_lock_cmp_fn(const struct lockdep_map *a, const struct lockdep_map *b)
 256{
 257	const struct net *net_a, *net_b;
 258
 259	net_a = container_of(a, struct net, rtnl_mutex.dep_map);
 260	net_b = container_of(b, struct net, rtnl_mutex.dep_map);
 261
 262	return rtnl_net_cmp_locks(net_a, net_b);
 263}
 264
 265bool rtnl_net_is_locked(struct net *net)
 266{
 267	return rtnl_is_locked() && mutex_is_locked(&net->rtnl_mutex);
 268}
 269EXPORT_SYMBOL(rtnl_net_is_locked);
 270
 271bool lockdep_rtnl_net_is_held(struct net *net)
 272{
 273	return lockdep_rtnl_is_held() && lockdep_is_held(&net->rtnl_mutex);
 274}
 275EXPORT_SYMBOL(lockdep_rtnl_net_is_held);
 276#else
 277static int rtnl_net_cmp_locks(const struct net *net_a, const struct net *net_b)
 278{
 279	/* No need to swap */
 280	return -1;
 281}
 282#endif
 283
 284struct rtnl_nets {
 285	/* ->newlink() needs to freeze 3 netns at most;
 286	 * 2 for the new device, 1 for its peer.
 287	 */
 288	struct net *net[3];
 289	unsigned char len;
 290};
 291
 292static void rtnl_nets_init(struct rtnl_nets *rtnl_nets)
 293{
 294	memset(rtnl_nets, 0, sizeof(*rtnl_nets));
 295}
 296
 297static void rtnl_nets_destroy(struct rtnl_nets *rtnl_nets)
 298{
 299	int i;
 300
 301	for (i = 0; i < rtnl_nets->len; i++) {
 302		put_net(rtnl_nets->net[i]);
 303		rtnl_nets->net[i] = NULL;
 304	}
 305
 306	rtnl_nets->len = 0;
 307}
 308
 309/**
 310 * rtnl_nets_add - Add netns to be locked before ->newlink().
 311 *
 312 * @rtnl_nets: rtnl_nets pointer passed to ->get_peer_net().
 313 * @net: netns pointer with an extra refcnt held.
 314 *
 315 * The extra refcnt is released in rtnl_nets_destroy().
 316 */
 317static void rtnl_nets_add(struct rtnl_nets *rtnl_nets, struct net *net)
 318{
 319	int i;
 320
 321	DEBUG_NET_WARN_ON_ONCE(rtnl_nets->len == ARRAY_SIZE(rtnl_nets->net));
 322
 323	for (i = 0; i < rtnl_nets->len; i++) {
 324		switch (rtnl_net_cmp_locks(rtnl_nets->net[i], net)) {
 325		case 0:
 326			put_net(net);
 327			return;
 328		case 1:
 329			swap(rtnl_nets->net[i], net);
 330		}
 331	}
 332
 333	rtnl_nets->net[i] = net;
 334	rtnl_nets->len++;
 335}
 336
 337static void rtnl_nets_lock(struct rtnl_nets *rtnl_nets)
 338{
 339	int i;
 340
 341	rtnl_lock();
 342
 343	for (i = 0; i < rtnl_nets->len; i++)
 344		__rtnl_net_lock(rtnl_nets->net[i]);
 345}
 346
 347static void rtnl_nets_unlock(struct rtnl_nets *rtnl_nets)
 348{
 349	int i;
 350
 351	for (i = 0; i < rtnl_nets->len; i++)
 352		__rtnl_net_unlock(rtnl_nets->net[i]);
 353
 354	rtnl_unlock();
 355}
 356
 357static struct rtnl_link __rcu *__rcu *rtnl_msg_handlers[RTNL_FAMILY_MAX + 1];
 358
 359static inline int rtm_msgindex(int msgtype)
 360{
 361	int msgindex = msgtype - RTM_BASE;
 362
 363	/*
 364	 * msgindex < 0 implies someone tried to register a netlink
 365	 * control code. msgindex >= RTM_NR_MSGTYPES may indicate that
 366	 * the message type has not been added to linux/rtnetlink.h
 367	 */
 368	BUG_ON(msgindex < 0 || msgindex >= RTM_NR_MSGTYPES);
 369
 370	return msgindex;
 371}
 372
 373static struct rtnl_link *rtnl_get_link(int protocol, int msgtype)
 374{
 375	struct rtnl_link __rcu **tab;
 376
 377	if (protocol >= ARRAY_SIZE(rtnl_msg_handlers))
 378		protocol = PF_UNSPEC;
 379
 380	tab = rcu_dereference_rtnl(rtnl_msg_handlers[protocol]);
 381	if (!tab)
 382		tab = rcu_dereference_rtnl(rtnl_msg_handlers[PF_UNSPEC]);
 383
 384	return rcu_dereference_rtnl(tab[msgtype]);
 385}
 386
 387static int rtnl_register_internal(struct module *owner,
 388				  int protocol, int msgtype,
 389				  rtnl_doit_func doit, rtnl_dumpit_func dumpit,
 390				  unsigned int flags)
 391{
 392	struct rtnl_link *link, *old;
 393	struct rtnl_link __rcu **tab;
 394	int msgindex;
 395	int ret = -ENOBUFS;
 396
 397	BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
 398	msgindex = rtm_msgindex(msgtype);
 399
 400	rtnl_lock();
 401	tab = rtnl_dereference(rtnl_msg_handlers[protocol]);
 402	if (tab == NULL) {
 403		tab = kcalloc(RTM_NR_MSGTYPES, sizeof(void *), GFP_KERNEL);
 404		if (!tab)
 405			goto unlock;
 406
 407		/* ensures we see the 0 stores */
 408		rcu_assign_pointer(rtnl_msg_handlers[protocol], tab);
 409	}
 410
 411	old = rtnl_dereference(tab[msgindex]);
 412	if (old) {
 413		link = kmemdup(old, sizeof(*old), GFP_KERNEL);
 414		if (!link)
 415			goto unlock;
 416	} else {
 417		link = kzalloc(sizeof(*link), GFP_KERNEL);
 418		if (!link)
 419			goto unlock;
 420	}
 421
 422	WARN_ON(link->owner && link->owner != owner);
 423	link->owner = owner;
 424
 425	WARN_ON(doit && link->doit && link->doit != doit);
 426	if (doit)
 427		link->doit = doit;
 428	WARN_ON(dumpit && link->dumpit && link->dumpit != dumpit);
 429	if (dumpit)
 430		link->dumpit = dumpit;
 431
 432	WARN_ON(rtnl_msgtype_kind(msgtype) != RTNL_KIND_DEL &&
 433		(flags & RTNL_FLAG_BULK_DEL_SUPPORTED));
 434	link->flags |= flags;
 435
 436	/* publish protocol:msgtype */
 437	rcu_assign_pointer(tab[msgindex], link);
 438	ret = 0;
 439	if (old)
 440		kfree_rcu(old, rcu);
 441unlock:
 442	rtnl_unlock();
 443	return ret;
 444}
 445
 446/**
 447 * rtnl_unregister - Unregister a rtnetlink message type
 448 * @protocol: Protocol family or PF_UNSPEC
 449 * @msgtype: rtnetlink message type
 450 *
 451 * Returns 0 on success or a negative error code.
 452 */
 453static int rtnl_unregister(int protocol, int msgtype)
 454{
 455	struct rtnl_link __rcu **tab;
 456	struct rtnl_link *link;
 457	int msgindex;
 458
 459	BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
 460	msgindex = rtm_msgindex(msgtype);
 461
 462	rtnl_lock();
 463	tab = rtnl_dereference(rtnl_msg_handlers[protocol]);
 464	if (!tab) {
 465		rtnl_unlock();
 466		return -ENOENT;
 467	}
 468
 469	link = rcu_replace_pointer_rtnl(tab[msgindex], NULL);
 470	rtnl_unlock();
 471
 472	kfree_rcu(link, rcu);
 473
 474	return 0;
 475}
 476
 477/**
 478 * rtnl_unregister_all - Unregister all rtnetlink message type of a protocol
 479 * @protocol : Protocol family or PF_UNSPEC
 480 *
 481 * Identical to calling rtnl_unregister() for all registered message types
 482 * of a certain protocol family.
 483 */
 484void rtnl_unregister_all(int protocol)
 485{
 486	struct rtnl_link __rcu **tab;
 487	struct rtnl_link *link;
 488	int msgindex;
 489
 490	BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
 491
 492	rtnl_lock();
 493	tab = rcu_replace_pointer_rtnl(rtnl_msg_handlers[protocol], NULL);
 494	if (!tab) {
 495		rtnl_unlock();
 496		return;
 497	}
 498	for (msgindex = 0; msgindex < RTM_NR_MSGTYPES; msgindex++) {
 499		link = rcu_replace_pointer_rtnl(tab[msgindex], NULL);
 500		kfree_rcu(link, rcu);
 501	}
 502	rtnl_unlock();
 503
 504	synchronize_net();
 505
 506	kfree(tab);
 507}
 508EXPORT_SYMBOL_GPL(rtnl_unregister_all);
 509
 510/**
 511 * __rtnl_register_many - Register rtnetlink message types
 512 * @handlers: Array of struct rtnl_msg_handlers
 513 * @n: The length of @handlers
 514 *
 515 * Registers the specified function pointers (at least one of them has
 516 * to be non-NULL) to be called whenever a request message for the
 517 * specified protocol family and message type is received.
 518 *
 519 * The special protocol family PF_UNSPEC may be used to define fallback
 520 * function pointers for the case when no entry for the specific protocol
 521 * family exists.
 522 *
 523 * When one element of @handlers fails to register,
 524 * 1) built-in: panics.
 525 * 2) modules : the previous successful registrations are unwinded
 526 *              and an error is returned.
 527 *
 528 * Use rtnl_register_many().
 529 */
 530int __rtnl_register_many(const struct rtnl_msg_handler *handlers, int n)
 531{
 532	const struct rtnl_msg_handler *handler;
 533	int i, err;
 534
 535	for (i = 0, handler = handlers; i < n; i++, handler++) {
 536		err = rtnl_register_internal(handler->owner, handler->protocol,
 537					     handler->msgtype, handler->doit,
 538					     handler->dumpit, handler->flags);
 539		if (err) {
 540			if (!handler->owner)
 541				panic("Unable to register rtnetlink message "
 542				      "handlers, %pS\n", handlers);
 543
 544			__rtnl_unregister_many(handlers, i);
 545			break;
 546		}
 547	}
 548
 549	return err;
 550}
 551EXPORT_SYMBOL_GPL(__rtnl_register_many);
 552
 553void __rtnl_unregister_many(const struct rtnl_msg_handler *handlers, int n)
 554{
 555	const struct rtnl_msg_handler *handler;
 556	int i;
 557
 558	for (i = n - 1, handler = handlers + n - 1; i >= 0; i--, handler--)
 559		rtnl_unregister(handler->protocol, handler->msgtype);
 560}
 561EXPORT_SYMBOL_GPL(__rtnl_unregister_many);
 562
 563static DEFINE_MUTEX(link_ops_mutex);
 564static LIST_HEAD(link_ops);
 565
 566static struct rtnl_link_ops *rtnl_link_ops_get(const char *kind, int *srcu_index)
 567{
 568	struct rtnl_link_ops *ops;
 569
 570	rcu_read_lock();
 571
 572	list_for_each_entry_rcu(ops, &link_ops, list) {
 573		if (!strcmp(ops->kind, kind)) {
 574			*srcu_index = srcu_read_lock(&ops->srcu);
 575			goto unlock;
 576		}
 577	}
 578
 579	ops = NULL;
 580unlock:
 581	rcu_read_unlock();
 582
 583	return ops;
 584}
 585
 586static void rtnl_link_ops_put(struct rtnl_link_ops *ops, int srcu_index)
 587{
 588	srcu_read_unlock(&ops->srcu, srcu_index);
 589}
 590
 591/**
 592 * rtnl_link_register - Register rtnl_link_ops with rtnetlink.
 593 * @ops: struct rtnl_link_ops * to register
 594 *
 595 * Returns 0 on success or a negative error code.
 596 */
 597int rtnl_link_register(struct rtnl_link_ops *ops)
 598{
 599	struct rtnl_link_ops *tmp;
 600	int err;
 601
 602	/* Sanity-check max sizes to avoid stack buffer overflow. */
 603	if (WARN_ON(ops->maxtype > RTNL_MAX_TYPE ||
 604		    ops->slave_maxtype > RTNL_SLAVE_MAX_TYPE))
 605		return -EINVAL;
 606
 607	/* The check for alloc/setup is here because if ops
 608	 * does not have that filled up, it is not possible
 609	 * to use the ops for creating device. So do not
 610	 * fill up dellink as well. That disables rtnl_dellink.
 611	 */
 612	if ((ops->alloc || ops->setup) && !ops->dellink)
 613		ops->dellink = unregister_netdevice_queue;
 614
 615	err = init_srcu_struct(&ops->srcu);
 616	if (err)
 617		return err;
 618
 619	mutex_lock(&link_ops_mutex);
 620
 621	list_for_each_entry(tmp, &link_ops, list) {
 622		if (!strcmp(ops->kind, tmp->kind)) {
 623			err = -EEXIST;
 624			goto unlock;
 625		}
 626	}
 627
 628	list_add_tail_rcu(&ops->list, &link_ops);
 629unlock:
 630	mutex_unlock(&link_ops_mutex);
 631
 632	if (err)
 633		cleanup_srcu_struct(&ops->srcu);
 634
 635	return err;
 636}
 637EXPORT_SYMBOL_GPL(rtnl_link_register);
 638
 639static void __rtnl_kill_links(struct net *net, struct rtnl_link_ops *ops)
 640{
 641	struct net_device *dev;
 642	LIST_HEAD(list_kill);
 643
 644	for_each_netdev(net, dev) {
 645		if (dev->rtnl_link_ops == ops)
 646			ops->dellink(dev, &list_kill);
 647	}
 648	unregister_netdevice_many(&list_kill);
 649}
 650
 651/* Return with the rtnl_lock held when there are no network
 652 * devices unregistering in any network namespace.
 653 */
 654static void rtnl_lock_unregistering_all(void)
 655{
 656	DEFINE_WAIT_FUNC(wait, woken_wake_function);
 657
 658	add_wait_queue(&netdev_unregistering_wq, &wait);
 659	for (;;) {
 660		rtnl_lock();
 661		/* We held write locked pernet_ops_rwsem, and parallel
 662		 * setup_net() and cleanup_net() are not possible.
 663		 */
 664		if (!atomic_read(&dev_unreg_count))
 665			break;
 666		__rtnl_unlock();
 667
 668		wait_woken(&wait, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
 669	}
 670	remove_wait_queue(&netdev_unregistering_wq, &wait);
 671}
 672
 673/**
 674 * rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink.
 675 * @ops: struct rtnl_link_ops * to unregister
 676 */
 677void rtnl_link_unregister(struct rtnl_link_ops *ops)
 678{
 679	struct net *net;
 680
 681	mutex_lock(&link_ops_mutex);
 682	list_del_rcu(&ops->list);
 683	mutex_unlock(&link_ops_mutex);
 684
 685	synchronize_srcu(&ops->srcu);
 686	cleanup_srcu_struct(&ops->srcu);
 687
 688	/* Close the race with setup_net() and cleanup_net() */
 689	down_write(&pernet_ops_rwsem);
 690	rtnl_lock_unregistering_all();
 691
 692	for_each_net(net)
 693		__rtnl_kill_links(net, ops);
 694
 695	rtnl_unlock();
 696	up_write(&pernet_ops_rwsem);
 697}
 698EXPORT_SYMBOL_GPL(rtnl_link_unregister);
 699
 700static size_t rtnl_link_get_slave_info_data_size(const struct net_device *dev)
 701{
 702	struct net_device *master_dev;
 703	const struct rtnl_link_ops *ops;
 704	size_t size = 0;
 705
 706	rcu_read_lock();
 707
 708	master_dev = netdev_master_upper_dev_get_rcu((struct net_device *)dev);
 709	if (!master_dev)
 710		goto out;
 711
 712	ops = master_dev->rtnl_link_ops;
 713	if (!ops)
 714		goto out;
 715	size += nla_total_size(strlen(ops->kind) + 1);  /* IFLA_INFO_SLAVE_KIND */
 716	if (!ops->get_slave_size)
 717		goto out;
 718	/* IFLA_INFO_SLAVE_DATA + nested data */
 719	size += nla_total_size(sizeof(struct nlattr)) +
 720		ops->get_slave_size(master_dev, dev);
 721
 722out:
 723	rcu_read_unlock();
 724	return size;
 725}
 726
 727static size_t rtnl_link_get_size(const struct net_device *dev)
 728{
 729	const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
 730	size_t size;
 731
 732	if (!ops)
 733		return 0;
 734
 735	size = nla_total_size(sizeof(struct nlattr)) + /* IFLA_LINKINFO */
 736	       nla_total_size(strlen(ops->kind) + 1);  /* IFLA_INFO_KIND */
 737
 738	if (ops->get_size)
 739		/* IFLA_INFO_DATA + nested data */
 740		size += nla_total_size(sizeof(struct nlattr)) +
 741			ops->get_size(dev);
 742
 743	if (ops->get_xstats_size)
 744		/* IFLA_INFO_XSTATS */
 745		size += nla_total_size(ops->get_xstats_size(dev));
 746
 747	size += rtnl_link_get_slave_info_data_size(dev);
 748
 749	return size;
 750}
 751
 752static LIST_HEAD(rtnl_af_ops);
 753
 754static struct rtnl_af_ops *rtnl_af_lookup(const int family, int *srcu_index)
 755{
 756	struct rtnl_af_ops *ops;
 757
 758	ASSERT_RTNL();
 759
 760	rcu_read_lock();
 761
 762	list_for_each_entry_rcu(ops, &rtnl_af_ops, list) {
 763		if (ops->family == family) {
 764			*srcu_index = srcu_read_lock(&ops->srcu);
 765			goto unlock;
 766		}
 767	}
 768
 769	ops = NULL;
 770unlock:
 771	rcu_read_unlock();
 772
 773	return ops;
 774}
 775
 776static void rtnl_af_put(struct rtnl_af_ops *ops, int srcu_index)
 777{
 778	srcu_read_unlock(&ops->srcu, srcu_index);
 779}
 780
 781/**
 782 * rtnl_af_register - Register rtnl_af_ops with rtnetlink.
 783 * @ops: struct rtnl_af_ops * to register
 784 *
 785 * Return: 0 on success or a negative error code.
 786 */
 787int rtnl_af_register(struct rtnl_af_ops *ops)
 788{
 789	int err = init_srcu_struct(&ops->srcu);
 790
 791	if (err)
 792		return err;
 793
 794	rtnl_lock();
 795	list_add_tail_rcu(&ops->list, &rtnl_af_ops);
 796	rtnl_unlock();
 797
 798	return 0;
 799}
 800EXPORT_SYMBOL_GPL(rtnl_af_register);
 801
 802/**
 803 * rtnl_af_unregister - Unregister rtnl_af_ops from rtnetlink.
 804 * @ops: struct rtnl_af_ops * to unregister
 805 */
 806void rtnl_af_unregister(struct rtnl_af_ops *ops)
 807{
 808	rtnl_lock();
 809	list_del_rcu(&ops->list);
 810	rtnl_unlock();
 811
 812	synchronize_rcu();
 813	synchronize_srcu(&ops->srcu);
 814	cleanup_srcu_struct(&ops->srcu);
 815}
 816EXPORT_SYMBOL_GPL(rtnl_af_unregister);
 817
 818static size_t rtnl_link_get_af_size(const struct net_device *dev,
 819				    u32 ext_filter_mask)
 820{
 821	struct rtnl_af_ops *af_ops;
 822	size_t size;
 823
 824	/* IFLA_AF_SPEC */
 825	size = nla_total_size(sizeof(struct nlattr));
 826
 827	rcu_read_lock();
 828	list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
 829		if (af_ops->get_link_af_size) {
 830			/* AF_* + nested data */
 831			size += nla_total_size(sizeof(struct nlattr)) +
 832				af_ops->get_link_af_size(dev, ext_filter_mask);
 833		}
 834	}
 835	rcu_read_unlock();
 836
 837	return size;
 838}
 839
 840static bool rtnl_have_link_slave_info(const struct net_device *dev)
 841{
 842	struct net_device *master_dev;
 843	bool ret = false;
 844
 845	rcu_read_lock();
 846
 847	master_dev = netdev_master_upper_dev_get_rcu((struct net_device *)dev);
 848	if (master_dev && master_dev->rtnl_link_ops)
 849		ret = true;
 850	rcu_read_unlock();
 851	return ret;
 852}
 853
 854static int rtnl_link_slave_info_fill(struct sk_buff *skb,
 855				     const struct net_device *dev)
 856{
 857	struct net_device *master_dev;
 858	const struct rtnl_link_ops *ops;
 859	struct nlattr *slave_data;
 860	int err;
 861
 862	master_dev = netdev_master_upper_dev_get((struct net_device *) dev);
 863	if (!master_dev)
 864		return 0;
 865	ops = master_dev->rtnl_link_ops;
 866	if (!ops)
 867		return 0;
 868	if (nla_put_string(skb, IFLA_INFO_SLAVE_KIND, ops->kind) < 0)
 869		return -EMSGSIZE;
 870	if (ops->fill_slave_info) {
 871		slave_data = nla_nest_start_noflag(skb, IFLA_INFO_SLAVE_DATA);
 872		if (!slave_data)
 873			return -EMSGSIZE;
 874		err = ops->fill_slave_info(skb, master_dev, dev);
 875		if (err < 0)
 876			goto err_cancel_slave_data;
 877		nla_nest_end(skb, slave_data);
 878	}
 879	return 0;
 880
 881err_cancel_slave_data:
 882	nla_nest_cancel(skb, slave_data);
 883	return err;
 884}
 885
 886static int rtnl_link_info_fill(struct sk_buff *skb,
 887			       const struct net_device *dev)
 888{
 889	const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
 890	struct nlattr *data;
 891	int err;
 892
 893	if (!ops)
 894		return 0;
 895	if (nla_put_string(skb, IFLA_INFO_KIND, ops->kind) < 0)
 896		return -EMSGSIZE;
 897	if (ops->fill_xstats) {
 898		err = ops->fill_xstats(skb, dev);
 899		if (err < 0)
 900			return err;
 901	}
 902	if (ops->fill_info) {
 903		data = nla_nest_start_noflag(skb, IFLA_INFO_DATA);
 904		if (data == NULL)
 905			return -EMSGSIZE;
 906		err = ops->fill_info(skb, dev);
 907		if (err < 0)
 908			goto err_cancel_data;
 909		nla_nest_end(skb, data);
 910	}
 911	return 0;
 912
 913err_cancel_data:
 914	nla_nest_cancel(skb, data);
 915	return err;
 916}
 917
 918static int rtnl_link_fill(struct sk_buff *skb, const struct net_device *dev)
 919{
 920	struct nlattr *linkinfo;
 921	int err = -EMSGSIZE;
 922
 923	linkinfo = nla_nest_start_noflag(skb, IFLA_LINKINFO);
 924	if (linkinfo == NULL)
 925		goto out;
 926
 927	err = rtnl_link_info_fill(skb, dev);
 928	if (err < 0)
 929		goto err_cancel_link;
 930
 931	err = rtnl_link_slave_info_fill(skb, dev);
 932	if (err < 0)
 933		goto err_cancel_link;
 934
 935	nla_nest_end(skb, linkinfo);
 936	return 0;
 937
 938err_cancel_link:
 939	nla_nest_cancel(skb, linkinfo);
 940out:
 941	return err;
 942}
 943
 944int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigned int group, int echo)
 945{
 946	struct sock *rtnl = net->rtnl;
 947
 948	return nlmsg_notify(rtnl, skb, pid, group, echo, GFP_KERNEL);
 949}
 950
 951int rtnl_unicast(struct sk_buff *skb, struct net *net, u32 pid)
 952{
 953	struct sock *rtnl = net->rtnl;
 954
 955	return nlmsg_unicast(rtnl, skb, pid);
 956}
 957EXPORT_SYMBOL(rtnl_unicast);
 958
 959void rtnl_notify(struct sk_buff *skb, struct net *net, u32 pid, u32 group,
 960		 const struct nlmsghdr *nlh, gfp_t flags)
 961{
 962	struct sock *rtnl = net->rtnl;
 963
 964	nlmsg_notify(rtnl, skb, pid, group, nlmsg_report(nlh), flags);
 965}
 966EXPORT_SYMBOL(rtnl_notify);
 967
 968void rtnl_set_sk_err(struct net *net, u32 group, int error)
 969{
 970	struct sock *rtnl = net->rtnl;
 971
 972	netlink_set_err(rtnl, 0, group, error);
 973}
 974EXPORT_SYMBOL(rtnl_set_sk_err);
 975
 976int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics)
 977{
 978	struct nlattr *mx;
 979	int i, valid = 0;
 980
 981	/* nothing is dumped for dst_default_metrics, so just skip the loop */
 982	if (metrics == dst_default_metrics.metrics)
 983		return 0;
 984
 985	mx = nla_nest_start_noflag(skb, RTA_METRICS);
 986	if (mx == NULL)
 987		return -ENOBUFS;
 988
 989	for (i = 0; i < RTAX_MAX; i++) {
 990		if (metrics[i]) {
 991			if (i == RTAX_CC_ALGO - 1) {
 992				char tmp[TCP_CA_NAME_MAX], *name;
 993
 994				name = tcp_ca_get_name_by_key(metrics[i], tmp);
 995				if (!name)
 996					continue;
 997				if (nla_put_string(skb, i + 1, name))
 998					goto nla_put_failure;
 999			} else if (i == RTAX_FEATURES - 1) {
1000				u32 user_features = metrics[i] & RTAX_FEATURE_MASK;
1001
1002				if (!user_features)
1003					continue;
1004				BUILD_BUG_ON(RTAX_FEATURE_MASK & DST_FEATURE_MASK);
1005				if (nla_put_u32(skb, i + 1, user_features))
1006					goto nla_put_failure;
1007			} else {
1008				if (nla_put_u32(skb, i + 1, metrics[i]))
1009					goto nla_put_failure;
1010			}
1011			valid++;
1012		}
1013	}
1014
1015	if (!valid) {
1016		nla_nest_cancel(skb, mx);
1017		return 0;
1018	}
1019
1020	return nla_nest_end(skb, mx);
1021
1022nla_put_failure:
1023	nla_nest_cancel(skb, mx);
1024	return -EMSGSIZE;
1025}
1026EXPORT_SYMBOL(rtnetlink_put_metrics);
1027
1028int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id,
1029		       long expires, u32 error)
1030{
1031	struct rta_cacheinfo ci = {
1032		.rta_error = error,
1033		.rta_id =  id,
1034	};
1035	unsigned long delta;
1036
1037	if (dst) {
1038		delta = jiffies - READ_ONCE(dst->lastuse);
1039		ci.rta_lastuse = jiffies_delta_to_clock_t(delta);
1040		ci.rta_used = dst->__use;
1041		ci.rta_clntref = rcuref_read(&dst->__rcuref);
1042	}
1043	if (expires) {
1044		unsigned long clock;
1045
1046		clock = jiffies_to_clock_t(abs(expires));
1047		clock = min_t(unsigned long, clock, INT_MAX);
1048		ci.rta_expires = (expires > 0) ? clock : -clock;
1049	}
1050	return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci);
1051}
1052EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo);
1053
1054void netif_set_operstate(struct net_device *dev, int newstate)
1055{
1056	unsigned int old = READ_ONCE(dev->operstate);
1057
1058	do {
1059		if (old == newstate)
1060			return;
1061	} while (!try_cmpxchg(&dev->operstate, &old, newstate));
1062
1063	netif_state_change(dev);
1064}
1065EXPORT_SYMBOL(netif_set_operstate);
1066
1067static void set_operstate(struct net_device *dev, unsigned char transition)
1068{
1069	unsigned char operstate = READ_ONCE(dev->operstate);
1070
1071	switch (transition) {
1072	case IF_OPER_UP:
1073		if ((operstate == IF_OPER_DORMANT ||
1074		     operstate == IF_OPER_TESTING ||
1075		     operstate == IF_OPER_UNKNOWN) &&
1076		    !netif_dormant(dev) && !netif_testing(dev))
1077			operstate = IF_OPER_UP;
1078		break;
1079
1080	case IF_OPER_TESTING:
1081		if (netif_oper_up(dev))
1082			operstate = IF_OPER_TESTING;
1083		break;
1084
1085	case IF_OPER_DORMANT:
1086		if (netif_oper_up(dev))
1087			operstate = IF_OPER_DORMANT;
1088		break;
1089	}
1090
1091	netif_set_operstate(dev, operstate);
1092}
1093
1094static unsigned int rtnl_dev_get_flags(const struct net_device *dev)
1095{
1096	return (dev->flags & ~(IFF_PROMISC | IFF_ALLMULTI)) |
1097	       (dev->gflags & (IFF_PROMISC | IFF_ALLMULTI));
1098}
1099
1100static unsigned int rtnl_dev_combine_flags(const struct net_device *dev,
1101					   const struct ifinfomsg *ifm)
1102{
1103	unsigned int flags = ifm->ifi_flags;
1104
1105	/* bugwards compatibility: ifi_change == 0 is treated as ~0 */
1106	if (ifm->ifi_change)
1107		flags = (flags & ifm->ifi_change) |
1108			(rtnl_dev_get_flags(dev) & ~ifm->ifi_change);
1109
1110	return flags;
1111}
1112
1113static void copy_rtnl_link_stats(struct rtnl_link_stats *a,
1114				 const struct rtnl_link_stats64 *b)
1115{
1116	a->rx_packets = b->rx_packets;
1117	a->tx_packets = b->tx_packets;
1118	a->rx_bytes = b->rx_bytes;
1119	a->tx_bytes = b->tx_bytes;
1120	a->rx_errors = b->rx_errors;
1121	a->tx_errors = b->tx_errors;
1122	a->rx_dropped = b->rx_dropped;
1123	a->tx_dropped = b->tx_dropped;
1124
1125	a->multicast = b->multicast;
1126	a->collisions = b->collisions;
1127
1128	a->rx_length_errors = b->rx_length_errors;
1129	a->rx_over_errors = b->rx_over_errors;
1130	a->rx_crc_errors = b->rx_crc_errors;
1131	a->rx_frame_errors = b->rx_frame_errors;
1132	a->rx_fifo_errors = b->rx_fifo_errors;
1133	a->rx_missed_errors = b->rx_missed_errors;
1134
1135	a->tx_aborted_errors = b->tx_aborted_errors;
1136	a->tx_carrier_errors = b->tx_carrier_errors;
1137	a->tx_fifo_errors = b->tx_fifo_errors;
1138	a->tx_heartbeat_errors = b->tx_heartbeat_errors;
1139	a->tx_window_errors = b->tx_window_errors;
1140
1141	a->rx_compressed = b->rx_compressed;
1142	a->tx_compressed = b->tx_compressed;
1143
1144	a->rx_nohandler = b->rx_nohandler;
1145}
1146
1147/* All VF info */
1148static inline int rtnl_vfinfo_size(const struct net_device *dev,
1149				   u32 ext_filter_mask)
1150{
1151	if (dev->dev.parent && (ext_filter_mask & RTEXT_FILTER_VF)) {
1152		int num_vfs = dev_num_vf(dev->dev.parent);
1153		size_t size = nla_total_size(0);
1154		size += num_vfs *
1155			(nla_total_size(0) +
1156			 nla_total_size(sizeof(struct ifla_vf_mac)) +
1157			 nla_total_size(sizeof(struct ifla_vf_broadcast)) +
1158			 nla_total_size(sizeof(struct ifla_vf_vlan)) +
1159			 nla_total_size(0) + /* nest IFLA_VF_VLAN_LIST */
1160			 nla_total_size(MAX_VLAN_LIST_LEN *
1161					sizeof(struct ifla_vf_vlan_info)) +
1162			 nla_total_size(sizeof(struct ifla_vf_spoofchk)) +
1163			 nla_total_size(sizeof(struct ifla_vf_tx_rate)) +
1164			 nla_total_size(sizeof(struct ifla_vf_rate)) +
1165			 nla_total_size(sizeof(struct ifla_vf_link_state)) +
1166			 nla_total_size(sizeof(struct ifla_vf_rss_query_en)) +
1167			 nla_total_size(sizeof(struct ifla_vf_trust)));
1168		if (~ext_filter_mask & RTEXT_FILTER_SKIP_STATS) {
1169			size += num_vfs *
1170				(nla_total_size(0) + /* nest IFLA_VF_STATS */
1171				 /* IFLA_VF_STATS_RX_PACKETS */
1172				 nla_total_size_64bit(sizeof(__u64)) +
1173				 /* IFLA_VF_STATS_TX_PACKETS */
1174				 nla_total_size_64bit(sizeof(__u64)) +
1175				 /* IFLA_VF_STATS_RX_BYTES */
1176				 nla_total_size_64bit(sizeof(__u64)) +
1177				 /* IFLA_VF_STATS_TX_BYTES */
1178				 nla_total_size_64bit(sizeof(__u64)) +
1179				 /* IFLA_VF_STATS_BROADCAST */
1180				 nla_total_size_64bit(sizeof(__u64)) +
1181				 /* IFLA_VF_STATS_MULTICAST */
1182				 nla_total_size_64bit(sizeof(__u64)) +
1183				 /* IFLA_VF_STATS_RX_DROPPED */
1184				 nla_total_size_64bit(sizeof(__u64)) +
1185				 /* IFLA_VF_STATS_TX_DROPPED */
1186				 nla_total_size_64bit(sizeof(__u64)));
1187		}
1188		if (dev->netdev_ops->ndo_get_vf_guid)
1189			size += num_vfs * 2 *
1190				nla_total_size(sizeof(struct ifla_vf_guid));
1191		return size;
1192	} else
1193		return 0;
1194}
1195
1196static size_t rtnl_port_size(const struct net_device *dev,
1197			     u32 ext_filter_mask)
1198{
1199	size_t port_size = nla_total_size(4)		/* PORT_VF */
1200		+ nla_total_size(PORT_PROFILE_MAX)	/* PORT_PROFILE */
1201		+ nla_total_size(PORT_UUID_MAX)		/* PORT_INSTANCE_UUID */
1202		+ nla_total_size(PORT_UUID_MAX)		/* PORT_HOST_UUID */
1203		+ nla_total_size(1)			/* PROT_VDP_REQUEST */
1204		+ nla_total_size(2);			/* PORT_VDP_RESPONSE */
1205	size_t vf_ports_size = nla_total_size(sizeof(struct nlattr));
1206	size_t vf_port_size = nla_total_size(sizeof(struct nlattr))
1207		+ port_size;
1208	size_t port_self_size = nla_total_size(sizeof(struct nlattr))
1209		+ port_size;
1210
1211	if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
1212	    !(ext_filter_mask & RTEXT_FILTER_VF))
1213		return 0;
1214	if (dev_num_vf(dev->dev.parent))
1215		return port_self_size + vf_ports_size +
1216			vf_port_size * dev_num_vf(dev->dev.parent);
1217	else
1218		return port_self_size;
1219}
1220
1221static size_t rtnl_xdp_size(void)
1222{
1223	size_t xdp_size = nla_total_size(0) +	/* nest IFLA_XDP */
1224			  nla_total_size(1) +	/* XDP_ATTACHED */
1225			  nla_total_size(4) +	/* XDP_PROG_ID (or 1st mode) */
1226			  nla_total_size(4);	/* XDP_<mode>_PROG_ID */
1227
1228	return xdp_size;
1229}
1230
1231static size_t rtnl_prop_list_size(const struct net_device *dev)
1232{
1233	struct netdev_name_node *name_node;
1234	unsigned int cnt = 0;
1235
1236	rcu_read_lock();
1237	list_for_each_entry_rcu(name_node, &dev->name_node->list, list)
1238		cnt++;
1239	rcu_read_unlock();
1240
1241	if (!cnt)
1242		return 0;
1243
1244	return nla_total_size(0) + cnt * nla_total_size(ALTIFNAMSIZ);
1245}
1246
1247static size_t rtnl_proto_down_size(const struct net_device *dev)
1248{
1249	size_t size = nla_total_size(1);
1250
1251	/* Assume dev->proto_down_reason is not zero. */
1252	size += nla_total_size(0) + nla_total_size(4);
1253
1254	return size;
1255}
1256
1257static size_t rtnl_devlink_port_size(const struct net_device *dev)
1258{
1259	size_t size = nla_total_size(0); /* nest IFLA_DEVLINK_PORT */
1260
1261	if (dev->devlink_port)
1262		size += devlink_nl_port_handle_size(dev->devlink_port);
1263
1264	return size;
1265}
1266
1267static size_t rtnl_dpll_pin_size(const struct net_device *dev)
1268{
1269	size_t size = nla_total_size(0); /* nest IFLA_DPLL_PIN */
1270
1271	size += dpll_netdev_pin_handle_size(dev);
1272
1273	return size;
1274}
1275
1276static size_t rtnl_dev_parent_size(const struct net_device *dev)
1277{
1278	size_t size = 0;
1279
1280	/* IFLA_PARENT_DEV_NAME */
1281	if (dev->dev.parent)
1282		size += nla_total_size(strlen(dev_name(dev->dev.parent)) + 1);
1283
1284	/* IFLA_PARENT_DEV_BUS_NAME */
1285	if (dev->dev.parent && dev->dev.parent->bus)
1286		size += nla_total_size(strlen(dev->dev.parent->bus->name) + 1);
1287
1288	return size;
1289}
1290
1291static noinline size_t if_nlmsg_size(const struct net_device *dev,
1292				     u32 ext_filter_mask)
1293{
1294	size_t size;
1295
1296	size = NLMSG_ALIGN(sizeof(struct ifinfomsg))
1297	       + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
1298	       + nla_total_size(IFALIASZ) /* IFLA_IFALIAS */
1299	       + nla_total_size(IFNAMSIZ) /* IFLA_QDISC */
1300	       + nla_total_size_64bit(sizeof(struct rtnl_link_ifmap))
1301	       + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
1302	       + nla_total_size(MAX_ADDR_LEN) /* IFLA_BROADCAST */
1303	       + nla_total_size(4) /* IFLA_TXQLEN */
1304	       + nla_total_size(4) /* IFLA_WEIGHT */
1305	       + nla_total_size(4) /* IFLA_MTU */
1306	       + nla_total_size(4) /* IFLA_LINK */
1307	       + nla_total_size(4) /* IFLA_MASTER */
1308	       + nla_total_size(1) /* IFLA_CARRIER */
1309	       + nla_total_size(4) /* IFLA_PROMISCUITY */
1310	       + nla_total_size(4) /* IFLA_ALLMULTI */
1311	       + nla_total_size(4) /* IFLA_NUM_TX_QUEUES */
1312	       + nla_total_size(4) /* IFLA_NUM_RX_QUEUES */
1313	       + nla_total_size(4) /* IFLA_GSO_MAX_SEGS */
1314	       + nla_total_size(4) /* IFLA_GSO_MAX_SIZE */
1315	       + nla_total_size(4) /* IFLA_GRO_MAX_SIZE */
1316	       + nla_total_size(4) /* IFLA_GSO_IPV4_MAX_SIZE */
1317	       + nla_total_size(4) /* IFLA_GRO_IPV4_MAX_SIZE */
1318	       + nla_total_size(4) /* IFLA_TSO_MAX_SIZE */
1319	       + nla_total_size(4) /* IFLA_TSO_MAX_SEGS */
1320	       + nla_total_size(1) /* IFLA_OPERSTATE */
1321	       + nla_total_size(1) /* IFLA_LINKMODE */
1322	       + nla_total_size(1) /* IFLA_NETNS_IMMUTABLE */
1323	       + nla_total_size(4) /* IFLA_CARRIER_CHANGES */
1324	       + nla_total_size(4) /* IFLA_LINK_NETNSID */
1325	       + nla_total_size(4) /* IFLA_GROUP */
1326	       + nla_total_size(ext_filter_mask
1327			        & RTEXT_FILTER_VF ? 4 : 0) /* IFLA_NUM_VF */
1328	       + rtnl_vfinfo_size(dev, ext_filter_mask) /* IFLA_VFINFO_LIST */
1329	       + rtnl_port_size(dev, ext_filter_mask) /* IFLA_VF_PORTS + IFLA_PORT_SELF */
1330	       + rtnl_link_get_size(dev) /* IFLA_LINKINFO */
1331	       + rtnl_link_get_af_size(dev, ext_filter_mask) /* IFLA_AF_SPEC */
1332	       + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_PORT_ID */
1333	       + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_SWITCH_ID */
1334	       + nla_total_size(IFNAMSIZ) /* IFLA_PHYS_PORT_NAME */
1335	       + rtnl_xdp_size() /* IFLA_XDP */
1336	       + nla_total_size(4)  /* IFLA_EVENT */
1337	       + nla_total_size(4)  /* IFLA_NEW_NETNSID */
1338	       + nla_total_size(4)  /* IFLA_NEW_IFINDEX */
1339	       + rtnl_proto_down_size(dev)  /* proto down */
1340	       + nla_total_size(4)  /* IFLA_TARGET_NETNSID */
1341	       + nla_total_size(4)  /* IFLA_CARRIER_UP_COUNT */
1342	       + nla_total_size(4)  /* IFLA_CARRIER_DOWN_COUNT */
1343	       + nla_total_size(4)  /* IFLA_MIN_MTU */
1344	       + nla_total_size(4)  /* IFLA_MAX_MTU */
1345	       + rtnl_prop_list_size(dev)
1346	       + nla_total_size(MAX_ADDR_LEN) /* IFLA_PERM_ADDRESS */
1347	       + rtnl_devlink_port_size(dev)
1348	       + rtnl_dpll_pin_size(dev)
1349	       + nla_total_size(8)  /* IFLA_MAX_PACING_OFFLOAD_HORIZON */
1350	       + nla_total_size(2)  /* IFLA_HEADROOM */
1351	       + nla_total_size(2)  /* IFLA_TAILROOM */
1352	       + rtnl_dev_parent_size(dev)
1353	       + 0;
1354
1355	if (!(ext_filter_mask & RTEXT_FILTER_SKIP_STATS))
1356		size += nla_total_size(sizeof(struct rtnl_link_stats)) +
1357			nla_total_size_64bit(sizeof(struct rtnl_link_stats64));
1358
1359	return size;
1360}
1361
1362static int rtnl_vf_ports_fill(struct sk_buff *skb, struct net_device *dev)
1363{
1364	struct nlattr *vf_ports;
1365	struct nlattr *vf_port;
1366	int vf;
1367	int err;
1368
1369	vf_ports = nla_nest_start_noflag(skb, IFLA_VF_PORTS);
1370	if (!vf_ports)
1371		return -EMSGSIZE;
1372
1373	for (vf = 0; vf < dev_num_vf(dev->dev.parent); vf++) {
1374		vf_port = nla_nest_start_noflag(skb, IFLA_VF_PORT);
1375		if (!vf_port)
1376			goto nla_put_failure;
1377		if (nla_put_u32(skb, IFLA_PORT_VF, vf))
1378			goto nla_put_failure;
1379		err = dev->netdev_ops->ndo_get_vf_port(dev, vf, skb);
1380		if (err == -EMSGSIZE)
1381			goto nla_put_failure;
1382		if (err) {
1383			nla_nest_cancel(skb, vf_port);
1384			continue;
1385		}
1386		nla_nest_end(skb, vf_port);
1387	}
1388
1389	nla_nest_end(skb, vf_ports);
1390
1391	return 0;
1392
1393nla_put_failure:
1394	nla_nest_cancel(skb, vf_ports);
1395	return -EMSGSIZE;
1396}
1397
1398static int rtnl_port_self_fill(struct sk_buff *skb, struct net_device *dev)
1399{
1400	struct nlattr *port_self;
1401	int err;
1402
1403	port_self = nla_nest_start_noflag(skb, IFLA_PORT_SELF);
1404	if (!port_self)
1405		return -EMSGSIZE;
1406
1407	err = dev->netdev_ops->ndo_get_vf_port(dev, PORT_SELF_VF, skb);
1408	if (err) {
1409		nla_nest_cancel(skb, port_self);
1410		return (err == -EMSGSIZE) ? err : 0;
1411	}
1412
1413	nla_nest_end(skb, port_self);
1414
1415	return 0;
1416}
1417
1418static int rtnl_port_fill(struct sk_buff *skb, struct net_device *dev,
1419			  u32 ext_filter_mask)
1420{
1421	int err;
1422
1423	if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
1424	    !(ext_filter_mask & RTEXT_FILTER_VF))
1425		return 0;
1426
1427	err = rtnl_port_self_fill(skb, dev);
1428	if (err)
1429		return err;
1430
1431	if (dev_num_vf(dev->dev.parent)) {
1432		err = rtnl_vf_ports_fill(skb, dev);
1433		if (err)
1434			return err;
1435	}
1436
1437	return 0;
1438}
1439
1440static int rtnl_phys_port_id_fill(struct sk_buff *skb, struct net_device *dev)
1441{
1442	int err;
1443	struct netdev_phys_item_id ppid;
1444
1445	err = dev_get_phys_port_id(dev, &ppid);
1446	if (err) {
1447		if (err == -EOPNOTSUPP)
1448			return 0;
1449		return err;
1450	}
1451
1452	if (nla_put(skb, IFLA_PHYS_PORT_ID, ppid.id_len, ppid.id))
1453		return -EMSGSIZE;
1454
1455	return 0;
1456}
1457
1458static int rtnl_phys_port_name_fill(struct sk_buff *skb, struct net_device *dev)
1459{
1460	char name[IFNAMSIZ];
1461	int err;
1462
1463	err = dev_get_phys_port_name(dev, name, sizeof(name));
1464	if (err) {
1465		if (err == -EOPNOTSUPP)
1466			return 0;
1467		return err;
1468	}
1469
1470	if (nla_put_string(skb, IFLA_PHYS_PORT_NAME, name))
1471		return -EMSGSIZE;
1472
1473	return 0;
1474}
1475
1476static int rtnl_phys_switch_id_fill(struct sk_buff *skb, struct net_device *dev)
1477{
1478	struct netdev_phys_item_id ppid = { };
1479	int err;
1480
1481	err = netif_get_port_parent_id(dev, &ppid, false);
1482	if (err) {
1483		if (err == -EOPNOTSUPP)
1484			return 0;
1485		return err;
1486	}
1487
1488	if (nla_put(skb, IFLA_PHYS_SWITCH_ID, ppid.id_len, ppid.id))
1489		return -EMSGSIZE;
1490
1491	return 0;
1492}
1493
1494static noinline_for_stack int rtnl_fill_stats(struct sk_buff *skb,
1495					      struct net_device *dev)
1496{
1497	struct rtnl_link_stats64 *sp;
1498	struct nlattr *attr;
1499
1500	attr = nla_reserve_64bit(skb, IFLA_STATS64,
1501				 sizeof(struct rtnl_link_stats64), IFLA_PAD);
1502	if (!attr)
1503		return -EMSGSIZE;
1504
1505	sp = nla_data(attr);
1506	dev_get_stats(dev, sp);
1507
1508	attr = nla_reserve(skb, IFLA_STATS,
1509			   sizeof(struct rtnl_link_stats));
1510	if (!attr)
1511		return -EMSGSIZE;
1512
1513	copy_rtnl_link_stats(nla_data(attr), sp);
1514
1515	return 0;
1516}
1517
1518static noinline_for_stack int rtnl_fill_vfinfo(struct sk_buff *skb,
1519					       struct net_device *dev,
1520					       int vfs_num,
1521					       u32 ext_filter_mask)
1522{
1523	struct ifla_vf_rss_query_en vf_rss_query_en;
1524	struct nlattr *vf, *vfstats, *vfvlanlist;
1525	struct ifla_vf_link_state vf_linkstate;
1526	struct ifla_vf_vlan_info vf_vlan_info;
1527	struct ifla_vf_spoofchk vf_spoofchk;
1528	struct ifla_vf_tx_rate vf_tx_rate;
1529	struct ifla_vf_stats vf_stats;
1530	struct ifla_vf_trust vf_trust;
1531	struct ifla_vf_vlan vf_vlan;
1532	struct ifla_vf_rate vf_rate;
1533	struct ifla_vf_mac vf_mac;
1534	struct ifla_vf_broadcast vf_broadcast;
1535	struct ifla_vf_info ivi;
1536	struct ifla_vf_guid node_guid;
1537	struct ifla_vf_guid port_guid;
1538
1539	memset(&ivi, 0, sizeof(ivi));
1540
1541	/* Not all SR-IOV capable drivers support the
1542	 * spoofcheck and "RSS query enable" query.  Preset to
1543	 * -1 so the user space tool can detect that the driver
1544	 * didn't report anything.
1545	 */
1546	ivi.spoofchk = -1;
1547	ivi.rss_query_en = -1;
1548	ivi.trusted = -1;
1549	/* The default value for VF link state is "auto"
1550	 * IFLA_VF_LINK_STATE_AUTO which equals zero
1551	 */
1552	ivi.linkstate = 0;
1553	/* VLAN Protocol by default is 802.1Q */
1554	ivi.vlan_proto = htons(ETH_P_8021Q);
1555	if (dev->netdev_ops->ndo_get_vf_config(dev, vfs_num, &ivi))
1556		return 0;
1557
1558	memset(&vf_vlan_info, 0, sizeof(vf_vlan_info));
1559	memset(&node_guid, 0, sizeof(node_guid));
1560	memset(&port_guid, 0, sizeof(port_guid));
1561
1562	vf_mac.vf =
1563		vf_vlan.vf =
1564		vf_vlan_info.vf =
1565		vf_rate.vf =
1566		vf_tx_rate.vf =
1567		vf_spoofchk.vf =
1568		vf_linkstate.vf =
1569		vf_rss_query_en.vf =
1570		vf_trust.vf =
1571		node_guid.vf =
1572		port_guid.vf = ivi.vf;
1573
1574	memcpy(vf_mac.mac, ivi.mac, sizeof(ivi.mac));
1575	memcpy(vf_broadcast.broadcast, dev->broadcast, dev->addr_len);
1576	vf_vlan.vlan = ivi.vlan;
1577	vf_vlan.qos = ivi.qos;
1578	vf_vlan_info.vlan = ivi.vlan;
1579	vf_vlan_info.qos = ivi.qos;
1580	vf_vlan_info.vlan_proto = ivi.vlan_proto;
1581	vf_tx_rate.rate = ivi.max_tx_rate;
1582	vf_rate.min_tx_rate = ivi.min_tx_rate;
1583	vf_rate.max_tx_rate = ivi.max_tx_rate;
1584	vf_spoofchk.setting = ivi.spoofchk;
1585	vf_linkstate.link_state = ivi.linkstate;
1586	vf_rss_query_en.setting = ivi.rss_query_en;
1587	vf_trust.setting = ivi.trusted;
1588	vf = nla_nest_start_noflag(skb, IFLA_VF_INFO);
1589	if (!vf)
1590		return -EMSGSIZE;
1591	if (nla_put(skb, IFLA_VF_MAC, sizeof(vf_mac), &vf_mac) ||
1592	    nla_put(skb, IFLA_VF_BROADCAST, sizeof(vf_broadcast), &vf_broadcast) ||
1593	    nla_put(skb, IFLA_VF_VLAN, sizeof(vf_vlan), &vf_vlan) ||
1594	    nla_put(skb, IFLA_VF_RATE, sizeof(vf_rate),
1595		    &vf_rate) ||
1596	    nla_put(skb, IFLA_VF_TX_RATE, sizeof(vf_tx_rate),
1597		    &vf_tx_rate) ||
1598	    nla_put(skb, IFLA_VF_SPOOFCHK, sizeof(vf_spoofchk),
1599		    &vf_spoofchk) ||
1600	    nla_put(skb, IFLA_VF_LINK_STATE, sizeof(vf_linkstate),
1601		    &vf_linkstate) ||
1602	    nla_put(skb, IFLA_VF_RSS_QUERY_EN,
1603		    sizeof(vf_rss_query_en),
1604		    &vf_rss_query_en) ||
1605	    nla_put(skb, IFLA_VF_TRUST,
1606		    sizeof(vf_trust), &vf_trust))
1607		goto nla_put_vf_failure;
1608
1609	if (dev->netdev_ops->ndo_get_vf_guid &&
1610	    !dev->netdev_ops->ndo_get_vf_guid(dev, vfs_num, &node_guid,
1611					      &port_guid)) {
1612		if (nla_put(skb, IFLA_VF_IB_NODE_GUID, sizeof(node_guid),
1613			    &node_guid) ||
1614		    nla_put(skb, IFLA_VF_IB_PORT_GUID, sizeof(port_guid),
1615			    &port_guid))
1616			goto nla_put_vf_failure;
1617	}
1618	vfvlanlist = nla_nest_start_noflag(skb, IFLA_VF_VLAN_LIST);
1619	if (!vfvlanlist)
1620		goto nla_put_vf_failure;
1621	if (nla_put(skb, IFLA_VF_VLAN_INFO, sizeof(vf_vlan_info),
1622		    &vf_vlan_info)) {
1623		nla_nest_cancel(skb, vfvlanlist);
1624		goto nla_put_vf_failure;
1625	}
1626	nla_nest_end(skb, vfvlanlist);
1627	if (~ext_filter_mask & RTEXT_FILTER_SKIP_STATS) {
1628		memset(&vf_stats, 0, sizeof(vf_stats));
1629		if (dev->netdev_ops->ndo_get_vf_stats)
1630			dev->netdev_ops->ndo_get_vf_stats(dev, vfs_num,
1631							  &vf_stats);
1632		vfstats = nla_nest_start_noflag(skb, IFLA_VF_STATS);
1633		if (!vfstats)
1634			goto nla_put_vf_failure;
1635		if (nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_PACKETS,
1636				      vf_stats.rx_packets, IFLA_VF_STATS_PAD) ||
1637		    nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS,
1638				      vf_stats.tx_packets, IFLA_VF_STATS_PAD) ||
1639		    nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES,
1640				      vf_stats.rx_bytes, IFLA_VF_STATS_PAD) ||
1641		    nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES,
1642				      vf_stats.tx_bytes, IFLA_VF_STATS_PAD) ||
1643		    nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST,
1644				      vf_stats.broadcast, IFLA_VF_STATS_PAD) ||
1645		    nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST,
1646				      vf_stats.multicast, IFLA_VF_STATS_PAD) ||
1647		    nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_DROPPED,
1648				      vf_stats.rx_dropped, IFLA_VF_STATS_PAD) ||
1649		    nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_DROPPED,
1650				      vf_stats.tx_dropped, IFLA_VF_STATS_PAD)) {
1651			nla_nest_cancel(skb, vfstats);
1652			goto nla_put_vf_failure;
1653		}
1654		nla_nest_end(skb, vfstats);
1655	}
1656	nla_nest_end(skb, vf);
1657	return 0;
1658
1659nla_put_vf_failure:
1660	nla_nest_cancel(skb, vf);
1661	return -EMSGSIZE;
1662}
1663
1664static noinline_for_stack int rtnl_fill_vf(struct sk_buff *skb,
1665					   struct net_device *dev,
1666					   u32 ext_filter_mask)
1667{
1668	struct nlattr *vfinfo;
1669	int i, num_vfs;
1670
1671	if (!dev->dev.parent || ((ext_filter_mask & RTEXT_FILTER_VF) == 0))
1672		return 0;
1673
1674	num_vfs = dev_num_vf(dev->dev.parent);
1675	if (nla_put_u32(skb, IFLA_NUM_VF, num_vfs))
1676		return -EMSGSIZE;
1677
1678	if (!dev->netdev_ops->ndo_get_vf_config)
1679		return 0;
1680
1681	vfinfo = nla_nest_start_noflag(skb, IFLA_VFINFO_LIST);
1682	if (!vfinfo)
1683		return -EMSGSIZE;
1684
1685	for (i = 0; i < num_vfs; i++) {
1686		if (rtnl_fill_vfinfo(skb, dev, i, ext_filter_mask)) {
1687			nla_nest_cancel(skb, vfinfo);
1688			return -EMSGSIZE;
1689		}
1690	}
1691
1692	nla_nest_end(skb, vfinfo);
1693	return 0;
1694}
1695
1696static int rtnl_fill_link_ifmap(struct sk_buff *skb,
1697				const struct net_device *dev)
1698{
1699	struct rtnl_link_ifmap map;
1700
1701	memset(&map, 0, sizeof(map));
1702	map.mem_start = READ_ONCE(dev->mem_start);
1703	map.mem_end   = READ_ONCE(dev->mem_end);
1704	map.base_addr = READ_ONCE(dev->base_addr);
1705	map.irq       = READ_ONCE(dev->irq);
1706	map.dma       = READ_ONCE(dev->dma);
1707	map.port      = READ_ONCE(dev->if_port);
1708
1709	if (nla_put_64bit(skb, IFLA_MAP, sizeof(map), &map, IFLA_PAD))
1710		return -EMSGSIZE;
1711
1712	return 0;
1713}
1714
1715static u32 rtnl_xdp_prog_skb(struct net_device *dev)
1716{
1717	const struct bpf_prog *generic_xdp_prog;
1718	u32 res = 0;
1719
1720	rcu_read_lock();
1721	generic_xdp_prog = rcu_dereference(dev->xdp_prog);
1722	if (generic_xdp_prog)
1723		res = generic_xdp_prog->aux->id;
1724	rcu_read_unlock();
1725
1726	return res;
1727}
1728
1729static u32 rtnl_xdp_prog_drv(struct net_device *dev)
1730{
1731	return dev_xdp_prog_id(dev, XDP_MODE_DRV);
1732}
1733
1734static u32 rtnl_xdp_prog_hw(struct net_device *dev)
1735{
1736	return dev_xdp_prog_id(dev, XDP_MODE_HW);
1737}
1738
1739static int rtnl_xdp_report_one(struct sk_buff *skb, struct net_device *dev,
1740			       u32 *prog_id, u8 *mode, u8 tgt_mode, u32 attr,
1741			       u32 (*get_prog_id)(struct net_device *dev))
1742{
1743	u32 curr_id;
1744	int err;
1745
1746	curr_id = get_prog_id(dev);
1747	if (!curr_id)
1748		return 0;
1749
1750	*prog_id = curr_id;
1751	err = nla_put_u32(skb, attr, curr_id);
1752	if (err)
1753		return err;
1754
1755	if (*mode != XDP_ATTACHED_NONE)
1756		*mode = XDP_ATTACHED_MULTI;
1757	else
1758		*mode = tgt_mode;
1759
1760	return 0;
1761}
1762
1763static int rtnl_xdp_fill(struct sk_buff *skb, struct net_device *dev)
1764{
1765	struct nlattr *xdp;
1766	u32 prog_id;
1767	int err;
1768	u8 mode;
1769
1770	xdp = nla_nest_start_noflag(skb, IFLA_XDP);
1771	if (!xdp)
1772		return -EMSGSIZE;
1773
1774	prog_id = 0;
1775	mode = XDP_ATTACHED_NONE;
1776	err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_SKB,
1777				  IFLA_XDP_SKB_PROG_ID, rtnl_xdp_prog_skb);
1778	if (err)
1779		goto err_cancel;
1780	err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_DRV,
1781				  IFLA_XDP_DRV_PROG_ID, rtnl_xdp_prog_drv);
1782	if (err)
1783		goto err_cancel;
1784	err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_HW,
1785				  IFLA_XDP_HW_PROG_ID, rtnl_xdp_prog_hw);
1786	if (err)
1787		goto err_cancel;
1788
1789	err = nla_put_u8(skb, IFLA_XDP_ATTACHED, mode);
1790	if (err)
1791		goto err_cancel;
1792
1793	if (prog_id && mode != XDP_ATTACHED_MULTI) {
1794		err = nla_put_u32(skb, IFLA_XDP_PROG_ID, prog_id);
1795		if (err)
1796			goto err_cancel;
1797	}
1798
1799	nla_nest_end(skb, xdp);
1800	return 0;
1801
1802err_cancel:
1803	nla_nest_cancel(skb, xdp);
1804	return err;
1805}
1806
1807static u32 rtnl_get_event(unsigned long event)
1808{
1809	u32 rtnl_event_type = IFLA_EVENT_NONE;
1810
1811	switch (event) {
1812	case NETDEV_REBOOT:
1813		rtnl_event_type = IFLA_EVENT_REBOOT;
1814		break;
1815	case NETDEV_FEAT_CHANGE:
1816		rtnl_event_type = IFLA_EVENT_FEATURES;
1817		break;
1818	case NETDEV_BONDING_FAILOVER:
1819		rtnl_event_type = IFLA_EVENT_BONDING_FAILOVER;
1820		break;
1821	case NETDEV_NOTIFY_PEERS:
1822		rtnl_event_type = IFLA_EVENT_NOTIFY_PEERS;
1823		break;
1824	case NETDEV_RESEND_IGMP:
1825		rtnl_event_type = IFLA_EVENT_IGMP_RESEND;
1826		break;
1827	case NETDEV_CHANGEINFODATA:
1828		rtnl_event_type = IFLA_EVENT_BONDING_OPTIONS;
1829		break;
1830	default:
1831		break;
1832	}
1833
1834	return rtnl_event_type;
1835}
1836
1837static int put_master_ifindex(struct sk_buff *skb, struct net_device *dev)
1838{
1839	const struct net_device *upper_dev;
1840	int ret = 0;
1841
1842	rcu_read_lock();
1843
1844	upper_dev = netdev_master_upper_dev_get_rcu(dev);
1845	if (upper_dev)
1846		ret = nla_put_u32(skb, IFLA_MASTER,
1847				  READ_ONCE(upper_dev->ifindex));
1848
1849	rcu_read_unlock();
1850	return ret;
1851}
1852
1853static int nla_put_iflink(struct sk_buff *skb, const struct net_device *dev,
1854			  bool force)
1855{
1856	int iflink = dev_get_iflink(dev);
1857
1858	if (force || READ_ONCE(dev->ifindex) != iflink)
1859		return nla_put_u32(skb, IFLA_LINK, iflink);
1860
1861	return 0;
1862}
1863
1864static noinline_for_stack int nla_put_ifalias(struct sk_buff *skb,
1865					      struct net_device *dev)
1866{
1867	char buf[IFALIASZ];
1868	int ret;
1869
1870	ret = dev_get_alias(dev, buf, sizeof(buf));
1871	return ret > 0 ? nla_put_string(skb, IFLA_IFALIAS, buf) : 0;
1872}
1873
1874static int rtnl_fill_link_netnsid(struct sk_buff *skb,
1875				  const struct net_device *dev,
1876				  struct net *src_net, gfp_t gfp)
1877{
1878	bool put_iflink = false;
1879
1880	if (dev->rtnl_link_ops && dev->rtnl_link_ops->get_link_net) {
1881		struct net *link_net = dev->rtnl_link_ops->get_link_net(dev);
1882
1883		if (!net_eq(dev_net(dev), link_net)) {
1884			int id = peernet2id_alloc(src_net, link_net, gfp);
1885
1886			if (nla_put_s32(skb, IFLA_LINK_NETNSID, id))
1887				return -EMSGSIZE;
1888
1889			put_iflink = true;
1890		}
1891	}
1892
1893	return nla_put_iflink(skb, dev, put_iflink);
1894}
1895
1896static int rtnl_fill_link_af(struct sk_buff *skb,
1897			     const struct net_device *dev,
1898			     u32 ext_filter_mask)
1899{
1900	const struct rtnl_af_ops *af_ops;
1901	struct nlattr *af_spec;
1902
1903	af_spec = nla_nest_start_noflag(skb, IFLA_AF_SPEC);
1904	if (!af_spec)
1905		return -EMSGSIZE;
1906
1907	list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
1908		struct nlattr *af;
1909		int err;
1910
1911		if (!af_ops->fill_link_af)
1912			continue;
1913
1914		af = nla_nest_start_noflag(skb, af_ops->family);
1915		if (!af)
1916			return -EMSGSIZE;
1917
1918		err = af_ops->fill_link_af(skb, dev, ext_filter_mask);
1919		/*
1920		 * Caller may return ENODATA to indicate that there
1921		 * was no data to be dumped. This is not an error, it
1922		 * means we should trim the attribute header and
1923		 * continue.
1924		 */
1925		if (err == -ENODATA)
1926			nla_nest_cancel(skb, af);
1927		else if (err < 0)
1928			return -EMSGSIZE;
1929
1930		nla_nest_end(skb, af);
1931	}
1932
1933	nla_nest_end(skb, af_spec);
1934	return 0;
1935}
1936
1937static int rtnl_fill_alt_ifnames(struct sk_buff *skb,
1938				 const struct net_device *dev)
1939{
1940	struct netdev_name_node *name_node;
1941	int count = 0;
1942
1943	list_for_each_entry_rcu(name_node, &dev->name_node->list, list) {
1944		if (nla_put_string(skb, IFLA_ALT_IFNAME, name_node->name))
1945			return -EMSGSIZE;
1946		count++;
1947	}
1948	return count;
1949}
1950
1951/* RCU protected. */
1952static int rtnl_fill_prop_list(struct sk_buff *skb,
1953			       const struct net_device *dev)
1954{
1955	struct nlattr *prop_list;
1956	int ret;
1957
1958	prop_list = nla_nest_start(skb, IFLA_PROP_LIST);
1959	if (!prop_list)
1960		return -EMSGSIZE;
1961
1962	ret = rtnl_fill_alt_ifnames(skb, dev);
1963	if (ret <= 0)
1964		goto nest_cancel;
1965
1966	nla_nest_end(skb, prop_list);
1967	return 0;
1968
1969nest_cancel:
1970	nla_nest_cancel(skb, prop_list);
1971	return ret;
1972}
1973
1974static int rtnl_fill_proto_down(struct sk_buff *skb,
1975				const struct net_device *dev)
1976{
1977	struct nlattr *pr;
1978	u32 preason;
1979
1980	if (nla_put_u8(skb, IFLA_PROTO_DOWN, READ_ONCE(dev->proto_down)))
1981		goto nla_put_failure;
1982
1983	preason = READ_ONCE(dev->proto_down_reason);
1984	if (!preason)
1985		return 0;
1986
1987	pr = nla_nest_start(skb, IFLA_PROTO_DOWN_REASON);
1988	if (!pr)
1989		return -EMSGSIZE;
1990
1991	if (nla_put_u32(skb, IFLA_PROTO_DOWN_REASON_VALUE, preason)) {
1992		nla_nest_cancel(skb, pr);
1993		goto nla_put_failure;
1994	}
1995
1996	nla_nest_end(skb, pr);
1997	return 0;
1998
1999nla_put_failure:
2000	return -EMSGSIZE;
2001}
2002
2003static int rtnl_fill_devlink_port(struct sk_buff *skb,
2004				  const struct net_device *dev)
2005{
2006	struct nlattr *devlink_port_nest;
2007	int ret;
2008
2009	devlink_port_nest = nla_nest_start(skb, IFLA_DEVLINK_PORT);
2010	if (!devlink_port_nest)
2011		return -EMSGSIZE;
2012
2013	if (dev->devlink_port) {
2014		ret = devlink_nl_port_handle_fill(skb, dev->devlink_port);
2015		if (ret < 0)
2016			goto nest_cancel;
2017	}
2018
2019	nla_nest_end(skb, devlink_port_nest);
2020	return 0;
2021
2022nest_cancel:
2023	nla_nest_cancel(skb, devlink_port_nest);
2024	return ret;
2025}
2026
2027static int rtnl_fill_dpll_pin(struct sk_buff *skb,
2028			      const struct net_device *dev)
2029{
2030	struct nlattr *dpll_pin_nest;
2031	int ret;
2032
2033	dpll_pin_nest = nla_nest_start(skb, IFLA_DPLL_PIN);
2034	if (!dpll_pin_nest)
2035		return -EMSGSIZE;
2036
2037	ret = dpll_netdev_add_pin_handle(skb, dev);
2038	if (ret < 0)
2039		goto nest_cancel;
2040
2041	nla_nest_end(skb, dpll_pin_nest);
2042	return 0;
2043
2044nest_cancel:
2045	nla_nest_cancel(skb, dpll_pin_nest);
2046	return ret;
2047}
2048
2049static int rtnl_fill_ifinfo(struct sk_buff *skb,
2050			    struct net_device *dev, struct net *src_net,
2051			    int type, u32 pid, u32 seq, u32 change,
2052			    unsigned int flags, u32 ext_filter_mask,
2053			    u32 event, int *new_nsid, int new_ifindex,
2054			    int tgt_netnsid, gfp_t gfp)
2055{
2056	char devname[IFNAMSIZ];
2057	struct ifinfomsg *ifm;
2058	struct nlmsghdr *nlh;
2059	struct Qdisc *qdisc;
2060
2061	ASSERT_RTNL();
2062	nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags);
2063	if (nlh == NULL)
2064		return -EMSGSIZE;
2065
2066	ifm = nlmsg_data(nlh);
2067	ifm->ifi_family = AF_UNSPEC;
2068	ifm->__ifi_pad = 0;
2069	ifm->ifi_type = READ_ONCE(dev->type);
2070	ifm->ifi_index = READ_ONCE(dev->ifindex);
2071	ifm->ifi_flags = netif_get_flags(dev);
2072	ifm->ifi_change = change;
2073
2074	if (tgt_netnsid >= 0 && nla_put_s32(skb, IFLA_TARGET_NETNSID, tgt_netnsid))
2075		goto nla_put_failure;
2076
2077	netdev_copy_name(dev, devname);
2078	if (nla_put_string(skb, IFLA_IFNAME, devname))
2079		goto nla_put_failure;
2080
2081	if (nla_put_u32(skb, IFLA_TXQLEN, READ_ONCE(dev->tx_queue_len)) ||
2082	    nla_put_u8(skb, IFLA_OPERSTATE,
2083		       netif_running(dev) ? READ_ONCE(dev->operstate) :
2084					    IF_OPER_DOWN) ||
2085	    nla_put_u8(skb, IFLA_LINKMODE, READ_ONCE(dev->link_mode)) ||
2086	    nla_put_u8(skb, IFLA_NETNS_IMMUTABLE, dev->netns_immutable) ||
2087	    nla_put_u32(skb, IFLA_MTU, READ_ONCE(dev->mtu)) ||
2088	    nla_put_u32(skb, IFLA_MIN_MTU, READ_ONCE(dev->min_mtu)) ||
2089	    nla_put_u32(skb, IFLA_MAX_MTU, READ_ONCE(dev->max_mtu)) ||
2090	    nla_put_u32(skb, IFLA_GROUP, READ_ONCE(dev->group)) ||
2091	    nla_put_u32(skb, IFLA_PROMISCUITY, READ_ONCE(dev->promiscuity)) ||
2092	    nla_put_u32(skb, IFLA_ALLMULTI, READ_ONCE(dev->allmulti)) ||
2093	    nla_put_u32(skb, IFLA_NUM_TX_QUEUES,
2094			READ_ONCE(dev->num_tx_queues)) ||
2095	    nla_put_u32(skb, IFLA_GSO_MAX_SEGS,
2096			READ_ONCE(dev->gso_max_segs)) ||
2097	    nla_put_u32(skb, IFLA_GSO_MAX_SIZE,
2098			READ_ONCE(dev->gso_max_size)) ||
2099	    nla_put_u32(skb, IFLA_GRO_MAX_SIZE,
2100			READ_ONCE(dev->gro_max_size)) ||
2101	    nla_put_u32(skb, IFLA_GSO_IPV4_MAX_SIZE,
2102			READ_ONCE(dev->gso_ipv4_max_size)) ||
2103	    nla_put_u32(skb, IFLA_GRO_IPV4_MAX_SIZE,
2104			READ_ONCE(dev->gro_ipv4_max_size)) ||
2105	    nla_put_u32(skb, IFLA_TSO_MAX_SIZE,
2106			READ_ONCE(dev->tso_max_size)) ||
2107	    nla_put_u32(skb, IFLA_TSO_MAX_SEGS,
2108			READ_ONCE(dev->tso_max_segs)) ||
2109	    nla_put_uint(skb, IFLA_MAX_PACING_OFFLOAD_HORIZON,
2110			 READ_ONCE(dev->max_pacing_offload_horizon)) ||
2111#ifdef CONFIG_RPS
2112	    nla_put_u32(skb, IFLA_NUM_RX_QUEUES,
2113			READ_ONCE(dev->num_rx_queues)) ||
2114#endif
2115	    put_master_ifindex(skb, dev) ||
2116	    nla_put_u8(skb, IFLA_CARRIER, netif_carrier_ok(dev)) ||
2117	    nla_put_ifalias(skb, dev) ||
2118	    nla_put_u32(skb, IFLA_CARRIER_CHANGES,
2119			atomic_read(&dev->carrier_up_count) +
2120			atomic_read(&dev->carrier_down_count)) ||
2121	    nla_put_u32(skb, IFLA_CARRIER_UP_COUNT,
2122			atomic_read(&dev->carrier_up_count)) ||
2123	    nla_put_u32(skb, IFLA_CARRIER_DOWN_COUNT,
2124			atomic_read(&dev->carrier_down_count)) ||
2125	    nla_put_u16(skb, IFLA_HEADROOM,
2126			READ_ONCE(dev->needed_headroom)) ||
2127	    nla_put_u16(skb, IFLA_TAILROOM,
2128			READ_ONCE(dev->needed_tailroom)))
2129		goto nla_put_failure;
2130
2131	if (rtnl_fill_proto_down(skb, dev))
2132		goto nla_put_failure;
2133
2134	if (event != IFLA_EVENT_NONE) {
2135		if (nla_put_u32(skb, IFLA_EVENT, event))
2136			goto nla_put_failure;
2137	}
2138
2139	if (dev->addr_len) {
2140		if (nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr) ||
2141		    nla_put(skb, IFLA_BROADCAST, dev->addr_len, dev->broadcast))
2142			goto nla_put_failure;
2143	}
2144
2145	if (rtnl_phys_port_id_fill(skb, dev))
2146		goto nla_put_failure;
2147
2148	if (rtnl_phys_port_name_fill(skb, dev))
2149		goto nla_put_failure;
2150
2151	if (rtnl_phys_switch_id_fill(skb, dev))
2152		goto nla_put_failure;
2153
2154	if (!(ext_filter_mask & RTEXT_FILTER_SKIP_STATS) &&
2155	    rtnl_fill_stats(skb, dev))
2156		goto nla_put_failure;
2157
2158	if (rtnl_fill_vf(skb, dev, ext_filter_mask))
2159		goto nla_put_failure;
2160
2161	if (rtnl_port_fill(skb, dev, ext_filter_mask))
2162		goto nla_put_failure;
2163
2164	if (rtnl_xdp_fill(skb, dev))
2165		goto nla_put_failure;
2166
2167	if (dev->rtnl_link_ops || rtnl_have_link_slave_info(dev)) {
2168		if (rtnl_link_fill(skb, dev) < 0)
2169			goto nla_put_failure;
2170	}
2171
2172	if (new_nsid &&
2173	    nla_put_s32(skb, IFLA_NEW_NETNSID, *new_nsid) < 0)
2174		goto nla_put_failure;
2175	if (new_ifindex &&
2176	    nla_put_s32(skb, IFLA_NEW_IFINDEX, new_ifindex) < 0)
2177		goto nla_put_failure;
2178
2179	if (memchr_inv(dev->perm_addr, '\0', dev->addr_len) &&
2180	    nla_put(skb, IFLA_PERM_ADDRESS, dev->addr_len, dev->perm_addr))
2181		goto nla_put_failure;
2182
2183	rcu_read_lock();
2184	if (rtnl_fill_link_netnsid(skb, dev, src_net, GFP_ATOMIC))
2185		goto nla_put_failure_rcu;
2186	qdisc = rcu_dereference(dev->qdisc);
2187	if (qdisc && nla_put_string(skb, IFLA_QDISC, qdisc->ops->id))
2188		goto nla_put_failure_rcu;
2189	if (rtnl_fill_link_af(skb, dev, ext_filter_mask))
2190		goto nla_put_failure_rcu;
2191	if (rtnl_fill_link_ifmap(skb, dev))
2192		goto nla_put_failure_rcu;
2193	if (rtnl_fill_prop_list(skb, dev))
2194		goto nla_put_failure_rcu;
2195	rcu_read_unlock();
2196
2197	if (dev->dev.parent &&
2198	    nla_put_string(skb, IFLA_PARENT_DEV_NAME,
2199			   dev_name(dev->dev.parent)))
2200		goto nla_put_failure;
2201
2202	if (dev->dev.parent && dev->dev.parent->bus &&
2203	    nla_put_string(skb, IFLA_PARENT_DEV_BUS_NAME,
2204			   dev->dev.parent->bus->name))
2205		goto nla_put_failure;
2206
2207	if (rtnl_fill_devlink_port(skb, dev))
2208		goto nla_put_failure;
2209
2210	if (rtnl_fill_dpll_pin(skb, dev))
2211		goto nla_put_failure;
2212
2213	nlmsg_end(skb, nlh);
2214	return 0;
2215
2216nla_put_failure_rcu:
2217	rcu_read_unlock();
2218nla_put_failure:
2219	nlmsg_cancel(skb, nlh);
2220	return -EMSGSIZE;
2221}
2222
2223static const struct nla_policy ifla_policy[IFLA_MAX+1] = {
2224	[IFLA_UNSPEC]		= { .strict_start_type = IFLA_DPLL_PIN },
2225	[IFLA_IFNAME]		= { .type = NLA_STRING, .len = IFNAMSIZ-1 },
2226	[IFLA_ADDRESS]		= { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
2227	[IFLA_BROADCAST]	= { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
2228	[IFLA_MAP]		= { .len = sizeof(struct rtnl_link_ifmap) },
2229	[IFLA_MTU]		= { .type = NLA_U32 },
2230	[IFLA_LINK]		= { .type = NLA_U32 },
2231	[IFLA_MASTER]		= { .type = NLA_U32 },
2232	[IFLA_CARRIER]		= { .type = NLA_U8 },
2233	[IFLA_TXQLEN]		= { .type = NLA_U32 },
2234	[IFLA_WEIGHT]		= { .type = NLA_U32 },
2235	[IFLA_OPERSTATE]	= { .type = NLA_U8 },
2236	[IFLA_LINKMODE]		= { .type = NLA_U8 },
2237	[IFLA_LINKINFO]		= { .type = NLA_NESTED },
2238	[IFLA_NET_NS_PID]	= { .type = NLA_U32 },
2239	[IFLA_NET_NS_FD]	= { .type = NLA_U32 },
2240	/* IFLA_IFALIAS is a string, but policy is set to NLA_BINARY to
2241	 * allow 0-length string (needed to remove an alias).
2242	 */
2243	[IFLA_IFALIAS]	        = { .type = NLA_BINARY, .len = IFALIASZ - 1 },
2244	[IFLA_VFINFO_LIST]	= {. type = NLA_NESTED },
2245	[IFLA_VF_PORTS]		= { .type = NLA_NESTED },
2246	[IFLA_PORT_SELF]	= { .type = NLA_NESTED },
2247	[IFLA_AF_SPEC]		= { .type = NLA_NESTED },
2248	[IFLA_EXT_MASK]		= { .type = NLA_U32 },
2249	[IFLA_PROMISCUITY]	= { .type = NLA_U32 },
2250	[IFLA_NUM_TX_QUEUES]	= { .type = NLA_U32 },
2251	[IFLA_NUM_RX_QUEUES]	= { .type = NLA_U32 },
2252	[IFLA_GSO_MAX_SEGS]	= { .type = NLA_U32 },
2253	[IFLA_GSO_MAX_SIZE]	= NLA_POLICY_MIN(NLA_U32, MAX_TCP_HEADER + 1),
2254	[IFLA_PHYS_PORT_ID]	= { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
2255	[IFLA_CARRIER_CHANGES]	= { .type = NLA_U32 },  /* ignored */
2256	[IFLA_PHYS_SWITCH_ID]	= { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
2257	[IFLA_LINK_NETNSID]	= { .type = NLA_S32 },
2258	[IFLA_PROTO_DOWN]	= { .type = NLA_U8 },
2259	[IFLA_XDP]		= { .type = NLA_NESTED },
2260	[IFLA_EVENT]		= { .type = NLA_U32 },
2261	[IFLA_GROUP]		= { .type = NLA_U32 },
2262	[IFLA_TARGET_NETNSID]	= { .type = NLA_S32 },
2263	[IFLA_CARRIER_UP_COUNT]	= { .type = NLA_U32 },
2264	[IFLA_CARRIER_DOWN_COUNT] = { .type = NLA_U32 },
2265	[IFLA_MIN_MTU]		= { .type = NLA_U32 },
2266	[IFLA_MAX_MTU]		= { .type = NLA_U32 },
2267	[IFLA_PROP_LIST]	= { .type = NLA_NESTED },
2268	[IFLA_ALT_IFNAME]	= { .type = NLA_STRING,
2269				    .len = ALTIFNAMSIZ - 1 },
2270	[IFLA_PERM_ADDRESS]	= { .type = NLA_REJECT },
2271	[IFLA_PROTO_DOWN_REASON] = { .type = NLA_NESTED },
2272	[IFLA_NEW_IFINDEX]	= NLA_POLICY_MIN(NLA_S32, 1),
2273	[IFLA_PARENT_DEV_NAME]	= { .type = NLA_NUL_STRING },
2274	[IFLA_GRO_MAX_SIZE]	= { .type = NLA_U32 },
2275	[IFLA_TSO_MAX_SIZE]	= { .type = NLA_REJECT },
2276	[IFLA_TSO_MAX_SEGS]	= { .type = NLA_REJECT },
2277	[IFLA_ALLMULTI]		= { .type = NLA_REJECT },
2278	[IFLA_GSO_IPV4_MAX_SIZE]	= NLA_POLICY_MIN(NLA_U32, MAX_TCP_HEADER + 1),
2279	[IFLA_GRO_IPV4_MAX_SIZE]	= { .type = NLA_U32 },
2280	[IFLA_NETNS_IMMUTABLE]	= { .type = NLA_REJECT },
2281	[IFLA_HEADROOM]		= { .type = NLA_REJECT },
2282	[IFLA_TAILROOM]		= { .type = NLA_REJECT },
2283};
2284
2285static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = {
2286	[IFLA_INFO_KIND]	= { .type = NLA_STRING },
2287	[IFLA_INFO_DATA]	= { .type = NLA_NESTED },
2288	[IFLA_INFO_SLAVE_KIND]	= { .type = NLA_STRING },
2289	[IFLA_INFO_SLAVE_DATA]	= { .type = NLA_NESTED },
2290};
2291
2292static const struct nla_policy ifla_vf_policy[IFLA_VF_MAX+1] = {
2293	[IFLA_VF_MAC]		= { .len = sizeof(struct ifla_vf_mac) },
2294	[IFLA_VF_BROADCAST]	= { .type = NLA_REJECT },
2295	[IFLA_VF_VLAN]		= { .len = sizeof(struct ifla_vf_vlan) },
2296	[IFLA_VF_VLAN_LIST]     = { .type = NLA_NESTED },
2297	[IFLA_VF_TX_RATE]	= { .len = sizeof(struct ifla_vf_tx_rate) },
2298	[IFLA_VF_SPOOFCHK]	= { .len = sizeof(struct ifla_vf_spoofchk) },
2299	[IFLA_VF_RATE]		= { .len = sizeof(struct ifla_vf_rate) },
2300	[IFLA_VF_LINK_STATE]	= { .len = sizeof(struct ifla_vf_link_state) },
2301	[IFLA_VF_RSS_QUERY_EN]	= { .len = sizeof(struct ifla_vf_rss_query_en) },
2302	[IFLA_VF_STATS]		= { .type = NLA_NESTED },
2303	[IFLA_VF_TRUST]		= { .len = sizeof(struct ifla_vf_trust) },
2304	[IFLA_VF_IB_NODE_GUID]	= { .len = sizeof(struct ifla_vf_guid) },
2305	[IFLA_VF_IB_PORT_GUID]	= { .len = sizeof(struct ifla_vf_guid) },
2306};
2307
2308static const struct nla_policy ifla_port_policy[IFLA_PORT_MAX+1] = {
2309	[IFLA_PORT_VF]		= { .type = NLA_U32 },
2310	[IFLA_PORT_PROFILE]	= { .type = NLA_STRING,
2311				    .len = PORT_PROFILE_MAX },
2312	[IFLA_PORT_INSTANCE_UUID] = { .type = NLA_BINARY,
2313				      .len = PORT_UUID_MAX },
2314	[IFLA_PORT_HOST_UUID]	= { .type = NLA_STRING,
2315				    .len = PORT_UUID_MAX },
2316	[IFLA_PORT_REQUEST]	= { .type = NLA_U8, },
2317	[IFLA_PORT_RESPONSE]	= { .type = NLA_U16, },
2318
2319	/* Unused, but we need to keep it here since user space could
2320	 * fill it. It's also broken with regard to NLA_BINARY use in
2321	 * combination with structs.
2322	 */
2323	[IFLA_PORT_VSI_TYPE]	= { .type = NLA_BINARY,
2324				    .len = sizeof(struct ifla_port_vsi) },
2325};
2326
2327static const struct nla_policy ifla_xdp_policy[IFLA_XDP_MAX + 1] = {
2328	[IFLA_XDP_UNSPEC]	= { .strict_start_type = IFLA_XDP_EXPECTED_FD },
2329	[IFLA_XDP_FD]		= { .type = NLA_S32 },
2330	[IFLA_XDP_EXPECTED_FD]	= { .type = NLA_S32 },
2331	[IFLA_XDP_ATTACHED]	= { .type = NLA_U8 },
2332	[IFLA_XDP_FLAGS]	= { .type = NLA_U32 },
2333	[IFLA_XDP_PROG_ID]	= { .type = NLA_U32 },
2334};
2335
2336static struct rtnl_link_ops *linkinfo_to_kind_ops(const struct nlattr *nla,
2337						  int *ops_srcu_index)
2338{
2339	struct nlattr *linfo[IFLA_INFO_MAX + 1];
2340	struct rtnl_link_ops *ops = NULL;
2341
2342	if (nla_parse_nested_deprecated(linfo, IFLA_INFO_MAX, nla, ifla_info_policy, NULL) < 0)
2343		return NULL;
2344
2345	if (linfo[IFLA_INFO_KIND]) {
2346		char kind[MODULE_NAME_LEN];
2347
2348		nla_strscpy(kind, linfo[IFLA_INFO_KIND], sizeof(kind));
2349		ops = rtnl_link_ops_get(kind, ops_srcu_index);
2350	}
2351
2352	return ops;
2353}
2354
2355static bool link_master_filtered(struct net_device *dev, int master_idx)
2356{
2357	struct net_device *master;
2358
2359	if (!master_idx)
2360		return false;
2361
2362	master = netdev_master_upper_dev_get(dev);
2363
2364	/* 0 is already used to denote IFLA_MASTER wasn't passed, therefore need
2365	 * another invalid value for ifindex to denote "no master".
2366	 */
2367	if (master_idx == -1)
2368		return !!master;
2369
2370	if (!master || master->ifindex != master_idx)
2371		return true;
2372
2373	return false;
2374}
2375
2376static bool link_kind_filtered(const struct net_device *dev,
2377			       const struct rtnl_link_ops *kind_ops)
2378{
2379	if (kind_ops && dev->rtnl_link_ops != kind_ops)
2380		return true;
2381
2382	return false;
2383}
2384
2385static bool link_dump_filtered(struct net_device *dev,
2386			       int master_idx,
2387			       const struct rtnl_link_ops *kind_ops)
2388{
2389	if (link_master_filtered(dev, master_idx) ||
2390	    link_kind_filtered(dev, kind_ops))
2391		return true;
2392
2393	return false;
2394}
2395
2396/**
2397 * rtnl_get_net_ns_capable - Get netns if sufficiently privileged.
2398 * @sk: netlink socket
2399 * @netnsid: network namespace identifier
2400 *
2401 * Returns the network namespace identified by netnsid on success or an error
2402 * pointer on failure.
2403 */
2404struct net *rtnl_get_net_ns_capable(struct sock *sk, int netnsid)
2405{
2406	struct net *net;
2407
2408	net = get_net_ns_by_id(sock_net(sk), netnsid);
2409	if (!net)
2410		return ERR_PTR(-EINVAL);
2411
2412	/* For now, the caller is required to have CAP_NET_ADMIN in
2413	 * the user namespace owning the target net ns.
2414	 */
2415	if (!sk_ns_capable(sk, net->user_ns, CAP_NET_ADMIN)) {
2416		put_net(net);
2417		return ERR_PTR(-EACCES);
2418	}
2419	return net;
2420}
2421EXPORT_SYMBOL_GPL(rtnl_get_net_ns_capable);
2422
2423static int rtnl_valid_dump_ifinfo_req(const struct nlmsghdr *nlh,
2424				      bool strict_check, struct nlattr **tb,
2425				      struct netlink_ext_ack *extack)
2426{
2427	int hdrlen;
2428
2429	if (strict_check) {
2430		struct ifinfomsg *ifm;
2431
2432		ifm = nlmsg_payload(nlh, sizeof(*ifm));
2433		if (!ifm) {
2434			NL_SET_ERR_MSG(extack, "Invalid header for link dump");
2435			return -EINVAL;
2436		}
2437
2438		if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
2439		    ifm->ifi_change) {
2440			NL_SET_ERR_MSG(extack, "Invalid values in header for link dump request");
2441			return -EINVAL;
2442		}
2443		if (ifm->ifi_index) {
2444			NL_SET_ERR_MSG(extack, "Filter by device index not supported for link dumps");
2445			return -EINVAL;
2446		}
2447
2448		return nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb,
2449						     IFLA_MAX, ifla_policy,
2450						     extack);
2451	}
2452
2453	/* A hack to preserve kernel<->userspace interface.
2454	 * The correct header is ifinfomsg. It is consistent with rtnl_getlink.
2455	 * However, before Linux v3.9 the code here assumed rtgenmsg and that's
2456	 * what iproute2 < v3.9.0 used.
2457	 * We can detect the old iproute2. Even including the IFLA_EXT_MASK
2458	 * attribute, its netlink message is shorter than struct ifinfomsg.
2459	 */
2460	hdrlen = nlmsg_len(nlh) < sizeof(struct ifinfomsg) ?
2461		 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg);
2462
2463	return nlmsg_parse_deprecated(nlh, hdrlen, tb, IFLA_MAX, ifla_policy,
2464				      extack);
2465}
2466
2467static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
2468{
2469	struct netlink_ext_ack *extack = cb->extack;
2470	struct rtnl_link_ops *kind_ops = NULL;
2471	const struct nlmsghdr *nlh = cb->nlh;
2472	struct net *net = sock_net(skb->sk);
2473	unsigned int flags = NLM_F_MULTI;
2474	struct nlattr *tb[IFLA_MAX+1];
2475	struct {
2476		unsigned long ifindex;
2477	} *ctx = (void *)cb->ctx;
2478	struct net *tgt_net = net;
2479	u32 ext_filter_mask = 0;
2480	struct net_device *dev;
2481	int ops_srcu_index;
2482	int master_idx = 0;
2483	int netnsid = -1;
2484	int err, i;
2485
2486	err = rtnl_valid_dump_ifinfo_req(nlh, cb->strict_check, tb, extack);
2487	if (err < 0) {
2488		if (cb->strict_check)
2489			return err;
2490
2491		goto walk_entries;
2492	}
2493
2494	for (i = 0; i <= IFLA_MAX; ++i) {
2495		if (!tb[i])
2496			continue;
2497
2498		/* new attributes should only be added with strict checking */
2499		switch (i) {
2500		case IFLA_TARGET_NETNSID:
2501			netnsid = nla_get_s32(tb[i]);
2502			tgt_net = rtnl_get_net_ns_capable(skb->sk, netnsid);
2503			if (IS_ERR(tgt_net)) {
2504				NL_SET_ERR_MSG(extack, "Invalid target network namespace id");
2505				err = PTR_ERR(tgt_net);
2506				netnsid = -1;
2507				goto out;
2508			}
2509			break;
2510		case IFLA_EXT_MASK:
2511			ext_filter_mask = nla_get_u32(tb[i]);
2512			break;
2513		case IFLA_MASTER:
2514			master_idx = nla_get_u32(tb[i]);
2515			break;
2516		case IFLA_LINKINFO:
2517			kind_ops = linkinfo_to_kind_ops(tb[i], &ops_srcu_index);
2518			break;
2519		default:
2520			if (cb->strict_check) {
2521				NL_SET_ERR_MSG(extack, "Unsupported attribute in link dump request");
2522				err = -EINVAL;
2523				goto out;
2524			}
2525		}
2526	}
2527
2528	if (master_idx || kind_ops)
2529		flags |= NLM_F_DUMP_FILTERED;
2530
2531walk_entries:
2532	err = 0;
2533	for_each_netdev_dump(tgt_net, dev, ctx->ifindex) {
2534		if (link_dump_filtered(dev, master_idx, kind_ops))
2535			continue;
2536		err = rtnl_fill_ifinfo(skb, dev, net, RTM_NEWLINK,
2537				       NETLINK_CB(cb->skb).portid,
2538				       nlh->nlmsg_seq, 0, flags,
2539				       ext_filter_mask, 0, NULL, 0,
2540				       netnsid, GFP_KERNEL);
2541		if (err < 0)
2542			break;
2543	}
2544
2545
2546	cb->seq = tgt_net->dev_base_seq;
2547	nl_dump_check_consistent(cb, nlmsg_hdr(skb));
2548
2549out:
2550
2551	if (kind_ops)
2552		rtnl_link_ops_put(kind_ops, ops_srcu_index);
2553	if (netnsid >= 0)
2554		put_net(tgt_net);
2555
2556	return err;
2557}
2558
2559int rtnl_nla_parse_ifinfomsg(struct nlattr **tb, const struct nlattr *nla_peer,
2560			     struct netlink_ext_ack *exterr)
2561{
2562	const struct ifinfomsg *ifmp;
2563	const struct nlattr *attrs;
2564	size_t len;
2565
2566	ifmp = nla_data(nla_peer);
2567	attrs = nla_data(nla_peer) + sizeof(struct ifinfomsg);
2568	len = nla_len(nla_peer) - sizeof(struct ifinfomsg);
2569
2570	if (ifmp->ifi_index < 0) {
2571		NL_SET_ERR_MSG_ATTR(exterr, nla_peer,
2572				    "ifindex can't be negative");
2573		return -EINVAL;
2574	}
2575
2576	return nla_parse_deprecated(tb, IFLA_MAX, attrs, len, ifla_policy,
2577				    exterr);
2578}
2579EXPORT_SYMBOL(rtnl_nla_parse_ifinfomsg);
2580
2581static struct net *rtnl_link_get_net_ifla(struct nlattr *tb[])
2582{
2583	struct net *net = NULL;
2584
2585	/* Examine the link attributes and figure out which
2586	 * network namespace we are talking about.
2587	 */
2588	if (tb[IFLA_NET_NS_PID])
2589		net = get_net_ns_by_pid(nla_get_u32(tb[IFLA_NET_NS_PID]));
2590	else if (tb[IFLA_NET_NS_FD])
2591		net = get_net_ns_by_fd(nla_get_u32(tb[IFLA_NET_NS_FD]));
2592
2593	return net;
2594}
2595
2596struct net *rtnl_link_get_net(struct net *src_net, struct nlattr *tb[])
2597{
2598	struct net *net = rtnl_link_get_net_ifla(tb);
2599
2600	if (!net)
2601		net = get_net(src_net);
2602
2603	return net;
2604}
2605EXPORT_SYMBOL(rtnl_link_get_net);
2606
2607/* Figure out which network namespace we are talking about by
2608 * examining the link attributes in the following order:
2609 *
2610 * 1. IFLA_NET_NS_PID
2611 * 2. IFLA_NET_NS_FD
2612 * 3. IFLA_TARGET_NETNSID
2613 */
2614static struct net *rtnl_link_get_net_by_nlattr(struct net *src_net,
2615					       struct nlattr *tb[])
2616{
2617	struct net *net;
2618
2619	if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD])
2620		return rtnl_link_get_net(src_net, tb);
2621
2622	if (!tb[IFLA_TARGET_NETNSID])
2623		return get_net(src_net);
2624
2625	net = get_net_ns_by_id(src_net, nla_get_u32(tb[IFLA_TARGET_NETNSID]));
2626	if (!net)
2627		return ERR_PTR(-EINVAL);
2628
2629	return net;
2630}
2631
2632static struct net *rtnl_link_get_net_capable(const struct sk_buff *skb,
2633					     struct net *src_net,
2634					     struct nlattr *tb[], int cap)
2635{
2636	struct net *net;
2637
2638	net = rtnl_link_get_net_by_nlattr(src_net, tb);
2639	if (IS_ERR(net))
2640		return net;
2641
2642	if (!netlink_ns_capable(skb, net->user_ns, cap)) {
2643		put_net(net);
2644		return ERR_PTR(-EPERM);
2645	}
2646
2647	return net;
2648}
2649
2650/* Verify that rtnetlink requests do not pass additional properties
2651 * potentially referring to different network namespaces.
2652 */
2653static int rtnl_ensure_unique_netns(struct nlattr *tb[],
2654				    struct netlink_ext_ack *extack,
2655				    bool netns_id_only)
2656{
2657
2658	if (netns_id_only) {
2659		if (!tb[IFLA_NET_NS_PID] && !tb[IFLA_NET_NS_FD])
2660			return 0;
2661
2662		NL_SET_ERR_MSG(extack, "specified netns attribute not supported");
2663		return -EOPNOTSUPP;
2664	}
2665
2666	if (tb[IFLA_TARGET_NETNSID] && (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD]))
2667		goto invalid_attr;
2668
2669	if (tb[IFLA_NET_NS_PID] && (tb[IFLA_TARGET_NETNSID] || tb[IFLA_NET_NS_FD]))
2670		goto invalid_attr;
2671
2672	if (tb[IFLA_NET_NS_FD] && (tb[IFLA_TARGET_NETNSID] || tb[IFLA_NET_NS_PID]))
2673		goto invalid_attr;
2674
2675	return 0;
2676
2677invalid_attr:
2678	NL_SET_ERR_MSG(extack, "multiple netns identifying attributes specified");
2679	return -EINVAL;
2680}
2681
2682static	int rtnl_set_vf_rate(struct net_device *dev, int vf, int min_tx_rate,
2683			     int max_tx_rate)
2684{
2685	const struct net_device_ops *ops = dev->netdev_ops;
2686
2687	if (!ops->ndo_set_vf_rate)
2688		return -EOPNOTSUPP;
2689	if (max_tx_rate && max_tx_rate < min_tx_rate)
2690		return -EINVAL;
2691
2692	return ops->ndo_set_vf_rate(dev, vf, min_tx_rate, max_tx_rate);
2693}
2694
2695static int validate_linkmsg(struct net_device *dev, struct nlattr *tb[],
2696			    struct netlink_ext_ack *extack)
2697{
2698	if (tb[IFLA_ADDRESS] &&
2699	    nla_len(tb[IFLA_ADDRESS]) < dev->addr_len)
2700		return -EINVAL;
2701
2702	if (tb[IFLA_BROADCAST] &&
2703	    nla_len(tb[IFLA_BROADCAST]) < dev->addr_len)
2704		return -EINVAL;
2705
2706	if (tb[IFLA_GSO_MAX_SIZE] &&
2707	    nla_get_u32(tb[IFLA_GSO_MAX_SIZE]) > dev->tso_max_size) {
2708		NL_SET_ERR_MSG(extack, "too big gso_max_size");
2709		return -EINVAL;
2710	}
2711
2712	if (tb[IFLA_GSO_MAX_SEGS] &&
2713	    (nla_get_u32(tb[IFLA_GSO_MAX_SEGS]) > GSO_MAX_SEGS ||
2714	     nla_get_u32(tb[IFLA_GSO_MAX_SEGS]) > dev->tso_max_segs)) {
2715		NL_SET_ERR_MSG(extack, "too big gso_max_segs");
2716		return -EINVAL;
2717	}
2718
2719	if (tb[IFLA_GRO_MAX_SIZE] &&
2720	    nla_get_u32(tb[IFLA_GRO_MAX_SIZE]) > GRO_MAX_SIZE) {
2721		NL_SET_ERR_MSG(extack, "too big gro_max_size");
2722		return -EINVAL;
2723	}
2724
2725	if (tb[IFLA_GSO_IPV4_MAX_SIZE] &&
2726	    nla_get_u32(tb[IFLA_GSO_IPV4_MAX_SIZE]) > dev->tso_max_size) {
2727		NL_SET_ERR_MSG(extack, "too big gso_ipv4_max_size");
2728		return -EINVAL;
2729	}
2730
2731	if (tb[IFLA_GRO_IPV4_MAX_SIZE] &&
2732	    nla_get_u32(tb[IFLA_GRO_IPV4_MAX_SIZE]) > GRO_MAX_SIZE) {
2733		NL_SET_ERR_MSG(extack, "too big gro_ipv4_max_size");
2734		return -EINVAL;
2735	}
2736
2737	if (tb[IFLA_AF_SPEC]) {
2738		struct nlattr *af;
2739		int rem, err;
2740
2741		nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
2742			struct rtnl_af_ops *af_ops;
2743			int af_ops_srcu_index;
2744
2745			af_ops = rtnl_af_lookup(nla_type(af), &af_ops_srcu_index);
2746			if (!af_ops)
2747				return -EAFNOSUPPORT;
2748
2749			if (!af_ops->set_link_af)
2750				err = -EOPNOTSUPP;
2751			else if (af_ops->validate_link_af)
2752				err = af_ops->validate_link_af(dev, af, extack);
2753			else
2754				err = 0;
2755
2756			rtnl_af_put(af_ops, af_ops_srcu_index);
2757
2758			if (err < 0)
2759				return err;
2760		}
2761	}
2762
2763	return 0;
2764}
2765
2766static int handle_infiniband_guid(struct net_device *dev, struct ifla_vf_guid *ivt,
2767				  int guid_type)
2768{
2769	const struct net_device_ops *ops = dev->netdev_ops;
2770
2771	return ops->ndo_set_vf_guid(dev, ivt->vf, ivt->guid, guid_type);
2772}
2773
2774static int handle_vf_guid(struct net_device *dev, struct ifla_vf_guid *ivt, int guid_type)
2775{
2776	if (dev->type != ARPHRD_INFINIBAND)
2777		return -EOPNOTSUPP;
2778
2779	return handle_infiniband_guid(dev, ivt, guid_type);
2780}
2781
2782static int do_setvfinfo(struct net_device *dev, struct nlattr **tb)
2783{
2784	const struct net_device_ops *ops = dev->netdev_ops;
2785	int err = -EINVAL;
2786
2787	if (tb[IFLA_VF_MAC]) {
2788		struct ifla_vf_mac *ivm = nla_data(tb[IFLA_VF_MAC]);
2789
2790		if (ivm->vf >= INT_MAX)
2791			return -EINVAL;
2792		err = -EOPNOTSUPP;
2793		if (ops->ndo_set_vf_mac)
2794			err = ops->ndo_set_vf_mac(dev, ivm->vf,
2795						  ivm->mac);
2796		if (err < 0)
2797			return err;
2798	}
2799
2800	if (tb[IFLA_VF_VLAN]) {
2801		struct ifla_vf_vlan *ivv = nla_data(tb[IFLA_VF_VLAN]);
2802
2803		if (ivv->vf >= INT_MAX)
2804			return -EINVAL;
2805		err = -EOPNOTSUPP;
2806		if (ops->ndo_set_vf_vlan)
2807			err = ops->ndo_set_vf_vlan(dev, ivv->vf, ivv->vlan,
2808						   ivv->qos,
2809						   htons(ETH_P_8021Q));
2810		if (err < 0)
2811			return err;
2812	}
2813
2814	if (tb[IFLA_VF_VLAN_LIST]) {
2815		struct ifla_vf_vlan_info *ivvl[MAX_VLAN_LIST_LEN];
2816		struct nlattr *attr;
2817		int rem, len = 0;
2818
2819		err = -EOPNOTSUPP;
2820		if (!ops->ndo_set_vf_vlan)
2821			return err;
2822
2823		nla_for_each_nested(attr, tb[IFLA_VF_VLAN_LIST], rem) {
2824			if (nla_type(attr) != IFLA_VF_VLAN_INFO ||
2825			    nla_len(attr) < sizeof(struct ifla_vf_vlan_info)) {
2826				return -EINVAL;
2827			}
2828			if (len >= MAX_VLAN_LIST_LEN)
2829				return -EOPNOTSUPP;
2830			ivvl[len] = nla_data(attr);
2831
2832			len++;
2833		}
2834		if (len == 0)
2835			return -EINVAL;
2836
2837		if (ivvl[0]->vf >= INT_MAX)
2838			return -EINVAL;
2839		err = ops->ndo_set_vf_vlan(dev, ivvl[0]->vf, ivvl[0]->vlan,
2840					   ivvl[0]->qos, ivvl[0]->vlan_proto);
2841		if (err < 0)
2842			return err;
2843	}
2844
2845	if (tb[IFLA_VF_TX_RATE]) {
2846		struct ifla_vf_tx_rate *ivt = nla_data(tb[IFLA_VF_TX_RATE]);
2847		struct ifla_vf_info ivf;
2848
2849		if (ivt->vf >= INT_MAX)
2850			return -EINVAL;
2851		err = -EOPNOTSUPP;
2852		if (ops->ndo_get_vf_config)
2853			err = ops->ndo_get_vf_config(dev, ivt->vf, &ivf);
2854		if (err < 0)
2855			return err;
2856
2857		err = rtnl_set_vf_rate(dev, ivt->vf,
2858				       ivf.min_tx_rate, ivt->rate);
2859		if (err < 0)
2860			return err;
2861	}
2862
2863	if (tb[IFLA_VF_RATE]) {
2864		struct ifla_vf_rate *ivt = nla_data(tb[IFLA_VF_RATE]);
2865
2866		if (ivt->vf >= INT_MAX)
2867			return -EINVAL;
2868
2869		err = rtnl_set_vf_rate(dev, ivt->vf,
2870				       ivt->min_tx_rate, ivt->max_tx_rate);
2871		if (err < 0)
2872			return err;
2873	}
2874
2875	if (tb[IFLA_VF_SPOOFCHK]) {
2876		struct ifla_vf_spoofchk *ivs = nla_data(tb[IFLA_VF_SPOOFCHK]);
2877
2878		if (ivs->vf >= INT_MAX)
2879			return -EINVAL;
2880		err = -EOPNOTSUPP;
2881		if (ops->ndo_set_vf_spoofchk)
2882			err = ops->ndo_set_vf_spoofchk(dev, ivs->vf,
2883						       ivs->setting);
2884		if (err < 0)
2885			return err;
2886	}
2887
2888	if (tb[IFLA_VF_LINK_STATE]) {
2889		struct ifla_vf_link_state *ivl = nla_data(tb[IFLA_VF_LINK_STATE]);
2890
2891		if (ivl->vf >= INT_MAX)
2892			return -EINVAL;
2893		err = -EOPNOTSUPP;
2894		if (ops->ndo_set_vf_link_state)
2895			err = ops->ndo_set_vf_link_state(dev, ivl->vf,
2896							 ivl->link_state);
2897		if (err < 0)
2898			return err;
2899	}
2900
2901	if (tb[IFLA_VF_RSS_QUERY_EN]) {
2902		struct ifla_vf_rss_query_en *ivrssq_en;
2903
2904		err = -EOPNOTSUPP;
2905		ivrssq_en = nla_data(tb[IFLA_VF_RSS_QUERY_EN]);
2906		if (ivrssq_en->vf >= INT_MAX)
2907			return -EINVAL;
2908		if (ops->ndo_set_vf_rss_query_en)
2909			err = ops->ndo_set_vf_rss_query_en(dev, ivrssq_en->vf,
2910							   ivrssq_en->setting);
2911		if (err < 0)
2912			return err;
2913	}
2914
2915	if (tb[IFLA_VF_TRUST]) {
2916		struct ifla_vf_trust *ivt = nla_data(tb[IFLA_VF_TRUST]);
2917
2918		if (ivt->vf >= INT_MAX)
2919			return -EINVAL;
2920		err = -EOPNOTSUPP;
2921		if (ops->ndo_set_vf_trust)
2922			err = ops->ndo_set_vf_trust(dev, ivt->vf, ivt->setting);
2923		if (err < 0)
2924			return err;
2925	}
2926
2927	if (tb[IFLA_VF_IB_NODE_GUID]) {
2928		struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_NODE_GUID]);
2929
2930		if (ivt->vf >= INT_MAX)
2931			return -EINVAL;
2932		if (!ops->ndo_set_vf_guid)
2933			return -EOPNOTSUPP;
2934		return handle_vf_guid(dev, ivt, IFLA_VF_IB_NODE_GUID);
2935	}
2936
2937	if (tb[IFLA_VF_IB_PORT_GUID]) {
2938		struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_PORT_GUID]);
2939
2940		if (ivt->vf >= INT_MAX)
2941			return -EINVAL;
2942		if (!ops->ndo_set_vf_guid)
2943			return -EOPNOTSUPP;
2944
2945		return handle_vf_guid(dev, ivt, IFLA_VF_IB_PORT_GUID);
2946	}
2947
2948	return err;
2949}
2950
2951static int do_set_master(struct net_device *dev, int ifindex,
2952			 struct netlink_ext_ack *extack)
2953{
2954	struct net_device *upper_dev = netdev_master_upper_dev_get(dev);
2955	const struct net_device_ops *ops;
2956	int err;
2957
2958	/* Release the lower lock, the upper is responsible for locking
2959	 * the lower if needed. None of the existing upper devices
2960	 * use netdev instance lock, so don't grab it.
2961	 */
2962
2963	if (upper_dev) {
2964		if (upper_dev->ifindex == ifindex)
2965			return 0;
2966		ops = upper_dev->netdev_ops;
2967		if (ops->ndo_del_slave) {
2968			netdev_unlock_ops(dev);
2969			err = ops->ndo_del_slave(upper_dev, dev);
2970			netdev_lock_ops(dev);
2971			if (err)
2972				return err;
2973		} else {
2974			return -EOPNOTSUPP;
2975		}
2976	}
2977
2978	if (ifindex) {
2979		upper_dev = __dev_get_by_index(dev_net(dev), ifindex);
2980		if (!upper_dev)
2981			return -EINVAL;
2982		ops = upper_dev->netdev_ops;
2983		if (ops->ndo_add_slave) {
2984			netdev_unlock_ops(dev);
2985			err = ops->ndo_add_slave(upper_dev, dev, extack);
2986			netdev_lock_ops(dev);
2987			if (err)
2988				return err;
2989		} else {
2990			return -EOPNOTSUPP;
2991		}
2992	}
2993	return 0;
2994}
2995
2996static const struct nla_policy ifla_proto_down_reason_policy[IFLA_PROTO_DOWN_REASON_VALUE + 1] = {
2997	[IFLA_PROTO_DOWN_REASON_MASK]	= { .type = NLA_U32 },
2998	[IFLA_PROTO_DOWN_REASON_VALUE]	= { .type = NLA_U32 },
2999};
3000
3001static int do_set_proto_down(struct net_device *dev,
3002			     struct nlattr *nl_proto_down,
3003			     struct nlattr *nl_proto_down_reason,
3004			     struct netlink_ext_ack *extack)
3005{
3006	struct nlattr *pdreason[IFLA_PROTO_DOWN_REASON_MAX + 1];
3007	unsigned long mask = 0;
3008	u32 value;
3009	bool proto_down;
3010	int err;
3011
3012	if (!dev->change_proto_down) {
3013		NL_SET_ERR_MSG(extack,  "Protodown not supported by device");
3014		return -EOPNOTSUPP;
3015	}
3016
3017	if (nl_proto_down_reason) {
3018		err = nla_parse_nested_deprecated(pdreason,
3019						  IFLA_PROTO_DOWN_REASON_MAX,
3020						  nl_proto_down_reason,
3021						  ifla_proto_down_reason_policy,
3022						  NULL);
3023		if (err < 0)
3024			return err;
3025
3026		if (!pdreason[IFLA_PROTO_DOWN_REASON_VALUE]) {
3027			NL_SET_ERR_MSG(extack, "Invalid protodown reason value");
3028			return -EINVAL;
3029		}
3030
3031		value = nla_get_u32(pdreason[IFLA_PROTO_DOWN_REASON_VALUE]);
3032
3033		if (pdreason[IFLA_PROTO_DOWN_REASON_MASK])
3034			mask = nla_get_u32(pdreason[IFLA_PROTO_DOWN_REASON_MASK]);
3035
3036		netdev_change_proto_down_reason_locked(dev, mask, value);
3037	}
3038
3039	if (nl_proto_down) {
3040		proto_down = nla_get_u8(nl_proto_down);
3041
3042		/* Don't turn off protodown if there are active reasons */
3043		if (!proto_down && dev->proto_down_reason) {
3044			NL_SET_ERR_MSG(extack, "Cannot clear protodown, active reasons");
3045			return -EBUSY;
3046		}
3047		err = netif_change_proto_down(dev, proto_down);
3048		if (err)
3049			return err;
3050	}
3051
3052	return 0;
3053}
3054
3055#define DO_SETLINK_MODIFIED	0x01
3056/* notify flag means notify + modified. */
3057#define DO_SETLINK_NOTIFY	0x03
3058static int do_setlink(const struct sk_buff *skb, struct net_device *dev,
3059		      struct net *tgt_net, struct ifinfomsg *ifm,
3060		      struct netlink_ext_ack *extack,
3061		      struct nlattr **tb, int status)
3062{
3063	const struct net_device_ops *ops = dev->netdev_ops;
3064	char ifname[IFNAMSIZ];
3065	int err;
3066
3067	err = validate_linkmsg(dev, tb, extack);
3068	if (err < 0)
3069		return err;
3070
3071	if (tb[IFLA_IFNAME])
3072		nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
3073	else
3074		ifname[0] = '\0';
3075
3076	if (!net_eq(tgt_net, dev_net(dev))) {
3077		const char *pat = ifname[0] ? ifname : NULL;
3078		int new_ifindex;
3079
3080		new_ifindex = nla_get_s32_default(tb[IFLA_NEW_IFINDEX], 0);
3081
3082		err = __dev_change_net_namespace(dev, tgt_net, pat,
3083						 new_ifindex, extack);
3084		if (err)
3085			return err;
3086
3087		status |= DO_SETLINK_MODIFIED;
3088	}
3089
3090	netdev_lock_ops(dev);
3091
3092	if (tb[IFLA_MAP]) {
3093		struct rtnl_link_ifmap *u_map;
3094		struct ifmap k_map;
3095
3096		if (!ops->ndo_set_config) {
3097			err = -EOPNOTSUPP;
3098			goto errout;
3099		}
3100
3101		if (!netif_device_present(dev)) {
3102			err = -ENODEV;
3103			goto errout;
3104		}
3105
3106		u_map = nla_data(tb[IFLA_MAP]);
3107		k_map.mem_start = (unsigned long) u_map->mem_start;
3108		k_map.mem_end = (unsigned long) u_map->mem_end;
3109		k_map.base_addr = (unsigned short) u_map->base_addr;
3110		k_map.irq = (unsigned char) u_map->irq;
3111		k_map.dma = (unsigned char) u_map->dma;
3112		k_map.port = (unsigned char) u_map->port;
3113
3114		err = ops->ndo_set_config(dev, &k_map);
3115		if (err < 0)
3116			goto errout;
3117
3118		status |= DO_SETLINK_NOTIFY;
3119	}
3120
3121	if (tb[IFLA_ADDRESS]) {
3122		struct sockaddr_storage ss = { };
3123
3124		netdev_unlock_ops(dev);
3125
3126		/* dev_addr_sem is an outer lock, enforce proper ordering */
3127		down_write(&dev_addr_sem);
3128		netdev_lock_ops(dev);
3129
3130		ss.ss_family = dev->type;
3131		memcpy(ss.__data, nla_data(tb[IFLA_ADDRESS]), dev->addr_len);
3132		err = netif_set_mac_address(dev, &ss, extack);
3133		if (err) {
3134			up_write(&dev_addr_sem);
3135			goto errout;
3136		}
3137		status |= DO_SETLINK_MODIFIED;
3138
3139		up_write(&dev_addr_sem);
3140	}
3141
3142	if (tb[IFLA_MTU]) {
3143		err = netif_set_mtu_ext(dev, nla_get_u32(tb[IFLA_MTU]), extack);
3144		if (err < 0)
3145			goto errout;
3146		status |= DO_SETLINK_MODIFIED;
3147	}
3148
3149	if (tb[IFLA_GROUP]) {
3150		netif_set_group(dev, nla_get_u32(tb[IFLA_GROUP]));
3151		status |= DO_SETLINK_NOTIFY;
3152	}
3153
3154	/*
3155	 * Interface selected by interface index but interface
3156	 * name provided implies that a name change has been
3157	 * requested.
3158	 */
3159	if (ifm->ifi_index > 0 && ifname[0]) {
3160		err = netif_change_name(dev, ifname);
3161		if (err < 0)
3162			goto errout;
3163		status |= DO_SETLINK_MODIFIED;
3164	}
3165
3166	if (tb[IFLA_IFALIAS]) {
3167		err = netif_set_alias(dev, nla_data(tb[IFLA_IFALIAS]),
3168				      nla_len(tb[IFLA_IFALIAS]));
3169		if (err < 0)
3170			goto errout;
3171		status |= DO_SETLINK_NOTIFY;
3172	}
3173
3174	if (tb[IFLA_BROADCAST]) {
3175		nla_memcpy(dev->broadcast, tb[IFLA_BROADCAST], dev->addr_len);
3176		call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3177	}
3178
3179	if (ifm->ifi_flags || ifm->ifi_change) {
3180		err = netif_change_flags(dev, rtnl_dev_combine_flags(dev, ifm),
3181					 extack);
3182		if (err < 0)
3183			goto errout;
3184	}
3185
3186	if (tb[IFLA_MASTER]) {
3187		err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), extack);
3188		if (err)
3189			goto errout;
3190		status |= DO_SETLINK_MODIFIED;
3191	}
3192
3193	if (tb[IFLA_CARRIER]) {
3194		err = netif_change_carrier(dev, nla_get_u8(tb[IFLA_CARRIER]));
3195		if (err)
3196			goto errout;
3197		status |= DO_SETLINK_MODIFIED;
3198	}
3199
3200	if (tb[IFLA_TXQLEN]) {
3201		unsigned int value = nla_get_u32(tb[IFLA_TXQLEN]);
3202
3203		err = netif_change_tx_queue_len(dev, value);
3204		if (err)
3205			goto errout;
3206		status |= DO_SETLINK_MODIFIED;
3207	}
3208
3209	if (tb[IFLA_GSO_MAX_SIZE]) {
3210		u32 max_size = nla_get_u32(tb[IFLA_GSO_MAX_SIZE]);
3211
3212		if (dev->gso_max_size ^ max_size) {
3213			netif_set_gso_max_size(dev, max_size);
3214			status |= DO_SETLINK_MODIFIED;
3215		}
3216	}
3217
3218	if (tb[IFLA_GSO_MAX_SEGS]) {
3219		u32 max_segs = nla_get_u32(tb[IFLA_GSO_MAX_SEGS]);
3220
3221		if (dev->gso_max_segs ^ max_segs) {
3222			netif_set_gso_max_segs(dev, max_segs);
3223			status |= DO_SETLINK_MODIFIED;
3224		}
3225	}
3226
3227	if (tb[IFLA_GRO_MAX_SIZE]) {
3228		u32 gro_max_size = nla_get_u32(tb[IFLA_GRO_MAX_SIZE]);
3229
3230		if (dev->gro_max_size ^ gro_max_size) {
3231			netif_set_gro_max_size(dev, gro_max_size);
3232			status |= DO_SETLINK_MODIFIED;
3233		}
3234	}
3235
3236	if (tb[IFLA_GSO_IPV4_MAX_SIZE]) {
3237		u32 max_size = nla_get_u32(tb[IFLA_GSO_IPV4_MAX_SIZE]);
3238
3239		if (dev->gso_ipv4_max_size ^ max_size) {
3240			netif_set_gso_ipv4_max_size(dev, max_size);
3241			status |= DO_SETLINK_MODIFIED;
3242		}
3243	}
3244
3245	if (tb[IFLA_GRO_IPV4_MAX_SIZE]) {
3246		u32 gro_max_size = nla_get_u32(tb[IFLA_GRO_IPV4_MAX_SIZE]);
3247
3248		if (dev->gro_ipv4_max_size ^ gro_max_size) {
3249			netif_set_gro_ipv4_max_size(dev, gro_max_size);
3250			status |= DO_SETLINK_MODIFIED;
3251		}
3252	}
3253
3254	if (tb[IFLA_OPERSTATE])
3255		set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
3256
3257	if (tb[IFLA_LINKMODE]) {
3258		unsigned char value = nla_get_u8(tb[IFLA_LINKMODE]);
3259
3260		if (dev->link_mode ^ value)
3261			status |= DO_SETLINK_NOTIFY;
3262		WRITE_ONCE(dev->link_mode, value);
3263	}
3264
3265	if (tb[IFLA_VFINFO_LIST]) {
3266		struct nlattr *vfinfo[IFLA_VF_MAX + 1];
3267		struct nlattr *attr;
3268		int rem;
3269
3270		nla_for_each_nested(attr, tb[IFLA_VFINFO_LIST], rem) {
3271			if (nla_type(attr) != IFLA_VF_INFO ||
3272			    nla_len(attr) < NLA_HDRLEN) {
3273				err = -EINVAL;
3274				goto errout;
3275			}
3276			err = nla_parse_nested_deprecated(vfinfo, IFLA_VF_MAX,
3277							  attr,
3278							  ifla_vf_policy,
3279							  NULL);
3280			if (err < 0)
3281				goto errout;
3282			err = do_setvfinfo(dev, vfinfo);
3283			if (err < 0)
3284				goto errout;
3285			status |= DO_SETLINK_NOTIFY;
3286		}
3287	}
3288	err = 0;
3289
3290	if (tb[IFLA_VF_PORTS]) {
3291		struct nlattr *port[IFLA_PORT_MAX+1];
3292		struct nlattr *attr;
3293		int vf;
3294		int rem;
3295
3296		err = -EOPNOTSUPP;
3297		if (!ops->ndo_set_vf_port)
3298			goto errout;
3299
3300		nla_for_each_nested(attr, tb[IFLA_VF_PORTS], rem) {
3301			if (nla_type(attr) != IFLA_VF_PORT ||
3302			    nla_len(attr) < NLA_HDRLEN) {
3303				err = -EINVAL;
3304				goto errout;
3305			}
3306			err = nla_parse_nested_deprecated(port, IFLA_PORT_MAX,
3307							  attr,
3308							  ifla_port_policy,
3309							  NULL);
3310			if (err < 0)
3311				goto errout;
3312			if (!port[IFLA_PORT_VF]) {
3313				err = -EOPNOTSUPP;
3314				goto errout;
3315			}
3316			vf = nla_get_u32(port[IFLA_PORT_VF]);
3317			err = ops->ndo_set_vf_port(dev, vf, port);
3318			if (err < 0)
3319				goto errout;
3320			status |= DO_SETLINK_NOTIFY;
3321		}
3322	}
3323	err = 0;
3324
3325	if (tb[IFLA_PORT_SELF]) {
3326		struct nlattr *port[IFLA_PORT_MAX+1];
3327
3328		err = nla_parse_nested_deprecated(port, IFLA_PORT_MAX,
3329						  tb[IFLA_PORT_SELF],
3330						  ifla_port_policy, NULL);
3331		if (err < 0)
3332			goto errout;
3333
3334		err = -EOPNOTSUPP;
3335		if (ops->ndo_set_vf_port)
3336			err = ops->ndo_set_vf_port(dev, PORT_SELF_VF, port);
3337		if (err < 0)
3338			goto errout;
3339		status |= DO_SETLINK_NOTIFY;
3340	}
3341
3342	if (tb[IFLA_AF_SPEC]) {
3343		struct nlattr *af;
3344		int rem;
3345
3346		nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
3347			struct rtnl_af_ops *af_ops;
3348			int af_ops_srcu_index;
3349
3350			af_ops = rtnl_af_lookup(nla_type(af), &af_ops_srcu_index);
3351			if (!af_ops) {
3352				err = -EAFNOSUPPORT;
3353				goto errout;
3354			}
3355
3356			err = af_ops->set_link_af(dev, af, extack);
3357			rtnl_af_put(af_ops, af_ops_srcu_index);
3358
3359			if (err < 0)
3360				goto errout;
3361
3362			status |= DO_SETLINK_NOTIFY;
3363		}
3364	}
3365	err = 0;
3366
3367	if (tb[IFLA_PROTO_DOWN] || tb[IFLA_PROTO_DOWN_REASON]) {
3368		err = do_set_proto_down(dev, tb[IFLA_PROTO_DOWN],
3369					tb[IFLA_PROTO_DOWN_REASON], extack);
3370		if (err)
3371			goto errout;
3372		status |= DO_SETLINK_NOTIFY;
3373	}
3374
3375	if (tb[IFLA_XDP]) {
3376		struct nlattr *xdp[IFLA_XDP_MAX + 1];
3377		u32 xdp_flags = 0;
3378
3379		err = nla_parse_nested_deprecated(xdp, IFLA_XDP_MAX,
3380						  tb[IFLA_XDP],
3381						  ifla_xdp_policy, NULL);
3382		if (err < 0)
3383			goto errout;
3384
3385		if (xdp[IFLA_XDP_ATTACHED] || xdp[IFLA_XDP_PROG_ID]) {
3386			err = -EINVAL;
3387			goto errout;
3388		}
3389
3390		if (xdp[IFLA_XDP_FLAGS]) {
3391			xdp_flags = nla_get_u32(xdp[IFLA_XDP_FLAGS]);
3392			if (xdp_flags & ~XDP_FLAGS_MASK) {
3393				err = -EINVAL;
3394				goto errout;
3395			}
3396			if (hweight32(xdp_flags & XDP_FLAGS_MODES) > 1) {
3397				err = -EINVAL;
3398				goto errout;
3399			}
3400		}
3401
3402		if (xdp[IFLA_XDP_FD]) {
3403			int expected_fd = -1;
3404
3405			if (xdp_flags & XDP_FLAGS_REPLACE) {
3406				if (!xdp[IFLA_XDP_EXPECTED_FD]) {
3407					err = -EINVAL;
3408					goto errout;
3409				}
3410				expected_fd =
3411					nla_get_s32(xdp[IFLA_XDP_EXPECTED_FD]);
3412			}
3413
3414			err = dev_change_xdp_fd(dev, extack,
3415						nla_get_s32(xdp[IFLA_XDP_FD]),
3416						expected_fd,
3417						xdp_flags);
3418			if (err)
3419				goto errout;
3420			status |= DO_SETLINK_NOTIFY;
3421		}
3422	}
3423
3424errout:
3425	if (status & DO_SETLINK_MODIFIED) {
3426		if ((status & DO_SETLINK_NOTIFY) == DO_SETLINK_NOTIFY)
3427			netif_state_change(dev);
3428
3429		if (err < 0)
3430			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",
3431					     dev->name);
3432	}
3433
3434	netdev_unlock_ops(dev);
3435
3436	return err;
3437}
3438
3439static struct net_device *rtnl_dev_get(struct net *net,
3440				       struct nlattr *tb[])
3441{
3442	char ifname[ALTIFNAMSIZ];
3443
3444	if (tb[IFLA_IFNAME])
3445		nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
3446	else if (tb[IFLA_ALT_IFNAME])
3447		nla_strscpy(ifname, tb[IFLA_ALT_IFNAME], ALTIFNAMSIZ);
3448	else
3449		return NULL;
3450
3451	return __dev_get_by_name(net, ifname);
3452}
3453
3454static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3455			struct netlink_ext_ack *extack)
3456{
3457	struct ifinfomsg *ifm = nlmsg_data(nlh);
3458	struct net *net = sock_net(skb->sk);
3459	struct nlattr *tb[IFLA_MAX+1];
3460	struct net_device *dev = NULL;
3461	struct rtnl_nets rtnl_nets;
3462	struct net *tgt_net;
3463	int err;
3464
3465	err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
3466				     ifla_policy, extack);
3467	if (err < 0)
3468		goto errout;
3469
3470	err = rtnl_ensure_unique_netns(tb, extack, false);
3471	if (err < 0)
3472		goto errout;
3473
3474	tgt_net = rtnl_link_get_net_capable(skb, net, tb, CAP_NET_ADMIN);
3475	if (IS_ERR(tgt_net)) {
3476		err = PTR_ERR(tgt_net);
3477		goto errout;
3478	}
3479
3480	rtnl_nets_init(&rtnl_nets);
3481	rtnl_nets_add(&rtnl_nets, get_net(net));
3482	rtnl_nets_add(&rtnl_nets, tgt_net);
3483
3484	rtnl_nets_lock(&rtnl_nets);
3485
3486	if (ifm->ifi_index > 0)
3487		dev = __dev_get_by_index(net, ifm->ifi_index);
3488	else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3489		dev = rtnl_dev_get(net, tb);
3490	else
3491		err = -EINVAL;
3492
3493	if (dev)
3494		err = do_setlink(skb, dev, tgt_net, ifm, extack, tb, 0);
3495	else if (!err)
3496		err = -ENODEV;
3497
3498	rtnl_nets_unlock(&rtnl_nets);
3499	rtnl_nets_destroy(&rtnl_nets);
3500errout:
3501	return err;
3502}
3503
3504static int rtnl_group_dellink(const struct net *net, int group)
3505{
3506	struct net_device *dev, *aux;
3507	LIST_HEAD(list_kill);
3508	bool found = false;
3509
3510	if (!group)
3511		return -EPERM;
3512
3513	for_each_netdev(net, dev) {
3514		if (dev->group == group) {
3515			const struct rtnl_link_ops *ops;
3516
3517			found = true;
3518			ops = dev->rtnl_link_ops;
3519			if (!ops || !ops->dellink)
3520				return -EOPNOTSUPP;
3521		}
3522	}
3523
3524	if (!found)
3525		return -ENODEV;
3526
3527	for_each_netdev_safe(net, dev, aux) {
3528		if (dev->group == group) {
3529			const struct rtnl_link_ops *ops;
3530
3531			ops = dev->rtnl_link_ops;
3532			ops->dellink(dev, &list_kill);
3533		}
3534	}
3535	unregister_netdevice_many(&list_kill);
3536
3537	return 0;
3538}
3539
3540int rtnl_delete_link(struct net_device *dev, u32 portid, const struct nlmsghdr *nlh)
3541{
3542	const struct rtnl_link_ops *ops;
3543	LIST_HEAD(list_kill);
3544
3545	ops = dev->rtnl_link_ops;
3546	if (!ops || !ops->dellink)
3547		return -EOPNOTSUPP;
3548
3549	ops->dellink(dev, &list_kill);
3550	unregister_netdevice_many_notify(&list_kill, portid, nlh);
3551
3552	return 0;
3553}
3554EXPORT_SYMBOL_GPL(rtnl_delete_link);
3555
3556static int rtnl_dellink(struct sk_buff *skb, struct nlmsghdr *nlh,
3557			struct netlink_ext_ack *extack)
3558{
3559	struct ifinfomsg *ifm = nlmsg_data(nlh);
3560	struct net *net = sock_net(skb->sk);
3561	u32 portid = NETLINK_CB(skb).portid;
3562	struct nlattr *tb[IFLA_MAX+1];
3563	struct net_device *dev = NULL;
3564	struct net *tgt_net = net;
3565	int netnsid = -1;
3566	int err;
3567
3568	err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
3569				     ifla_policy, extack);
3570	if (err < 0)
3571		return err;
3572
3573	err = rtnl_ensure_unique_netns(tb, extack, true);
3574	if (err < 0)
3575		return err;
3576
3577	if (tb[IFLA_TARGET_NETNSID]) {
3578		netnsid = nla_get_s32(tb[IFLA_TARGET_NETNSID]);
3579		tgt_net = rtnl_get_net_ns_capable(NETLINK_CB(skb).sk, netnsid);
3580		if (IS_ERR(tgt_net))
3581			return PTR_ERR(tgt_net);
3582	}
3583
3584	rtnl_net_lock(tgt_net);
3585
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);
3590
3591	if (dev)
3592		err = rtnl_delete_link(dev, portid, nlh);
3593	else if (ifm->ifi_index > 0 || tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3594		err = -ENODEV;
3595	else if (tb[IFLA_GROUP])
3596		err = rtnl_group_dellink(tgt_net, nla_get_u32(tb[IFLA_GROUP]));
3597	else
3598		err = -EINVAL;
3599
3600	rtnl_net_unlock(tgt_net);
3601
3602	if (netnsid >= 0)
3603		put_net(tgt_net);
3604
3605	return err;
3606}
3607
3608int rtnl_configure_link(struct net_device *dev, const struct ifinfomsg *ifm,
3609			u32 portid, const struct nlmsghdr *nlh)
3610{
3611	unsigned int old_flags, changed;
3612	int err;
3613
3614	old_flags = dev->flags;
3615	if (ifm && (ifm->ifi_flags || ifm->ifi_change)) {
3616		err = __dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm),
3617					 NULL);
3618		if (err < 0)
3619			return err;
3620	}
3621
3622	changed = old_flags ^ dev->flags;
3623	if (dev->rtnl_link_initializing) {
3624		dev->rtnl_link_initializing = false;
3625		changed = ~0U;
3626	}
3627
3628	__dev_notify_flags(dev, old_flags, changed, portid, nlh);
3629	return 0;
3630}
3631EXPORT_SYMBOL(rtnl_configure_link);
3632
3633struct net_device *rtnl_create_link(struct net *net, const char *ifname,
3634				    unsigned char name_assign_type,
3635				    const struct rtnl_link_ops *ops,
3636				    struct nlattr *tb[],
3637				    struct netlink_ext_ack *extack)
3638{
3639	struct net_device *dev;
3640	unsigned int num_tx_queues = 1;
3641	unsigned int num_rx_queues = 1;
3642	int err;
3643
3644	if (tb[IFLA_NUM_TX_QUEUES])
3645		num_tx_queues = nla_get_u32(tb[IFLA_NUM_TX_QUEUES]);
3646	else if (ops->get_num_tx_queues)
3647		num_tx_queues = ops->get_num_tx_queues();
3648
3649	if (tb[IFLA_NUM_RX_QUEUES])
3650		num_rx_queues = nla_get_u32(tb[IFLA_NUM_RX_QUEUES]);
3651	else if (ops->get_num_rx_queues)
3652		num_rx_queues = ops->get_num_rx_queues();
3653
3654	if (num_tx_queues < 1 || num_tx_queues > 4096) {
3655		NL_SET_ERR_MSG(extack, "Invalid number of transmit queues");
3656		return ERR_PTR(-EINVAL);
3657	}
3658
3659	if (num_rx_queues < 1 || num_rx_queues > 4096) {
3660		NL_SET_ERR_MSG(extack, "Invalid number of receive queues");
3661		return ERR_PTR(-EINVAL);
3662	}
3663
3664	if (ops->alloc) {
3665		dev = ops->alloc(tb, ifname, name_assign_type,
3666				 num_tx_queues, num_rx_queues);
3667		if (IS_ERR(dev))
3668			return dev;
3669	} else {
3670		dev = alloc_netdev_mqs(ops->priv_size, ifname,
3671				       name_assign_type, ops->setup,
3672				       num_tx_queues, num_rx_queues);
3673	}
3674
3675	if (!dev)
3676		return ERR_PTR(-ENOMEM);
3677
3678	err = validate_linkmsg(dev, tb, extack);
3679	if (err < 0) {
3680		free_netdev(dev);
3681		return ERR_PTR(err);
3682	}
3683
3684	dev_net_set(dev, net);
3685	dev->rtnl_link_ops = ops;
3686	dev->rtnl_link_initializing = true;
3687
3688	if (tb[IFLA_MTU]) {
3689		u32 mtu = nla_get_u32(tb[IFLA_MTU]);
3690
3691		err = dev_validate_mtu(dev, mtu, extack);
3692		if (err) {
3693			free_netdev(dev);
3694			return ERR_PTR(err);
3695		}
3696		dev->mtu = mtu;
3697	}
3698	if (tb[IFLA_ADDRESS]) {
3699		__dev_addr_set(dev, nla_data(tb[IFLA_ADDRESS]),
3700			       nla_len(tb[IFLA_ADDRESS]));
3701		dev->addr_assign_type = NET_ADDR_SET;
3702	}
3703	if (tb[IFLA_BROADCAST])
3704		memcpy(dev->broadcast, nla_data(tb[IFLA_BROADCAST]),
3705				nla_len(tb[IFLA_BROADCAST]));
3706	if (tb[IFLA_TXQLEN])
3707		dev->tx_queue_len = nla_get_u32(tb[IFLA_TXQLEN]);
3708	if (tb[IFLA_OPERSTATE])
3709		set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
3710	if (tb[IFLA_LINKMODE])
3711		dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]);
3712	if (tb[IFLA_GROUP])
3713		netif_set_group(dev, nla_get_u32(tb[IFLA_GROUP]));
3714	if (tb[IFLA_GSO_MAX_SIZE])
3715		netif_set_gso_max_size(dev, nla_get_u32(tb[IFLA_GSO_MAX_SIZE]));
3716	if (tb[IFLA_GSO_MAX_SEGS])
3717		netif_set_gso_max_segs(dev, nla_get_u32(tb[IFLA_GSO_MAX_SEGS]));
3718	if (tb[IFLA_GRO_MAX_SIZE])
3719		netif_set_gro_max_size(dev, nla_get_u32(tb[IFLA_GRO_MAX_SIZE]));
3720	if (tb[IFLA_GSO_IPV4_MAX_SIZE])
3721		netif_set_gso_ipv4_max_size(dev, nla_get_u32(tb[IFLA_GSO_IPV4_MAX_SIZE]));
3722	if (tb[IFLA_GRO_IPV4_MAX_SIZE])
3723		netif_set_gro_ipv4_max_size(dev, nla_get_u32(tb[IFLA_GRO_IPV4_MAX_SIZE]));
3724
3725	return dev;
3726}
3727EXPORT_SYMBOL(rtnl_create_link);
3728
3729struct rtnl_newlink_tbs {
3730	struct nlattr *tb[IFLA_MAX + 1];
3731	struct nlattr *linkinfo[IFLA_INFO_MAX + 1];
3732	struct nlattr *attr[RTNL_MAX_TYPE + 1];
3733	struct nlattr *slave_attr[RTNL_SLAVE_MAX_TYPE + 1];
3734};
3735
3736static int rtnl_changelink(const struct sk_buff *skb, struct nlmsghdr *nlh,
3737			   const struct rtnl_link_ops *ops,
3738			   struct net_device *dev, struct net *tgt_net,
3739			   struct rtnl_newlink_tbs *tbs,
3740			   struct nlattr **data,
3741			   struct netlink_ext_ack *extack)
3742{
3743	struct nlattr ** const linkinfo = tbs->linkinfo;
3744	struct nlattr ** const tb = tbs->tb;
3745	int status = 0;
3746	int err;
3747
3748	if (nlh->nlmsg_flags & NLM_F_EXCL)
3749		return -EEXIST;
3750
3751	if (nlh->nlmsg_flags & NLM_F_REPLACE)
3752		return -EOPNOTSUPP;
3753
3754	if (linkinfo[IFLA_INFO_DATA]) {
3755		if (!ops || ops != dev->rtnl_link_ops || !ops->changelink)
3756			return -EOPNOTSUPP;
3757
3758		err = ops->changelink(dev, tb, data, extack);
3759		if (err < 0)
3760			return err;
3761
3762		status |= DO_SETLINK_NOTIFY;
3763	}
3764
3765	if (linkinfo[IFLA_INFO_SLAVE_DATA]) {
3766		const struct rtnl_link_ops *m_ops = NULL;
3767		struct nlattr **slave_data = NULL;
3768		struct net_device *master_dev;
3769
3770		master_dev = netdev_master_upper_dev_get(dev);
3771		if (master_dev)
3772			m_ops = master_dev->rtnl_link_ops;
3773
3774		if (!m_ops || !m_ops->slave_changelink)
3775			return -EOPNOTSUPP;
3776
3777		if (m_ops->slave_maxtype > RTNL_SLAVE_MAX_TYPE)
3778			return -EINVAL;
3779
3780		if (m_ops->slave_maxtype) {
3781			err = nla_parse_nested_deprecated(tbs->slave_attr,
3782							  m_ops->slave_maxtype,
3783							  linkinfo[IFLA_INFO_SLAVE_DATA],
3784							  m_ops->slave_policy, extack);
3785			if (err < 0)
3786				return err;
3787
3788			slave_data = tbs->slave_attr;
3789		}
3790
3791		err = m_ops->slave_changelink(master_dev, dev, tb, slave_data, extack);
3792		if (err < 0)
3793			return err;
3794
3795		status |= DO_SETLINK_NOTIFY;
3796	}
3797
3798	return do_setlink(skb, dev, tgt_net, nlmsg_data(nlh), extack, tb, status);
3799}
3800
3801static int rtnl_group_changelink(const struct sk_buff *skb,
3802				 struct net *net, struct net *tgt_net,
3803				 int group, struct ifinfomsg *ifm,
3804				 struct netlink_ext_ack *extack,
3805				 struct nlattr **tb)
3806{
3807	struct net_device *dev, *aux;
3808	int err;
3809
3810	for_each_netdev_safe(net, dev, aux) {
3811		if (dev->group == group) {
3812			err = do_setlink(skb, dev, tgt_net, ifm, extack, tb, 0);
3813			if (err < 0)
3814				return err;
3815		}
3816	}
3817
3818	return 0;
3819}
3820
3821static int rtnl_newlink_create(struct sk_buff *skb, struct ifinfomsg *ifm,
3822			       const struct rtnl_link_ops *ops,
3823			       struct net *tgt_net, struct net *link_net,
3824			       struct net *peer_net,
3825			       const struct nlmsghdr *nlh,
3826			       struct nlattr **tb, struct nlattr **data,
3827			       struct netlink_ext_ack *extack)
3828{
3829	unsigned char name_assign_type = NET_NAME_USER;
3830	struct rtnl_newlink_params params = {
3831		.src_net = sock_net(skb->sk),
3832		.link_net = link_net,
3833		.peer_net = peer_net,
3834		.tb = tb,
3835		.data = data,
3836	};
3837	u32 portid = NETLINK_CB(skb).portid;
3838	struct net_device *dev;
3839	char ifname[IFNAMSIZ];
3840	int err;
3841
3842	if (!ops->alloc && !ops->setup)
3843		return -EOPNOTSUPP;
3844
3845	if (tb[IFLA_IFNAME]) {
3846		nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
3847	} else {
3848		snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind);
3849		name_assign_type = NET_NAME_ENUM;
3850	}
3851
3852	dev = rtnl_create_link(tgt_net, ifname, name_assign_type, ops, tb,
3853			       extack);
3854	if (IS_ERR(dev)) {
3855		err = PTR_ERR(dev);
3856		goto out;
3857	}
3858
3859	dev->ifindex = ifm->ifi_index;
3860
3861	if (ops->newlink)
3862		err = ops->newlink(dev, &params, extack);
3863	else
3864		err = register_netdevice(dev);
3865	if (err < 0) {
3866		free_netdev(dev);
3867		goto out;
3868	}
3869
3870	netdev_lock_ops(dev);
3871
3872	err = rtnl_configure_link(dev, ifm, portid, nlh);
3873	if (err < 0)
3874		goto out_unregister;
3875	if (tb[IFLA_MASTER]) {
3876		err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), extack);
3877		if (err)
3878			goto out_unregister;
3879	}
3880
3881	netdev_unlock_ops(dev);
3882out:
3883	return err;
3884out_unregister:
3885	netdev_unlock_ops(dev);
3886	if (ops->newlink) {
3887		LIST_HEAD(list_kill);
3888
3889		ops->dellink(dev, &list_kill);
3890		unregister_netdevice_many(&list_kill);
3891	} else {
3892		unregister_netdevice(dev);
3893	}
3894	goto out;
3895}
3896
3897static struct net *rtnl_get_peer_net(struct sk_buff *skb,
3898				     const struct rtnl_link_ops *ops,
3899				     struct nlattr *tbp[],
3900				     struct nlattr *data[],
3901				     struct netlink_ext_ack *extack)
3902{
3903	struct nlattr *tb[IFLA_MAX + 1], **attrs;
3904	struct net *net;
3905	int err;
3906
3907	if (!data || !data[ops->peer_type]) {
3908		attrs = tbp;
3909	} else {
3910		err = rtnl_nla_parse_ifinfomsg(tb, data[ops->peer_type], extack);
3911		if (err < 0)
3912			return ERR_PTR(err);
3913
3914		if (ops->validate) {
3915			err = ops->validate(tb, NULL, extack);
3916			if (err < 0)
3917				return ERR_PTR(err);
3918		}
3919
3920		attrs = tb;
3921	}
3922
3923	net = rtnl_link_get_net_ifla(attrs);
3924	if (IS_ERR_OR_NULL(net))
3925		return net;
3926
3927	if (!netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN)) {
3928		put_net(net);
3929		return ERR_PTR(-EPERM);
3930	}
3931
3932	return net;
3933}
3934
3935static int __rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3936			  const struct rtnl_link_ops *ops,
3937			  struct net *tgt_net, struct net *link_net,
3938			  struct net *peer_net,
3939			  struct rtnl_newlink_tbs *tbs,
3940			  struct nlattr **data,
3941			  struct netlink_ext_ack *extack)
3942{
3943	struct nlattr ** const tb = tbs->tb;
3944	struct net *net = sock_net(skb->sk);
3945	struct net *device_net;
3946	struct net_device *dev;
3947	struct ifinfomsg *ifm;
3948	bool link_specified;
3949
3950	/* When creating, lookup for existing device in target net namespace */
3951	device_net = (nlh->nlmsg_flags & NLM_F_CREATE) &&
3952		     (nlh->nlmsg_flags & NLM_F_EXCL) ?
3953		     tgt_net : net;
3954
3955	ifm = nlmsg_data(nlh);
3956	if (ifm->ifi_index > 0) {
3957		link_specified = true;
3958		dev = __dev_get_by_index(device_net, ifm->ifi_index);
3959	} else if (ifm->ifi_index < 0) {
3960		NL_SET_ERR_MSG(extack, "ifindex can't be negative");
3961		return -EINVAL;
3962	} else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME]) {
3963		link_specified = true;
3964		dev = rtnl_dev_get(device_net, tb);
3965	} else {
3966		link_specified = false;
3967		dev = NULL;
3968	}
3969
3970	if (dev)
3971		return rtnl_changelink(skb, nlh, ops, dev, tgt_net, tbs, data, extack);
3972
3973	if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
3974		/* No dev found and NLM_F_CREATE not set. Requested dev does not exist,
3975		 * or it's for a group
3976		*/
3977		if (link_specified || !tb[IFLA_GROUP])
3978			return -ENODEV;
3979
3980		return rtnl_group_changelink(skb, net, tgt_net,
3981					     nla_get_u32(tb[IFLA_GROUP]),
3982					     ifm, extack, tb);
3983	}
3984
3985	if (tb[IFLA_MAP] || tb[IFLA_PROTINFO])
3986		return -EOPNOTSUPP;
3987
3988	if (!ops) {
3989		NL_SET_ERR_MSG(extack, "Unknown device type");
3990		return -EOPNOTSUPP;
3991	}
3992
3993	return rtnl_newlink_create(skb, ifm, ops, tgt_net, link_net, peer_net, nlh,
3994				   tb, data, extack);
3995}
3996
3997static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3998			struct netlink_ext_ack *extack)
3999{
4000	struct net *tgt_net, *link_net = NULL, *peer_net = NULL;
4001	struct nlattr **tb, **linkinfo, **data = NULL;
4002	struct rtnl_link_ops *ops = NULL;
4003	struct rtnl_newlink_tbs *tbs;
4004	struct rtnl_nets rtnl_nets;
4005	int ops_srcu_index;
4006	int ret;
4007
4008	tbs = kmalloc(sizeof(*tbs), GFP_KERNEL);
4009	if (!tbs)
4010		return -ENOMEM;
4011
4012	tb = tbs->tb;
4013	ret = nlmsg_parse_deprecated(nlh, sizeof(struct ifinfomsg), tb,
4014				     IFLA_MAX, ifla_policy, extack);
4015	if (ret < 0)
4016		goto free;
4017
4018	ret = rtnl_ensure_unique_netns(tb, extack, false);
4019	if (ret < 0)
4020		goto free;
4021
4022	linkinfo = tbs->linkinfo;
4023	if (tb[IFLA_LINKINFO]) {
4024		ret = nla_parse_nested_deprecated(linkinfo, IFLA_INFO_MAX,
4025						  tb[IFLA_LINKINFO],
4026						  ifla_info_policy, NULL);
4027		if (ret < 0)
4028			goto free;
4029	} else {
4030		memset(linkinfo, 0, sizeof(tbs->linkinfo));
4031	}
4032
4033	if (linkinfo[IFLA_INFO_KIND]) {
4034		char kind[MODULE_NAME_LEN];
4035
4036		nla_strscpy(kind, linkinfo[IFLA_INFO_KIND], sizeof(kind));
4037		ops = rtnl_link_ops_get(kind, &ops_srcu_index);
4038#ifdef CONFIG_MODULES
4039		if (!ops) {
4040			request_module("rtnl-link-%s", kind);
4041			ops = rtnl_link_ops_get(kind, &ops_srcu_index);
4042		}
4043#endif
4044	}
4045
4046	rtnl_nets_init(&rtnl_nets);
4047
4048	if (ops) {
4049		if (ops->maxtype > RTNL_MAX_TYPE) {
4050			ret = -EINVAL;
4051			goto put_ops;
4052		}
4053
4054		if (ops->maxtype && linkinfo[IFLA_INFO_DATA]) {
4055			ret = nla_parse_nested_deprecated(tbs->attr, ops->maxtype,
4056							  linkinfo[IFLA_INFO_DATA],
4057							  ops->policy, extack);
4058			if (ret < 0)
4059				goto put_ops;
4060
4061			data = tbs->attr;
4062		}
4063
4064		if (ops->validate) {
4065			ret = ops->validate(tb, data, extack);
4066			if (ret < 0)
4067				goto put_ops;
4068		}
4069
4070		if (ops->peer_type) {
4071			peer_net = rtnl_get_peer_net(skb, ops, tb, data, extack);
4072			if (IS_ERR(peer_net)) {
4073				ret = PTR_ERR(peer_net);
4074				goto put_ops;
4075			}
4076			if (peer_net)
4077				rtnl_nets_add(&rtnl_nets, peer_net);
4078		}
4079	}
4080
4081	tgt_net = rtnl_link_get_net_capable(skb, sock_net(skb->sk), tb, CAP_NET_ADMIN);
4082	if (IS_ERR(tgt_net)) {
4083		ret = PTR_ERR(tgt_net);
4084		goto put_net;
4085	}
4086
4087	rtnl_nets_add(&rtnl_nets, tgt_net);
4088
4089	if (tb[IFLA_LINK_NETNSID]) {
4090		int id = nla_get_s32(tb[IFLA_LINK_NETNSID]);
4091
4092		link_net = get_net_ns_by_id(tgt_net, id);
4093		if (!link_net) {
4094			NL_SET_ERR_MSG(extack, "Unknown network namespace id");
4095			ret =  -EINVAL;
4096			goto put_net;
4097		}
4098
4099		rtnl_nets_add(&rtnl_nets, link_net);
4100
4101		if (!netlink_ns_capable(skb, link_net->user_ns, CAP_NET_ADMIN)) {
4102			ret = -EPERM;
4103			goto put_net;
4104		}
4105	}
4106
4107	rtnl_nets_lock(&rtnl_nets);
4108	ret = __rtnl_newlink(skb, nlh, ops, tgt_net, link_net, peer_net, tbs, data, extack);
4109	rtnl_nets_unlock(&rtnl_nets);
4110
4111put_net:
4112	rtnl_nets_destroy(&rtnl_nets);
4113put_ops:
4114	if (ops)
4115		rtnl_link_ops_put(ops, ops_srcu_index);
4116free:
4117	kfree(tbs);
4118	return ret;
4119}
4120
4121static int rtnl_valid_getlink_req(struct sk_buff *skb,
4122				  const struct nlmsghdr *nlh,
4123				  struct nlattr **tb,
4124				  struct netlink_ext_ack *extack)
4125{
4126	struct ifinfomsg *ifm;
4127	int i, err;
4128
4129	ifm = nlmsg_payload(nlh, sizeof(*ifm));
4130	if (!ifm) {
4131		NL_SET_ERR_MSG(extack, "Invalid header for get link");
4132		return -EINVAL;
4133	}
4134
4135	if (!netlink_strict_get_check(skb))
4136		return nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
4137					      ifla_policy, extack);
4138
4139	if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
4140	    ifm->ifi_change) {
4141		NL_SET_ERR_MSG(extack, "Invalid values in header for get link request");
4142		return -EINVAL;
4143	}
4144
4145	err = nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb, IFLA_MAX,
4146					    ifla_policy, extack);
4147	if (err)
4148		return err;
4149
4150	for (i = 0; i <= IFLA_MAX; i++) {
4151		if (!tb[i])
4152			continue;
4153
4154		switch (i) {
4155		case IFLA_IFNAME:
4156		case IFLA_ALT_IFNAME:
4157		case IFLA_EXT_MASK:
4158		case IFLA_TARGET_NETNSID:
4159			break;
4160		default:
4161			NL_SET_ERR_MSG(extack, "Unsupported attribute in get link request");
4162			return -EINVAL;
4163		}
4164	}
4165
4166	return 0;
4167}
4168
4169static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr *nlh,
4170			struct netlink_ext_ack *extack)
4171{
4172	struct net *net = sock_net(skb->sk);
4173	struct net *tgt_net = net;
4174	struct ifinfomsg *ifm;
4175	struct nlattr *tb[IFLA_MAX+1];
4176	struct net_device *dev = NULL;
4177	struct sk_buff *nskb;
4178	int netnsid = -1;
4179	int err;
4180	u32 ext_filter_mask = 0;
4181
4182	err = rtnl_valid_getlink_req(skb, nlh, tb, extack);
4183	if (err < 0)
4184		return err;
4185
4186	err = rtnl_ensure_unique_netns(tb, extack, true);
4187	if (err < 0)
4188		return err;
4189
4190	if (tb[IFLA_TARGET_NETNSID]) {
4191		netnsid = nla_get_s32(tb[IFLA_TARGET_NETNSID]);
4192		tgt_net = rtnl_get_net_ns_capable(NETLINK_CB(skb).sk, netnsid);
4193		if (IS_ERR(tgt_net))
4194			return PTR_ERR(tgt_net);
4195	}
4196
4197	if (tb[IFLA_EXT_MASK])
4198		ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
4199
4200	err = -EINVAL;
4201	ifm = nlmsg_data(nlh);
4202	if (ifm->ifi_index > 0)
4203		dev = __dev_get_by_index(tgt_net, ifm->ifi_index);
4204	else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
4205		dev = rtnl_dev_get(tgt_net, tb);
4206	else
4207		goto out;
4208
4209	err = -ENODEV;
4210	if (dev == NULL)
4211		goto out;
4212
4213	err = -ENOBUFS;
4214	nskb = nlmsg_new_large(if_nlmsg_size(dev, ext_filter_mask));
4215	if (nskb == NULL)
4216		goto out;
4217
4218	/* Synchronize the carrier state so we don't report a state
4219	 * that we're not actually going to honour immediately; if
4220	 * the driver just did a carrier off->on transition, we can
4221	 * only TX if link watch work has run, but without this we'd
4222	 * already report carrier on, even if it doesn't work yet.
4223	 */
4224	linkwatch_sync_dev(dev);
4225
4226	err = rtnl_fill_ifinfo(nskb, dev, net,
4227			       RTM_NEWLINK, NETLINK_CB(skb).portid,
4228			       nlh->nlmsg_seq, 0, 0, ext_filter_mask,
4229			       0, NULL, 0, netnsid, GFP_KERNEL);
4230	if (err < 0) {
4231		/* -EMSGSIZE implies BUG in if_nlmsg_size */
4232		WARN_ON(err == -EMSGSIZE);
4233		kfree_skb(nskb);
4234	} else
4235		err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid);
4236out:
4237	if (netnsid >= 0)
4238		put_net(tgt_net);
4239
4240	return err;
4241}
4242
4243static int rtnl_alt_ifname(int cmd, struct net_device *dev, struct nlattr *attr,
4244			   bool *changed, struct netlink_ext_ack *extack)
4245{
4246	char *alt_ifname;
4247	size_t size;
4248	int err;
4249
4250	err = nla_validate(attr, attr->nla_len, IFLA_MAX, ifla_policy, extack);
4251	if (err)
4252		return err;
4253
4254	if (cmd == RTM_NEWLINKPROP) {
4255		size = rtnl_prop_list_size(dev);
4256		size += nla_total_size(ALTIFNAMSIZ);
4257		if (size >= U16_MAX) {
4258			NL_SET_ERR_MSG(extack,
4259				       "effective property list too long");
4260			return -EINVAL;
4261		}
4262	}
4263
4264	alt_ifname = nla_strdup(attr, GFP_KERNEL_ACCOUNT);
4265	if (!alt_ifname)
4266		return -ENOMEM;
4267
4268	if (cmd == RTM_NEWLINKPROP) {
4269		err = netdev_name_node_alt_create(dev, alt_ifname);
4270		if (!err)
4271			alt_ifname = NULL;
4272	} else if (cmd == RTM_DELLINKPROP) {
4273		err = netdev_name_node_alt_destroy(dev, alt_ifname);
4274	} else {
4275		WARN_ON_ONCE(1);
4276		err = -EINVAL;
4277	}
4278
4279	kfree(alt_ifname);
4280	if (!err)
4281		*changed = true;
4282	return err;
4283}
4284
4285static int rtnl_linkprop(int cmd, struct sk_buff *skb, struct nlmsghdr *nlh,
4286			 struct netlink_ext_ack *extack)
4287{
4288	struct net *net = sock_net(skb->sk);
4289	struct nlattr *tb[IFLA_MAX + 1];
4290	struct net_device *dev;
4291	struct ifinfomsg *ifm;
4292	bool changed = false;
4293	struct nlattr *attr;
4294	int err, rem;
4295
4296	err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy, extack);
4297	if (err)
4298		return err;
4299
4300	err = rtnl_ensure_unique_netns(tb, extack, true);
4301	if (err)
4302		return err;
4303
4304	ifm = nlmsg_data(nlh);
4305	if (ifm->ifi_index > 0)
4306		dev = __dev_get_by_index(net, ifm->ifi_index);
4307	else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
4308		dev = rtnl_dev_get(net, tb);
4309	else
4310		return -EINVAL;
4311
4312	if (!dev)
4313		return -ENODEV;
4314
4315	if (!tb[IFLA_PROP_LIST])
4316		return 0;
4317
4318	nla_for_each_nested(attr, tb[IFLA_PROP_LIST], rem) {
4319		switch (nla_type(attr)) {
4320		case IFLA_ALT_IFNAME:
4321			err = rtnl_alt_ifname(cmd, dev, attr, &changed, extack);
4322			if (err)
4323				return err;
4324			break;
4325		}
4326	}
4327
4328	if (changed)
4329		netdev_state_change(dev);
4330	return 0;
4331}
4332
4333static int rtnl_newlinkprop(struct sk_buff *skb, struct nlmsghdr *nlh,
4334			    struct netlink_ext_ack *extack)
4335{
4336	return rtnl_linkprop(RTM_NEWLINKPROP, skb, nlh, extack);
4337}
4338
4339static int rtnl_dellinkprop(struct sk_buff *skb, struct nlmsghdr *nlh,
4340			    struct netlink_ext_ack *extack)
4341{
4342	return rtnl_linkprop(RTM_DELLINKPROP, skb, nlh, extack);
4343}
4344
4345static noinline_for_stack u32 rtnl_calcit(struct sk_buff *skb,
4346					  struct nlmsghdr *nlh)
4347{
4348	struct net *net = sock_net(skb->sk);
4349	size_t min_ifinfo_dump_size = 0;
4350	u32 ext_filter_mask = 0;
4351	struct net_device *dev;
4352	struct nlattr *nla;
4353	int hdrlen, rem;
4354
4355	/* Same kernel<->userspace interface hack as in rtnl_dump_ifinfo. */
4356	hdrlen = nlmsg_len(nlh) < sizeof(struct ifinfomsg) ?
4357		 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg);
4358
4359	if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
4360		return NLMSG_GOODSIZE;
4361
4362	nla_for_each_attr_type(nla, IFLA_EXT_MASK,
4363			       nlmsg_attrdata(nlh, hdrlen),
4364			       nlmsg_attrlen(nlh, hdrlen), rem) {
4365		if (nla_len(nla) == sizeof(u32))
4366			ext_filter_mask = nla_get_u32(nla);
4367	}
4368
4369	if (!ext_filter_mask)
4370		return NLMSG_GOODSIZE;
4371	/*
4372	 * traverse the list of net devices and compute the minimum
4373	 * buffer size based upon the filter mask.
4374	 */
4375	rcu_read_lock();
4376	for_each_netdev_rcu(net, dev) {
4377		min_ifinfo_dump_size = max(min_ifinfo_dump_size,
4378					   if_nlmsg_size(dev, ext_filter_mask));
4379	}
4380	rcu_read_unlock();
4381
4382	return nlmsg_total_size(min_ifinfo_dump_size);
4383}
4384
4385static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb)
4386{
4387	int idx;
4388	int s_idx = cb->family;
4389	int type = cb->nlh->nlmsg_type - RTM_BASE;
4390	int ret = 0;
4391
4392	if (s_idx == 0)
4393		s_idx = 1;
4394
4395	for (idx = 1; idx <= RTNL_FAMILY_MAX; idx++) {
4396		struct rtnl_link __rcu **tab;
4397		struct rtnl_link *link;
4398		rtnl_dumpit_func dumpit;
4399
4400		if (idx < s_idx || idx == PF_PACKET)
4401			continue;
4402
4403		if (type < 0 || type >= RTM_NR_MSGTYPES)
4404			continue;
4405
4406		tab = rcu_dereference_rtnl(rtnl_msg_handlers[idx]);
4407		if (!tab)
4408			continue;
4409
4410		link = rcu_dereference_rtnl(tab[type]);
4411		if (!link)
4412			continue;
4413
4414		dumpit = link->dumpit;
4415		if (!dumpit)
4416			continue;
4417
4418		if (idx > s_idx) {
4419			memset(&cb->args[0], 0, sizeof(cb->args));
4420			cb->prev_seq = 0;
4421			cb->seq = 0;
4422		}
4423		ret = dumpit(skb, cb);
4424		if (ret)
4425			break;
4426	}
4427	cb->family = idx;
4428
4429	return skb->len ? : ret;
4430}
4431
4432struct sk_buff *rtmsg_ifinfo_build_skb(int type, struct net_device *dev,
4433				       unsigned int change,
4434				       u32 event, gfp_t flags, int *new_nsid,
4435				       int new_ifindex, u32 portid,
4436				       const struct nlmsghdr *nlh)
4437{
4438	struct net *net = dev_net(dev);
4439	struct sk_buff *skb;
4440	int err = -ENOBUFS;
4441	u32 seq = 0;
4442
4443	skb = nlmsg_new(if_nlmsg_size(dev, 0), flags);
4444	if (skb == NULL)
4445		goto errout;
4446
4447	if (nlmsg_report(nlh))
4448		seq = nlmsg_seq(nlh);
4449	else
4450		portid = 0;
4451
4452	err = rtnl_fill_ifinfo(skb, dev, dev_net(dev),
4453			       type, portid, seq, change, 0, 0, event,
4454			       new_nsid, new_ifindex, -1, flags);
4455	if (err < 0) {
4456		/* -EMSGSIZE implies BUG in if_nlmsg_size() */
4457		WARN_ON(err == -EMSGSIZE);
4458		kfree_skb(skb);
4459		goto errout;
4460	}
4461	return skb;
4462errout:
4463	rtnl_set_sk_err(net, RTNLGRP_LINK, err);
4464	return NULL;
4465}
4466
4467void rtmsg_ifinfo_send(struct sk_buff *skb, struct net_device *dev, gfp_t flags,
4468		       u32 portid, const struct nlmsghdr *nlh)
4469{
4470	struct net *net = dev_net(dev);
4471
4472	rtnl_notify(skb, net, portid, RTNLGRP_LINK, nlh, flags);
4473}
4474
4475static void rtmsg_ifinfo_event(int type, struct net_device *dev,
4476			       unsigned int change, u32 event,
4477			       gfp_t flags, int *new_nsid, int new_ifindex,
4478			       u32 portid, const struct nlmsghdr *nlh)
4479{
4480	struct sk_buff *skb;
4481
4482	if (dev->reg_state != NETREG_REGISTERED)
4483		return;
4484
4485	skb = rtmsg_ifinfo_build_skb(type, dev, change, event, flags, new_nsid,
4486				     new_ifindex, portid, nlh);
4487	if (skb)
4488		rtmsg_ifinfo_send(skb, dev, flags, portid, nlh);
4489}
4490
4491void rtmsg_ifinfo(int type, struct net_device *dev, unsigned int change,
4492		  gfp_t flags, u32 portid, const struct nlmsghdr *nlh)
4493{
4494	rtmsg_ifinfo_event(type, dev, change, rtnl_get_event(0), flags,
4495			   NULL, 0, portid, nlh);
4496}
4497
4498void rtmsg_ifinfo_newnet(int type, struct net_device *dev, unsigned int change,
4499			 gfp_t flags, int *new_nsid, int new_ifindex)
4500{
4501	rtmsg_ifinfo_event(type, dev, change, rtnl_get_event(0), flags,
4502			   new_nsid, new_ifindex, 0, NULL);
4503}
4504
4505static int nlmsg_populate_fdb_fill(struct sk_buff *skb,
4506				   struct net_device *dev,
4507				   u8 *addr, u16 vid, u32 pid, u32 seq,
4508				   int type, unsigned int flags,
4509				   int nlflags, u16 ndm_state)
4510{
4511	struct nlmsghdr *nlh;
4512	struct ndmsg *ndm;
4513
4514	nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), nlflags);
4515	if (!nlh)
4516		return -EMSGSIZE;
4517
4518	ndm = nlmsg_data(nlh);
4519	ndm->ndm_family  = AF_BRIDGE;
4520	ndm->ndm_pad1	 = 0;
4521	ndm->ndm_pad2    = 0;
4522	ndm->ndm_flags	 = flags;
4523	ndm->ndm_type	 = 0;
4524	ndm->ndm_ifindex = dev->ifindex;
4525	ndm->ndm_state   = ndm_state;
4526
4527	if (nla_put(skb, NDA_LLADDR, dev->addr_len, addr))
4528		goto nla_put_failure;
4529	if (vid)
4530		if (nla_put(skb, NDA_VLAN, sizeof(u16), &vid))
4531			goto nla_put_failure;
4532
4533	nlmsg_end(skb, nlh);
4534	return 0;
4535
4536nla_put_failure:
4537	nlmsg_cancel(skb, nlh);
4538	return -EMSGSIZE;
4539}
4540
4541static inline size_t rtnl_fdb_nlmsg_size(const struct net_device *dev)
4542{
4543	return NLMSG_ALIGN(sizeof(struct ndmsg)) +
4544	       nla_total_size(dev->addr_len) +	/* NDA_LLADDR */
4545	       nla_total_size(sizeof(u16)) +	/* NDA_VLAN */
4546	       0;
4547}
4548
4549static void rtnl_fdb_notify(struct net_device *dev, u8 *addr, u16 vid, int type,
4550			    u16 ndm_state)
4551{
4552	struct net *net = dev_net(dev);
4553	struct sk_buff *skb;
4554	int err = -ENOBUFS;
4555
4556	skb = nlmsg_new(rtnl_fdb_nlmsg_size(dev), GFP_ATOMIC);
4557	if (!skb)
4558		goto errout;
4559
4560	err = nlmsg_populate_fdb_fill(skb, dev, addr, vid,
4561				      0, 0, type, NTF_SELF, 0, ndm_state);
4562	if (err < 0) {
4563		kfree_skb(skb);
4564		goto errout;
4565	}
4566
4567	rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
4568	return;
4569errout:
4570	rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
4571}
4572
4573/*
4574 * ndo_dflt_fdb_add - default netdevice operation to add an FDB entry
4575 */
4576int ndo_dflt_fdb_add(struct ndmsg *ndm,
4577		     struct nlattr *tb[],
4578		     struct net_device *dev,
4579		     const unsigned char *addr, u16 vid,
4580		     u16 flags)
4581{
4582	int err = -EINVAL;
4583
4584	/* If aging addresses are supported device will need to
4585	 * implement its own handler for this.
4586	 */
4587	if (ndm->ndm_state && !(ndm->ndm_state & NUD_PERMANENT)) {
4588		netdev_info(dev, "default FDB implementation only supports local addresses\n");
4589		return err;
4590	}
4591
4592	if (tb[NDA_FLAGS_EXT]) {
4593		netdev_info(dev, "invalid flags given to default FDB implementation\n");
4594		return err;
4595	}
4596
4597	if (vid) {
4598		netdev_info(dev, "vlans aren't supported yet for dev_uc|mc_add()\n");
4599		return err;
4600	}
4601
4602	if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr))
4603		err = dev_uc_add_excl(dev, addr);
4604	else if (is_multicast_ether_addr(addr))
4605		err = dev_mc_add_excl(dev, addr);
4606
4607	/* Only return duplicate errors if NLM_F_EXCL is set */
4608	if (err == -EEXIST && !(flags & NLM_F_EXCL))
4609		err = 0;
4610
4611	return err;
4612}
4613EXPORT_SYMBOL(ndo_dflt_fdb_add);
4614
4615static int fdb_vid_parse(struct nlattr *vlan_attr, u16 *p_vid,
4616			 struct netlink_ext_ack *extack)
4617{
4618	u16 vid = 0;
4619
4620	if (vlan_attr) {
4621		if (nla_len(vlan_attr) != sizeof(u16)) {
4622			NL_SET_ERR_MSG(extack, "invalid vlan attribute size");
4623			return -EINVAL;
4624		}
4625
4626		vid = nla_get_u16(vlan_attr);
4627
4628		if (!vid || vid >= VLAN_VID_MASK) {
4629			NL_SET_ERR_MSG(extack, "invalid vlan id");
4630			return -EINVAL;
4631		}
4632	}
4633	*p_vid = vid;
4634	return 0;
4635}
4636
4637static int rtnl_fdb_add(struct sk_buff *skb, struct nlmsghdr *nlh,
4638			struct netlink_ext_ack *extack)
4639{
4640	struct net *net = sock_net(skb->sk);
4641	struct ndmsg *ndm;
4642	struct nlattr *tb[NDA_MAX+1];
4643	struct net_device *dev;
4644	u8 *addr;
4645	u16 vid;
4646	int err;
4647
4648	err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX, NULL,
4649				     extack);
4650	if (err < 0)
4651		return err;
4652
4653	ndm = nlmsg_data(nlh);
4654	if (ndm->ndm_ifindex == 0) {
4655		NL_SET_ERR_MSG(extack, "invalid ifindex");
4656		return -EINVAL;
4657	}
4658
4659	dev = __dev_get_by_index(net, ndm->ndm_ifindex);
4660	if (dev == NULL) {
4661		NL_SET_ERR_MSG(extack, "unknown ifindex");
4662		return -ENODEV;
4663	}
4664
4665	if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
4666		NL_SET_ERR_MSG(extack, "invalid address");
4667		return -EINVAL;
4668	}
4669
4670	if (dev->type != ARPHRD_ETHER) {
4671		NL_SET_ERR_MSG(extack, "FDB add only supported for Ethernet devices");
4672		return -EINVAL;
4673	}
4674
4675	addr = nla_data(tb[NDA_LLADDR]);
4676
4677	err = fdb_vid_parse(tb[NDA_VLAN], &vid, extack);
4678	if (err)
4679		return err;
4680
4681	err = -EOPNOTSUPP;
4682
4683	/* Support fdb on master device the net/bridge default case */
4684	if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) &&
4685	    netif_is_bridge_port(dev)) {
4686		struct net_device *br_dev = netdev_master_upper_dev_get(dev);
4687		const struct net_device_ops *ops = br_dev->netdev_ops;
4688		bool notified = false;
4689
4690		err = ops->ndo_fdb_add(ndm, tb, dev, addr, vid,
4691				       nlh->nlmsg_flags, &notified, extack);
4692		if (err)
4693			goto out;
4694		else
4695			ndm->ndm_flags &= ~NTF_MASTER;
4696	}
4697
4698	/* Embedded bridge, macvlan, and any other device support */
4699	if ((ndm->ndm_flags & NTF_SELF)) {
4700		bool notified = false;
4701
4702		if (dev->netdev_ops->ndo_fdb_add)
4703			err = dev->netdev_ops->ndo_fdb_add(ndm, tb, dev, addr,
4704							   vid,
4705							   nlh->nlmsg_flags,
4706							   &notified, extack);
4707		else
4708			err = ndo_dflt_fdb_add(ndm, tb, dev, addr, vid,
4709					       nlh->nlmsg_flags);
4710
4711		if (!err && !notified) {
4712			rtnl_fdb_notify(dev, addr, vid, RTM_NEWNEIGH,
4713					ndm->ndm_state);
4714			ndm->ndm_flags &= ~NTF_SELF;
4715		}
4716	}
4717out:
4718	return err;
4719}
4720
4721/*
4722 * ndo_dflt_fdb_del - default netdevice operation to delete an FDB entry
4723 */
4724int ndo_dflt_fdb_del(struct ndmsg *ndm,
4725		     struct nlattr *tb[],
4726		     struct net_device *dev,
4727		     const unsigned char *addr, u16 vid)
4728{
4729	int err = -EINVAL;
4730
4731	/* If aging addresses are supported device will need to
4732	 * implement its own handler for this.
4733	 */
4734	if (!(ndm->ndm_state & NUD_PERMANENT)) {
4735		netdev_info(dev, "default FDB implementation only supports local addresses\n");
4736		return err;
4737	}
4738
4739	if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr))
4740		err = dev_uc_del(dev, addr);
4741	else if (is_multicast_ether_addr(addr))
4742		err = dev_mc_del(dev, addr);
4743
4744	return err;
4745}
4746EXPORT_SYMBOL(ndo_dflt_fdb_del);
4747
4748static int rtnl_fdb_del(struct sk_buff *skb, struct nlmsghdr *nlh,
4749			struct netlink_ext_ack *extack)
4750{
4751	bool del_bulk = !!(nlh->nlmsg_flags & NLM_F_BULK);
4752	struct net *net = sock_net(skb->sk);
4753	const struct net_device_ops *ops;
4754	struct ndmsg *ndm;
4755	struct nlattr *tb[NDA_MAX+1];
4756	struct net_device *dev;
4757	__u8 *addr = NULL;
4758	int err;
4759	u16 vid;
4760
4761	if (!del_bulk) {
4762		err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX,
4763					     NULL, extack);
4764	} else {
4765		/* For bulk delete, the drivers will parse the message with
4766		 * policy.
4767		 */
4768		err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL, extack);
4769	}
4770	if (err < 0)
4771		return err;
4772
4773	ndm = nlmsg_data(nlh);
4774	if (ndm->ndm_ifindex == 0) {
4775		NL_SET_ERR_MSG(extack, "invalid ifindex");
4776		return -EINVAL;
4777	}
4778
4779	dev = __dev_get_by_index(net, ndm->ndm_ifindex);
4780	if (dev == NULL) {
4781		NL_SET_ERR_MSG(extack, "unknown ifindex");
4782		return -ENODEV;
4783	}
4784
4785	if (!del_bulk) {
4786		if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
4787			NL_SET_ERR_MSG(extack, "invalid address");
4788			return -EINVAL;
4789		}
4790		addr = nla_data(tb[NDA_LLADDR]);
4791
4792		err = fdb_vid_parse(tb[NDA_VLAN], &vid, extack);
4793		if (err)
4794			return err;
4795	}
4796
4797	if (dev->type != ARPHRD_ETHER) {
4798		NL_SET_ERR_MSG(extack, "FDB delete only supported for Ethernet devices");
4799		return -EINVAL;
4800	}
4801
4802	err = -EOPNOTSUPP;
4803
4804	/* Support fdb on master device the net/bridge default case */
4805	if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) &&
4806	    netif_is_bridge_port(dev)) {
4807		struct net_device *br_dev = netdev_master_upper_dev_get(dev);
4808		bool notified = false;
4809
4810		ops = br_dev->netdev_ops;
4811		if (!del_bulk) {
4812			if (ops->ndo_fdb_del)
4813				err = ops->ndo_fdb_del(ndm, tb, dev, addr, vid,
4814						       &notified, extack);
4815		} else {
4816			if (ops->ndo_fdb_del_bulk)
4817				err = ops->ndo_fdb_del_bulk(nlh, dev, extack);
4818		}
4819
4820		if (err)
4821			goto out;
4822		else
4823			ndm->ndm_flags &= ~NTF_MASTER;
4824	}
4825
4826	/* Embedded bridge, macvlan, and any other device support */
4827	if (ndm->ndm_flags & NTF_SELF) {
4828		bool notified = false;
4829
4830		ops = dev->netdev_ops;
4831		if (!del_bulk) {
4832			if (ops->ndo_fdb_del)
4833				err = ops->ndo_fdb_del(ndm, tb, dev, addr, vid,
4834						       &notified, extack);
4835			else
4836				err = ndo_dflt_fdb_del(ndm, tb, dev, addr, vid);
4837		} else {
4838			/* in case err was cleared by NTF_MASTER call */
4839			err = -EOPNOTSUPP;
4840			if (ops->ndo_fdb_del_bulk)
4841				err = ops->ndo_fdb_del_bulk(nlh, dev, extack);
4842		}
4843
4844		if (!err) {
4845			if (!del_bulk && !notified)
4846				rtnl_fdb_notify(dev, addr, vid, RTM_DELNEIGH,
4847						ndm->ndm_state);
4848			ndm->ndm_flags &= ~NTF_SELF;
4849		}
4850	}
4851out:
4852	return err;
4853}
4854
4855static int nlmsg_populate_fdb(struct sk_buff *skb,
4856			      struct netlink_callback *cb,
4857			      struct net_device *dev,
4858			      int *idx,
4859			      struct netdev_hw_addr_list *list)
4860{
4861	struct ndo_fdb_dump_context *ctx = (void *)cb->ctx;
4862	struct netdev_hw_addr *ha;
4863	u32 portid, seq;
4864	int err;
4865
4866	portid = NETLINK_CB(cb->skb).portid;
4867	seq = cb->nlh->nlmsg_seq;
4868
4869	list_for_each_entry(ha, &list->list, list) {
4870		if (*idx < ctx->fdb_idx)
4871			goto skip;
4872
4873		err = nlmsg_populate_fdb_fill(skb, dev, ha->addr, 0,
4874					      portid, seq,
4875					      RTM_NEWNEIGH, NTF_SELF,
4876					      NLM_F_MULTI, NUD_PERMANENT);
4877		if (err < 0)
4878			return err;
4879skip:
4880		*idx += 1;
4881	}
4882	return 0;
4883}
4884
4885/**
4886 * ndo_dflt_fdb_dump - default netdevice operation to dump an FDB table.
4887 * @skb: socket buffer to store message in
4888 * @cb: netlink callback
4889 * @dev: netdevice
4890 * @filter_dev: ignored
4891 * @idx: the number of FDB table entries dumped is added to *@idx
4892 *
4893 * Default netdevice operation to dump the existing unicast address list.
4894 * Returns number of addresses from list put in skb.
4895 */
4896int ndo_dflt_fdb_dump(struct sk_buff *skb,
4897		      struct netlink_callback *cb,
4898		      struct net_device *dev,
4899		      struct net_device *filter_dev,
4900		      int *idx)
4901{
4902	int err;
4903
4904	if (dev->type != ARPHRD_ETHER)
4905		return -EINVAL;
4906
4907	netif_addr_lock_bh(dev);
4908	err = nlmsg_populate_fdb(skb, cb, dev, idx, &dev->uc);
4909	if (err)
4910		goto out;
4911	err = nlmsg_populate_fdb(skb, cb, dev, idx, &dev->mc);
4912out:
4913	netif_addr_unlock_bh(dev);
4914	return err;
4915}
4916EXPORT_SYMBOL(ndo_dflt_fdb_dump);
4917
4918static int valid_fdb_dump_strict(const struct nlmsghdr *nlh,
4919				 int *br_idx, int *brport_idx,
4920				 struct netlink_ext_ack *extack)
4921{
4922	struct nlattr *tb[NDA_MAX + 1];
4923	struct ndmsg *ndm;
4924	int err, i;
4925
4926	ndm = nlmsg_payload(nlh, sizeof(*ndm));
4927	if (!ndm) {
4928		NL_SET_ERR_MSG(extack, "Invalid header for fdb dump request");
4929		return -EINVAL;
4930	}
4931
4932	if (ndm->ndm_pad1  || ndm->ndm_pad2  || ndm->ndm_state ||
4933	    ndm->ndm_flags || ndm->ndm_type) {
4934		NL_SET_ERR_MSG(extack, "Invalid values in header for fdb dump request");
4935		return -EINVAL;
4936	}
4937
4938	err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct ndmsg), tb,
4939					    NDA_MAX, NULL, extack);
4940	if (err < 0)
4941		return err;
4942
4943	*brport_idx = ndm->ndm_ifindex;
4944	for (i = 0; i <= NDA_MAX; ++i) {
4945		if (!tb[i])
4946			continue;
4947
4948		switch (i) {
4949		case NDA_IFINDEX:
4950			if (nla_len(tb[i]) != sizeof(u32)) {
4951				NL_SET_ERR_MSG(extack, "Invalid IFINDEX attribute in fdb dump request");
4952				return -EINVAL;
4953			}
4954			*brport_idx = nla_get_u32(tb[NDA_IFINDEX]);
4955			break;
4956		case NDA_MASTER:
4957			if (nla_len(tb[i]) != sizeof(u32)) {
4958				NL_SET_ERR_MSG(extack, "Invalid MASTER attribute in fdb dump request");
4959				return -EINVAL;
4960			}
4961			*br_idx = nla_get_u32(tb[NDA_MASTER]);
4962			break;
4963		default:
4964			NL_SET_ERR_MSG(extack, "Unsupported attribute in fdb dump request");
4965			return -EINVAL;
4966		}
4967	}
4968
4969	return 0;
4970}
4971
4972static int valid_fdb_dump_legacy(const struct nlmsghdr *nlh,
4973				 int *br_idx, int *brport_idx,
4974				 struct netlink_ext_ack *extack)
4975{
4976	struct nlattr *tb[IFLA_MAX+1];
4977	int err;
4978
4979	/* A hack to preserve kernel<->userspace interface.
4980	 * Before Linux v4.12 this code accepted ndmsg since iproute2 v3.3.0.
4981	 * However, ndmsg is shorter than ifinfomsg thus nlmsg_parse() bails.
4982	 * So, check for ndmsg with an optional u32 attribute (not used here).
4983	 * Fortunately these sizes don't conflict with the size of ifinfomsg
4984	 * with an optional attribute.
4985	 */
4986	if (nlmsg_len(nlh) != sizeof(struct ndmsg) &&
4987	    (nlmsg_len(nlh) != sizeof(struct ndmsg) +
4988	     nla_attr_size(sizeof(u32)))) {
4989		struct ifinfomsg *ifm;
4990
4991		err = nlmsg_parse_deprecated(nlh, sizeof(struct ifinfomsg),
4992					     tb, IFLA_MAX, ifla_policy,
4993					     extack);
4994		if (err < 0) {
4995			return -EINVAL;
4996		} else if (err == 0) {
4997			if (tb[IFLA_MASTER])
4998				*br_idx = nla_get_u32(tb[IFLA_MASTER]);
4999		}
5000
5001		ifm = nlmsg_data(nlh);
5002		*brport_idx = ifm->ifi_index;
5003	}
5004	return 0;
5005}
5006
5007static int rtnl_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb)
5008{
5009	const struct net_device_ops *ops = NULL, *cops = NULL;
5010	struct ndo_fdb_dump_context *ctx = (void *)cb->ctx;
5011	struct net_device *dev, *br_dev = NULL;
5012	struct net *net = sock_net(skb->sk);
5013	int brport_idx = 0;
5014	int br_idx = 0;
5015	int fidx = 0;
5016	int err;
5017
5018	NL_ASSERT_CTX_FITS(struct ndo_fdb_dump_context);
5019
5020	if (cb->strict_check)
5021		err = valid_fdb_dump_strict(cb->nlh, &br_idx, &brport_idx,
5022					    cb->extack);
5023	else
5024		err = valid_fdb_dump_legacy(cb->nlh, &br_idx, &brport_idx,
5025					    cb->extack);
5026	if (err < 0)
5027		return err;
5028
5029	if (br_idx) {
5030		br_dev = __dev_get_by_index(net, br_idx);
5031		if (!br_dev)
5032			return -ENODEV;
5033
5034		ops = br_dev->netdev_ops;
5035	}
5036
5037	for_each_netdev_dump(net, dev, ctx->ifindex) {
5038		if (brport_idx && (dev->ifindex != brport_idx))
5039			continue;
5040
5041		if (!br_idx) { /* user did not specify a specific bridge */
5042			if (netif_is_bridge_port(dev)) {
5043				br_dev = netdev_master_upper_dev_get(dev);
5044				cops = br_dev->netdev_ops;
5045			}
5046		} else {
5047			if (dev != br_dev &&
5048			    !netif_is_bridge_port(dev))
5049				continue;
5050
5051			if (br_dev != netdev_master_upper_dev_get(dev) &&
5052			    !netif_is_bridge_master(dev))
5053				continue;
5054			cops = ops;
5055		}
5056
5057		if (netif_is_bridge_port(dev)) {
5058			if (cops && cops->ndo_fdb_dump) {
5059				err = cops->ndo_fdb_dump(skb, cb, br_dev, dev,
5060							&fidx);
5061				if (err == -EMSGSIZE)
5062					break;
5063			}
5064		}
5065
5066		if (dev->netdev_ops->ndo_fdb_dump)
5067			err = dev->netdev_ops->ndo_fdb_dump(skb, cb, dev, NULL,
5068							    &fidx);
5069		else
5070			err = ndo_dflt_fdb_dump(skb, cb, dev, NULL, &fidx);
5071		if (err == -EMSGSIZE)
5072			break;
5073
5074		cops = NULL;
5075
5076		/* reset fdb offset to 0 for rest of the interfaces */
5077		ctx->fdb_idx = 0;
5078		fidx = 0;
5079	}
5080
5081	ctx->fdb_idx = fidx;
5082
5083	return skb->len;
5084}
5085
5086static int valid_fdb_get_strict(const struct nlmsghdr *nlh,
5087				struct nlattr **tb, u8 *ndm_flags,
5088				int *br_idx, int *brport_idx, u8 **addr,
5089				u16 *vid, struct netlink_ext_ack *extack)
5090{
5091	struct ndmsg *ndm;
5092	int err, i;
5093
5094	ndm = nlmsg_payload(nlh, sizeof(*ndm));
5095	if (!ndm) {
5096		NL_SET_ERR_MSG(extack, "Invalid header for fdb get request");
5097		return -EINVAL;
5098	}
5099
5100	if (ndm->ndm_pad1  || ndm->ndm_pad2  || ndm->ndm_state ||
5101	    ndm->ndm_type) {
5102		NL_SET_ERR_MSG(extack, "Invalid values in header for fdb get request");
5103		return -EINVAL;
5104	}
5105
5106	if (ndm->ndm_flags & ~(NTF_MASTER | NTF_SELF)) {
5107		NL_SET_ERR_MSG(extack, "Invalid flags in header for fdb get request");
5108		return -EINVAL;
5109	}
5110
5111	err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct ndmsg), tb,
5112					    NDA_MAX, nda_policy, extack);
5113	if (err < 0)
5114		return err;
5115
5116	*ndm_flags = ndm->ndm_flags;
5117	*brport_idx = ndm->ndm_ifindex;
5118	for (i = 0; i <= NDA_MAX; ++i) {
5119		if (!tb[i])
5120			continue;
5121
5122		switch (i) {
5123		case NDA_MASTER:
5124			*br_idx = nla_get_u32(tb[i]);
5125			break;
5126		case NDA_LLADDR:
5127			if (nla_len(tb[i]) != ETH_ALEN) {
5128				NL_SET_ERR_MSG(extack, "Invalid address in fdb get request");
5129				return -EINVAL;
5130			}
5131			*addr = nla_data(tb[i]);
5132			break;
5133		case NDA_VLAN:
5134			err = fdb_vid_parse(tb[i], vid, extack);
5135			if (err)
5136				return err;
5137			break;
5138		case NDA_VNI:
5139			break;
5140		default:
5141			NL_SET_ERR_MSG(extack, "Unsupported attribute in fdb get request");
5142			return -EINVAL;
5143		}
5144	}
5145
5146	return 0;
5147}
5148
5149static int rtnl_fdb_get(struct sk_buff *in_skb, struct nlmsghdr *nlh,
5150			struct netlink_ext_ack *extack)
5151{
5152	struct net_device *dev = NULL, *br_dev = NULL;
5153	const struct net_device_ops *ops = NULL;
5154	struct net *net = sock_net(in_skb->sk);
5155	struct nlattr *tb[NDA_MAX + 1];
5156	struct sk_buff *skb;
5157	int brport_idx = 0;
5158	u8 ndm_flags = 0;
5159	int br_idx = 0;
5160	u8 *addr = NULL;
5161	u16 vid = 0;
5162	int err;
5163
5164	err = valid_fdb_get_strict(nlh, tb, &ndm_flags, &br_idx,
5165				   &brport_idx, &addr, &vid, extack);
5166	if (err < 0)
5167		return err;
5168
5169	if (!addr) {
5170		NL_SET_ERR_MSG(extack, "Missing lookup address for fdb get request");
5171		return -EINVAL;
5172	}
5173
5174	if (brport_idx) {
5175		dev = __dev_get_by_index(net, brport_idx);
5176		if (!dev) {
5177			NL_SET_ERR_MSG(extack, "Unknown device ifindex");
5178			return -ENODEV;
5179		}
5180	}
5181
5182	if (br_idx) {
5183		if (dev) {
5184			NL_SET_ERR_MSG(extack, "Master and device are mutually exclusive");
5185			return -EINVAL;
5186		}
5187
5188		br_dev = __dev_get_by_index(net, br_idx);
5189		if (!br_dev) {
5190			NL_SET_ERR_MSG(extack, "Invalid master ifindex");
5191			return -EINVAL;
5192		}
5193		ops = br_dev->netdev_ops;
5194	}
5195
5196	if (dev) {
5197		if (!ndm_flags || (ndm_flags & NTF_MASTER)) {
5198			if (!netif_is_bridge_port(dev)) {
5199				NL_SET_ERR_MSG(extack, "Device is not a bridge port");
5200				return -EINVAL;
5201			}
5202			br_dev = netdev_master_upper_dev_get(dev);
5203			if (!br_dev) {
5204				NL_SET_ERR_MSG(extack, "Master of device not found");
5205				return -EINVAL;
5206			}
5207			ops = br_dev->netdev_ops;
5208		} else {
5209			if (!(ndm_flags & NTF_SELF)) {
5210				NL_SET_ERR_MSG(extack, "Missing NTF_SELF");
5211				return -EINVAL;
5212			}
5213			ops = dev->netdev_ops;
5214		}
5215	}
5216
5217	if (!br_dev && !dev) {
5218		NL_SET_ERR_MSG(extack, "No device specified");
5219		return -ENODEV;
5220	}
5221
5222	if (!ops || !ops->ndo_fdb_get) {
5223		NL_SET_ERR_MSG(extack, "Fdb get operation not supported by device");
5224		return -EOPNOTSUPP;
5225	}
5226
5227	skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
5228	if (!skb)
5229		return -ENOBUFS;
5230
5231	if (br_dev)
5232		dev = br_dev;
5233	err = ops->ndo_fdb_get(skb, tb, dev, addr, vid,
5234			       NETLINK_CB(in_skb).portid,
5235			       nlh->nlmsg_seq, extack);
5236	if (err)
5237		goto out;
5238
5239	return rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
5240out:
5241	kfree_skb(skb);
5242	return err;
5243}
5244
5245static int brport_nla_put_flag(struct sk_buff *skb, u32 flags, u32 mask,
5246			       unsigned int attrnum, unsigned int flag)
5247{
5248	if (mask & flag)
5249		return nla_put_u8(skb, attrnum, !!(flags & flag));
5250	return 0;
5251}
5252
5253int ndo_dflt_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
5254			    struct net_device *dev, u16 mode,
5255			    u32 flags, u32 mask, int nlflags,
5256			    u32 filter_mask,
5257			    int (*vlan_fill)(struct sk_buff *skb,
5258					     struct net_device *dev,
5259					     u32 filter_mask))
5260{
5261	struct nlmsghdr *nlh;
5262	struct ifinfomsg *ifm;
5263	struct nlattr *br_afspec;
5264	struct nlattr *protinfo;
5265	u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN;
5266	struct net_device *br_dev = netdev_master_upper_dev_get(dev);
5267	int err = 0;
5268
5269	nlh = nlmsg_put(skb, pid, seq, RTM_NEWLINK, sizeof(*ifm), nlflags);
5270	if (nlh == NULL)
5271		return -EMSGSIZE;
5272
5273	ifm = nlmsg_data(nlh);
5274	ifm->ifi_family = AF_BRIDGE;
5275	ifm->__ifi_pad = 0;
5276	ifm->ifi_type = dev->type;
5277	ifm->ifi_index = dev->ifindex;
5278	ifm->ifi_flags = netif_get_flags(dev);
5279	ifm->ifi_change = 0;
5280
5281
5282	if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
5283	    nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
5284	    nla_put_u8(skb, IFLA_OPERSTATE, operstate) ||
5285	    (br_dev &&
5286	     nla_put_u32(skb, IFLA_MASTER, br_dev->ifindex)) ||
5287	    (dev->addr_len &&
5288	     nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
5289	    (dev->ifindex != dev_get_iflink(dev) &&
5290	     nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))))
5291		goto nla_put_failure;
5292
5293	br_afspec = nla_nest_start_noflag(skb, IFLA_AF_SPEC);
5294	if (!br_afspec)
5295		goto nla_put_failure;
5296
5297	if (nla_put_u16(skb, IFLA_BRIDGE_FLAGS, BRIDGE_FLAGS_SELF)) {
5298		nla_nest_cancel(skb, br_afspec);
5299		goto nla_put_failure;
5300	}
5301
5302	if (mode != BRIDGE_MODE_UNDEF) {
5303		if (nla_put_u16(skb, IFLA_BRIDGE_MODE, mode)) {
5304			nla_nest_cancel(skb, br_afspec);
5305			goto nla_put_failure;
5306		}
5307	}
5308	if (vlan_fill) {
5309		err = vlan_fill(skb, dev, filter_mask);
5310		if (err) {
5311			nla_nest_cancel(skb, br_afspec);
5312			goto nla_put_failure;
5313		}
5314	}
5315	nla_nest_end(skb, br_afspec);
5316
5317	protinfo = nla_nest_start(skb, IFLA_PROTINFO);
5318	if (!protinfo)
5319		goto nla_put_failure;
5320
5321	if (brport_nla_put_flag(skb, flags, mask,
5322				IFLA_BRPORT_MODE, BR_HAIRPIN_MODE) ||
5323	    brport_nla_put_flag(skb, flags, mask,
5324				IFLA_BRPORT_GUARD, BR_BPDU_GUARD) ||
5325	    brport_nla_put_flag(skb, flags, mask,
5326				IFLA_BRPORT_FAST_LEAVE,
5327				BR_MULTICAST_FAST_LEAVE) ||
5328	    brport_nla_put_flag(skb, flags, mask,
5329				IFLA_BRPORT_PROTECT, BR_ROOT_BLOCK) ||
5330	    brport_nla_put_flag(skb, flags, mask,
5331				IFLA_BRPORT_LEARNING, BR_LEARNING) ||
5332	    brport_nla_put_flag(skb, flags, mask,
5333				IFLA_BRPORT_LEARNING_SYNC, BR_LEARNING_SYNC) ||
5334	    brport_nla_put_flag(skb, flags, mask,
5335				IFLA_BRPORT_UNICAST_FLOOD, BR_FLOOD) ||
5336	    brport_nla_put_flag(skb, flags, mask,
5337				IFLA_BRPORT_PROXYARP, BR_PROXYARP) ||
5338	    brport_nla_put_flag(skb, flags, mask,
5339				IFLA_BRPORT_MCAST_FLOOD, BR_MCAST_FLOOD) ||
5340	    brport_nla_put_flag(skb, flags, mask,
5341				IFLA_BRPORT_BCAST_FLOOD, BR_BCAST_FLOOD)) {
5342		nla_nest_cancel(skb, protinfo);
5343		goto nla_put_failure;
5344	}
5345
5346	nla_nest_end(skb, protinfo);
5347
5348	nlmsg_end(skb, nlh);
5349	return 0;
5350nla_put_failure:
5351	nlmsg_cancel(skb, nlh);
5352	return err ? err : -EMSGSIZE;
5353}
5354EXPORT_SYMBOL_GPL(ndo_dflt_bridge_getlink);
5355
5356static int valid_bridge_getlink_req(const struct nlmsghdr *nlh,
5357				    bool strict_check, u32 *filter_mask,
5358				    struct netlink_ext_ack *extack)
5359{
5360	struct nlattr *tb[IFLA_MAX+1];
5361	int err, i;
5362
5363	if (strict_check) {
5364		struct ifinfomsg *ifm;
5365
5366		ifm = nlmsg_payload(nlh, sizeof(*ifm));
5367		if (!ifm) {
5368			NL_SET_ERR_MSG(extack, "Invalid header for bridge link dump");
5369			return -EINVAL;
5370		}
5371
5372		if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
5373		    ifm->ifi_change || ifm->ifi_index) {
5374			NL_SET_ERR_MSG(extack, "Invalid values in header for bridge link dump request");
5375			return -EINVAL;
5376		}
5377
5378		err = nlmsg_parse_deprecated_strict(nlh,
5379						    sizeof(struct ifinfomsg),
5380						    tb, IFLA_MAX, ifla_policy,
5381						    extack);
5382	} else {
5383		err = nlmsg_parse_deprecated(nlh, sizeof(struct ifinfomsg),
5384					     tb, IFLA_MAX, ifla_policy,
5385					     extack);
5386	}
5387	if (err < 0)
5388		return err;
5389
5390	/* new attributes should only be added with strict checking */
5391	for (i = 0; i <= IFLA_MAX; ++i) {
5392		if (!tb[i])
5393			continue;
5394
5395		switch (i) {
5396		case IFLA_EXT_MASK:
5397			*filter_mask = nla_get_u32(tb[i]);
5398			break;
5399		default:
5400			if (strict_check) {
5401				NL_SET_ERR_MSG(extack, "Unsupported attribute in bridge link dump request");
5402				return -EINVAL;
5403			}
5404		}
5405	}
5406
5407	return 0;
5408}
5409
5410static int rtnl_bridge_getlink(struct sk_buff *skb, struct netlink_callback *cb)
5411{
5412	const struct nlmsghdr *nlh = cb->nlh;
5413	struct net *net = sock_net(skb->sk);
5414	struct net_device *dev;
5415	int idx = 0;
5416	u32 portid = NETLINK_CB(cb->skb).portid;
5417	u32 seq = nlh->nlmsg_seq;
5418	u32 filter_mask = 0;
5419	int err;
5420
5421	err = valid_bridge_getlink_req(nlh, cb->strict_check, &filter_mask,
5422				       cb->extack);
5423	if (err < 0 && cb->strict_check)
5424		return err;
5425
5426	rcu_read_lock();
5427	for_each_netdev_rcu(net, dev) {
5428		const struct net_device_ops *ops = dev->netdev_ops;
5429		struct net_device *br_dev = netdev_master_upper_dev_get(dev);
5430
5431		if (br_dev && br_dev->netdev_ops->ndo_bridge_getlink) {
5432			if (idx >= cb->args[0]) {
5433				err = br_dev->netdev_ops->ndo_bridge_getlink(
5434						skb, portid, seq, dev,
5435						filter_mask, NLM_F_MULTI);
5436				if (err < 0 && err != -EOPNOTSUPP) {
5437					if (likely(skb->len))
5438						break;
5439
5440					goto out_err;
5441				}
5442			}
5443			idx++;
5444		}
5445
5446		if (ops->ndo_bridge_getlink) {
5447			if (idx >= cb->args[0]) {
5448				err = ops->ndo_bridge_getlink(skb, portid,
5449							      seq, dev,
5450							      filter_mask,
5451							      NLM_F_MULTI);
5452				if (err < 0 && err != -EOPNOTSUPP) {
5453					if (likely(skb->len))
5454						break;
5455
5456					goto out_err;
5457				}
5458			}
5459			idx++;
5460		}
5461	}
5462	err = skb->len;
5463out_err:
5464	rcu_read_unlock();
5465	cb->args[0] = idx;
5466
5467	return err;
5468}
5469
5470static inline size_t bridge_nlmsg_size(void)
5471{
5472	return NLMSG_ALIGN(sizeof(struct ifinfomsg))
5473		+ nla_total_size(IFNAMSIZ)	/* IFLA_IFNAME */
5474		+ nla_total_size(MAX_ADDR_LEN)	/* IFLA_ADDRESS */
5475		+ nla_total_size(sizeof(u32))	/* IFLA_MASTER */
5476		+ nla_total_size(sizeof(u32))	/* IFLA_MTU */
5477		+ nla_total_size(sizeof(u32))	/* IFLA_LINK */
5478		+ nla_total_size(sizeof(u32))	/* IFLA_OPERSTATE */
5479		+ nla_total_size(sizeof(u8))	/* IFLA_PROTINFO */
5480		+ nla_total_size(sizeof(struct nlattr))	/* IFLA_AF_SPEC */
5481		+ nla_total_size(sizeof(u16))	/* IFLA_BRIDGE_FLAGS */
5482		+ nla_total_size(sizeof(u16));	/* IFLA_BRIDGE_MODE */
5483}
5484
5485static int rtnl_bridge_notify(struct net_device *dev)
5486{
5487	struct net *net = dev_net(dev);
5488	struct sk_buff *skb;
5489	int err = -EOPNOTSUPP;
5490
5491	if (!dev->netdev_ops->ndo_bridge_getlink)
5492		return 0;
5493
5494	skb = nlmsg_new(bridge_nlmsg_size(), GFP_ATOMIC);
5495	if (!skb) {
5496		err = -ENOMEM;
5497		goto errout;
5498	}
5499
5500	err = dev->netdev_ops->ndo_bridge_getlink(skb, 0, 0, dev, 0, 0);
5501	if (err < 0)
5502		goto errout;
5503
5504	/* Notification info is only filled for bridge ports, not the bridge
5505	 * device itself. Therefore, a zero notification length is valid and
5506	 * should not result in an error.
5507	 */
5508	if (!skb->len)
5509		goto errout;
5510
5511	rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
5512	return 0;
5513errout:
5514	WARN_ON(err == -EMSGSIZE);
5515	kfree_skb(skb);
5516	if (err)
5517		rtnl_set_sk_err(net, RTNLGRP_LINK, err);
5518	return err;
5519}
5520
5521static int rtnl_bridge_setlink(struct sk_buff *skb, struct nlmsghdr *nlh,
5522			       struct netlink_ext_ack *extack)
5523{
5524	struct net *net = sock_net(skb->sk);
5525	struct ifinfomsg *ifm;
5526	struct net_device *dev;
5527	struct nlattr *br_spec, *attr, *br_flags_attr = NULL;
5528	int rem, err = -EOPNOTSUPP;
5529	u16 flags = 0;
5530
5531	if (nlmsg_len(nlh) < sizeof(*ifm))
5532		return -EINVAL;
5533
5534	ifm = nlmsg_data(nlh);
5535	if (ifm->ifi_family != AF_BRIDGE)
5536		return -EPFNOSUPPORT;
5537
5538	dev = __dev_get_by_index(net, ifm->ifi_index);
5539	if (!dev) {
5540		NL_SET_ERR_MSG(extack, "unknown ifindex");
5541		return -ENODEV;
5542	}
5543
5544	br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
5545	if (br_spec) {
5546		nla_for_each_nested(attr, br_spec, rem) {
5547			if (nla_type(attr) == IFLA_BRIDGE_FLAGS && !br_flags_attr) {
5548				if (nla_len(attr) < sizeof(flags))
5549					return -EINVAL;
5550
5551				br_flags_attr = attr;
5552				flags = nla_get_u16(attr);
5553			}
5554
5555			if (nla_type(attr) == IFLA_BRIDGE_MODE) {
5556				if (nla_len(attr) < sizeof(u16))
5557					return -EINVAL;
5558			}
5559		}
5560	}
5561
5562	if (!flags || (flags & BRIDGE_FLAGS_MASTER)) {
5563		struct net_device *br_dev = netdev_master_upper_dev_get(dev);
5564
5565		if (!br_dev || !br_dev->netdev_ops->ndo_bridge_setlink) {
5566			err = -EOPNOTSUPP;
5567			goto out;
5568		}
5569
5570		err = br_dev->netdev_ops->ndo_bridge_setlink(dev, nlh, flags,
5571							     extack);
5572		if (err)
5573			goto out;
5574
5575		flags &= ~BRIDGE_FLAGS_MASTER;
5576	}
5577
5578	if ((flags & BRIDGE_FLAGS_SELF)) {
5579		if (!dev->netdev_ops->ndo_bridge_setlink)
5580			err = -EOPNOTSUPP;
5581		else
5582			err = dev->netdev_ops->ndo_bridge_setlink(dev, nlh,
5583								  flags,
5584								  extack);
5585		if (!err) {
5586			flags &= ~BRIDGE_FLAGS_SELF;
5587
5588			/* Generate event to notify upper layer of bridge
5589			 * change
5590			 */
5591			err = rtnl_bridge_notify(dev);
5592		}
5593	}
5594
5595	if (br_flags_attr)
5596		memcpy(nla_data(br_flags_attr), &flags, sizeof(flags));
5597out:
5598	return err;
5599}
5600
5601static int rtnl_bridge_dellink(struct sk_buff *skb, struct nlmsghdr *nlh,
5602			       struct netlink_ext_ack *extack)
5603{
5604	struct net *net = sock_net(skb->sk);
5605	struct ifinfomsg *ifm;
5606	struct net_device *dev;
5607	struct nlattr *br_spec, *attr = NULL;
5608	int rem, err = -EOPNOTSUPP;
5609	u16 flags = 0;
5610	bool have_flags = false;
5611
5612	if (nlmsg_len(nlh) < sizeof(*ifm))
5613		return -EINVAL;
5614
5615	ifm = nlmsg_data(nlh);
5616	if (ifm->ifi_family != AF_BRIDGE)
5617		return -EPFNOSUPPORT;
5618
5619	dev = __dev_get_by_index(net, ifm->ifi_index);
5620	if (!dev) {
5621		NL_SET_ERR_MSG(extack, "unknown ifindex");
5622		return -ENODEV;
5623	}
5624
5625	br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
5626	if (br_spec) {
5627		nla_for_each_nested_type(attr, IFLA_BRIDGE_FLAGS, br_spec,
5628					 rem) {
5629			if (nla_len(attr) < sizeof(flags))
5630				return -EINVAL;
5631
5632			have_flags = true;
5633			flags = nla_get_u16(attr);
5634			break;
5635		}
5636	}
5637
5638	if (!flags || (flags & BRIDGE_FLAGS_MASTER)) {
5639		struct net_device *br_dev = netdev_master_upper_dev_get(dev);
5640
5641		if (!br_dev || !br_dev->netdev_ops->ndo_bridge_dellink) {
5642			err = -EOPNOTSUPP;
5643			goto out;
5644		}
5645
5646		err = br_dev->netdev_ops->ndo_bridge_dellink(dev, nlh, flags);
5647		if (err)
5648			goto out;
5649
5650		flags &= ~BRIDGE_FLAGS_MASTER;
5651	}
5652
5653	if ((flags & BRIDGE_FLAGS_SELF)) {
5654		if (!dev->netdev_ops->ndo_bridge_dellink)
5655			err = -EOPNOTSUPP;
5656		else
5657			err = dev->netdev_ops->ndo_bridge_dellink(dev, nlh,
5658								  flags);
5659
5660		if (!err) {
5661			flags &= ~BRIDGE_FLAGS_SELF;
5662
5663			/* Generate event to notify upper layer of bridge
5664			 * change
5665			 */
5666			err = rtnl_bridge_notify(dev);
5667		}
5668	}
5669
5670	if (have_flags)
5671		memcpy(nla_data(attr), &flags, sizeof(flags));
5672out:
5673	return err;
5674}
5675
5676static bool stats_attr_valid(unsigned int mask, int attrid, int idxattr)
5677{
5678	return (mask & IFLA_STATS_FILTER_BIT(attrid)) &&
5679	       (!idxattr || idxattr == attrid);
5680}
5681
5682static bool
5683rtnl_offload_xstats_have_ndo(const struct net_device *dev, int attr_id)
5684{
5685	return dev->netdev_ops &&
5686	       dev->netdev_ops->ndo_has_offload_stats &&
5687	       dev->netdev_ops->ndo_get_offload_stats &&
5688	       dev->netdev_ops->ndo_has_offload_stats(dev, attr_id);
5689}
5690
5691static unsigned int
5692rtnl_offload_xstats_get_size_ndo(const struct net_device *dev, int attr_id)
5693{
5694	return rtnl_offload_xstats_have_ndo(dev, attr_id) ?
5695	       sizeof(struct rtnl_link_stats64) : 0;
5696}
5697
5698static int
5699rtnl_offload_xstats_fill_ndo(struct net_device *dev, int attr_id,
5700			     struct sk_buff *skb)
5701{
5702	unsigned int size = rtnl_offload_xstats_get_size_ndo(dev, attr_id);
5703	struct nlattr *attr = NULL;
5704	void *attr_data;
5705	int err;
5706
5707	if (!size)
5708		return -ENODATA;
5709
5710	attr = nla_reserve_64bit(skb, attr_id, size,
5711				 IFLA_OFFLOAD_XSTATS_UNSPEC);
5712	if (!attr)
5713		return -EMSGSIZE;
5714
5715	attr_data = nla_data(attr);
5716	memset(attr_data, 0, size);
5717
5718	err = dev->netdev_ops->ndo_get_offload_stats(attr_id, dev, attr_data);
5719	if (err)
5720		return err;
5721
5722	return 0;
5723}
5724
5725static unsigned int
5726rtnl_offload_xstats_get_size_stats(const struct net_device *dev,
5727				   enum netdev_offload_xstats_type type)
5728{
5729	bool enabled = netdev_offload_xstats_enabled(dev, type);
5730
5731	return enabled ? sizeof(struct rtnl_hw_stats64) : 0;
5732}
5733
5734struct rtnl_offload_xstats_request_used {
5735	bool request;
5736	bool used;
5737};
5738
5739static int
5740rtnl_offload_xstats_get_stats(struct net_device *dev,
5741			      enum netdev_offload_xstats_type type,
5742			      struct rtnl_offload_xstats_request_used *ru,
5743			      struct rtnl_hw_stats64 *stats,
5744			      struct netlink_ext_ack *extack)
5745{
5746	bool request;
5747	bool used;
5748	int err;
5749
5750	request = netdev_offload_xstats_enabled(dev, type);
5751	if (!request) {
5752		used = false;
5753		goto out;
5754	}
5755
5756	err = netdev_offload_xstats_get(dev, type, stats, &used, extack);
5757	if (err)
5758		return err;
5759
5760out:
5761	if (ru) {
5762		ru->request = request;
5763		ru->used = used;
5764	}
5765	return 0;
5766}
5767
5768static int
5769rtnl_offload_xstats_fill_hw_s_info_one(struct sk_buff *skb, int attr_id,
5770				       struct rtnl_offload_xstats_request_used *ru)
5771{
5772	struct nlattr *nest;
5773
5774	nest = nla_nest_start(skb, attr_id);
5775	if (!nest)
5776		return -EMSGSIZE;
5777
5778	if (nla_put_u8(skb, IFLA_OFFLOAD_XSTATS_HW_S_INFO_REQUEST, ru->request))
5779		goto nla_put_failure;
5780
5781	if (nla_put_u8(skb, IFLA_OFFLOAD_XSTATS_HW_S_INFO_USED, ru->used))
5782		goto nla_put_failure;
5783
5784	nla_nest_end(skb, nest);
5785	return 0;
5786
5787nla_put_failure:
5788	nla_nest_cancel(skb, nest);
5789	return -EMSGSIZE;
5790}
5791
5792static int
5793rtnl_offload_xstats_fill_hw_s_info(struct sk_buff *skb, struct net_device *dev,
5794				   struct netlink_ext_ack *extack)
5795{
5796	enum netdev_offload_xstats_type t_l3 = NETDEV_OFFLOAD_XSTATS_TYPE_L3;
5797	struct rtnl_offload_xstats_request_used ru_l3;
5798	struct nlattr *nest;
5799	int err;
5800
5801	err = rtnl_offload_xstats_get_stats(dev, t_l3, &ru_l3, NULL, extack);
5802	if (err)
5803		return err;
5804
5805	nest = nla_nest_start(skb, IFLA_OFFLOAD_XSTATS_HW_S_INFO);
5806	if (!nest)
5807		return -EMSGSIZE;
5808
5809	if (rtnl_offload_xstats_fill_hw_s_info_one(skb,
5810						   IFLA_OFFLOAD_XSTATS_L3_STATS,
5811						   &ru_l3))
5812		goto nla_put_failure;
5813
5814	nla_nest_end(skb, nest);
5815	return 0;
5816
5817nla_put_failure:
5818	nla_nest_cancel(skb, nest);
5819	return -EMSGSIZE;
5820}
5821
5822static int rtnl_offload_xstats_fill(struct sk_buff *skb, struct net_device *dev,
5823				    int *prividx, u32 off_filter_mask,
5824				    struct netlink_ext_ack *extack)
5825{
5826	enum netdev_offload_xstats_type t_l3 = NETDEV_OFFLOAD_XSTATS_TYPE_L3;
5827	int attr_id_hw_s_info = IFLA_OFFLOAD_XSTATS_HW_S_INFO;
5828	int attr_id_l3_stats = IFLA_OFFLOAD_XSTATS_L3_STATS;
5829	int attr_id_cpu_hit = IFLA_OFFLOAD_XSTATS_CPU_HIT;
5830	bool have_data = false;
5831	int err;
5832
5833	if (*prividx <= attr_id_cpu_hit &&
5834	    (off_filter_mask &
5835	     IFLA_STATS_FILTER_BIT(attr_id_cpu_hit))) {
5836		err = rtnl_offload_xstats_fill_ndo(dev, attr_id_cpu_hit, skb);
5837		if (!err) {
5838			have_data = true;
5839		} else if (err != -ENODATA) {
5840			*prividx = attr_id_cpu_hit;
5841			return err;
5842		}
5843	}
5844
5845	if (*prividx <= attr_id_hw_s_info &&
5846	    (off_filter_mask & IFLA_STATS_FILTER_BIT(attr_id_hw_s_info))) {
5847		*prividx = attr_id_hw_s_info;
5848
5849		err = rtnl_offload_xstats_fill_hw_s_info(skb, dev, extack);
5850		if (err)
5851			return err;
5852
5853		have_data = true;
5854		*prividx = 0;
5855	}
5856
5857	if (*prividx <= attr_id_l3_stats &&
5858	    (off_filter_mask & IFLA_STATS_FILTER_BIT(attr_id_l3_stats))) {
5859		unsigned int size_l3;
5860		struct nlattr *attr;
5861
5862		*prividx = attr_id_l3_stats;
5863
5864		size_l3 = rtnl_offload_xstats_get_size_stats(dev, t_l3);
5865		if (!size_l3)
5866			goto skip_l3_stats;
5867		attr = nla_reserve_64bit(skb, attr_id_l3_stats, size_l3,
5868					 IFLA_OFFLOAD_XSTATS_UNSPEC);
5869		if (!attr)
5870			return -EMSGSIZE;
5871
5872		err = rtnl_offload_xstats_get_stats(dev, t_l3, NULL,
5873						    nla_data(attr), extack);
5874		if (err)
5875			return err;
5876
5877		have_data = true;
5878skip_l3_stats:
5879		*prividx = 0;
5880	}
5881
5882	if (!have_data)
5883		return -ENODATA;
5884
5885	*prividx = 0;
5886	return 0;
5887}
5888
5889static unsigned int
5890rtnl_offload_xstats_get_size_hw_s_info_one(const struct net_device *dev,
5891					   enum netdev_offload_xstats_type type)
5892{
5893	return nla_total_size(0) +
5894		/* IFLA_OFFLOAD_XSTATS_HW_S_INFO_REQUEST */
5895		nla_total_size(sizeof(u8)) +
5896		/* IFLA_OFFLOAD_XSTATS_HW_S_INFO_USED */
5897		nla_total_size(sizeof(u8)) +
5898		0;
5899}
5900
5901static unsigned int
5902rtnl_offload_xstats_get_size_hw_s_info(const struct net_device *dev)
5903{
5904	enum netdev_offload_xstats_type t_l3 = NETDEV_OFFLOAD_XSTATS_TYPE_L3;
5905
5906	return nla_total_size(0) +
5907		/* IFLA_OFFLOAD_XSTATS_L3_STATS */
5908		rtnl_offload_xstats_get_size_hw_s_info_one(dev, t_l3) +
5909		0;
5910}
5911
5912static int rtnl_offload_xstats_get_size(const struct net_device *dev,
5913					u32 off_filter_mask)
5914{
5915	enum netdev_offload_xstats_type t_l3 = NETDEV_OFFLOAD_XSTATS_TYPE_L3;
5916	int attr_id_cpu_hit = IFLA_OFFLOAD_XSTATS_CPU_HIT;
5917	int nla_size = 0;
5918	int size;
5919
5920	if (off_filter_mask &
5921	    IFLA_STATS_FILTER_BIT(attr_id_cpu_hit)) {
5922		size = rtnl_offload_xstats_get_size_ndo(dev, attr_id_cpu_hit);
5923		nla_size += nla_total_size_64bit(size);
5924	}
5925
5926	if (off_filter_mask &
5927	    IFLA_STATS_FILTER_BIT(IFLA_OFFLOAD_XSTATS_HW_S_INFO))
5928		nla_size += rtnl_offload_xstats_get_size_hw_s_info(dev);
5929
5930	if (off_filter_mask &
5931	    IFLA_STATS_FILTER_BIT(IFLA_OFFLOAD_XSTATS_L3_STATS)) {
5932		size = rtnl_offload_xstats_get_size_stats(dev, t_l3);
5933		nla_size += nla_total_size_64bit(size);
5934	}
5935
5936	if (nla_size != 0)
5937		nla_size += nla_total_size(0);
5938
5939	return nla_size;
5940}
5941
5942struct rtnl_stats_dump_filters {
5943	/* mask[0] filters outer attributes. Then individual nests have their
5944	 * filtering mask at the index of the nested attribute.
5945	 */
5946	u32 mask[IFLA_STATS_MAX + 1];
5947};
5948
5949static int rtnl_fill_statsinfo(struct sk_buff *skb, struct net_device *dev,
5950			       int type, u32 pid, u32 seq, u32 change,
5951			       unsigned int flags,
5952			       const struct rtnl_stats_dump_filters *filters,
5953			       int *idxattr, int *prividx,
5954			       struct netlink_ext_ack *extack)
5955{
5956	unsigned int filter_mask = filters->mask[0];
5957	struct if_stats_msg *ifsm;
5958	struct nlmsghdr *nlh;
5959	struct nlattr *attr;
5960	int s_prividx = *prividx;
5961	int err;
5962
5963	ASSERT_RTNL();
5964
5965	nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifsm), flags);
5966	if (!nlh)
5967		return -EMSGSIZE;
5968
5969	ifsm = nlmsg_data(nlh);
5970	ifsm->family = PF_UNSPEC;
5971	ifsm->pad1 = 0;
5972	ifsm->pad2 = 0;
5973	ifsm->ifindex = dev->ifindex;
5974	ifsm->filter_mask = filter_mask;
5975
5976	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_64, *idxattr)) {
5977		struct rtnl_link_stats64 *sp;
5978
5979		attr = nla_reserve_64bit(skb, IFLA_STATS_LINK_64,
5980					 sizeof(struct rtnl_link_stats64),
5981					 IFLA_STATS_UNSPEC);
5982		if (!attr) {
5983			err = -EMSGSIZE;
5984			goto nla_put_failure;
5985		}
5986
5987		sp = nla_data(attr);
5988		dev_get_stats(dev, sp);
5989	}
5990
5991	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS, *idxattr)) {
5992		const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
5993
5994		if (ops && ops->fill_linkxstats) {
5995			*idxattr = IFLA_STATS_LINK_XSTATS;
5996			attr = nla_nest_start_noflag(skb,
5997						     IFLA_STATS_LINK_XSTATS);
5998			if (!attr) {
5999				err = -EMSGSIZE;
6000				goto nla_put_failure;
6001			}
6002
6003			err = ops->fill_linkxstats(skb, dev, prividx, *idxattr);
6004			nla_nest_end(skb, attr);
6005			if (err)
6006				goto nla_put_failure;
6007			*idxattr = 0;
6008		}
6009	}
6010
6011	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS_SLAVE,
6012			     *idxattr)) {
6013		const struct rtnl_link_ops *ops = NULL;
6014		const struct net_device *master;
6015
6016		master = netdev_master_upper_dev_get(dev);
6017		if (master)
6018			ops = master->rtnl_link_ops;
6019		if (ops && ops->fill_linkxstats) {
6020			*idxattr = IFLA_STATS_LINK_XSTATS_SLAVE;
6021			attr = nla_nest_start_noflag(skb,
6022						     IFLA_STATS_LINK_XSTATS_SLAVE);
6023			if (!attr) {
6024				err = -EMSGSIZE;
6025				goto nla_put_failure;
6026			}
6027
6028			err = ops->fill_linkxstats(skb, dev, prividx, *idxattr);
6029			nla_nest_end(skb, attr);
6030			if (err)
6031				goto nla_put_failure;
6032			*idxattr = 0;
6033		}
6034	}
6035
6036	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_OFFLOAD_XSTATS,
6037			     *idxattr)) {
6038		u32 off_filter_mask;
6039
6040		off_filter_mask = filters->mask[IFLA_STATS_LINK_OFFLOAD_XSTATS];
6041		*idxattr = IFLA_STATS_LINK_OFFLOAD_XSTATS;
6042		attr = nla_nest_start_noflag(skb,
6043					     IFLA_STATS_LINK_OFFLOAD_XSTATS);
6044		if (!attr) {
6045			err = -EMSGSIZE;
6046			goto nla_put_failure;
6047		}
6048
6049		err = rtnl_offload_xstats_fill(skb, dev, prividx,
6050					       off_filter_mask, extack);
6051		if (err == -ENODATA)
6052			nla_nest_cancel(skb, attr);
6053		else
6054			nla_nest_end(skb, attr);
6055
6056		if (err && err != -ENODATA)
6057			goto nla_put_failure;
6058		*idxattr = 0;
6059	}
6060
6061	if (stats_attr_valid(filter_mask, IFLA_STATS_AF_SPEC, *idxattr)) {
6062		struct rtnl_af_ops *af_ops;
6063
6064		*idxattr = IFLA_STATS_AF_SPEC;
6065		attr = nla_nest_start_noflag(skb, IFLA_STATS_AF_SPEC);
6066		if (!attr) {
6067			err = -EMSGSIZE;
6068			goto nla_put_failure;
6069		}
6070
6071		rcu_read_lock();
6072		list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
6073			if (af_ops->fill_stats_af) {
6074				struct nlattr *af;
6075
6076				af = nla_nest_start_noflag(skb,
6077							   af_ops->family);
6078				if (!af) {
6079					rcu_read_unlock();
6080					err = -EMSGSIZE;
6081					goto nla_put_failure;
6082				}
6083				err = af_ops->fill_stats_af(skb, dev);
6084
6085				if (err == -ENODATA) {
6086					nla_nest_cancel(skb, af);
6087				} else if (err < 0) {
6088					rcu_read_unlock();
6089					goto nla_put_failure;
6090				}
6091
6092				nla_nest_end(skb, af);
6093			}
6094		}
6095		rcu_read_unlock();
6096
6097		nla_nest_end(skb, attr);
6098
6099		*idxattr = 0;
6100	}
6101
6102	nlmsg_end(skb, nlh);
6103
6104	return 0;
6105
6106nla_put_failure:
6107	/* not a multi message or no progress mean a real error */
6108	if (!(flags & NLM_F_MULTI) || s_prividx == *prividx)
6109		nlmsg_cancel(skb, nlh);
6110	else
6111		nlmsg_end(skb, nlh);
6112
6113	return err;
6114}
6115
6116static size_t if_nlmsg_stats_size(const struct net_device *dev,
6117				  const struct rtnl_stats_dump_filters *filters)
6118{
6119	size_t size = NLMSG_ALIGN(sizeof(struct if_stats_msg));
6120	unsigned int filter_mask = filters->mask[0];
6121
6122	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_64, 0))
6123		size += nla_total_size_64bit(sizeof(struct rtnl_link_stats64));
6124
6125	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS, 0)) {
6126		const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
6127		int attr = IFLA_STATS_LINK_XSTATS;
6128
6129		if (ops && ops->get_linkxstats_size) {
6130			size += nla_total_size(ops->get_linkxstats_size(dev,
6131									attr));
6132			/* for IFLA_STATS_LINK_XSTATS */
6133			size += nla_total_size(0);
6134		}
6135	}
6136
6137	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS_SLAVE, 0)) {
6138		struct net_device *_dev = (struct net_device *)dev;
6139		const struct rtnl_link_ops *ops = NULL;
6140		const struct net_device *master;
6141
6142		/* netdev_master_upper_dev_get can't take const */
6143		master = netdev_master_upper_dev_get(_dev);
6144		if (master)
6145			ops = master->rtnl_link_ops;
6146		if (ops && ops->get_linkxstats_size) {
6147			int attr = IFLA_STATS_LINK_XSTATS_SLAVE;
6148
6149			size += nla_total_size(ops->get_linkxstats_size(dev,
6150									attr));
6151			/* for IFLA_STATS_LINK_XSTATS_SLAVE */
6152			size += nla_total_size(0);
6153		}
6154	}
6155
6156	if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_OFFLOAD_XSTATS, 0)) {
6157		u32 off_filter_mask;
6158
6159		off_filter_mask = filters->mask[IFLA_STATS_LINK_OFFLOAD_XSTATS];
6160		size += rtnl_offload_xstats_get_size(dev, off_filter_mask);
6161	}
6162
6163	if (stats_attr_valid(filter_mask, IFLA_STATS_AF_SPEC, 0)) {
6164		struct rtnl_af_ops *af_ops;
6165
6166		/* for IFLA_STATS_AF_SPEC */
6167		size += nla_total_size(0);
6168
6169		rcu_read_lock();
6170		list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
6171			if (af_ops->get_stats_af_size) {
6172				size += nla_total_size(
6173					af_ops->get_stats_af_size(dev));
6174
6175				/* for AF_* */
6176				size += nla_total_size(0);
6177			}
6178		}
6179		rcu_read_unlock();
6180	}
6181
6182	return size;
6183}
6184
6185#define RTNL_STATS_OFFLOAD_XSTATS_VALID ((1 << __IFLA_OFFLOAD_XSTATS_MAX) - 1)
6186
6187static const struct nla_policy
6188rtnl_stats_get_policy_filters[IFLA_STATS_MAX + 1] = {
6189	[IFLA_STATS_LINK_OFFLOAD_XSTATS] =
6190		    NLA_POLICY_MASK(NLA_U32, RTNL_STATS_OFFLOAD_XSTATS_VALID),
6191};
6192
6193static const struct nla_policy
6194rtnl_stats_get_policy[IFLA_STATS_GETSET_MAX + 1] = {
6195	[IFLA_STATS_GET_FILTERS] =
6196		    NLA_POLICY_NESTED(rtnl_stats_get_policy_filters),
6197};
6198
6199static const struct nla_policy
6200ifla_stats_set_policy[IFLA_STATS_GETSET_MAX + 1] = {
6201	[IFLA_STATS_SET_OFFLOAD_XSTATS_L3_STATS] = NLA_POLICY_MAX(NLA_U8, 1),
6202};
6203
6204static int rtnl_stats_get_parse_filters(struct nlattr *ifla_filters,
6205					struct rtnl_stats_dump_filters *filters,
6206					struct netlink_ext_ack *extack)
6207{
6208	struct nlattr *tb[IFLA_STATS_MAX + 1];
6209	int err;
6210	int at;
6211
6212	err = nla_parse_nested(tb, IFLA_STATS_MAX, ifla_filters,
6213			       rtnl_stats_get_policy_filters, extack);
6214	if (err < 0)
6215		return err;
6216
6217	for (at = 1; at <= IFLA_STATS_MAX; at++) {
6218		if (tb[at]) {
6219			if (!(filters->mask[0] & IFLA_STATS_FILTER_BIT(at))) {
6220				NL_SET_ERR_MSG(extack, "Filtered attribute not enabled in filter_mask");
6221				return -EINVAL;
6222			}
6223			filters->mask[at] = nla_get_u32(tb[at]);
6224		}
6225	}
6226
6227	return 0;
6228}
6229
6230static int rtnl_stats_get_parse(const struct nlmsghdr *nlh,
6231				u32 filter_mask,
6232				struct rtnl_stats_dump_filters *filters,
6233				struct netlink_ext_ack *extack)
6234{
6235	struct nlattr *tb[IFLA_STATS_GETSET_MAX + 1];
6236	int err;
6237	int i;
6238
6239	filters->mask[0] = filter_mask;
6240	for (i = 1; i < ARRAY_SIZE(filters->mask); i++)
6241		filters->mask[i] = -1U;
6242
6243	err = nlmsg_parse(nlh, sizeof(struct if_stats_msg), tb,
6244			  IFLA_STATS_GETSET_MAX, rtnl_stats_get_policy, extack);
6245	if (err < 0)
6246		return err;
6247
6248	if (tb[IFLA_STATS_GET_FILTERS]) {
6249		err = rtnl_stats_get_parse_filters(tb[IFLA_STATS_GET_FILTERS],
6250						   filters, extack);
6251		if (err)
6252			return err;
6253	}
6254
6255	return 0;
6256}
6257
6258static int rtnl_valid_stats_req(const struct nlmsghdr *nlh, bool strict_check,
6259				bool is_dump, struct netlink_ext_ack *extack)
6260{
6261	struct if_stats_msg *ifsm;
6262
6263	ifsm = nlmsg_payload(nlh, sizeof(*ifsm));
6264	if (!ifsm) {
6265		NL_SET_ERR_MSG(extack, "Invalid header for stats dump");
6266		return -EINVAL;
6267	}
6268
6269	if (!strict_check)
6270		return 0;
6271
6272	/* only requests using strict checks can pass data to influence
6273	 * the dump. The legacy exception is filter_mask.
6274	 */
6275	if (ifsm->pad1 || ifsm->pad2 || (is_dump && ifsm->ifindex)) {
6276		NL_SET_ERR_MSG(extack, "Invalid values in header for stats dump request");
6277		return -EINVAL;
6278	}
6279	if (ifsm->filter_mask >= IFLA_STATS_FILTER_BIT(IFLA_STATS_MAX + 1)) {
6280		NL_SET_ERR_MSG(extack, "Invalid stats requested through filter mask");
6281		return -EINVAL;
6282	}
6283
6284	return 0;
6285}
6286
6287static int rtnl_stats_get(struct sk_buff *skb, struct nlmsghdr *nlh,
6288			  struct netlink_ext_ack *extack)
6289{
6290	struct rtnl_stats_dump_filters filters;
6291	struct net *net = sock_net(skb->sk);
6292	struct net_device *dev = NULL;
6293	int idxattr = 0, prividx = 0;
6294	struct if_stats_msg *ifsm;
6295	struct sk_buff *nskb;
6296	int err;
6297
6298	err = rtnl_valid_stats_req(nlh, netlink_strict_get_check(skb),
6299				   false, extack);
6300	if (err)
6301		return err;
6302
6303	ifsm = nlmsg_data(nlh);
6304	if (ifsm->ifindex > 0)
6305		dev = __dev_get_by_index(net, ifsm->ifindex);
6306	else
6307		return -EINVAL;
6308
6309	if (!dev)
6310		return -ENODEV;
6311
6312	if (!ifsm->filter_mask) {
6313		NL_SET_ERR_MSG(extack, "Filter mask must be set for stats get");
6314		return -EINVAL;
6315	}
6316
6317	err = rtnl_stats_get_parse(nlh, ifsm->filter_mask, &filters, extack);
6318	if (err)
6319		return err;
6320
6321	nskb = nlmsg_new(if_nlmsg_stats_size(dev, &filters), GFP_KERNEL);
6322	if (!nskb)
6323		return -ENOBUFS;
6324
6325	err = rtnl_fill_statsinfo(nskb, dev, RTM_NEWSTATS,
6326				  NETLINK_CB(skb).portid, nlh->nlmsg_seq, 0,
6327				  0, &filters, &idxattr, &prividx, extack);
6328	if (err < 0) {
6329		/* -EMSGSIZE implies BUG in if_nlmsg_stats_size */
6330		WARN_ON(err == -EMSGSIZE);
6331		kfree_skb(nskb);
6332	} else {
6333		err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid);
6334	}
6335
6336	return err;
6337}
6338
6339static int rtnl_stats_dump(struct sk_buff *skb, struct netlink_callback *cb)
6340{
6341	struct netlink_ext_ack *extack = cb->extack;
6342	struct rtnl_stats_dump_filters filters;
6343	struct net *net = sock_net(skb->sk);
6344	unsigned int flags = NLM_F_MULTI;
6345	struct if_stats_msg *ifsm;
6346	struct {
6347		unsigned long ifindex;
6348		int idxattr;
6349		int prividx;
6350	} *ctx = (void *)cb->ctx;
6351	struct net_device *dev;
6352	int err;
6353
6354	cb->seq = net->dev_base_seq;
6355
6356	err = rtnl_valid_stats_req(cb->nlh, cb->strict_check, true, extack);
6357	if (err)
6358		return err;
6359
6360	ifsm = nlmsg_data(cb->nlh);
6361	if (!ifsm->filter_mask) {
6362		NL_SET_ERR_MSG(extack, "Filter mask must be set for stats dump");
6363		return -EINVAL;
6364	}
6365
6366	err = rtnl_stats_get_parse(cb->nlh, ifsm->filter_mask, &filters,
6367				   extack);
6368	if (err)
6369		return err;
6370
6371	for_each_netdev_dump(net, dev, ctx->ifindex) {
6372		err = rtnl_fill_statsinfo(skb, dev, RTM_NEWSTATS,
6373					  NETLINK_CB(cb->skb).portid,
6374					  cb->nlh->nlmsg_seq, 0,
6375					  flags, &filters,
6376					  &ctx->idxattr, &ctx->prividx,
6377					  extack);
6378		/* If we ran out of room on the first message,
6379		 * we're in trouble.
6380		 */
6381		WARN_ON((err == -EMSGSIZE) && (skb->len == 0));
6382
6383		if (err < 0)
6384			break;
6385		ctx->prividx = 0;
6386		ctx->idxattr = 0;
6387		nl_dump_check_consistent(cb, nlmsg_hdr(skb));
6388	}
6389
6390	return err;
6391}
6392
6393void rtnl_offload_xstats_notify(struct net_device *dev)
6394{
6395	struct rtnl_stats_dump_filters response_filters = {};
6396	struct net *net = dev_net(dev);
6397	int idxattr = 0, prividx = 0;
6398	struct sk_buff *skb;
6399	int err = -ENOBUFS;
6400
6401	ASSERT_RTNL();
6402
6403	response_filters.mask[0] |=
6404		IFLA_STATS_FILTER_BIT(IFLA_STATS_LINK_OFFLOAD_XSTATS);
6405	response_filters.mask[IFLA_STATS_LINK_OFFLOAD_XSTATS] |=
6406		IFLA_STATS_FILTER_BIT(IFLA_OFFLOAD_XSTATS_HW_S_INFO);
6407
6408	skb = nlmsg_new(if_nlmsg_stats_size(dev, &response_filters),
6409			GFP_KERNEL);
6410	if (!skb)
6411		goto errout;
6412
6413	err = rtnl_fill_statsinfo(skb, dev, RTM_NEWSTATS, 0, 0, 0, 0,
6414				  &response_filters, &idxattr, &prividx, NULL);
6415	if (err < 0) {
6416		kfree_skb(skb);
6417		goto errout;
6418	}
6419
6420	rtnl_notify(skb, net, 0, RTNLGRP_STATS, NULL, GFP_KERNEL);
6421	return;
6422
6423errout:
6424	rtnl_set_sk_err(net, RTNLGRP_STATS, err);
6425}
6426EXPORT_SYMBOL(rtnl_offload_xstats_notify);
6427
6428static int rtnl_stats_set(struct sk_buff *skb, struct nlmsghdr *nlh,
6429			  struct netlink_ext_ack *extack)
6430{
6431	enum netdev_offload_xstats_type t_l3 = NETDEV_OFFLOAD_XSTATS_TYPE_L3;
6432	struct rtnl_stats_dump_filters response_filters = {};
6433	struct nlattr *tb[IFLA_STATS_GETSET_MAX + 1];
6434	struct net *net = sock_net(skb->sk);
6435	struct net_device *dev = NULL;
6436	struct if_stats_msg *ifsm;
6437	bool notify = false;
6438	int err;
6439
6440	err = rtnl_valid_stats_req(nlh, netlink_strict_get_check(skb),
6441				   false, extack);
6442	if (err)
6443		return err;
6444
6445	ifsm = nlmsg_data(nlh);
6446	if (ifsm->family != AF_UNSPEC) {
6447		NL_SET_ERR_MSG(extack, "Address family should be AF_UNSPEC");
6448		return -EINVAL;
6449	}
6450
6451	if (ifsm->ifindex > 0)
6452		dev = __dev_get_by_index(net, ifsm->ifindex);
6453	else
6454		return -EINVAL;
6455
6456	if (!dev)
6457		return -ENODEV;
6458
6459	if (ifsm->filter_mask) {
6460		NL_SET_ERR_MSG(extack, "Filter mask must be 0 for stats set");
6461		return -EINVAL;
6462	}
6463
6464	err = nlmsg_parse(nlh, sizeof(*ifsm), tb, IFLA_STATS_GETSET_MAX,
6465			  ifla_stats_set_policy, extack);
6466	if (err < 0)
6467		return err;
6468
6469	if (tb[IFLA_STATS_SET_OFFLOAD_XSTATS_L3_STATS]) {
6470		u8 req = nla_get_u8(tb[IFLA_STATS_SET_OFFLOAD_XSTATS_L3_STATS]);
6471
6472		if (req)
6473			err = netdev_offload_xstats_enable(dev, t_l3, extack);
6474		else
6475			err = netdev_offload_xstats_disable(dev, t_l3);
6476
6477		if (!err)
6478			notify = true;
6479		else if (err != -EALREADY)
6480			return err;
6481
6482		response_filters.mask[0] |=
6483			IFLA_STATS_FILTER_BIT(IFLA_STATS_LINK_OFFLOAD_XSTATS);
6484		response_filters.mask[IFLA_STATS_LINK_OFFLOAD_XSTATS] |=
6485			IFLA_STATS_FILTER_BIT(IFLA_OFFLOAD_XSTATS_HW_S_INFO);
6486	}
6487
6488	if (notify)
6489		rtnl_offload_xstats_notify(dev);
6490
6491	return 0;
6492}
6493
6494static int rtnl_mdb_valid_dump_req(const struct nlmsghdr *nlh,
6495				   struct netlink_ext_ack *extack)
6496{
6497	struct br_port_msg *bpm;
6498
6499	bpm = nlmsg_payload(nlh, sizeof(*bpm));
6500	if (!bpm) {
6501		NL_SET_ERR_MSG(extack, "Invalid header for mdb dump request");
6502		return -EINVAL;
6503	}
6504
6505	if (bpm->ifindex) {
6506		NL_SET_ERR_MSG(extack, "Filtering by device index is not supported for mdb dump request");
6507		return -EINVAL;
6508	}
6509	if (nlmsg_attrlen(nlh, sizeof(*bpm))) {
6510		NL_SET_ERR_MSG(extack, "Invalid data after header in mdb dump request");
6511		return -EINVAL;
6512	}
6513
6514	return 0;
6515}
6516
6517struct rtnl_mdb_dump_ctx {
6518	long idx;
6519};
6520
6521static int rtnl_mdb_dump(struct sk_buff *skb, struct netlink_callback *cb)
6522{
6523	struct rtnl_mdb_dump_ctx *ctx = (void *)cb->ctx;
6524	struct net *net = sock_net(skb->sk);
6525	struct net_device *dev;
6526	int idx, s_idx;
6527	int err;
6528
6529	NL_ASSERT_CTX_FITS(struct rtnl_mdb_dump_ctx);
6530
6531	if (cb->strict_check) {
6532		err = rtnl_mdb_valid_dump_req(cb->nlh, cb->extack);
6533		if (err)
6534			return err;
6535	}
6536
6537	s_idx = ctx->idx;
6538	idx = 0;
6539
6540	for_each_netdev(net, dev) {
6541		if (idx < s_idx)
6542			goto skip;
6543		if (!dev->netdev_ops->ndo_mdb_dump)
6544			goto skip;
6545
6546		err = dev->netdev_ops->ndo_mdb_dump(dev, skb, cb);
6547		if (err == -EMSGSIZE)
6548			goto out;
6549		/* Moving on to next device, reset markers and sequence
6550		 * counters since they are all maintained per-device.
6551		 */
6552		memset(cb->ctx, 0, sizeof(cb->ctx));
6553		cb->prev_seq = 0;
6554		cb->seq = 0;
6555skip:
6556		idx++;
6557	}
6558
6559out:
6560	ctx->idx = idx;
6561	return skb->len;
6562}
6563
6564static int rtnl_validate_mdb_entry_get(const struct nlattr *attr,
6565				       struct netlink_ext_ack *extack)
6566{
6567	struct br_mdb_entry *entry = nla_data(attr);
6568
6569	if (nla_len(attr) != sizeof(struct br_mdb_entry)) {
6570		NL_SET_ERR_MSG_ATTR(extack, attr, "Invalid attribute length");
6571		return -EINVAL;
6572	}
6573
6574	if (entry->ifindex) {
6575		NL_SET_ERR_MSG(extack, "Entry ifindex cannot be specified");
6576		return -EINVAL;
6577	}
6578
6579	if (entry->state) {
6580		NL_SET_ERR_MSG(extack, "Entry state cannot be specified");
6581		return -EINVAL;
6582	}
6583
6584	if (entry->flags) {
6585		NL_SET_ERR_MSG(extack, "Entry flags cannot be specified");
6586		return -EINVAL;
6587	}
6588
6589	if (entry->vid >= VLAN_VID_MASK) {
6590		NL_SET_ERR_MSG(extack, "Invalid entry VLAN id");
6591		return -EINVAL;
6592	}
6593
6594	if (entry->addr.proto != htons(ETH_P_IP) &&
6595	    entry->addr.proto != htons(ETH_P_IPV6) &&
6596	    entry->addr.proto != 0) {
6597		NL_SET_ERR_MSG(extack, "Unknown entry protocol");
6598		return -EINVAL;
6599	}
6600
6601	return 0;
6602}
6603
6604static const struct nla_policy mdba_get_policy[MDBA_GET_ENTRY_MAX + 1] = {
6605	[MDBA_GET_ENTRY] = NLA_POLICY_VALIDATE_FN(NLA_BINARY,
6606						  rtnl_validate_mdb_entry_get,
6607						  sizeof(struct br_mdb_entry)),
6608	[MDBA_GET_ENTRY_ATTRS] = { .type = NLA_NESTED },
6609};
6610
6611static int rtnl_mdb_get(struct sk_buff *in_skb, struct nlmsghdr *nlh,
6612			struct netlink_ext_ack *extack)
6613{
6614	struct nlattr *tb[MDBA_GET_ENTRY_MAX + 1];
6615	struct net *net = sock_net(in_skb->sk);
6616	struct br_port_msg *bpm;
6617	struct net_device *dev;
6618	int err;
6619
6620	err = nlmsg_parse(nlh, sizeof(struct br_port_msg), tb,
6621			  MDBA_GET_ENTRY_MAX, mdba_get_policy, extack);
6622	if (err)
6623		return err;
6624
6625	bpm = nlmsg_data(nlh);
6626	if (!bpm->ifindex) {
6627		NL_SET_ERR_MSG(extack, "Invalid ifindex");
6628		return -EINVAL;
6629	}
6630
6631	dev = __dev_get_by_index(net, bpm->ifindex);
6632	if (!dev) {
6633		NL_SET_ERR_MSG(extack, "Device doesn't exist");
6634		return -ENODEV;
6635	}
6636
6637	if (NL_REQ_ATTR_CHECK(extack, NULL, tb, MDBA_GET_ENTRY)) {
6638		NL_SET_ERR_MSG(extack, "Missing MDBA_GET_ENTRY attribute");
6639		return -EINVAL;
6640	}
6641
6642	if (!dev->netdev_ops->ndo_mdb_get) {
6643		NL_SET_ERR_MSG(extack, "Device does not support MDB operations");
6644		return -EOPNOTSUPP;
6645	}
6646
6647	return dev->netdev_ops->ndo_mdb_get(dev, tb, NETLINK_CB(in_skb).portid,
6648					    nlh->nlmsg_seq, extack);
6649}
6650
6651static int rtnl_validate_mdb_entry(const struct nlattr *attr,
6652				   struct netlink_ext_ack *extack)
6653{
6654	struct br_mdb_entry *entry = nla_data(attr);
6655
6656	if (nla_len(attr) != sizeof(struct br_mdb_entry)) {
6657		NL_SET_ERR_MSG_ATTR(extack, attr, "Invalid attribute length");
6658		return -EINVAL;
6659	}
6660
6661	if (entry->ifindex == 0) {
6662		NL_SET_ERR_MSG(extack, "Zero entry ifindex is not allowed");
6663		return -EINVAL;
6664	}
6665
6666	if (entry->addr.proto == htons(ETH_P_IP)) {
6667		if (!ipv4_is_multicast(entry->addr.u.ip4) &&
6668		    !ipv4_is_zeronet(entry->addr.u.ip4)) {
6669			NL_SET_ERR_MSG(extack, "IPv4 entry group address is not multicast or 0.0.0.0");
6670			return -EINVAL;
6671		}
6672		if (ipv4_is_local_multicast(entry->addr.u.ip4)) {
6673			NL_SET_ERR_MSG(extack, "IPv4 entry group address is local multicast");
6674			return -EINVAL;
6675		}
6676#if IS_ENABLED(CONFIG_IPV6)
6677	} else if (entry->addr.proto == htons(ETH_P_IPV6)) {
6678		if (ipv6_addr_is_ll_all_nodes(&entry->addr.u.ip6)) {
6679			NL_SET_ERR_MSG(extack, "IPv6 entry group address is link-local all nodes");
6680			return -EINVAL;
6681		}
6682#endif
6683	} else if (entry->addr.proto == 0) {
6684		/* L2 mdb */
6685		if (!is_multicast_ether_addr(entry->addr.u.mac_addr)) {
6686			NL_SET_ERR_MSG(extack, "L2 entry group is not multicast");
6687			return -EINVAL;
6688		}
6689	} else {
6690		NL_SET_ERR_MSG(extack, "Unknown entry protocol");
6691		return -EINVAL;
6692	}
6693
6694	if (entry->state != MDB_PERMANENT && entry->state != MDB_TEMPORARY) {
6695		NL_SET_ERR_MSG(extack, "Unknown entry state");
6696		return -EINVAL;
6697	}
6698	if (entry->vid >= VLAN_VID_MASK) {
6699		NL_SET_ERR_MSG(extack, "Invalid entry VLAN id");
6700		return -EINVAL;
6701	}
6702
6703	return 0;
6704}
6705
6706static const struct nla_policy mdba_policy[MDBA_SET_ENTRY_MAX + 1] = {
6707	[MDBA_SET_ENTRY_UNSPEC] = { .strict_start_type = MDBA_SET_ENTRY_ATTRS + 1 },
6708	[MDBA_SET_ENTRY] = NLA_POLICY_VALIDATE_FN(NLA_BINARY,
6709						  rtnl_validate_mdb_entry,
6710						  sizeof(struct br_mdb_entry)),
6711	[MDBA_SET_ENTRY_ATTRS] = { .type = NLA_NESTED },
6712};
6713
6714static int rtnl_mdb_add(struct sk_buff *skb, struct nlmsghdr *nlh,
6715			struct netlink_ext_ack *extack)
6716{
6717	struct nlattr *tb[MDBA_SET_ENTRY_MAX + 1];
6718	struct net *net = sock_net(skb->sk);
6719	struct br_port_msg *bpm;
6720	struct net_device *dev;
6721	int err;
6722
6723	err = nlmsg_parse_deprecated(nlh, sizeof(*bpm), tb,
6724				     MDBA_SET_ENTRY_MAX, mdba_policy, extack);
6725	if (err)
6726		return err;
6727
6728	bpm = nlmsg_data(nlh);
6729	if (!bpm->ifindex) {
6730		NL_SET_ERR_MSG(extack, "Invalid ifindex");
6731		return -EINVAL;
6732	}
6733
6734	dev = __dev_get_by_index(net, bpm->ifindex);
6735	if (!dev) {
6736		NL_SET_ERR_MSG(extack, "Device doesn't exist");
6737		return -ENODEV;
6738	}
6739
6740	if (NL_REQ_ATTR_CHECK(extack, NULL, tb, MDBA_SET_ENTRY)) {
6741		NL_SET_ERR_MSG(extack, "Missing MDBA_SET_ENTRY attribute");
6742		return -EINVAL;
6743	}
6744
6745	if (!dev->netdev_ops->ndo_mdb_add) {
6746		NL_SET_ERR_MSG(extack, "Device does not support MDB operations");
6747		return -EOPNOTSUPP;
6748	}
6749
6750	return dev->netdev_ops->ndo_mdb_add(dev, tb, nlh->nlmsg_flags, extack);
6751}
6752
6753static int rtnl_validate_mdb_entry_del_bulk(const struct nlattr *attr,
6754					    struct netlink_ext_ack *extack)
6755{
6756	struct br_mdb_entry *entry = nla_data(attr);
6757	struct br_mdb_entry zero_entry = {};
6758
6759	if (nla_len(attr) != sizeof(struct br_mdb_entry)) {
6760		NL_SET_ERR_MSG_ATTR(extack, attr, "Invalid attribute length");
6761		return -EINVAL;
6762	}
6763
6764	if (entry->state != MDB_PERMANENT && entry->state != MDB_TEMPORARY) {
6765		NL_SET_ERR_MSG(extack, "Unknown entry state");
6766		return -EINVAL;
6767	}
6768
6769	if (entry->flags) {
6770		NL_SET_ERR_MSG(extack, "Entry flags cannot be set");
6771		return -EINVAL;
6772	}
6773
6774	if (entry->vid >= VLAN_N_VID - 1) {
6775		NL_SET_ERR_MSG(extack, "Invalid entry VLAN id");
6776		return -EINVAL;
6777	}
6778
6779	if (memcmp(&entry->addr, &zero_entry.addr, sizeof(entry->addr))) {
6780		NL_SET_ERR_MSG(extack, "Entry address cannot be set");
6781		return -EINVAL;
6782	}
6783
6784	return 0;
6785}
6786
6787static const struct nla_policy mdba_del_bulk_policy[MDBA_SET_ENTRY_MAX + 1] = {
6788	[MDBA_SET_ENTRY] = NLA_POLICY_VALIDATE_FN(NLA_BINARY,
6789						  rtnl_validate_mdb_entry_del_bulk,
6790						  sizeof(struct br_mdb_entry)),
6791	[MDBA_SET_ENTRY_ATTRS] = { .type = NLA_NESTED },
6792};
6793
6794static int rtnl_mdb_del(struct sk_buff *skb, struct nlmsghdr *nlh,
6795			struct netlink_ext_ack *extack)
6796{
6797	bool del_bulk = !!(nlh->nlmsg_flags & NLM_F_BULK);
6798	struct nlattr *tb[MDBA_SET_ENTRY_MAX + 1];
6799	struct net *net = sock_net(skb->sk);
6800	struct br_port_msg *bpm;
6801	struct net_device *dev;
6802	int err;
6803
6804	if (!del_bulk)
6805		err = nlmsg_parse_deprecated(nlh, sizeof(*bpm), tb,
6806					     MDBA_SET_ENTRY_MAX, mdba_policy,
6807					     extack);
6808	else
6809		err = nlmsg_parse(nlh, sizeof(*bpm), tb, MDBA_SET_ENTRY_MAX,
6810				  mdba_del_bulk_policy, extack);
6811	if (err)
6812		return err;
6813
6814	bpm = nlmsg_data(nlh);
6815	if (!bpm->ifindex) {
6816		NL_SET_ERR_MSG(extack, "Invalid ifindex");
6817		return -EINVAL;
6818	}
6819
6820	dev = __dev_get_by_index(net, bpm->ifindex);
6821	if (!dev) {
6822		NL_SET_ERR_MSG(extack, "Device doesn't exist");
6823		return -ENODEV;
6824	}
6825
6826	if (NL_REQ_ATTR_CHECK(extack, NULL, tb, MDBA_SET_ENTRY)) {
6827		NL_SET_ERR_MSG(extack, "Missing MDBA_SET_ENTRY attribute");
6828		return -EINVAL;
6829	}
6830
6831	if (del_bulk) {
6832		if (!dev->netdev_ops->ndo_mdb_del_bulk) {
6833			NL_SET_ERR_MSG(extack, "Device does not support MDB bulk deletion");
6834			return -EOPNOTSUPP;
6835		}
6836		return dev->netdev_ops->ndo_mdb_del_bulk(dev, tb, extack);
6837	}
6838
6839	if (!dev->netdev_ops->ndo_mdb_del) {
6840		NL_SET_ERR_MSG(extack, "Device does not support MDB operations");
6841		return -EOPNOTSUPP;
6842	}
6843
6844	return dev->netdev_ops->ndo_mdb_del(dev, tb, extack);
6845}
6846
6847/* Process one rtnetlink message. */
6848
6849static int rtnl_dumpit(struct sk_buff *skb, struct netlink_callback *cb)
6850{
6851	const bool needs_lock = !(cb->flags & RTNL_FLAG_DUMP_UNLOCKED);
6852	rtnl_dumpit_func dumpit = cb->data;
6853	int err;
6854
6855	/* Previous iteration have already finished, avoid calling->dumpit()
6856	 * again, it may not expect to be called after it reached the end.
6857	 */
6858	if (!dumpit)
6859		return 0;
6860
6861	if (needs_lock)
6862		rtnl_lock();
6863	err = dumpit(skb, cb);
6864	if (needs_lock)
6865		rtnl_unlock();
6866
6867	/* Old dump handlers used to send NLM_DONE as in a separate recvmsg().
6868	 * Some applications which parse netlink manually depend on this.
6869	 */
6870	if (cb->flags & RTNL_FLAG_DUMP_SPLIT_NLM_DONE) {
6871		if (err < 0 && err != -EMSGSIZE)
6872			return err;
6873		if (!err)
6874			cb->data = NULL;
6875
6876		return skb->len;
6877	}
6878	return err;
6879}
6880
6881static int rtnetlink_dump_start(struct sock *ssk, struct sk_buff *skb,
6882				const struct nlmsghdr *nlh,
6883				struct netlink_dump_control *control)
6884{
6885	if (control->flags & RTNL_FLAG_DUMP_SPLIT_NLM_DONE ||
6886	    !(control->flags & RTNL_FLAG_DUMP_UNLOCKED)) {
6887		WARN_ON(control->data);
6888		control->data = control->dump;
6889		control->dump = rtnl_dumpit;
6890	}
6891
6892	return netlink_dump_start(ssk, skb, nlh, control);
6893}
6894
6895static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
6896			     struct netlink_ext_ack *extack)
6897{
6898	struct net *net = sock_net(skb->sk);
6899	struct rtnl_link *link;
6900	enum rtnl_kinds kind;
6901	struct module *owner;
6902	int err = -EOPNOTSUPP;
6903	rtnl_doit_func doit;
6904	unsigned int flags;
6905	int family;
6906	int type;
6907
6908	type = nlh->nlmsg_type;
6909	if (type > RTM_MAX)
6910		return -EOPNOTSUPP;
6911
6912	type -= RTM_BASE;
6913
6914	/* All the messages must have at least 1 byte length */
6915	if (nlmsg_len(nlh) < sizeof(struct rtgenmsg))
6916		return 0;
6917
6918	family = ((struct rtgenmsg *)nlmsg_data(nlh))->rtgen_family;
6919	kind = rtnl_msgtype_kind(type);
6920
6921	if (kind != RTNL_KIND_GET && !netlink_net_capable(skb, CAP_NET_ADMIN))
6922		return -EPERM;
6923
6924	rcu_read_lock();
6925	if (kind == RTNL_KIND_GET && (nlh->nlmsg_flags & NLM_F_DUMP)) {
6926		struct sock *rtnl;
6927		rtnl_dumpit_func dumpit;
6928		u32 min_dump_alloc = 0;
6929
6930		link = rtnl_get_link(family, type);
6931		if (!link || !link->dumpit) {
6932			family = PF_UNSPEC;
6933			link = rtnl_get_link(family, type);
6934			if (!link || !link->dumpit)
6935				goto err_unlock;
6936		}
6937		owner = link->owner;
6938		dumpit = link->dumpit;
6939		flags = link->flags;
6940
6941		if (type == RTM_GETLINK - RTM_BASE)
6942			min_dump_alloc = rtnl_calcit(skb, nlh);
6943
6944		err = 0;
6945		/* need to do this before rcu_read_unlock() */
6946		if (!try_module_get(owner))
6947			err = -EPROTONOSUPPORT;
6948
6949		rcu_read_unlock();
6950
6951		rtnl = net->rtnl;
6952		if (err == 0) {
6953			struct netlink_dump_control c = {
6954				.dump		= dumpit,
6955				.min_dump_alloc	= min_dump_alloc,
6956				.module		= owner,
6957				.flags		= flags,
6958			};
6959			err = rtnetlink_dump_start(rtnl, skb, nlh, &c);
6960			/* netlink_dump_start() will keep a reference on
6961			 * module if dump is still in progress.
6962			 */
6963			module_put(owner);
6964		}
6965		return err;
6966	}
6967
6968	link = rtnl_get_link(family, type);
6969	if (!link || !link->doit) {
6970		family = PF_UNSPEC;
6971		link = rtnl_get_link(PF_UNSPEC, type);
6972		if (!link || !link->doit)
6973			goto out_unlock;
6974	}
6975
6976	owner = link->owner;
6977	if (!try_module_get(owner)) {
6978		err = -EPROTONOSUPPORT;
6979		goto out_unlock;
6980	}
6981
6982	flags = link->flags;
6983	if (kind == RTNL_KIND_DEL && (nlh->nlmsg_flags & NLM_F_BULK) &&
6984	    !(flags & RTNL_FLAG_BULK_DEL_SUPPORTED)) {
6985		NL_SET_ERR_MSG(extack, "Bulk delete is not supported");
6986		module_put(owner);
6987		goto err_unlock;
6988	}
6989
6990	if (flags & RTNL_FLAG_DOIT_UNLOCKED) {
6991		doit = link->doit;
6992		rcu_read_unlock();
6993		if (doit)
6994			err = doit(skb, nlh, extack);
6995		module_put(owner);
6996		return err;
6997	}
6998	rcu_read_unlock();
6999
7000	rtnl_lock();
7001	link = rtnl_get_link(family, type);
7002	if (link && link->doit)
7003		err = link->doit(skb, nlh, extack);
7004	rtnl_unlock();
7005
7006	module_put(owner);
7007
7008	return err;
7009
7010out_unlock:
7011	rcu_read_unlock();
7012	return err;
7013
7014err_unlock:
7015	rcu_read_unlock();
7016	return -EOPNOTSUPP;
7017}
7018
7019static void rtnetlink_rcv(struct sk_buff *skb)
7020{
7021	netlink_rcv_skb(skb, &rtnetlink_rcv_msg);
7022}
7023
7024static int rtnetlink_bind(struct net *net, int group)
7025{
7026	switch (group) {
7027	case RTNLGRP_IPV4_MROUTE_R:
7028	case RTNLGRP_IPV6_MROUTE_R:
7029		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
7030			return -EPERM;
7031		break;
7032	}
7033	return 0;
7034}
7035
7036static int rtnetlink_event(struct notifier_block *this, unsigned long event, void *ptr)
7037{
7038	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
7039
7040	switch (event) {
7041	case NETDEV_REBOOT:
7042	case NETDEV_CHANGEMTU:
7043	case NETDEV_CHANGEADDR:
7044	case NETDEV_CHANGENAME:
7045	case NETDEV_FEAT_CHANGE:
7046	case NETDEV_BONDING_FAILOVER:
7047	case NETDEV_POST_TYPE_CHANGE:
7048	case NETDEV_NOTIFY_PEERS:
7049	case NETDEV_CHANGEUPPER:
7050	case NETDEV_RESEND_IGMP:
7051	case NETDEV_CHANGEINFODATA:
7052	case NETDEV_CHANGELOWERSTATE:
7053	case NETDEV_CHANGE_TX_QUEUE_LEN:
7054		rtmsg_ifinfo_event(RTM_NEWLINK, dev, 0, rtnl_get_event(event),
7055				   GFP_KERNEL, NULL, 0, 0, NULL);
7056		break;
7057	default:
7058		break;
7059	}
7060	return NOTIFY_DONE;
7061}
7062
7063static struct notifier_block rtnetlink_dev_notifier = {
7064	.notifier_call	= rtnetlink_event,
7065};
7066
7067
7068static int __net_init rtnetlink_net_init(struct net *net)
7069{
7070	struct sock *sk;
7071	struct netlink_kernel_cfg cfg = {
7072		.groups		= RTNLGRP_MAX,
7073		.input		= rtnetlink_rcv,
7074		.flags		= NL_CFG_F_NONROOT_RECV,
7075		.bind		= rtnetlink_bind,
7076	};
7077
7078	sk = netlink_kernel_create(net, NETLINK_ROUTE, &cfg);
7079	if (!sk)
7080		return -ENOMEM;
7081	net->rtnl = sk;
7082	return 0;
7083}
7084
7085static void __net_exit rtnetlink_net_exit(struct net *net)
7086{
7087	netlink_kernel_release(net->rtnl);
7088	net->rtnl = NULL;
7089}
7090
7091static struct pernet_operations rtnetlink_net_ops = {
7092	.init = rtnetlink_net_init,
7093	.exit = rtnetlink_net_exit,
7094};
7095
7096static const struct rtnl_msg_handler rtnetlink_rtnl_msg_handlers[] __initconst = {
7097	{.msgtype = RTM_NEWLINK, .doit = rtnl_newlink,
7098	 .flags = RTNL_FLAG_DOIT_PERNET},
7099	{.msgtype = RTM_DELLINK, .doit = rtnl_dellink,
7100	 .flags = RTNL_FLAG_DOIT_PERNET_WIP},
7101	{.msgtype = RTM_GETLINK, .doit = rtnl_getlink,
7102	 .dumpit = rtnl_dump_ifinfo, .flags = RTNL_FLAG_DUMP_SPLIT_NLM_DONE},
7103	{.msgtype = RTM_SETLINK, .doit = rtnl_setlink,
7104	 .flags = RTNL_FLAG_DOIT_PERNET_WIP},
7105	{.msgtype = RTM_GETADDR, .dumpit = rtnl_dump_all},
7106	{.msgtype = RTM_GETROUTE, .dumpit = rtnl_dump_all},
7107	{.msgtype = RTM_GETNETCONF, .dumpit = rtnl_dump_all},
7108	{.msgtype = RTM_GETSTATS, .doit = rtnl_stats_get,
7109	 .dumpit = rtnl_stats_dump},
7110	{.msgtype = RTM_SETSTATS, .doit = rtnl_stats_set},
7111	{.msgtype = RTM_NEWLINKPROP, .doit = rtnl_newlinkprop},
7112	{.msgtype = RTM_DELLINKPROP, .doit = rtnl_dellinkprop},
7113	{.protocol = PF_BRIDGE, .msgtype = RTM_GETLINK,
7114	 .dumpit = rtnl_bridge_getlink},
7115	{.protocol = PF_BRIDGE, .msgtype = RTM_DELLINK,
7116	 .doit = rtnl_bridge_dellink},
7117	{.protocol = PF_BRIDGE, .msgtype = RTM_SETLINK,
7118	 .doit = rtnl_bridge_setlink},
7119	{.protocol = PF_BRIDGE, .msgtype = RTM_NEWNEIGH, .doit = rtnl_fdb_add},
7120	{.protocol = PF_BRIDGE, .msgtype = RTM_DELNEIGH, .doit = rtnl_fdb_del,
7121	 .flags = RTNL_FLAG_BULK_DEL_SUPPORTED},
7122	{.protocol = PF_BRIDGE, .msgtype = RTM_GETNEIGH, .doit = rtnl_fdb_get,
7123	 .dumpit = rtnl_fdb_dump},
7124	{.protocol = PF_BRIDGE, .msgtype = RTM_NEWMDB, .doit = rtnl_mdb_add},
7125	{.protocol = PF_BRIDGE, .msgtype = RTM_DELMDB, .doit = rtnl_mdb_del,
7126	 .flags = RTNL_FLAG_BULK_DEL_SUPPORTED},
7127	{.protocol = PF_BRIDGE, .msgtype = RTM_GETMDB, .doit = rtnl_mdb_get,
7128	 .dumpit = rtnl_mdb_dump},
7129};
7130
7131void __init rtnetlink_init(void)
7132{
7133	if (register_pernet_subsys(&rtnetlink_net_ops))
7134		panic("rtnetlink_init: cannot initialize rtnetlink\n");
7135
7136	register_netdevice_notifier(&rtnetlink_dev_notifier);
7137
7138	rtnl_register_many(rtnetlink_rtnl_msg_handlers);
7139}