projects/linux·blob master · refs

7291 lines · 177.0 KiB

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