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