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