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