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