1
2
3
4
5
6
7
8
9
10
11
12
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
57#define RTNL_MAX_TYPE 50
58#define RTNL_SLAVE_MAX_TYPE 36
59
60struct rtnl_link {
61 rtnl_doit_func doit;
62 rtnl_dumpit_func dumpit;
63 struct module *owner;
64 unsigned int flags;
65 struct rcu_head rcu;
66};
67
68static DEFINE_MUTEX(rtnl_mutex);
69
70void rtnl_lock(void)
71{
72 mutex_lock(&rtnl_mutex);
73}
74EXPORT_SYMBOL(rtnl_lock);
75
76int rtnl_lock_killable(void)
77{
78 return mutex_lock_killable(&rtnl_mutex);
79}
80EXPORT_SYMBOL(rtnl_lock_killable);
81
82static struct sk_buff *defer_kfree_skb_list;
83void rtnl_kfree_skbs(struct sk_buff *head, struct sk_buff *tail)
84{
85 if (head && tail) {
86 tail->next = defer_kfree_skb_list;
87 defer_kfree_skb_list = head;
88 }
89}
90EXPORT_SYMBOL(rtnl_kfree_skbs);
91
92void __rtnl_unlock(void)
93{
94 struct sk_buff *head = defer_kfree_skb_list;
95
96 defer_kfree_skb_list = NULL;
97
98 mutex_unlock(&rtnl_mutex);
99
100 while (head) {
101 struct sk_buff *next = head->next;
102
103 kfree_skb(head);
104 cond_resched();
105 head = next;
106 }
107}
108
109void rtnl_unlock(void)
110{
111
112 netdev_run_todo();
113}
114EXPORT_SYMBOL(rtnl_unlock);
115
116int rtnl_trylock(void)
117{
118 return mutex_trylock(&rtnl_mutex);
119}
120EXPORT_SYMBOL(rtnl_trylock);
121
122int rtnl_is_locked(void)
123{
124 return mutex_is_locked(&rtnl_mutex);
125}
126EXPORT_SYMBOL(rtnl_is_locked);
127
128bool refcount_dec_and_rtnl_lock(refcount_t *r)
129{
130 return refcount_dec_and_mutex_lock(r, &rtnl_mutex);
131}
132EXPORT_SYMBOL(refcount_dec_and_rtnl_lock);
133
134#ifdef CONFIG_PROVE_LOCKING
135bool lockdep_rtnl_is_held(void)
136{
137 return lockdep_is_held(&rtnl_mutex);
138}
139EXPORT_SYMBOL(lockdep_rtnl_is_held);
140#endif
141
142static struct rtnl_link *__rcu *rtnl_msg_handlers[RTNL_FAMILY_MAX + 1];
143
144static inline int rtm_msgindex(int msgtype)
145{
146 int msgindex = msgtype - RTM_BASE;
147
148
149
150
151
152
153 BUG_ON(msgindex < 0 || msgindex >= RTM_NR_MSGTYPES);
154
155 return msgindex;
156}
157
158static struct rtnl_link *rtnl_get_link(int protocol, int msgtype)
159{
160 struct rtnl_link **tab;
161
162 if (protocol >= ARRAY_SIZE(rtnl_msg_handlers))
163 protocol = PF_UNSPEC;
164
165 tab = rcu_dereference_rtnl(rtnl_msg_handlers[protocol]);
166 if (!tab)
167 tab = rcu_dereference_rtnl(rtnl_msg_handlers[PF_UNSPEC]);
168
169 return tab[msgtype];
170}
171
172static int rtnl_register_internal(struct module *owner,
173 int protocol, int msgtype,
174 rtnl_doit_func doit, rtnl_dumpit_func dumpit,
175 unsigned int flags)
176{
177 struct rtnl_link *link, *old;
178 struct rtnl_link __rcu **tab;
179 int msgindex;
180 int ret = -ENOBUFS;
181
182 BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
183 msgindex = rtm_msgindex(msgtype);
184
185 rtnl_lock();
186 tab = rtnl_msg_handlers[protocol];
187 if (tab == NULL) {
188 tab = kcalloc(RTM_NR_MSGTYPES, sizeof(void *), GFP_KERNEL);
189 if (!tab)
190 goto unlock;
191
192
193 rcu_assign_pointer(rtnl_msg_handlers[protocol], tab);
194 }
195
196 old = rtnl_dereference(tab[msgindex]);
197 if (old) {
198 link = kmemdup(old, sizeof(*old), GFP_KERNEL);
199 if (!link)
200 goto unlock;
201 } else {
202 link = kzalloc(sizeof(*link), GFP_KERNEL);
203 if (!link)
204 goto unlock;
205 }
206
207 WARN_ON(link->owner && link->owner != owner);
208 link->owner = owner;
209
210 WARN_ON(doit && link->doit && link->doit != doit);
211 if (doit)
212 link->doit = doit;
213 WARN_ON(dumpit && link->dumpit && link->dumpit != dumpit);
214 if (dumpit)
215 link->dumpit = dumpit;
216
217 link->flags |= flags;
218
219
220 rcu_assign_pointer(tab[msgindex], link);
221 ret = 0;
222 if (old)
223 kfree_rcu(old, rcu);
224unlock:
225 rtnl_unlock();
226 return ret;
227}
228
229
230
231
232
233
234
235
236
237
238
239
240
241int rtnl_register_module(struct module *owner,
242 int protocol, int msgtype,
243 rtnl_doit_func doit, rtnl_dumpit_func dumpit,
244 unsigned int flags)
245{
246 return rtnl_register_internal(owner, protocol, msgtype,
247 doit, dumpit, flags);
248}
249EXPORT_SYMBOL_GPL(rtnl_register_module);
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267void rtnl_register(int protocol, int msgtype,
268 rtnl_doit_func doit, rtnl_dumpit_func dumpit,
269 unsigned int flags)
270{
271 int err;
272
273 err = rtnl_register_internal(NULL, protocol, msgtype, doit, dumpit,
274 flags);
275 if (err)
276 pr_err("Unable to register rtnetlink message handler, "
277 "protocol = %d, message type = %d\n", protocol, msgtype);
278}
279
280
281
282
283
284
285
286
287int rtnl_unregister(int protocol, int msgtype)
288{
289 struct rtnl_link **tab, *link;
290 int msgindex;
291
292 BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
293 msgindex = rtm_msgindex(msgtype);
294
295 rtnl_lock();
296 tab = rtnl_dereference(rtnl_msg_handlers[protocol]);
297 if (!tab) {
298 rtnl_unlock();
299 return -ENOENT;
300 }
301
302 link = tab[msgindex];
303 rcu_assign_pointer(tab[msgindex], NULL);
304 rtnl_unlock();
305
306 kfree_rcu(link, rcu);
307
308 return 0;
309}
310EXPORT_SYMBOL_GPL(rtnl_unregister);
311
312
313
314
315
316
317
318
319void rtnl_unregister_all(int protocol)
320{
321 struct rtnl_link **tab, *link;
322 int msgindex;
323
324 BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
325
326 rtnl_lock();
327 tab = rtnl_msg_handlers[protocol];
328 if (!tab) {
329 rtnl_unlock();
330 return;
331 }
332 RCU_INIT_POINTER(rtnl_msg_handlers[protocol], NULL);
333 for (msgindex = 0; msgindex < RTM_NR_MSGTYPES; msgindex++) {
334 link = tab[msgindex];
335 if (!link)
336 continue;
337
338 rcu_assign_pointer(tab[msgindex], NULL);
339 kfree_rcu(link, rcu);
340 }
341 rtnl_unlock();
342
343 synchronize_net();
344
345 kfree(tab);
346}
347EXPORT_SYMBOL_GPL(rtnl_unregister_all);
348
349static LIST_HEAD(link_ops);
350
351static const struct rtnl_link_ops *rtnl_link_ops_get(const char *kind)
352{
353 const struct rtnl_link_ops *ops;
354
355 list_for_each_entry(ops, &link_ops, list) {
356 if (!strcmp(ops->kind, kind))
357 return ops;
358 }
359 return NULL;
360}
361
362
363
364
365
366
367
368
369
370
371
372int __rtnl_link_register(struct rtnl_link_ops *ops)
373{
374 if (rtnl_link_ops_get(ops->kind))
375 return -EEXIST;
376
377
378
379
380
381
382 if (ops->setup && !ops->dellink)
383 ops->dellink = unregister_netdevice_queue;
384
385 list_add_tail(&ops->list, &link_ops);
386 return 0;
387}
388EXPORT_SYMBOL_GPL(__rtnl_link_register);
389
390
391
392
393
394
395
396int rtnl_link_register(struct rtnl_link_ops *ops)
397{
398 int err;
399
400
401 if (WARN_ON(ops->maxtype > RTNL_MAX_TYPE ||
402 ops->slave_maxtype > RTNL_SLAVE_MAX_TYPE))
403 return -EINVAL;
404
405 rtnl_lock();
406 err = __rtnl_link_register(ops);
407 rtnl_unlock();
408 return err;
409}
410EXPORT_SYMBOL_GPL(rtnl_link_register);
411
412static void __rtnl_kill_links(struct net *net, struct rtnl_link_ops *ops)
413{
414 struct net_device *dev;
415 LIST_HEAD(list_kill);
416
417 for_each_netdev(net, dev) {
418 if (dev->rtnl_link_ops == ops)
419 ops->dellink(dev, &list_kill);
420 }
421 unregister_netdevice_many(&list_kill);
422}
423
424
425
426
427
428
429
430
431
432void __rtnl_link_unregister(struct rtnl_link_ops *ops)
433{
434 struct net *net;
435
436 for_each_net(net) {
437 __rtnl_kill_links(net, ops);
438 }
439 list_del(&ops->list);
440}
441EXPORT_SYMBOL_GPL(__rtnl_link_unregister);
442
443
444
445
446static void rtnl_lock_unregistering_all(void)
447{
448 struct net *net;
449 bool unregistering;
450 DEFINE_WAIT_FUNC(wait, woken_wake_function);
451
452 add_wait_queue(&netdev_unregistering_wq, &wait);
453 for (;;) {
454 unregistering = false;
455 rtnl_lock();
456
457
458
459 for_each_net(net) {
460 if (net->dev_unreg_count > 0) {
461 unregistering = true;
462 break;
463 }
464 }
465 if (!unregistering)
466 break;
467 __rtnl_unlock();
468
469 wait_woken(&wait, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
470 }
471 remove_wait_queue(&netdev_unregistering_wq, &wait);
472}
473
474
475
476
477
478void rtnl_link_unregister(struct rtnl_link_ops *ops)
479{
480
481 down_write(&pernet_ops_rwsem);
482 rtnl_lock_unregistering_all();
483 __rtnl_link_unregister(ops);
484 rtnl_unlock();
485 up_write(&pernet_ops_rwsem);
486}
487EXPORT_SYMBOL_GPL(rtnl_link_unregister);
488
489static size_t rtnl_link_get_slave_info_data_size(const struct net_device *dev)
490{
491 struct net_device *master_dev;
492 const struct rtnl_link_ops *ops;
493 size_t size = 0;
494
495 rcu_read_lock();
496
497 master_dev = netdev_master_upper_dev_get_rcu((struct net_device *)dev);
498 if (!master_dev)
499 goto out;
500
501 ops = master_dev->rtnl_link_ops;
502 if (!ops || !ops->get_slave_size)
503 goto out;
504
505 size = nla_total_size(sizeof(struct nlattr)) +
506 ops->get_slave_size(master_dev, dev);
507
508out:
509 rcu_read_unlock();
510 return size;
511}
512
513static size_t rtnl_link_get_size(const struct net_device *dev)
514{
515 const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
516 size_t size;
517
518 if (!ops)
519 return 0;
520
521 size = nla_total_size(sizeof(struct nlattr)) +
522 nla_total_size(strlen(ops->kind) + 1);
523
524 if (ops->get_size)
525
526 size += nla_total_size(sizeof(struct nlattr)) +
527 ops->get_size(dev);
528
529 if (ops->get_xstats_size)
530
531 size += nla_total_size(ops->get_xstats_size(dev));
532
533 size += rtnl_link_get_slave_info_data_size(dev);
534
535 return size;
536}
537
538static LIST_HEAD(rtnl_af_ops);
539
540static const struct rtnl_af_ops *rtnl_af_lookup(const int family)
541{
542 const struct rtnl_af_ops *ops;
543
544 list_for_each_entry_rcu(ops, &rtnl_af_ops, list) {
545 if (ops->family == family)
546 return ops;
547 }
548
549 return NULL;
550}
551
552
553
554
555
556
557
558void rtnl_af_register(struct rtnl_af_ops *ops)
559{
560 rtnl_lock();
561 list_add_tail_rcu(&ops->list, &rtnl_af_ops);
562 rtnl_unlock();
563}
564EXPORT_SYMBOL_GPL(rtnl_af_register);
565
566
567
568
569
570void rtnl_af_unregister(struct rtnl_af_ops *ops)
571{
572 rtnl_lock();
573 list_del_rcu(&ops->list);
574 rtnl_unlock();
575
576 synchronize_rcu();
577}
578EXPORT_SYMBOL_GPL(rtnl_af_unregister);
579
580static size_t rtnl_link_get_af_size(const struct net_device *dev,
581 u32 ext_filter_mask)
582{
583 struct rtnl_af_ops *af_ops;
584 size_t size;
585
586
587 size = nla_total_size(sizeof(struct nlattr));
588
589 rcu_read_lock();
590 list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
591 if (af_ops->get_link_af_size) {
592
593 size += nla_total_size(sizeof(struct nlattr)) +
594 af_ops->get_link_af_size(dev, ext_filter_mask);
595 }
596 }
597 rcu_read_unlock();
598
599 return size;
600}
601
602static bool rtnl_have_link_slave_info(const struct net_device *dev)
603{
604 struct net_device *master_dev;
605 bool ret = false;
606
607 rcu_read_lock();
608
609 master_dev = netdev_master_upper_dev_get_rcu((struct net_device *)dev);
610 if (master_dev && master_dev->rtnl_link_ops)
611 ret = true;
612 rcu_read_unlock();
613 return ret;
614}
615
616static int rtnl_link_slave_info_fill(struct sk_buff *skb,
617 const struct net_device *dev)
618{
619 struct net_device *master_dev;
620 const struct rtnl_link_ops *ops;
621 struct nlattr *slave_data;
622 int err;
623
624 master_dev = netdev_master_upper_dev_get((struct net_device *) dev);
625 if (!master_dev)
626 return 0;
627 ops = master_dev->rtnl_link_ops;
628 if (!ops)
629 return 0;
630 if (nla_put_string(skb, IFLA_INFO_SLAVE_KIND, ops->kind) < 0)
631 return -EMSGSIZE;
632 if (ops->fill_slave_info) {
633 slave_data = nla_nest_start_noflag(skb, IFLA_INFO_SLAVE_DATA);
634 if (!slave_data)
635 return -EMSGSIZE;
636 err = ops->fill_slave_info(skb, master_dev, dev);
637 if (err < 0)
638 goto err_cancel_slave_data;
639 nla_nest_end(skb, slave_data);
640 }
641 return 0;
642
643err_cancel_slave_data:
644 nla_nest_cancel(skb, slave_data);
645 return err;
646}
647
648static int rtnl_link_info_fill(struct sk_buff *skb,
649 const struct net_device *dev)
650{
651 const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
652 struct nlattr *data;
653 int err;
654
655 if (!ops)
656 return 0;
657 if (nla_put_string(skb, IFLA_INFO_KIND, ops->kind) < 0)
658 return -EMSGSIZE;
659 if (ops->fill_xstats) {
660 err = ops->fill_xstats(skb, dev);
661 if (err < 0)
662 return err;
663 }
664 if (ops->fill_info) {
665 data = nla_nest_start_noflag(skb, IFLA_INFO_DATA);
666 if (data == NULL)
667 return -EMSGSIZE;
668 err = ops->fill_info(skb, dev);
669 if (err < 0)
670 goto err_cancel_data;
671 nla_nest_end(skb, data);
672 }
673 return 0;
674
675err_cancel_data:
676 nla_nest_cancel(skb, data);
677 return err;
678}
679
680static int rtnl_link_fill(struct sk_buff *skb, const struct net_device *dev)
681{
682 struct nlattr *linkinfo;
683 int err = -EMSGSIZE;
684
685 linkinfo = nla_nest_start_noflag(skb, IFLA_LINKINFO);
686 if (linkinfo == NULL)
687 goto out;
688
689 err = rtnl_link_info_fill(skb, dev);
690 if (err < 0)
691 goto err_cancel_link;
692
693 err = rtnl_link_slave_info_fill(skb, dev);
694 if (err < 0)
695 goto err_cancel_link;
696
697 nla_nest_end(skb, linkinfo);
698 return 0;
699
700err_cancel_link:
701 nla_nest_cancel(skb, linkinfo);
702out:
703 return err;
704}
705
706int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigned int group, int echo)
707{
708 struct sock *rtnl = net->rtnl;
709 int err = 0;
710
711 NETLINK_CB(skb).dst_group = group;
712 if (echo)
713 refcount_inc(&skb->users);
714 netlink_broadcast(rtnl, skb, pid, group, GFP_KERNEL);
715 if (echo)
716 err = netlink_unicast(rtnl, skb, pid, MSG_DONTWAIT);
717 return err;
718}
719
720int rtnl_unicast(struct sk_buff *skb, struct net *net, u32 pid)
721{
722 struct sock *rtnl = net->rtnl;
723
724 return nlmsg_unicast(rtnl, skb, pid);
725}
726EXPORT_SYMBOL(rtnl_unicast);
727
728void rtnl_notify(struct sk_buff *skb, struct net *net, u32 pid, u32 group,
729 struct nlmsghdr *nlh, gfp_t flags)
730{
731 struct sock *rtnl = net->rtnl;
732 int report = 0;
733
734 if (nlh)
735 report = nlmsg_report(nlh);
736
737 nlmsg_notify(rtnl, skb, pid, group, report, flags);
738}
739EXPORT_SYMBOL(rtnl_notify);
740
741void rtnl_set_sk_err(struct net *net, u32 group, int error)
742{
743 struct sock *rtnl = net->rtnl;
744
745 netlink_set_err(rtnl, 0, group, error);
746}
747EXPORT_SYMBOL(rtnl_set_sk_err);
748
749int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics)
750{
751 struct nlattr *mx;
752 int i, valid = 0;
753
754
755 if (metrics == dst_default_metrics.metrics)
756 return 0;
757
758 mx = nla_nest_start_noflag(skb, RTA_METRICS);
759 if (mx == NULL)
760 return -ENOBUFS;
761
762 for (i = 0; i < RTAX_MAX; i++) {
763 if (metrics[i]) {
764 if (i == RTAX_CC_ALGO - 1) {
765 char tmp[TCP_CA_NAME_MAX], *name;
766
767 name = tcp_ca_get_name_by_key(metrics[i], tmp);
768 if (!name)
769 continue;
770 if (nla_put_string(skb, i + 1, name))
771 goto nla_put_failure;
772 } else if (i == RTAX_FEATURES - 1) {
773 u32 user_features = metrics[i] & RTAX_FEATURE_MASK;
774
775 if (!user_features)
776 continue;
777 BUILD_BUG_ON(RTAX_FEATURE_MASK & DST_FEATURE_MASK);
778 if (nla_put_u32(skb, i + 1, user_features))
779 goto nla_put_failure;
780 } else {
781 if (nla_put_u32(skb, i + 1, metrics[i]))
782 goto nla_put_failure;
783 }
784 valid++;
785 }
786 }
787
788 if (!valid) {
789 nla_nest_cancel(skb, mx);
790 return 0;
791 }
792
793 return nla_nest_end(skb, mx);
794
795nla_put_failure:
796 nla_nest_cancel(skb, mx);
797 return -EMSGSIZE;
798}
799EXPORT_SYMBOL(rtnetlink_put_metrics);
800
801int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id,
802 long expires, u32 error)
803{
804 struct rta_cacheinfo ci = {
805 .rta_error = error,
806 .rta_id = id,
807 };
808
809 if (dst) {
810 ci.rta_lastuse = jiffies_delta_to_clock_t(jiffies - dst->lastuse);
811 ci.rta_used = dst->__use;
812 ci.rta_clntref = atomic_read(&dst->__refcnt);
813 }
814 if (expires) {
815 unsigned long clock;
816
817 clock = jiffies_to_clock_t(abs(expires));
818 clock = min_t(unsigned long, clock, INT_MAX);
819 ci.rta_expires = (expires > 0) ? clock : -clock;
820 }
821 return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci);
822}
823EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo);
824
825static void set_operstate(struct net_device *dev, unsigned char transition)
826{
827 unsigned char operstate = dev->operstate;
828
829 switch (transition) {
830 case IF_OPER_UP:
831 if ((operstate == IF_OPER_DORMANT ||
832 operstate == IF_OPER_UNKNOWN) &&
833 !netif_dormant(dev))
834 operstate = IF_OPER_UP;
835 break;
836
837 case IF_OPER_DORMANT:
838 if (operstate == IF_OPER_UP ||
839 operstate == IF_OPER_UNKNOWN)
840 operstate = IF_OPER_DORMANT;
841 break;
842 }
843
844 if (dev->operstate != operstate) {
845 write_lock_bh(&dev_base_lock);
846 dev->operstate = operstate;
847 write_unlock_bh(&dev_base_lock);
848 netdev_state_change(dev);
849 }
850}
851
852static unsigned int rtnl_dev_get_flags(const struct net_device *dev)
853{
854 return (dev->flags & ~(IFF_PROMISC | IFF_ALLMULTI)) |
855 (dev->gflags & (IFF_PROMISC | IFF_ALLMULTI));
856}
857
858static unsigned int rtnl_dev_combine_flags(const struct net_device *dev,
859 const struct ifinfomsg *ifm)
860{
861 unsigned int flags = ifm->ifi_flags;
862
863
864 if (ifm->ifi_change)
865 flags = (flags & ifm->ifi_change) |
866 (rtnl_dev_get_flags(dev) & ~ifm->ifi_change);
867
868 return flags;
869}
870
871static void copy_rtnl_link_stats(struct rtnl_link_stats *a,
872 const struct rtnl_link_stats64 *b)
873{
874 a->rx_packets = b->rx_packets;
875 a->tx_packets = b->tx_packets;
876 a->rx_bytes = b->rx_bytes;
877 a->tx_bytes = b->tx_bytes;
878 a->rx_errors = b->rx_errors;
879 a->tx_errors = b->tx_errors;
880 a->rx_dropped = b->rx_dropped;
881 a->tx_dropped = b->tx_dropped;
882
883 a->multicast = b->multicast;
884 a->collisions = b->collisions;
885
886 a->rx_length_errors = b->rx_length_errors;
887 a->rx_over_errors = b->rx_over_errors;
888 a->rx_crc_errors = b->rx_crc_errors;
889 a->rx_frame_errors = b->rx_frame_errors;
890 a->rx_fifo_errors = b->rx_fifo_errors;
891 a->rx_missed_errors = b->rx_missed_errors;
892
893 a->tx_aborted_errors = b->tx_aborted_errors;
894 a->tx_carrier_errors = b->tx_carrier_errors;
895 a->tx_fifo_errors = b->tx_fifo_errors;
896 a->tx_heartbeat_errors = b->tx_heartbeat_errors;
897 a->tx_window_errors = b->tx_window_errors;
898
899 a->rx_compressed = b->rx_compressed;
900 a->tx_compressed = b->tx_compressed;
901
902 a->rx_nohandler = b->rx_nohandler;
903}
904
905
906static inline int rtnl_vfinfo_size(const struct net_device *dev,
907 u32 ext_filter_mask)
908{
909 if (dev->dev.parent && (ext_filter_mask & RTEXT_FILTER_VF)) {
910 int num_vfs = dev_num_vf(dev->dev.parent);
911 size_t size = nla_total_size(0);
912 size += num_vfs *
913 (nla_total_size(0) +
914 nla_total_size(sizeof(struct ifla_vf_mac)) +
915 nla_total_size(sizeof(struct ifla_vf_broadcast)) +
916 nla_total_size(sizeof(struct ifla_vf_vlan)) +
917 nla_total_size(0) +
918 nla_total_size(MAX_VLAN_LIST_LEN *
919 sizeof(struct ifla_vf_vlan_info)) +
920 nla_total_size(sizeof(struct ifla_vf_spoofchk)) +
921 nla_total_size(sizeof(struct ifla_vf_tx_rate)) +
922 nla_total_size(sizeof(struct ifla_vf_rate)) +
923 nla_total_size(sizeof(struct ifla_vf_link_state)) +
924 nla_total_size(sizeof(struct ifla_vf_rss_query_en)) +
925 nla_total_size(0) +
926
927 nla_total_size_64bit(sizeof(__u64)) +
928
929 nla_total_size_64bit(sizeof(__u64)) +
930
931 nla_total_size_64bit(sizeof(__u64)) +
932
933 nla_total_size_64bit(sizeof(__u64)) +
934
935 nla_total_size_64bit(sizeof(__u64)) +
936
937 nla_total_size_64bit(sizeof(__u64)) +
938
939 nla_total_size_64bit(sizeof(__u64)) +
940
941 nla_total_size_64bit(sizeof(__u64)) +
942 nla_total_size(sizeof(struct ifla_vf_trust)));
943 return size;
944 } else
945 return 0;
946}
947
948static size_t rtnl_port_size(const struct net_device *dev,
949 u32 ext_filter_mask)
950{
951 size_t port_size = nla_total_size(4)
952 + nla_total_size(PORT_PROFILE_MAX)
953 + nla_total_size(PORT_UUID_MAX)
954 + nla_total_size(PORT_UUID_MAX)
955 + nla_total_size(1)
956 + nla_total_size(2);
957 size_t vf_ports_size = nla_total_size(sizeof(struct nlattr));
958 size_t vf_port_size = nla_total_size(sizeof(struct nlattr))
959 + port_size;
960 size_t port_self_size = nla_total_size(sizeof(struct nlattr))
961 + port_size;
962
963 if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
964 !(ext_filter_mask & RTEXT_FILTER_VF))
965 return 0;
966 if (dev_num_vf(dev->dev.parent))
967 return port_self_size + vf_ports_size +
968 vf_port_size * dev_num_vf(dev->dev.parent);
969 else
970 return port_self_size;
971}
972
973static size_t rtnl_xdp_size(void)
974{
975 size_t xdp_size = nla_total_size(0) +
976 nla_total_size(1) +
977 nla_total_size(4) +
978 nla_total_size(4);
979
980 return xdp_size;
981}
982
983static size_t rtnl_prop_list_size(const struct net_device *dev)
984{
985 struct netdev_name_node *name_node;
986 size_t size;
987
988 if (list_empty(&dev->name_node->list))
989 return 0;
990 size = nla_total_size(0);
991 list_for_each_entry(name_node, &dev->name_node->list, list)
992 size += nla_total_size(ALTIFNAMSIZ);
993 return size;
994}
995
996static noinline size_t if_nlmsg_size(const struct net_device *dev,
997 u32 ext_filter_mask)
998{
999 return NLMSG_ALIGN(sizeof(struct ifinfomsg))
1000 + nla_total_size(IFNAMSIZ)
1001 + nla_total_size(IFALIASZ)
1002 + nla_total_size(IFNAMSIZ)
1003 + nla_total_size_64bit(sizeof(struct rtnl_link_ifmap))
1004 + nla_total_size(sizeof(struct rtnl_link_stats))
1005 + nla_total_size_64bit(sizeof(struct rtnl_link_stats64))
1006 + nla_total_size(MAX_ADDR_LEN)
1007 + nla_total_size(MAX_ADDR_LEN)
1008 + nla_total_size(4)
1009 + nla_total_size(4)
1010 + nla_total_size(4)
1011 + nla_total_size(4)
1012 + nla_total_size(4)
1013 + nla_total_size(1)
1014 + nla_total_size(4)
1015 + nla_total_size(4)
1016 + nla_total_size(4)
1017 + nla_total_size(4)
1018 + nla_total_size(4)
1019 + nla_total_size(1)
1020 + nla_total_size(1)
1021 + nla_total_size(4)
1022 + nla_total_size(4)
1023 + nla_total_size(4)
1024 + nla_total_size(ext_filter_mask
1025 & RTEXT_FILTER_VF ? 4 : 0)
1026 + rtnl_vfinfo_size(dev, ext_filter_mask)
1027 + rtnl_port_size(dev, ext_filter_mask)
1028 + rtnl_link_get_size(dev)
1029 + rtnl_link_get_af_size(dev, ext_filter_mask)
1030 + nla_total_size(MAX_PHYS_ITEM_ID_LEN)
1031 + nla_total_size(MAX_PHYS_ITEM_ID_LEN)
1032 + nla_total_size(IFNAMSIZ)
1033 + rtnl_xdp_size()
1034 + nla_total_size(4)
1035 + nla_total_size(4)
1036 + nla_total_size(4)
1037 + nla_total_size(1)
1038 + nla_total_size(4)
1039 + nla_total_size(4)
1040 + nla_total_size(4)
1041 + nla_total_size(4)
1042 + nla_total_size(4)
1043 + rtnl_prop_list_size(dev)
1044 + 0;
1045}
1046
1047static int rtnl_vf_ports_fill(struct sk_buff *skb, struct net_device *dev)
1048{
1049 struct nlattr *vf_ports;
1050 struct nlattr *vf_port;
1051 int vf;
1052 int err;
1053
1054 vf_ports = nla_nest_start_noflag(skb, IFLA_VF_PORTS);
1055 if (!vf_ports)
1056 return -EMSGSIZE;
1057
1058 for (vf = 0; vf < dev_num_vf(dev->dev.parent); vf++) {
1059 vf_port = nla_nest_start_noflag(skb, IFLA_VF_PORT);
1060 if (!vf_port)
1061 goto nla_put_failure;
1062 if (nla_put_u32(skb, IFLA_PORT_VF, vf))
1063 goto nla_put_failure;
1064 err = dev->netdev_ops->ndo_get_vf_port(dev, vf, skb);
1065 if (err == -EMSGSIZE)
1066 goto nla_put_failure;
1067 if (err) {
1068 nla_nest_cancel(skb, vf_port);
1069 continue;
1070 }
1071 nla_nest_end(skb, vf_port);
1072 }
1073
1074 nla_nest_end(skb, vf_ports);
1075
1076 return 0;
1077
1078nla_put_failure:
1079 nla_nest_cancel(skb, vf_ports);
1080 return -EMSGSIZE;
1081}
1082
1083static int rtnl_port_self_fill(struct sk_buff *skb, struct net_device *dev)
1084{
1085 struct nlattr *port_self;
1086 int err;
1087
1088 port_self = nla_nest_start_noflag(skb, IFLA_PORT_SELF);
1089 if (!port_self)
1090 return -EMSGSIZE;
1091
1092 err = dev->netdev_ops->ndo_get_vf_port(dev, PORT_SELF_VF, skb);
1093 if (err) {
1094 nla_nest_cancel(skb, port_self);
1095 return (err == -EMSGSIZE) ? err : 0;
1096 }
1097
1098 nla_nest_end(skb, port_self);
1099
1100 return 0;
1101}
1102
1103static int rtnl_port_fill(struct sk_buff *skb, struct net_device *dev,
1104 u32 ext_filter_mask)
1105{
1106 int err;
1107
1108 if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
1109 !(ext_filter_mask & RTEXT_FILTER_VF))
1110 return 0;
1111
1112 err = rtnl_port_self_fill(skb, dev);
1113 if (err)
1114 return err;
1115
1116 if (dev_num_vf(dev->dev.parent)) {
1117 err = rtnl_vf_ports_fill(skb, dev);
1118 if (err)
1119 return err;
1120 }
1121
1122 return 0;
1123}
1124
1125static int rtnl_phys_port_id_fill(struct sk_buff *skb, struct net_device *dev)
1126{
1127 int err;
1128 struct netdev_phys_item_id ppid;
1129
1130 err = dev_get_phys_port_id(dev, &ppid);
1131 if (err) {
1132 if (err == -EOPNOTSUPP)
1133 return 0;
1134 return err;
1135 }
1136
1137 if (nla_put(skb, IFLA_PHYS_PORT_ID, ppid.id_len, ppid.id))
1138 return -EMSGSIZE;
1139
1140 return 0;
1141}
1142
1143static int rtnl_phys_port_name_fill(struct sk_buff *skb, struct net_device *dev)
1144{
1145 char name[IFNAMSIZ];
1146 int err;
1147
1148 err = dev_get_phys_port_name(dev, name, sizeof(name));
1149 if (err) {
1150 if (err == -EOPNOTSUPP)
1151 return 0;
1152 return err;
1153 }
1154
1155 if (nla_put_string(skb, IFLA_PHYS_PORT_NAME, name))
1156 return -EMSGSIZE;
1157
1158 return 0;
1159}
1160
1161static int rtnl_phys_switch_id_fill(struct sk_buff *skb, struct net_device *dev)
1162{
1163 struct netdev_phys_item_id ppid = { };
1164 int err;
1165
1166 err = dev_get_port_parent_id(dev, &ppid, false);
1167 if (err) {
1168 if (err == -EOPNOTSUPP)
1169 return 0;
1170 return err;
1171 }
1172
1173 if (nla_put(skb, IFLA_PHYS_SWITCH_ID, ppid.id_len, ppid.id))
1174 return -EMSGSIZE;
1175
1176 return 0;
1177}
1178
1179static noinline_for_stack int rtnl_fill_stats(struct sk_buff *skb,
1180 struct net_device *dev)
1181{
1182 struct rtnl_link_stats64 *sp;
1183 struct nlattr *attr;
1184
1185 attr = nla_reserve_64bit(skb, IFLA_STATS64,
1186 sizeof(struct rtnl_link_stats64), IFLA_PAD);
1187 if (!attr)
1188 return -EMSGSIZE;
1189
1190 sp = nla_data(attr);
1191 dev_get_stats(dev, sp);
1192
1193 attr = nla_reserve(skb, IFLA_STATS,
1194 sizeof(struct rtnl_link_stats));
1195 if (!attr)
1196 return -EMSGSIZE;
1197
1198 copy_rtnl_link_stats(nla_data(attr), sp);
1199
1200 return 0;
1201}
1202
1203static noinline_for_stack int rtnl_fill_vfinfo(struct sk_buff *skb,
1204 struct net_device *dev,
1205 int vfs_num,
1206 struct nlattr *vfinfo)
1207{
1208 struct ifla_vf_rss_query_en vf_rss_query_en;
1209 struct nlattr *vf, *vfstats, *vfvlanlist;
1210 struct ifla_vf_link_state vf_linkstate;
1211 struct ifla_vf_vlan_info vf_vlan_info;
1212 struct ifla_vf_spoofchk vf_spoofchk;
1213 struct ifla_vf_tx_rate vf_tx_rate;
1214 struct ifla_vf_stats vf_stats;
1215 struct ifla_vf_trust vf_trust;
1216 struct ifla_vf_vlan vf_vlan;
1217 struct ifla_vf_rate vf_rate;
1218 struct ifla_vf_mac vf_mac;
1219 struct ifla_vf_broadcast vf_broadcast;
1220 struct ifla_vf_info ivi;
1221 struct ifla_vf_guid node_guid;
1222 struct ifla_vf_guid port_guid;
1223
1224 memset(&ivi, 0, sizeof(ivi));
1225
1226
1227
1228
1229
1230
1231 ivi.spoofchk = -1;
1232 ivi.rss_query_en = -1;
1233 ivi.trusted = -1;
1234
1235
1236
1237 ivi.linkstate = 0;
1238
1239 ivi.vlan_proto = htons(ETH_P_8021Q);
1240 if (dev->netdev_ops->ndo_get_vf_config(dev, vfs_num, &ivi))
1241 return 0;
1242
1243 memset(&vf_vlan_info, 0, sizeof(vf_vlan_info));
1244
1245 vf_mac.vf =
1246 vf_vlan.vf =
1247 vf_vlan_info.vf =
1248 vf_rate.vf =
1249 vf_tx_rate.vf =
1250 vf_spoofchk.vf =
1251 vf_linkstate.vf =
1252 vf_rss_query_en.vf =
1253 vf_trust.vf =
1254 node_guid.vf =
1255 port_guid.vf = ivi.vf;
1256
1257 memcpy(vf_mac.mac, ivi.mac, sizeof(ivi.mac));
1258 memcpy(vf_broadcast.broadcast, dev->broadcast, dev->addr_len);
1259 vf_vlan.vlan = ivi.vlan;
1260 vf_vlan.qos = ivi.qos;
1261 vf_vlan_info.vlan = ivi.vlan;
1262 vf_vlan_info.qos = ivi.qos;
1263 vf_vlan_info.vlan_proto = ivi.vlan_proto;
1264 vf_tx_rate.rate = ivi.max_tx_rate;
1265 vf_rate.min_tx_rate = ivi.min_tx_rate;
1266 vf_rate.max_tx_rate = ivi.max_tx_rate;
1267 vf_spoofchk.setting = ivi.spoofchk;
1268 vf_linkstate.link_state = ivi.linkstate;
1269 vf_rss_query_en.setting = ivi.rss_query_en;
1270 vf_trust.setting = ivi.trusted;
1271 vf = nla_nest_start_noflag(skb, IFLA_VF_INFO);
1272 if (!vf)
1273 goto nla_put_vfinfo_failure;
1274 if (nla_put(skb, IFLA_VF_MAC, sizeof(vf_mac), &vf_mac) ||
1275 nla_put(skb, IFLA_VF_BROADCAST, sizeof(vf_broadcast), &vf_broadcast) ||
1276 nla_put(skb, IFLA_VF_VLAN, sizeof(vf_vlan), &vf_vlan) ||
1277 nla_put(skb, IFLA_VF_RATE, sizeof(vf_rate),
1278 &vf_rate) ||
1279 nla_put(skb, IFLA_VF_TX_RATE, sizeof(vf_tx_rate),
1280 &vf_tx_rate) ||
1281 nla_put(skb, IFLA_VF_SPOOFCHK, sizeof(vf_spoofchk),
1282 &vf_spoofchk) ||
1283 nla_put(skb, IFLA_VF_LINK_STATE, sizeof(vf_linkstate),
1284 &vf_linkstate) ||
1285 nla_put(skb, IFLA_VF_RSS_QUERY_EN,
1286 sizeof(vf_rss_query_en),
1287 &vf_rss_query_en) ||
1288 nla_put(skb, IFLA_VF_TRUST,
1289 sizeof(vf_trust), &vf_trust))
1290 goto nla_put_vf_failure;
1291
1292 memset(&node_guid, 0, sizeof(node_guid));
1293 memset(&port_guid, 0, sizeof(port_guid));
1294 if (dev->netdev_ops->ndo_get_vf_guid &&
1295 !dev->netdev_ops->ndo_get_vf_guid(dev, vfs_num, &node_guid,
1296 &port_guid)) {
1297 if (nla_put(skb, IFLA_VF_IB_NODE_GUID, sizeof(node_guid),
1298 &node_guid) ||
1299 nla_put(skb, IFLA_VF_IB_PORT_GUID, sizeof(port_guid),
1300 &port_guid))
1301 goto nla_put_vf_failure;
1302 }
1303 vfvlanlist = nla_nest_start_noflag(skb, IFLA_VF_VLAN_LIST);
1304 if (!vfvlanlist)
1305 goto nla_put_vf_failure;
1306 if (nla_put(skb, IFLA_VF_VLAN_INFO, sizeof(vf_vlan_info),
1307 &vf_vlan_info)) {
1308 nla_nest_cancel(skb, vfvlanlist);
1309 goto nla_put_vf_failure;
1310 }
1311 nla_nest_end(skb, vfvlanlist);
1312 memset(&vf_stats, 0, sizeof(vf_stats));
1313 if (dev->netdev_ops->ndo_get_vf_stats)
1314 dev->netdev_ops->ndo_get_vf_stats(dev, vfs_num,
1315 &vf_stats);
1316 vfstats = nla_nest_start_noflag(skb, IFLA_VF_STATS);
1317 if (!vfstats)
1318 goto nla_put_vf_failure;
1319 if (nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_PACKETS,
1320 vf_stats.rx_packets, IFLA_VF_STATS_PAD) ||
1321 nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS,
1322 vf_stats.tx_packets, IFLA_VF_STATS_PAD) ||
1323 nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES,
1324 vf_stats.rx_bytes, IFLA_VF_STATS_PAD) ||
1325 nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES,
1326 vf_stats.tx_bytes, IFLA_VF_STATS_PAD) ||
1327 nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST,
1328 vf_stats.broadcast, IFLA_VF_STATS_PAD) ||
1329 nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST,
1330 vf_stats.multicast, IFLA_VF_STATS_PAD) ||
1331 nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_DROPPED,
1332 vf_stats.rx_dropped, IFLA_VF_STATS_PAD) ||
1333 nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_DROPPED,
1334 vf_stats.tx_dropped, IFLA_VF_STATS_PAD)) {
1335 nla_nest_cancel(skb, vfstats);
1336 goto nla_put_vf_failure;
1337 }
1338 nla_nest_end(skb, vfstats);
1339 nla_nest_end(skb, vf);
1340 return 0;
1341
1342nla_put_vf_failure:
1343 nla_nest_cancel(skb, vf);
1344nla_put_vfinfo_failure:
1345 nla_nest_cancel(skb, vfinfo);
1346 return -EMSGSIZE;
1347}
1348
1349static noinline_for_stack int rtnl_fill_vf(struct sk_buff *skb,
1350 struct net_device *dev,
1351 u32 ext_filter_mask)
1352{
1353 struct nlattr *vfinfo;
1354 int i, num_vfs;
1355
1356 if (!dev->dev.parent || ((ext_filter_mask & RTEXT_FILTER_VF) == 0))
1357 return 0;
1358
1359 num_vfs = dev_num_vf(dev->dev.parent);
1360 if (nla_put_u32(skb, IFLA_NUM_VF, num_vfs))
1361 return -EMSGSIZE;
1362
1363 if (!dev->netdev_ops->ndo_get_vf_config)
1364 return 0;
1365
1366 vfinfo = nla_nest_start_noflag(skb, IFLA_VFINFO_LIST);
1367 if (!vfinfo)
1368 return -EMSGSIZE;
1369
1370 for (i = 0; i < num_vfs; i++) {
1371 if (rtnl_fill_vfinfo(skb, dev, i, vfinfo))
1372 return -EMSGSIZE;
1373 }
1374
1375 nla_nest_end(skb, vfinfo);
1376 return 0;
1377}
1378
1379static int rtnl_fill_link_ifmap(struct sk_buff *skb, struct net_device *dev)
1380{
1381 struct rtnl_link_ifmap map;
1382
1383 memset(&map, 0, sizeof(map));
1384 map.mem_start = dev->mem_start;
1385 map.mem_end = dev->mem_end;
1386 map.base_addr = dev->base_addr;
1387 map.irq = dev->irq;
1388 map.dma = dev->dma;
1389 map.port = dev->if_port;
1390
1391 if (nla_put_64bit(skb, IFLA_MAP, sizeof(map), &map, IFLA_PAD))
1392 return -EMSGSIZE;
1393
1394 return 0;
1395}
1396
1397static u32 rtnl_xdp_prog_skb(struct net_device *dev)
1398{
1399 const struct bpf_prog *generic_xdp_prog;
1400
1401 ASSERT_RTNL();
1402
1403 generic_xdp_prog = rtnl_dereference(dev->xdp_prog);
1404 if (!generic_xdp_prog)
1405 return 0;
1406 return generic_xdp_prog->aux->id;
1407}
1408
1409static u32 rtnl_xdp_prog_drv(struct net_device *dev)
1410{
1411 return __dev_xdp_query(dev, dev->netdev_ops->ndo_bpf, XDP_QUERY_PROG);
1412}
1413
1414static u32 rtnl_xdp_prog_hw(struct net_device *dev)
1415{
1416 return __dev_xdp_query(dev, dev->netdev_ops->ndo_bpf,
1417 XDP_QUERY_PROG_HW);
1418}
1419
1420static int rtnl_xdp_report_one(struct sk_buff *skb, struct net_device *dev,
1421 u32 *prog_id, u8 *mode, u8 tgt_mode, u32 attr,
1422 u32 (*get_prog_id)(struct net_device *dev))
1423{
1424 u32 curr_id;
1425 int err;
1426
1427 curr_id = get_prog_id(dev);
1428 if (!curr_id)
1429 return 0;
1430
1431 *prog_id = curr_id;
1432 err = nla_put_u32(skb, attr, curr_id);
1433 if (err)
1434 return err;
1435
1436 if (*mode != XDP_ATTACHED_NONE)
1437 *mode = XDP_ATTACHED_MULTI;
1438 else
1439 *mode = tgt_mode;
1440
1441 return 0;
1442}
1443
1444static int rtnl_xdp_fill(struct sk_buff *skb, struct net_device *dev)
1445{
1446 struct nlattr *xdp;
1447 u32 prog_id;
1448 int err;
1449 u8 mode;
1450
1451 xdp = nla_nest_start_noflag(skb, IFLA_XDP);
1452 if (!xdp)
1453 return -EMSGSIZE;
1454
1455 prog_id = 0;
1456 mode = XDP_ATTACHED_NONE;
1457 err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_SKB,
1458 IFLA_XDP_SKB_PROG_ID, rtnl_xdp_prog_skb);
1459 if (err)
1460 goto err_cancel;
1461 err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_DRV,
1462 IFLA_XDP_DRV_PROG_ID, rtnl_xdp_prog_drv);
1463 if (err)
1464 goto err_cancel;
1465 err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_HW,
1466 IFLA_XDP_HW_PROG_ID, rtnl_xdp_prog_hw);
1467 if (err)
1468 goto err_cancel;
1469
1470 err = nla_put_u8(skb, IFLA_XDP_ATTACHED, mode);
1471 if (err)
1472 goto err_cancel;
1473
1474 if (prog_id && mode != XDP_ATTACHED_MULTI) {
1475 err = nla_put_u32(skb, IFLA_XDP_PROG_ID, prog_id);
1476 if (err)
1477 goto err_cancel;
1478 }
1479
1480 nla_nest_end(skb, xdp);
1481 return 0;
1482
1483err_cancel:
1484 nla_nest_cancel(skb, xdp);
1485 return err;
1486}
1487
1488static u32 rtnl_get_event(unsigned long event)
1489{
1490 u32 rtnl_event_type = IFLA_EVENT_NONE;
1491
1492 switch (event) {
1493 case NETDEV_REBOOT:
1494 rtnl_event_type = IFLA_EVENT_REBOOT;
1495 break;
1496 case NETDEV_FEAT_CHANGE:
1497 rtnl_event_type = IFLA_EVENT_FEATURES;
1498 break;
1499 case NETDEV_BONDING_FAILOVER:
1500 rtnl_event_type = IFLA_EVENT_BONDING_FAILOVER;
1501 break;
1502 case NETDEV_NOTIFY_PEERS:
1503 rtnl_event_type = IFLA_EVENT_NOTIFY_PEERS;
1504 break;
1505 case NETDEV_RESEND_IGMP:
1506 rtnl_event_type = IFLA_EVENT_IGMP_RESEND;
1507 break;
1508 case NETDEV_CHANGEINFODATA:
1509 rtnl_event_type = IFLA_EVENT_BONDING_OPTIONS;
1510 break;
1511 default:
1512 break;
1513 }
1514
1515 return rtnl_event_type;
1516}
1517
1518static int put_master_ifindex(struct sk_buff *skb, struct net_device *dev)
1519{
1520 const struct net_device *upper_dev;
1521 int ret = 0;
1522
1523 rcu_read_lock();
1524
1525 upper_dev = netdev_master_upper_dev_get_rcu(dev);
1526 if (upper_dev)
1527 ret = nla_put_u32(skb, IFLA_MASTER, upper_dev->ifindex);
1528
1529 rcu_read_unlock();
1530 return ret;
1531}
1532
1533static int nla_put_iflink(struct sk_buff *skb, const struct net_device *dev,
1534 bool force)
1535{
1536 int ifindex = dev_get_iflink(dev);
1537
1538 if (force || dev->ifindex != ifindex)
1539 return nla_put_u32(skb, IFLA_LINK, ifindex);
1540
1541 return 0;
1542}
1543
1544static noinline_for_stack int nla_put_ifalias(struct sk_buff *skb,
1545 struct net_device *dev)
1546{
1547 char buf[IFALIASZ];
1548 int ret;
1549
1550 ret = dev_get_alias(dev, buf, sizeof(buf));
1551 return ret > 0 ? nla_put_string(skb, IFLA_IFALIAS, buf) : 0;
1552}
1553
1554static int rtnl_fill_link_netnsid(struct sk_buff *skb,
1555 const struct net_device *dev,
1556 struct net *src_net, gfp_t gfp)
1557{
1558 bool put_iflink = false;
1559
1560 if (dev->rtnl_link_ops && dev->rtnl_link_ops->get_link_net) {
1561 struct net *link_net = dev->rtnl_link_ops->get_link_net(dev);
1562
1563 if (!net_eq(dev_net(dev), link_net)) {
1564 int id = peernet2id_alloc(src_net, link_net, gfp);
1565
1566 if (nla_put_s32(skb, IFLA_LINK_NETNSID, id))
1567 return -EMSGSIZE;
1568
1569 put_iflink = true;
1570 }
1571 }
1572
1573 return nla_put_iflink(skb, dev, put_iflink);
1574}
1575
1576static int rtnl_fill_link_af(struct sk_buff *skb,
1577 const struct net_device *dev,
1578 u32 ext_filter_mask)
1579{
1580 const struct rtnl_af_ops *af_ops;
1581 struct nlattr *af_spec;
1582
1583 af_spec = nla_nest_start_noflag(skb, IFLA_AF_SPEC);
1584 if (!af_spec)
1585 return -EMSGSIZE;
1586
1587 list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
1588 struct nlattr *af;
1589 int err;
1590
1591 if (!af_ops->fill_link_af)
1592 continue;
1593
1594 af = nla_nest_start_noflag(skb, af_ops->family);
1595 if (!af)
1596 return -EMSGSIZE;
1597
1598 err = af_ops->fill_link_af(skb, dev, ext_filter_mask);
1599
1600
1601
1602
1603
1604
1605 if (err == -ENODATA)
1606 nla_nest_cancel(skb, af);
1607 else if (err < 0)
1608 return -EMSGSIZE;
1609
1610 nla_nest_end(skb, af);
1611 }
1612
1613 nla_nest_end(skb, af_spec);
1614 return 0;
1615}
1616
1617static int rtnl_fill_alt_ifnames(struct sk_buff *skb,
1618 const struct net_device *dev)
1619{
1620 struct netdev_name_node *name_node;
1621 int count = 0;
1622
1623 list_for_each_entry(name_node, &dev->name_node->list, list) {
1624 if (nla_put_string(skb, IFLA_ALT_IFNAME, name_node->name))
1625 return -EMSGSIZE;
1626 count++;
1627 }
1628 return count;
1629}
1630
1631static int rtnl_fill_prop_list(struct sk_buff *skb,
1632 const struct net_device *dev)
1633{
1634 struct nlattr *prop_list;
1635 int ret;
1636
1637 prop_list = nla_nest_start(skb, IFLA_PROP_LIST);
1638 if (!prop_list)
1639 return -EMSGSIZE;
1640
1641 ret = rtnl_fill_alt_ifnames(skb, dev);
1642 if (ret <= 0)
1643 goto nest_cancel;
1644
1645 nla_nest_end(skb, prop_list);
1646 return 0;
1647
1648nest_cancel:
1649 nla_nest_cancel(skb, prop_list);
1650 return ret;
1651}
1652
1653static int rtnl_fill_ifinfo(struct sk_buff *skb,
1654 struct net_device *dev, struct net *src_net,
1655 int type, u32 pid, u32 seq, u32 change,
1656 unsigned int flags, u32 ext_filter_mask,
1657 u32 event, int *new_nsid, int new_ifindex,
1658 int tgt_netnsid, gfp_t gfp)
1659{
1660 struct ifinfomsg *ifm;
1661 struct nlmsghdr *nlh;
1662
1663 ASSERT_RTNL();
1664 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags);
1665 if (nlh == NULL)
1666 return -EMSGSIZE;
1667
1668 ifm = nlmsg_data(nlh);
1669 ifm->ifi_family = AF_UNSPEC;
1670 ifm->__ifi_pad = 0;
1671 ifm->ifi_type = dev->type;
1672 ifm->ifi_index = dev->ifindex;
1673 ifm->ifi_flags = dev_get_flags(dev);
1674 ifm->ifi_change = change;
1675
1676 if (tgt_netnsid >= 0 && nla_put_s32(skb, IFLA_TARGET_NETNSID, tgt_netnsid))
1677 goto nla_put_failure;
1678
1679 if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
1680 nla_put_u32(skb, IFLA_TXQLEN, dev->tx_queue_len) ||
1681 nla_put_u8(skb, IFLA_OPERSTATE,
1682 netif_running(dev) ? dev->operstate : IF_OPER_DOWN) ||
1683 nla_put_u8(skb, IFLA_LINKMODE, dev->link_mode) ||
1684 nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
1685 nla_put_u32(skb, IFLA_MIN_MTU, dev->min_mtu) ||
1686 nla_put_u32(skb, IFLA_MAX_MTU, dev->max_mtu) ||
1687 nla_put_u32(skb, IFLA_GROUP, dev->group) ||
1688 nla_put_u32(skb, IFLA_PROMISCUITY, dev->promiscuity) ||
1689 nla_put_u32(skb, IFLA_NUM_TX_QUEUES, dev->num_tx_queues) ||
1690 nla_put_u32(skb, IFLA_GSO_MAX_SEGS, dev->gso_max_segs) ||
1691 nla_put_u32(skb, IFLA_GSO_MAX_SIZE, dev->gso_max_size) ||
1692#ifdef CONFIG_RPS
1693 nla_put_u32(skb, IFLA_NUM_RX_QUEUES, dev->num_rx_queues) ||
1694#endif
1695 put_master_ifindex(skb, dev) ||
1696 nla_put_u8(skb, IFLA_CARRIER, netif_carrier_ok(dev)) ||
1697 (dev->qdisc &&
1698 nla_put_string(skb, IFLA_QDISC, dev->qdisc->ops->id)) ||
1699 nla_put_ifalias(skb, dev) ||
1700 nla_put_u32(skb, IFLA_CARRIER_CHANGES,
1701 atomic_read(&dev->carrier_up_count) +
1702 atomic_read(&dev->carrier_down_count)) ||
1703 nla_put_u8(skb, IFLA_PROTO_DOWN, dev->proto_down) ||
1704 nla_put_u32(skb, IFLA_CARRIER_UP_COUNT,
1705 atomic_read(&dev->carrier_up_count)) ||
1706 nla_put_u32(skb, IFLA_CARRIER_DOWN_COUNT,
1707 atomic_read(&dev->carrier_down_count)))
1708 goto nla_put_failure;
1709
1710 if (event != IFLA_EVENT_NONE) {
1711 if (nla_put_u32(skb, IFLA_EVENT, event))
1712 goto nla_put_failure;
1713 }
1714
1715 if (rtnl_fill_link_ifmap(skb, dev))
1716 goto nla_put_failure;
1717
1718 if (dev->addr_len) {
1719 if (nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr) ||
1720 nla_put(skb, IFLA_BROADCAST, dev->addr_len, dev->broadcast))
1721 goto nla_put_failure;
1722 }
1723
1724 if (rtnl_phys_port_id_fill(skb, dev))
1725 goto nla_put_failure;
1726
1727 if (rtnl_phys_port_name_fill(skb, dev))
1728 goto nla_put_failure;
1729
1730 if (rtnl_phys_switch_id_fill(skb, dev))
1731 goto nla_put_failure;
1732
1733 if (rtnl_fill_stats(skb, dev))
1734 goto nla_put_failure;
1735
1736 if (rtnl_fill_vf(skb, dev, ext_filter_mask))
1737 goto nla_put_failure;
1738
1739 if (rtnl_port_fill(skb, dev, ext_filter_mask))
1740 goto nla_put_failure;
1741
1742 if (rtnl_xdp_fill(skb, dev))
1743 goto nla_put_failure;
1744
1745 if (dev->rtnl_link_ops || rtnl_have_link_slave_info(dev)) {
1746 if (rtnl_link_fill(skb, dev) < 0)
1747 goto nla_put_failure;
1748 }
1749
1750 if (rtnl_fill_link_netnsid(skb, dev, src_net, gfp))
1751 goto nla_put_failure;
1752
1753 if (new_nsid &&
1754 nla_put_s32(skb, IFLA_NEW_NETNSID, *new_nsid) < 0)
1755 goto nla_put_failure;
1756 if (new_ifindex &&
1757 nla_put_s32(skb, IFLA_NEW_IFINDEX, new_ifindex) < 0)
1758 goto nla_put_failure;
1759
1760
1761 rcu_read_lock();
1762 if (rtnl_fill_link_af(skb, dev, ext_filter_mask))
1763 goto nla_put_failure_rcu;
1764 rcu_read_unlock();
1765
1766 if (rtnl_fill_prop_list(skb, dev))
1767 goto nla_put_failure;
1768
1769 nlmsg_end(skb, nlh);
1770 return 0;
1771
1772nla_put_failure_rcu:
1773 rcu_read_unlock();
1774nla_put_failure:
1775 nlmsg_cancel(skb, nlh);
1776 return -EMSGSIZE;
1777}
1778
1779static const struct nla_policy ifla_policy[IFLA_MAX+1] = {
1780 [IFLA_IFNAME] = { .type = NLA_STRING, .len = IFNAMSIZ-1 },
1781 [IFLA_ADDRESS] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
1782 [IFLA_BROADCAST] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
1783 [IFLA_MAP] = { .len = sizeof(struct rtnl_link_ifmap) },
1784 [IFLA_MTU] = { .type = NLA_U32 },
1785 [IFLA_LINK] = { .type = NLA_U32 },
1786 [IFLA_MASTER] = { .type = NLA_U32 },
1787 [IFLA_CARRIER] = { .type = NLA_U8 },
1788 [IFLA_TXQLEN] = { .type = NLA_U32 },
1789 [IFLA_WEIGHT] = { .type = NLA_U32 },
1790 [IFLA_OPERSTATE] = { .type = NLA_U8 },
1791 [IFLA_LINKMODE] = { .type = NLA_U8 },
1792 [IFLA_LINKINFO] = { .type = NLA_NESTED },
1793 [IFLA_NET_NS_PID] = { .type = NLA_U32 },
1794 [IFLA_NET_NS_FD] = { .type = NLA_U32 },
1795
1796
1797
1798 [IFLA_IFALIAS] = { .type = NLA_BINARY, .len = IFALIASZ - 1 },
1799 [IFLA_VFINFO_LIST] = {. type = NLA_NESTED },
1800 [IFLA_VF_PORTS] = { .type = NLA_NESTED },
1801 [IFLA_PORT_SELF] = { .type = NLA_NESTED },
1802 [IFLA_AF_SPEC] = { .type = NLA_NESTED },
1803 [IFLA_EXT_MASK] = { .type = NLA_U32 },
1804 [IFLA_PROMISCUITY] = { .type = NLA_U32 },
1805 [IFLA_NUM_TX_QUEUES] = { .type = NLA_U32 },
1806 [IFLA_NUM_RX_QUEUES] = { .type = NLA_U32 },
1807 [IFLA_GSO_MAX_SEGS] = { .type = NLA_U32 },
1808 [IFLA_GSO_MAX_SIZE] = { .type = NLA_U32 },
1809 [IFLA_PHYS_PORT_ID] = { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
1810 [IFLA_CARRIER_CHANGES] = { .type = NLA_U32 },
1811 [IFLA_PHYS_SWITCH_ID] = { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
1812 [IFLA_LINK_NETNSID] = { .type = NLA_S32 },
1813 [IFLA_PROTO_DOWN] = { .type = NLA_U8 },
1814 [IFLA_XDP] = { .type = NLA_NESTED },
1815 [IFLA_EVENT] = { .type = NLA_U32 },
1816 [IFLA_GROUP] = { .type = NLA_U32 },
1817 [IFLA_TARGET_NETNSID] = { .type = NLA_S32 },
1818 [IFLA_CARRIER_UP_COUNT] = { .type = NLA_U32 },
1819 [IFLA_CARRIER_DOWN_COUNT] = { .type = NLA_U32 },
1820 [IFLA_MIN_MTU] = { .type = NLA_U32 },
1821 [IFLA_MAX_MTU] = { .type = NLA_U32 },
1822 [IFLA_PROP_LIST] = { .type = NLA_NESTED },
1823 [IFLA_ALT_IFNAME] = { .type = NLA_STRING,
1824 .len = ALTIFNAMSIZ - 1 },
1825};
1826
1827static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = {
1828 [IFLA_INFO_KIND] = { .type = NLA_STRING },
1829 [IFLA_INFO_DATA] = { .type = NLA_NESTED },
1830 [IFLA_INFO_SLAVE_KIND] = { .type = NLA_STRING },
1831 [IFLA_INFO_SLAVE_DATA] = { .type = NLA_NESTED },
1832};
1833
1834static const struct nla_policy ifla_vf_policy[IFLA_VF_MAX+1] = {
1835 [IFLA_VF_MAC] = { .len = sizeof(struct ifla_vf_mac) },
1836 [IFLA_VF_BROADCAST] = { .type = NLA_REJECT },
1837 [IFLA_VF_VLAN] = { .len = sizeof(struct ifla_vf_vlan) },
1838 [IFLA_VF_VLAN_LIST] = { .type = NLA_NESTED },
1839 [IFLA_VF_TX_RATE] = { .len = sizeof(struct ifla_vf_tx_rate) },
1840 [IFLA_VF_SPOOFCHK] = { .len = sizeof(struct ifla_vf_spoofchk) },
1841 [IFLA_VF_RATE] = { .len = sizeof(struct ifla_vf_rate) },
1842 [IFLA_VF_LINK_STATE] = { .len = sizeof(struct ifla_vf_link_state) },
1843 [IFLA_VF_RSS_QUERY_EN] = { .len = sizeof(struct ifla_vf_rss_query_en) },
1844 [IFLA_VF_STATS] = { .type = NLA_NESTED },
1845 [IFLA_VF_TRUST] = { .len = sizeof(struct ifla_vf_trust) },
1846 [IFLA_VF_IB_NODE_GUID] = { .len = sizeof(struct ifla_vf_guid) },
1847 [IFLA_VF_IB_PORT_GUID] = { .len = sizeof(struct ifla_vf_guid) },
1848};
1849
1850static const struct nla_policy ifla_port_policy[IFLA_PORT_MAX+1] = {
1851 [IFLA_PORT_VF] = { .type = NLA_U32 },
1852 [IFLA_PORT_PROFILE] = { .type = NLA_STRING,
1853 .len = PORT_PROFILE_MAX },
1854 [IFLA_PORT_INSTANCE_UUID] = { .type = NLA_BINARY,
1855 .len = PORT_UUID_MAX },
1856 [IFLA_PORT_HOST_UUID] = { .type = NLA_STRING,
1857 .len = PORT_UUID_MAX },
1858 [IFLA_PORT_REQUEST] = { .type = NLA_U8, },
1859 [IFLA_PORT_RESPONSE] = { .type = NLA_U16, },
1860
1861
1862
1863
1864
1865 [IFLA_PORT_VSI_TYPE] = { .type = NLA_BINARY,
1866 .len = sizeof(struct ifla_port_vsi) },
1867};
1868
1869static const struct nla_policy ifla_xdp_policy[IFLA_XDP_MAX + 1] = {
1870 [IFLA_XDP_FD] = { .type = NLA_S32 },
1871 [IFLA_XDP_ATTACHED] = { .type = NLA_U8 },
1872 [IFLA_XDP_FLAGS] = { .type = NLA_U32 },
1873 [IFLA_XDP_PROG_ID] = { .type = NLA_U32 },
1874};
1875
1876static const struct rtnl_link_ops *linkinfo_to_kind_ops(const struct nlattr *nla)
1877{
1878 const struct rtnl_link_ops *ops = NULL;
1879 struct nlattr *linfo[IFLA_INFO_MAX + 1];
1880
1881 if (nla_parse_nested_deprecated(linfo, IFLA_INFO_MAX, nla, ifla_info_policy, NULL) < 0)
1882 return NULL;
1883
1884 if (linfo[IFLA_INFO_KIND]) {
1885 char kind[MODULE_NAME_LEN];
1886
1887 nla_strlcpy(kind, linfo[IFLA_INFO_KIND], sizeof(kind));
1888 ops = rtnl_link_ops_get(kind);
1889 }
1890
1891 return ops;
1892}
1893
1894static bool link_master_filtered(struct net_device *dev, int master_idx)
1895{
1896 struct net_device *master;
1897
1898 if (!master_idx)
1899 return false;
1900
1901 master = netdev_master_upper_dev_get(dev);
1902 if (!master || master->ifindex != master_idx)
1903 return true;
1904
1905 return false;
1906}
1907
1908static bool link_kind_filtered(const struct net_device *dev,
1909 const struct rtnl_link_ops *kind_ops)
1910{
1911 if (kind_ops && dev->rtnl_link_ops != kind_ops)
1912 return true;
1913
1914 return false;
1915}
1916
1917static bool link_dump_filtered(struct net_device *dev,
1918 int master_idx,
1919 const struct rtnl_link_ops *kind_ops)
1920{
1921 if (link_master_filtered(dev, master_idx) ||
1922 link_kind_filtered(dev, kind_ops))
1923 return true;
1924
1925 return false;
1926}
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936struct net *rtnl_get_net_ns_capable(struct sock *sk, int netnsid)
1937{
1938 struct net *net;
1939
1940 net = get_net_ns_by_id(sock_net(sk), netnsid);
1941 if (!net)
1942 return ERR_PTR(-EINVAL);
1943
1944
1945
1946
1947 if (!sk_ns_capable(sk, net->user_ns, CAP_NET_ADMIN)) {
1948 put_net(net);
1949 return ERR_PTR(-EACCES);
1950 }
1951 return net;
1952}
1953EXPORT_SYMBOL_GPL(rtnl_get_net_ns_capable);
1954
1955static int rtnl_valid_dump_ifinfo_req(const struct nlmsghdr *nlh,
1956 bool strict_check, struct nlattr **tb,
1957 struct netlink_ext_ack *extack)
1958{
1959 int hdrlen;
1960
1961 if (strict_check) {
1962 struct ifinfomsg *ifm;
1963
1964 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
1965 NL_SET_ERR_MSG(extack, "Invalid header for link dump");
1966 return -EINVAL;
1967 }
1968
1969 ifm = nlmsg_data(nlh);
1970 if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
1971 ifm->ifi_change) {
1972 NL_SET_ERR_MSG(extack, "Invalid values in header for link dump request");
1973 return -EINVAL;
1974 }
1975 if (ifm->ifi_index) {
1976 NL_SET_ERR_MSG(extack, "Filter by device index not supported for link dumps");
1977 return -EINVAL;
1978 }
1979
1980 return nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb,
1981 IFLA_MAX, ifla_policy,
1982 extack);
1983 }
1984
1985
1986
1987
1988
1989
1990
1991
1992 hdrlen = nlmsg_len(nlh) < sizeof(struct ifinfomsg) ?
1993 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg);
1994
1995 return nlmsg_parse_deprecated(nlh, hdrlen, tb, IFLA_MAX, ifla_policy,
1996 extack);
1997}
1998
1999static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
2000{
2001 struct netlink_ext_ack *extack = cb->extack;
2002 const struct nlmsghdr *nlh = cb->nlh;
2003 struct net *net = sock_net(skb->sk);
2004 struct net *tgt_net = net;
2005 int h, s_h;
2006 int idx = 0, s_idx;
2007 struct net_device *dev;
2008 struct hlist_head *head;
2009 struct nlattr *tb[IFLA_MAX+1];
2010 u32 ext_filter_mask = 0;
2011 const struct rtnl_link_ops *kind_ops = NULL;
2012 unsigned int flags = NLM_F_MULTI;
2013 int master_idx = 0;
2014 int netnsid = -1;
2015 int err, i;
2016
2017 s_h = cb->args[0];
2018 s_idx = cb->args[1];
2019
2020 err = rtnl_valid_dump_ifinfo_req(nlh, cb->strict_check, tb, extack);
2021 if (err < 0) {
2022 if (cb->strict_check)
2023 return err;
2024
2025 goto walk_entries;
2026 }
2027
2028 for (i = 0; i <= IFLA_MAX; ++i) {
2029 if (!tb[i])
2030 continue;
2031
2032
2033 switch (i) {
2034 case IFLA_TARGET_NETNSID:
2035 netnsid = nla_get_s32(tb[i]);
2036 tgt_net = rtnl_get_net_ns_capable(skb->sk, netnsid);
2037 if (IS_ERR(tgt_net)) {
2038 NL_SET_ERR_MSG(extack, "Invalid target network namespace id");
2039 return PTR_ERR(tgt_net);
2040 }
2041 break;
2042 case IFLA_EXT_MASK:
2043 ext_filter_mask = nla_get_u32(tb[i]);
2044 break;
2045 case IFLA_MASTER:
2046 master_idx = nla_get_u32(tb[i]);
2047 break;
2048 case IFLA_LINKINFO:
2049 kind_ops = linkinfo_to_kind_ops(tb[i]);
2050 break;
2051 default:
2052 if (cb->strict_check) {
2053 NL_SET_ERR_MSG(extack, "Unsupported attribute in link dump request");
2054 return -EINVAL;
2055 }
2056 }
2057 }
2058
2059 if (master_idx || kind_ops)
2060 flags |= NLM_F_DUMP_FILTERED;
2061
2062walk_entries:
2063 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
2064 idx = 0;
2065 head = &tgt_net->dev_index_head[h];
2066 hlist_for_each_entry(dev, head, index_hlist) {
2067 if (link_dump_filtered(dev, master_idx, kind_ops))
2068 goto cont;
2069 if (idx < s_idx)
2070 goto cont;
2071 err = rtnl_fill_ifinfo(skb, dev, net,
2072 RTM_NEWLINK,
2073 NETLINK_CB(cb->skb).portid,
2074 nlh->nlmsg_seq, 0, flags,
2075 ext_filter_mask, 0, NULL, 0,
2076 netnsid, GFP_KERNEL);
2077
2078 if (err < 0) {
2079 if (likely(skb->len))
2080 goto out;
2081
2082 goto out_err;
2083 }
2084cont:
2085 idx++;
2086 }
2087 }
2088out:
2089 err = skb->len;
2090out_err:
2091 cb->args[1] = idx;
2092 cb->args[0] = h;
2093 cb->seq = net->dev_base_seq;
2094 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
2095 if (netnsid >= 0)
2096 put_net(tgt_net);
2097
2098 return err;
2099}
2100
2101int rtnl_nla_parse_ifla(struct nlattr **tb, const struct nlattr *head, int len,
2102 struct netlink_ext_ack *exterr)
2103{
2104 return nla_parse_deprecated(tb, IFLA_MAX, head, len, ifla_policy,
2105 exterr);
2106}
2107EXPORT_SYMBOL(rtnl_nla_parse_ifla);
2108
2109struct net *rtnl_link_get_net(struct net *src_net, struct nlattr *tb[])
2110{
2111 struct net *net;
2112
2113
2114
2115 if (tb[IFLA_NET_NS_PID])
2116 net = get_net_ns_by_pid(nla_get_u32(tb[IFLA_NET_NS_PID]));
2117 else if (tb[IFLA_NET_NS_FD])
2118 net = get_net_ns_by_fd(nla_get_u32(tb[IFLA_NET_NS_FD]));
2119 else
2120 net = get_net(src_net);
2121 return net;
2122}
2123EXPORT_SYMBOL(rtnl_link_get_net);
2124
2125
2126
2127
2128
2129
2130
2131
2132static struct net *rtnl_link_get_net_by_nlattr(struct net *src_net,
2133 struct nlattr *tb[])
2134{
2135 struct net *net;
2136
2137 if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD])
2138 return rtnl_link_get_net(src_net, tb);
2139
2140 if (!tb[IFLA_TARGET_NETNSID])
2141 return get_net(src_net);
2142
2143 net = get_net_ns_by_id(src_net, nla_get_u32(tb[IFLA_TARGET_NETNSID]));
2144 if (!net)
2145 return ERR_PTR(-EINVAL);
2146
2147 return net;
2148}
2149
2150static struct net *rtnl_link_get_net_capable(const struct sk_buff *skb,
2151 struct net *src_net,
2152 struct nlattr *tb[], int cap)
2153{
2154 struct net *net;
2155
2156 net = rtnl_link_get_net_by_nlattr(src_net, tb);
2157 if (IS_ERR(net))
2158 return net;
2159
2160 if (!netlink_ns_capable(skb, net->user_ns, cap)) {
2161 put_net(net);
2162 return ERR_PTR(-EPERM);
2163 }
2164
2165 return net;
2166}
2167
2168
2169
2170
2171static int rtnl_ensure_unique_netns(struct nlattr *tb[],
2172 struct netlink_ext_ack *extack,
2173 bool netns_id_only)
2174{
2175
2176 if (netns_id_only) {
2177 if (!tb[IFLA_NET_NS_PID] && !tb[IFLA_NET_NS_FD])
2178 return 0;
2179
2180 NL_SET_ERR_MSG(extack, "specified netns attribute not supported");
2181 return -EOPNOTSUPP;
2182 }
2183
2184 if (tb[IFLA_TARGET_NETNSID] && (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD]))
2185 goto invalid_attr;
2186
2187 if (tb[IFLA_NET_NS_PID] && (tb[IFLA_TARGET_NETNSID] || tb[IFLA_NET_NS_FD]))
2188 goto invalid_attr;
2189
2190 if (tb[IFLA_NET_NS_FD] && (tb[IFLA_TARGET_NETNSID] || tb[IFLA_NET_NS_PID]))
2191 goto invalid_attr;
2192
2193 return 0;
2194
2195invalid_attr:
2196 NL_SET_ERR_MSG(extack, "multiple netns identifying attributes specified");
2197 return -EINVAL;
2198}
2199
2200static int validate_linkmsg(struct net_device *dev, struct nlattr *tb[])
2201{
2202 if (dev) {
2203 if (tb[IFLA_ADDRESS] &&
2204 nla_len(tb[IFLA_ADDRESS]) < dev->addr_len)
2205 return -EINVAL;
2206
2207 if (tb[IFLA_BROADCAST] &&
2208 nla_len(tb[IFLA_BROADCAST]) < dev->addr_len)
2209 return -EINVAL;
2210 }
2211
2212 if (tb[IFLA_AF_SPEC]) {
2213 struct nlattr *af;
2214 int rem, err;
2215
2216 nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
2217 const struct rtnl_af_ops *af_ops;
2218
2219 rcu_read_lock();
2220 af_ops = rtnl_af_lookup(nla_type(af));
2221 if (!af_ops) {
2222 rcu_read_unlock();
2223 return -EAFNOSUPPORT;
2224 }
2225
2226 if (!af_ops->set_link_af) {
2227 rcu_read_unlock();
2228 return -EOPNOTSUPP;
2229 }
2230
2231 if (af_ops->validate_link_af) {
2232 err = af_ops->validate_link_af(dev, af);
2233 if (err < 0) {
2234 rcu_read_unlock();
2235 return err;
2236 }
2237 }
2238
2239 rcu_read_unlock();
2240 }
2241 }
2242
2243 return 0;
2244}
2245
2246static int handle_infiniband_guid(struct net_device *dev, struct ifla_vf_guid *ivt,
2247 int guid_type)
2248{
2249 const struct net_device_ops *ops = dev->netdev_ops;
2250
2251 return ops->ndo_set_vf_guid(dev, ivt->vf, ivt->guid, guid_type);
2252}
2253
2254static int handle_vf_guid(struct net_device *dev, struct ifla_vf_guid *ivt, int guid_type)
2255{
2256 if (dev->type != ARPHRD_INFINIBAND)
2257 return -EOPNOTSUPP;
2258
2259 return handle_infiniband_guid(dev, ivt, guid_type);
2260}
2261
2262static int do_setvfinfo(struct net_device *dev, struct nlattr **tb)
2263{
2264 const struct net_device_ops *ops = dev->netdev_ops;
2265 int err = -EINVAL;
2266
2267 if (tb[IFLA_VF_MAC]) {
2268 struct ifla_vf_mac *ivm = nla_data(tb[IFLA_VF_MAC]);
2269
2270 if (ivm->vf >= INT_MAX)
2271 return -EINVAL;
2272 err = -EOPNOTSUPP;
2273 if (ops->ndo_set_vf_mac)
2274 err = ops->ndo_set_vf_mac(dev, ivm->vf,
2275 ivm->mac);
2276 if (err < 0)
2277 return err;
2278 }
2279
2280 if (tb[IFLA_VF_VLAN]) {
2281 struct ifla_vf_vlan *ivv = nla_data(tb[IFLA_VF_VLAN]);
2282
2283 if (ivv->vf >= INT_MAX)
2284 return -EINVAL;
2285 err = -EOPNOTSUPP;
2286 if (ops->ndo_set_vf_vlan)
2287 err = ops->ndo_set_vf_vlan(dev, ivv->vf, ivv->vlan,
2288 ivv->qos,
2289 htons(ETH_P_8021Q));
2290 if (err < 0)
2291 return err;
2292 }
2293
2294 if (tb[IFLA_VF_VLAN_LIST]) {
2295 struct ifla_vf_vlan_info *ivvl[MAX_VLAN_LIST_LEN];
2296 struct nlattr *attr;
2297 int rem, len = 0;
2298
2299 err = -EOPNOTSUPP;
2300 if (!ops->ndo_set_vf_vlan)
2301 return err;
2302
2303 nla_for_each_nested(attr, tb[IFLA_VF_VLAN_LIST], rem) {
2304 if (nla_type(attr) != IFLA_VF_VLAN_INFO ||
2305 nla_len(attr) < NLA_HDRLEN) {
2306 return -EINVAL;
2307 }
2308 if (len >= MAX_VLAN_LIST_LEN)
2309 return -EOPNOTSUPP;
2310 ivvl[len] = nla_data(attr);
2311
2312 len++;
2313 }
2314 if (len == 0)
2315 return -EINVAL;
2316
2317 if (ivvl[0]->vf >= INT_MAX)
2318 return -EINVAL;
2319 err = ops->ndo_set_vf_vlan(dev, ivvl[0]->vf, ivvl[0]->vlan,
2320 ivvl[0]->qos, ivvl[0]->vlan_proto);
2321 if (err < 0)
2322 return err;
2323 }
2324
2325 if (tb[IFLA_VF_TX_RATE]) {
2326 struct ifla_vf_tx_rate *ivt = nla_data(tb[IFLA_VF_TX_RATE]);
2327 struct ifla_vf_info ivf;
2328
2329 if (ivt->vf >= INT_MAX)
2330 return -EINVAL;
2331 err = -EOPNOTSUPP;
2332 if (ops->ndo_get_vf_config)
2333 err = ops->ndo_get_vf_config(dev, ivt->vf, &ivf);
2334 if (err < 0)
2335 return err;
2336
2337 err = -EOPNOTSUPP;
2338 if (ops->ndo_set_vf_rate)
2339 err = ops->ndo_set_vf_rate(dev, ivt->vf,
2340 ivf.min_tx_rate,
2341 ivt->rate);
2342 if (err < 0)
2343 return err;
2344 }
2345
2346 if (tb[IFLA_VF_RATE]) {
2347 struct ifla_vf_rate *ivt = nla_data(tb[IFLA_VF_RATE]);
2348
2349 if (ivt->vf >= INT_MAX)
2350 return -EINVAL;
2351 err = -EOPNOTSUPP;
2352 if (ops->ndo_set_vf_rate)
2353 err = ops->ndo_set_vf_rate(dev, ivt->vf,
2354 ivt->min_tx_rate,
2355 ivt->max_tx_rate);
2356 if (err < 0)
2357 return err;
2358 }
2359
2360 if (tb[IFLA_VF_SPOOFCHK]) {
2361 struct ifla_vf_spoofchk *ivs = nla_data(tb[IFLA_VF_SPOOFCHK]);
2362
2363 if (ivs->vf >= INT_MAX)
2364 return -EINVAL;
2365 err = -EOPNOTSUPP;
2366 if (ops->ndo_set_vf_spoofchk)
2367 err = ops->ndo_set_vf_spoofchk(dev, ivs->vf,
2368 ivs->setting);
2369 if (err < 0)
2370 return err;
2371 }
2372
2373 if (tb[IFLA_VF_LINK_STATE]) {
2374 struct ifla_vf_link_state *ivl = nla_data(tb[IFLA_VF_LINK_STATE]);
2375
2376 if (ivl->vf >= INT_MAX)
2377 return -EINVAL;
2378 err = -EOPNOTSUPP;
2379 if (ops->ndo_set_vf_link_state)
2380 err = ops->ndo_set_vf_link_state(dev, ivl->vf,
2381 ivl->link_state);
2382 if (err < 0)
2383 return err;
2384 }
2385
2386 if (tb[IFLA_VF_RSS_QUERY_EN]) {
2387 struct ifla_vf_rss_query_en *ivrssq_en;
2388
2389 err = -EOPNOTSUPP;
2390 ivrssq_en = nla_data(tb[IFLA_VF_RSS_QUERY_EN]);
2391 if (ivrssq_en->vf >= INT_MAX)
2392 return -EINVAL;
2393 if (ops->ndo_set_vf_rss_query_en)
2394 err = ops->ndo_set_vf_rss_query_en(dev, ivrssq_en->vf,
2395 ivrssq_en->setting);
2396 if (err < 0)
2397 return err;
2398 }
2399
2400 if (tb[IFLA_VF_TRUST]) {
2401 struct ifla_vf_trust *ivt = nla_data(tb[IFLA_VF_TRUST]);
2402
2403 if (ivt->vf >= INT_MAX)
2404 return -EINVAL;
2405 err = -EOPNOTSUPP;
2406 if (ops->ndo_set_vf_trust)
2407 err = ops->ndo_set_vf_trust(dev, ivt->vf, ivt->setting);
2408 if (err < 0)
2409 return err;
2410 }
2411
2412 if (tb[IFLA_VF_IB_NODE_GUID]) {
2413 struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_NODE_GUID]);
2414
2415 if (ivt->vf >= INT_MAX)
2416 return -EINVAL;
2417 if (!ops->ndo_set_vf_guid)
2418 return -EOPNOTSUPP;
2419 return handle_vf_guid(dev, ivt, IFLA_VF_IB_NODE_GUID);
2420 }
2421
2422 if (tb[IFLA_VF_IB_PORT_GUID]) {
2423 struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_PORT_GUID]);
2424
2425 if (ivt->vf >= INT_MAX)
2426 return -EINVAL;
2427 if (!ops->ndo_set_vf_guid)
2428 return -EOPNOTSUPP;
2429
2430 return handle_vf_guid(dev, ivt, IFLA_VF_IB_PORT_GUID);
2431 }
2432
2433 return err;
2434}
2435
2436static int do_set_master(struct net_device *dev, int ifindex,
2437 struct netlink_ext_ack *extack)
2438{
2439 struct net_device *upper_dev = netdev_master_upper_dev_get(dev);
2440 const struct net_device_ops *ops;
2441 int err;
2442
2443 if (upper_dev) {
2444 if (upper_dev->ifindex == ifindex)
2445 return 0;
2446 ops = upper_dev->netdev_ops;
2447 if (ops->ndo_del_slave) {
2448 err = ops->ndo_del_slave(upper_dev, dev);
2449 if (err)
2450 return err;
2451 netdev_update_lockdep_key(dev);
2452 } else {
2453 return -EOPNOTSUPP;
2454 }
2455 }
2456
2457 if (ifindex) {
2458 upper_dev = __dev_get_by_index(dev_net(dev), ifindex);
2459 if (!upper_dev)
2460 return -EINVAL;
2461 ops = upper_dev->netdev_ops;
2462 if (ops->ndo_add_slave) {
2463 err = ops->ndo_add_slave(upper_dev, dev, extack);
2464 if (err)
2465 return err;
2466 } else {
2467 return -EOPNOTSUPP;
2468 }
2469 }
2470 return 0;
2471}
2472
2473#define DO_SETLINK_MODIFIED 0x01
2474
2475#define DO_SETLINK_NOTIFY 0x03
2476static int do_setlink(const struct sk_buff *skb,
2477 struct net_device *dev, struct ifinfomsg *ifm,
2478 struct netlink_ext_ack *extack,
2479 struct nlattr **tb, char *ifname, int status)
2480{
2481 const struct net_device_ops *ops = dev->netdev_ops;
2482 int err;
2483
2484 err = validate_linkmsg(dev, tb);
2485 if (err < 0)
2486 return err;
2487
2488 if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD] || tb[IFLA_TARGET_NETNSID]) {
2489 struct net *net = rtnl_link_get_net_capable(skb, dev_net(dev),
2490 tb, CAP_NET_ADMIN);
2491 if (IS_ERR(net)) {
2492 err = PTR_ERR(net);
2493 goto errout;
2494 }
2495
2496 err = dev_change_net_namespace(dev, net, ifname);
2497 put_net(net);
2498 if (err)
2499 goto errout;
2500 status |= DO_SETLINK_MODIFIED;
2501 }
2502
2503 if (tb[IFLA_MAP]) {
2504 struct rtnl_link_ifmap *u_map;
2505 struct ifmap k_map;
2506
2507 if (!ops->ndo_set_config) {
2508 err = -EOPNOTSUPP;
2509 goto errout;
2510 }
2511
2512 if (!netif_device_present(dev)) {
2513 err = -ENODEV;
2514 goto errout;
2515 }
2516
2517 u_map = nla_data(tb[IFLA_MAP]);
2518 k_map.mem_start = (unsigned long) u_map->mem_start;
2519 k_map.mem_end = (unsigned long) u_map->mem_end;
2520 k_map.base_addr = (unsigned short) u_map->base_addr;
2521 k_map.irq = (unsigned char) u_map->irq;
2522 k_map.dma = (unsigned char) u_map->dma;
2523 k_map.port = (unsigned char) u_map->port;
2524
2525 err = ops->ndo_set_config(dev, &k_map);
2526 if (err < 0)
2527 goto errout;
2528
2529 status |= DO_SETLINK_NOTIFY;
2530 }
2531
2532 if (tb[IFLA_ADDRESS]) {
2533 struct sockaddr *sa;
2534 int len;
2535
2536 len = sizeof(sa_family_t) + max_t(size_t, dev->addr_len,
2537 sizeof(*sa));
2538 sa = kmalloc(len, GFP_KERNEL);
2539 if (!sa) {
2540 err = -ENOMEM;
2541 goto errout;
2542 }
2543 sa->sa_family = dev->type;
2544 memcpy(sa->sa_data, nla_data(tb[IFLA_ADDRESS]),
2545 dev->addr_len);
2546 err = dev_set_mac_address(dev, sa, extack);
2547 kfree(sa);
2548 if (err)
2549 goto errout;
2550 status |= DO_SETLINK_MODIFIED;
2551 }
2552
2553 if (tb[IFLA_MTU]) {
2554 err = dev_set_mtu_ext(dev, nla_get_u32(tb[IFLA_MTU]), extack);
2555 if (err < 0)
2556 goto errout;
2557 status |= DO_SETLINK_MODIFIED;
2558 }
2559
2560 if (tb[IFLA_GROUP]) {
2561 dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP]));
2562 status |= DO_SETLINK_NOTIFY;
2563 }
2564
2565
2566
2567
2568
2569
2570 if (ifm->ifi_index > 0 && ifname[0]) {
2571 err = dev_change_name(dev, ifname);
2572 if (err < 0)
2573 goto errout;
2574 status |= DO_SETLINK_MODIFIED;
2575 }
2576
2577 if (tb[IFLA_IFALIAS]) {
2578 err = dev_set_alias(dev, nla_data(tb[IFLA_IFALIAS]),
2579 nla_len(tb[IFLA_IFALIAS]));
2580 if (err < 0)
2581 goto errout;
2582 status |= DO_SETLINK_NOTIFY;
2583 }
2584
2585 if (tb[IFLA_BROADCAST]) {
2586 nla_memcpy(dev->broadcast, tb[IFLA_BROADCAST], dev->addr_len);
2587 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
2588 }
2589
2590 if (ifm->ifi_flags || ifm->ifi_change) {
2591 err = dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm),
2592 extack);
2593 if (err < 0)
2594 goto errout;
2595 }
2596
2597 if (tb[IFLA_MASTER]) {
2598 err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), extack);
2599 if (err)
2600 goto errout;
2601 status |= DO_SETLINK_MODIFIED;
2602 }
2603
2604 if (tb[IFLA_CARRIER]) {
2605 err = dev_change_carrier(dev, nla_get_u8(tb[IFLA_CARRIER]));
2606 if (err)
2607 goto errout;
2608 status |= DO_SETLINK_MODIFIED;
2609 }
2610
2611 if (tb[IFLA_TXQLEN]) {
2612 unsigned int value = nla_get_u32(tb[IFLA_TXQLEN]);
2613
2614 err = dev_change_tx_queue_len(dev, value);
2615 if (err)
2616 goto errout;
2617 status |= DO_SETLINK_MODIFIED;
2618 }
2619
2620 if (tb[IFLA_GSO_MAX_SIZE]) {
2621 u32 max_size = nla_get_u32(tb[IFLA_GSO_MAX_SIZE]);
2622
2623 if (max_size > GSO_MAX_SIZE) {
2624 err = -EINVAL;
2625 goto errout;
2626 }
2627
2628 if (dev->gso_max_size ^ max_size) {
2629 netif_set_gso_max_size(dev, max_size);
2630 status |= DO_SETLINK_MODIFIED;
2631 }
2632 }
2633
2634 if (tb[IFLA_GSO_MAX_SEGS]) {
2635 u32 max_segs = nla_get_u32(tb[IFLA_GSO_MAX_SEGS]);
2636
2637 if (max_segs > GSO_MAX_SEGS) {
2638 err = -EINVAL;
2639 goto errout;
2640 }
2641
2642 if (dev->gso_max_segs ^ max_segs) {
2643 dev->gso_max_segs = max_segs;
2644 status |= DO_SETLINK_MODIFIED;
2645 }
2646 }
2647
2648 if (tb[IFLA_OPERSTATE])
2649 set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
2650
2651 if (tb[IFLA_LINKMODE]) {
2652 unsigned char value = nla_get_u8(tb[IFLA_LINKMODE]);
2653
2654 write_lock_bh(&dev_base_lock);
2655 if (dev->link_mode ^ value)
2656 status |= DO_SETLINK_NOTIFY;
2657 dev->link_mode = value;
2658 write_unlock_bh(&dev_base_lock);
2659 }
2660
2661 if (tb[IFLA_VFINFO_LIST]) {
2662 struct nlattr *vfinfo[IFLA_VF_MAX + 1];
2663 struct nlattr *attr;
2664 int rem;
2665
2666 nla_for_each_nested(attr, tb[IFLA_VFINFO_LIST], rem) {
2667 if (nla_type(attr) != IFLA_VF_INFO ||
2668 nla_len(attr) < NLA_HDRLEN) {
2669 err = -EINVAL;
2670 goto errout;
2671 }
2672 err = nla_parse_nested_deprecated(vfinfo, IFLA_VF_MAX,
2673 attr,
2674 ifla_vf_policy,
2675 NULL);
2676 if (err < 0)
2677 goto errout;
2678 err = do_setvfinfo(dev, vfinfo);
2679 if (err < 0)
2680 goto errout;
2681 status |= DO_SETLINK_NOTIFY;
2682 }
2683 }
2684 err = 0;
2685
2686 if (tb[IFLA_VF_PORTS]) {
2687 struct nlattr *port[IFLA_PORT_MAX+1];
2688 struct nlattr *attr;
2689 int vf;
2690 int rem;
2691
2692 err = -EOPNOTSUPP;
2693 if (!ops->ndo_set_vf_port)
2694 goto errout;
2695
2696 nla_for_each_nested(attr, tb[IFLA_VF_PORTS], rem) {
2697 if (nla_type(attr) != IFLA_VF_PORT ||
2698 nla_len(attr) < NLA_HDRLEN) {
2699 err = -EINVAL;
2700 goto errout;
2701 }
2702 err = nla_parse_nested_deprecated(port, IFLA_PORT_MAX,
2703 attr,
2704 ifla_port_policy,
2705 NULL);
2706 if (err < 0)
2707 goto errout;
2708 if (!port[IFLA_PORT_VF]) {
2709 err = -EOPNOTSUPP;
2710 goto errout;
2711 }
2712 vf = nla_get_u32(port[IFLA_PORT_VF]);
2713 err = ops->ndo_set_vf_port(dev, vf, port);
2714 if (err < 0)
2715 goto errout;
2716 status |= DO_SETLINK_NOTIFY;
2717 }
2718 }
2719 err = 0;
2720
2721 if (tb[IFLA_PORT_SELF]) {
2722 struct nlattr *port[IFLA_PORT_MAX+1];
2723
2724 err = nla_parse_nested_deprecated(port, IFLA_PORT_MAX,
2725 tb[IFLA_PORT_SELF],
2726 ifla_port_policy, NULL);
2727 if (err < 0)
2728 goto errout;
2729
2730 err = -EOPNOTSUPP;
2731 if (ops->ndo_set_vf_port)
2732 err = ops->ndo_set_vf_port(dev, PORT_SELF_VF, port);
2733 if (err < 0)
2734 goto errout;
2735 status |= DO_SETLINK_NOTIFY;
2736 }
2737
2738 if (tb[IFLA_AF_SPEC]) {
2739 struct nlattr *af;
2740 int rem;
2741
2742 nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
2743 const struct rtnl_af_ops *af_ops;
2744
2745 rcu_read_lock();
2746
2747 BUG_ON(!(af_ops = rtnl_af_lookup(nla_type(af))));
2748
2749 err = af_ops->set_link_af(dev, af);
2750 if (err < 0) {
2751 rcu_read_unlock();
2752 goto errout;
2753 }
2754
2755 rcu_read_unlock();
2756 status |= DO_SETLINK_NOTIFY;
2757 }
2758 }
2759 err = 0;
2760
2761 if (tb[IFLA_PROTO_DOWN]) {
2762 err = dev_change_proto_down(dev,
2763 nla_get_u8(tb[IFLA_PROTO_DOWN]));
2764 if (err)
2765 goto errout;
2766 status |= DO_SETLINK_NOTIFY;
2767 }
2768
2769 if (tb[IFLA_XDP]) {
2770 struct nlattr *xdp[IFLA_XDP_MAX + 1];
2771 u32 xdp_flags = 0;
2772
2773 err = nla_parse_nested_deprecated(xdp, IFLA_XDP_MAX,
2774 tb[IFLA_XDP],
2775 ifla_xdp_policy, NULL);
2776 if (err < 0)
2777 goto errout;
2778
2779 if (xdp[IFLA_XDP_ATTACHED] || xdp[IFLA_XDP_PROG_ID]) {
2780 err = -EINVAL;
2781 goto errout;
2782 }
2783
2784 if (xdp[IFLA_XDP_FLAGS]) {
2785 xdp_flags = nla_get_u32(xdp[IFLA_XDP_FLAGS]);
2786 if (xdp_flags & ~XDP_FLAGS_MASK) {
2787 err = -EINVAL;
2788 goto errout;
2789 }
2790 if (hweight32(xdp_flags & XDP_FLAGS_MODES) > 1) {
2791 err = -EINVAL;
2792 goto errout;
2793 }
2794 }
2795
2796 if (xdp[IFLA_XDP_FD]) {
2797 err = dev_change_xdp_fd(dev, extack,
2798 nla_get_s32(xdp[IFLA_XDP_FD]),
2799 xdp_flags);
2800 if (err)
2801 goto errout;
2802 status |= DO_SETLINK_NOTIFY;
2803 }
2804 }
2805
2806errout:
2807 if (status & DO_SETLINK_MODIFIED) {
2808 if ((status & DO_SETLINK_NOTIFY) == DO_SETLINK_NOTIFY)
2809 netdev_state_change(dev);
2810
2811 if (err < 0)
2812 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",
2813 dev->name);
2814 }
2815
2816 return err;
2817}
2818
2819static struct net_device *rtnl_dev_get(struct net *net,
2820 struct nlattr *ifname_attr,
2821 struct nlattr *altifname_attr,
2822 char *ifname)
2823{
2824 char buffer[ALTIFNAMSIZ];
2825
2826 if (!ifname) {
2827 ifname = buffer;
2828 if (ifname_attr)
2829 nla_strlcpy(ifname, ifname_attr, IFNAMSIZ);
2830 else if (altifname_attr)
2831 nla_strlcpy(ifname, altifname_attr, ALTIFNAMSIZ);
2832 else
2833 return NULL;
2834 }
2835
2836 return __dev_get_by_name(net, ifname);
2837}
2838
2839static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh,
2840 struct netlink_ext_ack *extack)
2841{
2842 struct net *net = sock_net(skb->sk);
2843 struct ifinfomsg *ifm;
2844 struct net_device *dev;
2845 int err;
2846 struct nlattr *tb[IFLA_MAX+1];
2847 char ifname[IFNAMSIZ];
2848
2849 err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
2850 ifla_policy, extack);
2851 if (err < 0)
2852 goto errout;
2853
2854 err = rtnl_ensure_unique_netns(tb, extack, false);
2855 if (err < 0)
2856 goto errout;
2857
2858 if (tb[IFLA_IFNAME])
2859 nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
2860 else
2861 ifname[0] = '\0';
2862
2863 err = -EINVAL;
2864 ifm = nlmsg_data(nlh);
2865 if (ifm->ifi_index > 0)
2866 dev = __dev_get_by_index(net, ifm->ifi_index);
2867 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
2868 dev = rtnl_dev_get(net, NULL, tb[IFLA_ALT_IFNAME], ifname);
2869 else
2870 goto errout;
2871
2872 if (dev == NULL) {
2873 err = -ENODEV;
2874 goto errout;
2875 }
2876
2877 err = do_setlink(skb, dev, ifm, extack, tb, ifname, 0);
2878errout:
2879 return err;
2880}
2881
2882static int rtnl_group_dellink(const struct net *net, int group)
2883{
2884 struct net_device *dev, *aux;
2885 LIST_HEAD(list_kill);
2886 bool found = false;
2887
2888 if (!group)
2889 return -EPERM;
2890
2891 for_each_netdev(net, dev) {
2892 if (dev->group == group) {
2893 const struct rtnl_link_ops *ops;
2894
2895 found = true;
2896 ops = dev->rtnl_link_ops;
2897 if (!ops || !ops->dellink)
2898 return -EOPNOTSUPP;
2899 }
2900 }
2901
2902 if (!found)
2903 return -ENODEV;
2904
2905 for_each_netdev_safe(net, dev, aux) {
2906 if (dev->group == group) {
2907 const struct rtnl_link_ops *ops;
2908
2909 ops = dev->rtnl_link_ops;
2910 ops->dellink(dev, &list_kill);
2911 }
2912 }
2913 unregister_netdevice_many(&list_kill);
2914
2915 return 0;
2916}
2917
2918int rtnl_delete_link(struct net_device *dev)
2919{
2920 const struct rtnl_link_ops *ops;
2921 LIST_HEAD(list_kill);
2922
2923 ops = dev->rtnl_link_ops;
2924 if (!ops || !ops->dellink)
2925 return -EOPNOTSUPP;
2926
2927 ops->dellink(dev, &list_kill);
2928 unregister_netdevice_many(&list_kill);
2929
2930 return 0;
2931}
2932EXPORT_SYMBOL_GPL(rtnl_delete_link);
2933
2934static int rtnl_dellink(struct sk_buff *skb, struct nlmsghdr *nlh,
2935 struct netlink_ext_ack *extack)
2936{
2937 struct net *net = sock_net(skb->sk);
2938 struct net *tgt_net = net;
2939 struct net_device *dev = NULL;
2940 struct ifinfomsg *ifm;
2941 struct nlattr *tb[IFLA_MAX+1];
2942 int err;
2943 int netnsid = -1;
2944
2945 err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
2946 ifla_policy, extack);
2947 if (err < 0)
2948 return err;
2949
2950 err = rtnl_ensure_unique_netns(tb, extack, true);
2951 if (err < 0)
2952 return err;
2953
2954 if (tb[IFLA_TARGET_NETNSID]) {
2955 netnsid = nla_get_s32(tb[IFLA_TARGET_NETNSID]);
2956 tgt_net = rtnl_get_net_ns_capable(NETLINK_CB(skb).sk, netnsid);
2957 if (IS_ERR(tgt_net))
2958 return PTR_ERR(tgt_net);
2959 }
2960
2961 err = -EINVAL;
2962 ifm = nlmsg_data(nlh);
2963 if (ifm->ifi_index > 0)
2964 dev = __dev_get_by_index(tgt_net, ifm->ifi_index);
2965 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
2966 dev = rtnl_dev_get(net, tb[IFLA_IFNAME],
2967 tb[IFLA_ALT_IFNAME], NULL);
2968 else if (tb[IFLA_GROUP])
2969 err = rtnl_group_dellink(tgt_net, nla_get_u32(tb[IFLA_GROUP]));
2970 else
2971 goto out;
2972
2973 if (!dev) {
2974 if (tb[IFLA_IFNAME] || ifm->ifi_index > 0)
2975 err = -ENODEV;
2976
2977 goto out;
2978 }
2979
2980 err = rtnl_delete_link(dev);
2981
2982out:
2983 if (netnsid >= 0)
2984 put_net(tgt_net);
2985
2986 return err;
2987}
2988
2989int rtnl_configure_link(struct net_device *dev, const struct ifinfomsg *ifm)
2990{
2991 unsigned int old_flags;
2992 int err;
2993
2994 old_flags = dev->flags;
2995 if (ifm && (ifm->ifi_flags || ifm->ifi_change)) {
2996 err = __dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm),
2997 NULL);
2998 if (err < 0)
2999 return err;
3000 }
3001
3002 if (dev->rtnl_link_state == RTNL_LINK_INITIALIZED) {
3003 __dev_notify_flags(dev, old_flags, (old_flags ^ dev->flags));
3004 } else {
3005 dev->rtnl_link_state = RTNL_LINK_INITIALIZED;
3006 __dev_notify_flags(dev, old_flags, ~0U);
3007 }
3008 return 0;
3009}
3010EXPORT_SYMBOL(rtnl_configure_link);
3011
3012struct net_device *rtnl_create_link(struct net *net, const char *ifname,
3013 unsigned char name_assign_type,
3014 const struct rtnl_link_ops *ops,
3015 struct nlattr *tb[],
3016 struct netlink_ext_ack *extack)
3017{
3018 struct net_device *dev;
3019 unsigned int num_tx_queues = 1;
3020 unsigned int num_rx_queues = 1;
3021
3022 if (tb[IFLA_NUM_TX_QUEUES])
3023 num_tx_queues = nla_get_u32(tb[IFLA_NUM_TX_QUEUES]);
3024 else if (ops->get_num_tx_queues)
3025 num_tx_queues = ops->get_num_tx_queues();
3026
3027 if (tb[IFLA_NUM_RX_QUEUES])
3028 num_rx_queues = nla_get_u32(tb[IFLA_NUM_RX_QUEUES]);
3029 else if (ops->get_num_rx_queues)
3030 num_rx_queues = ops->get_num_rx_queues();
3031
3032 if (num_tx_queues < 1 || num_tx_queues > 4096) {
3033 NL_SET_ERR_MSG(extack, "Invalid number of transmit queues");
3034 return ERR_PTR(-EINVAL);
3035 }
3036
3037 if (num_rx_queues < 1 || num_rx_queues > 4096) {
3038 NL_SET_ERR_MSG(extack, "Invalid number of receive queues");
3039 return ERR_PTR(-EINVAL);
3040 }
3041
3042 dev = alloc_netdev_mqs(ops->priv_size, ifname, name_assign_type,
3043 ops->setup, num_tx_queues, num_rx_queues);
3044 if (!dev)
3045 return ERR_PTR(-ENOMEM);
3046
3047 dev_net_set(dev, net);
3048 dev->rtnl_link_ops = ops;
3049 dev->rtnl_link_state = RTNL_LINK_INITIALIZING;
3050
3051 if (tb[IFLA_MTU]) {
3052 u32 mtu = nla_get_u32(tb[IFLA_MTU]);
3053 int err;
3054
3055 err = dev_validate_mtu(dev, mtu, extack);
3056 if (err) {
3057 free_netdev(dev);
3058 return ERR_PTR(err);
3059 }
3060 dev->mtu = mtu;
3061 }
3062 if (tb[IFLA_ADDRESS]) {
3063 memcpy(dev->dev_addr, nla_data(tb[IFLA_ADDRESS]),
3064 nla_len(tb[IFLA_ADDRESS]));
3065 dev->addr_assign_type = NET_ADDR_SET;
3066 }
3067 if (tb[IFLA_BROADCAST])
3068 memcpy(dev->broadcast, nla_data(tb[IFLA_BROADCAST]),
3069 nla_len(tb[IFLA_BROADCAST]));
3070 if (tb[IFLA_TXQLEN])
3071 dev->tx_queue_len = nla_get_u32(tb[IFLA_TXQLEN]);
3072 if (tb[IFLA_OPERSTATE])
3073 set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
3074 if (tb[IFLA_LINKMODE])
3075 dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]);
3076 if (tb[IFLA_GROUP])
3077 dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP]));
3078 if (tb[IFLA_GSO_MAX_SIZE])
3079 netif_set_gso_max_size(dev, nla_get_u32(tb[IFLA_GSO_MAX_SIZE]));
3080 if (tb[IFLA_GSO_MAX_SEGS])
3081 dev->gso_max_segs = nla_get_u32(tb[IFLA_GSO_MAX_SEGS]);
3082
3083 return dev;
3084}
3085EXPORT_SYMBOL(rtnl_create_link);
3086
3087static int rtnl_group_changelink(const struct sk_buff *skb,
3088 struct net *net, int group,
3089 struct ifinfomsg *ifm,
3090 struct netlink_ext_ack *extack,
3091 struct nlattr **tb)
3092{
3093 struct net_device *dev, *aux;
3094 int err;
3095
3096 for_each_netdev_safe(net, dev, aux) {
3097 if (dev->group == group) {
3098 err = do_setlink(skb, dev, ifm, extack, tb, NULL, 0);
3099 if (err < 0)
3100 return err;
3101 }
3102 }
3103
3104 return 0;
3105}
3106
3107static int __rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3108 struct nlattr **attr, struct netlink_ext_ack *extack)
3109{
3110 struct nlattr *slave_attr[RTNL_SLAVE_MAX_TYPE + 1];
3111 unsigned char name_assign_type = NET_NAME_USER;
3112 struct nlattr *linkinfo[IFLA_INFO_MAX + 1];
3113 const struct rtnl_link_ops *m_ops = NULL;
3114 struct net_device *master_dev = NULL;
3115 struct net *net = sock_net(skb->sk);
3116 const struct rtnl_link_ops *ops;
3117 struct nlattr *tb[IFLA_MAX + 1];
3118 struct net *dest_net, *link_net;
3119 struct nlattr **slave_data;
3120 char kind[MODULE_NAME_LEN];
3121 struct net_device *dev;
3122 struct ifinfomsg *ifm;
3123 char ifname[IFNAMSIZ];
3124 struct nlattr **data;
3125 int err;
3126
3127#ifdef CONFIG_MODULES
3128replay:
3129#endif
3130 err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
3131 ifla_policy, extack);
3132 if (err < 0)
3133 return err;
3134
3135 err = rtnl_ensure_unique_netns(tb, extack, false);
3136 if (err < 0)
3137 return err;
3138
3139 if (tb[IFLA_IFNAME])
3140 nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
3141 else
3142 ifname[0] = '\0';
3143
3144 ifm = nlmsg_data(nlh);
3145 if (ifm->ifi_index > 0)
3146 dev = __dev_get_by_index(net, ifm->ifi_index);
3147 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3148 dev = rtnl_dev_get(net, NULL, tb[IFLA_ALT_IFNAME], ifname);
3149 else
3150 dev = NULL;
3151
3152 if (dev) {
3153 master_dev = netdev_master_upper_dev_get(dev);
3154 if (master_dev)
3155 m_ops = master_dev->rtnl_link_ops;
3156 }
3157
3158 err = validate_linkmsg(dev, tb);
3159 if (err < 0)
3160 return err;
3161
3162 if (tb[IFLA_LINKINFO]) {
3163 err = nla_parse_nested_deprecated(linkinfo, IFLA_INFO_MAX,
3164 tb[IFLA_LINKINFO],
3165 ifla_info_policy, NULL);
3166 if (err < 0)
3167 return err;
3168 } else
3169 memset(linkinfo, 0, sizeof(linkinfo));
3170
3171 if (linkinfo[IFLA_INFO_KIND]) {
3172 nla_strlcpy(kind, linkinfo[IFLA_INFO_KIND], sizeof(kind));
3173 ops = rtnl_link_ops_get(kind);
3174 } else {
3175 kind[0] = '\0';
3176 ops = NULL;
3177 }
3178
3179 data = NULL;
3180 if (ops) {
3181 if (ops->maxtype > RTNL_MAX_TYPE)
3182 return -EINVAL;
3183
3184 if (ops->maxtype && linkinfo[IFLA_INFO_DATA]) {
3185 err = nla_parse_nested_deprecated(attr, ops->maxtype,
3186 linkinfo[IFLA_INFO_DATA],
3187 ops->policy, extack);
3188 if (err < 0)
3189 return err;
3190 data = attr;
3191 }
3192 if (ops->validate) {
3193 err = ops->validate(tb, data, extack);
3194 if (err < 0)
3195 return err;
3196 }
3197 }
3198
3199 slave_data = NULL;
3200 if (m_ops) {
3201 if (m_ops->slave_maxtype > RTNL_SLAVE_MAX_TYPE)
3202 return -EINVAL;
3203
3204 if (m_ops->slave_maxtype &&
3205 linkinfo[IFLA_INFO_SLAVE_DATA]) {
3206 err = nla_parse_nested_deprecated(slave_attr,
3207 m_ops->slave_maxtype,
3208 linkinfo[IFLA_INFO_SLAVE_DATA],
3209 m_ops->slave_policy,
3210 extack);
3211 if (err < 0)
3212 return err;
3213 slave_data = slave_attr;
3214 }
3215 }
3216
3217 if (dev) {
3218 int status = 0;
3219
3220 if (nlh->nlmsg_flags & NLM_F_EXCL)
3221 return -EEXIST;
3222 if (nlh->nlmsg_flags & NLM_F_REPLACE)
3223 return -EOPNOTSUPP;
3224
3225 if (linkinfo[IFLA_INFO_DATA]) {
3226 if (!ops || ops != dev->rtnl_link_ops ||
3227 !ops->changelink)
3228 return -EOPNOTSUPP;
3229
3230 err = ops->changelink(dev, tb, data, extack);
3231 if (err < 0)
3232 return err;
3233 status |= DO_SETLINK_NOTIFY;
3234 }
3235
3236 if (linkinfo[IFLA_INFO_SLAVE_DATA]) {
3237 if (!m_ops || !m_ops->slave_changelink)
3238 return -EOPNOTSUPP;
3239
3240 err = m_ops->slave_changelink(master_dev, dev, tb,
3241 slave_data, extack);
3242 if (err < 0)
3243 return err;
3244 status |= DO_SETLINK_NOTIFY;
3245 }
3246
3247 return do_setlink(skb, dev, ifm, extack, tb, ifname, status);
3248 }
3249
3250 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
3251 if (ifm->ifi_index == 0 && tb[IFLA_GROUP])
3252 return rtnl_group_changelink(skb, net,
3253 nla_get_u32(tb[IFLA_GROUP]),
3254 ifm, extack, tb);
3255 return -ENODEV;
3256 }
3257
3258 if (tb[IFLA_MAP] || tb[IFLA_PROTINFO])
3259 return -EOPNOTSUPP;
3260
3261 if (!ops) {
3262#ifdef CONFIG_MODULES
3263 if (kind[0]) {
3264 __rtnl_unlock();
3265 request_module("rtnl-link-%s", kind);
3266 rtnl_lock();
3267 ops = rtnl_link_ops_get(kind);
3268 if (ops)
3269 goto replay;
3270 }
3271#endif
3272 NL_SET_ERR_MSG(extack, "Unknown device type");
3273 return -EOPNOTSUPP;
3274 }
3275
3276 if (!ops->setup)
3277 return -EOPNOTSUPP;
3278
3279 if (!ifname[0]) {
3280 snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind);
3281 name_assign_type = NET_NAME_ENUM;
3282 }
3283
3284 dest_net = rtnl_link_get_net_capable(skb, net, tb, CAP_NET_ADMIN);
3285 if (IS_ERR(dest_net))
3286 return PTR_ERR(dest_net);
3287
3288 if (tb[IFLA_LINK_NETNSID]) {
3289 int id = nla_get_s32(tb[IFLA_LINK_NETNSID]);
3290
3291 link_net = get_net_ns_by_id(dest_net, id);
3292 if (!link_net) {
3293 NL_SET_ERR_MSG(extack, "Unknown network namespace id");
3294 err = -EINVAL;
3295 goto out;
3296 }
3297 err = -EPERM;
3298 if (!netlink_ns_capable(skb, link_net->user_ns, CAP_NET_ADMIN))
3299 goto out;
3300 } else {
3301 link_net = NULL;
3302 }
3303
3304 dev = rtnl_create_link(link_net ? : dest_net, ifname,
3305 name_assign_type, ops, tb, extack);
3306 if (IS_ERR(dev)) {
3307 err = PTR_ERR(dev);
3308 goto out;
3309 }
3310
3311 dev->ifindex = ifm->ifi_index;
3312
3313 if (ops->newlink) {
3314 err = ops->newlink(link_net ? : net, dev, tb, data, extack);
3315
3316
3317
3318
3319 if (err < 0) {
3320
3321 if (dev->reg_state == NETREG_UNINITIALIZED)
3322 free_netdev(dev);
3323 goto out;
3324 }
3325 } else {
3326 err = register_netdevice(dev);
3327 if (err < 0) {
3328 free_netdev(dev);
3329 goto out;
3330 }
3331 }
3332 err = rtnl_configure_link(dev, ifm);
3333 if (err < 0)
3334 goto out_unregister;
3335 if (link_net) {
3336 err = dev_change_net_namespace(dev, dest_net, ifname);
3337 if (err < 0)
3338 goto out_unregister;
3339 }
3340 if (tb[IFLA_MASTER]) {
3341 err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), extack);
3342 if (err)
3343 goto out_unregister;
3344 }
3345out:
3346 if (link_net)
3347 put_net(link_net);
3348 put_net(dest_net);
3349 return err;
3350out_unregister:
3351 if (ops->newlink) {
3352 LIST_HEAD(list_kill);
3353
3354 ops->dellink(dev, &list_kill);
3355 unregister_netdevice_many(&list_kill);
3356 } else {
3357 unregister_netdevice(dev);
3358 }
3359 goto out;
3360}
3361
3362static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3363 struct netlink_ext_ack *extack)
3364{
3365 struct nlattr **attr;
3366 int ret;
3367
3368 attr = kmalloc_array(RTNL_MAX_TYPE + 1, sizeof(*attr), GFP_KERNEL);
3369 if (!attr)
3370 return -ENOMEM;
3371
3372 ret = __rtnl_newlink(skb, nlh, attr, extack);
3373 kfree(attr);
3374 return ret;
3375}
3376
3377static int rtnl_valid_getlink_req(struct sk_buff *skb,
3378 const struct nlmsghdr *nlh,
3379 struct nlattr **tb,
3380 struct netlink_ext_ack *extack)
3381{
3382 struct ifinfomsg *ifm;
3383 int i, err;
3384
3385 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
3386 NL_SET_ERR_MSG(extack, "Invalid header for get link");
3387 return -EINVAL;
3388 }
3389
3390 if (!netlink_strict_get_check(skb))
3391 return nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
3392 ifla_policy, extack);
3393
3394 ifm = nlmsg_data(nlh);
3395 if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
3396 ifm->ifi_change) {
3397 NL_SET_ERR_MSG(extack, "Invalid values in header for get link request");
3398 return -EINVAL;
3399 }
3400
3401 err = nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb, IFLA_MAX,
3402 ifla_policy, extack);
3403 if (err)
3404 return err;
3405
3406 for (i = 0; i <= IFLA_MAX; i++) {
3407 if (!tb[i])
3408 continue;
3409
3410 switch (i) {
3411 case IFLA_IFNAME:
3412 case IFLA_ALT_IFNAME:
3413 case IFLA_EXT_MASK:
3414 case IFLA_TARGET_NETNSID:
3415 break;
3416 default:
3417 NL_SET_ERR_MSG(extack, "Unsupported attribute in get link request");
3418 return -EINVAL;
3419 }
3420 }
3421
3422 return 0;
3423}
3424
3425static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr *nlh,
3426 struct netlink_ext_ack *extack)
3427{
3428 struct net *net = sock_net(skb->sk);
3429 struct net *tgt_net = net;
3430 struct ifinfomsg *ifm;
3431 struct nlattr *tb[IFLA_MAX+1];
3432 struct net_device *dev = NULL;
3433 struct sk_buff *nskb;
3434 int netnsid = -1;
3435 int err;
3436 u32 ext_filter_mask = 0;
3437
3438 err = rtnl_valid_getlink_req(skb, nlh, tb, extack);
3439 if (err < 0)
3440 return err;
3441
3442 err = rtnl_ensure_unique_netns(tb, extack, true);
3443 if (err < 0)
3444 return err;
3445
3446 if (tb[IFLA_TARGET_NETNSID]) {
3447 netnsid = nla_get_s32(tb[IFLA_TARGET_NETNSID]);
3448 tgt_net = rtnl_get_net_ns_capable(NETLINK_CB(skb).sk, netnsid);
3449 if (IS_ERR(tgt_net))
3450 return PTR_ERR(tgt_net);
3451 }
3452
3453 if (tb[IFLA_EXT_MASK])
3454 ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
3455
3456 err = -EINVAL;
3457 ifm = nlmsg_data(nlh);
3458 if (ifm->ifi_index > 0)
3459 dev = __dev_get_by_index(tgt_net, ifm->ifi_index);
3460 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3461 dev = rtnl_dev_get(tgt_net, tb[IFLA_IFNAME],
3462 tb[IFLA_ALT_IFNAME], NULL);
3463 else
3464 goto out;
3465
3466 err = -ENODEV;
3467 if (dev == NULL)
3468 goto out;
3469
3470 err = -ENOBUFS;
3471 nskb = nlmsg_new(if_nlmsg_size(dev, ext_filter_mask), GFP_KERNEL);
3472 if (nskb == NULL)
3473 goto out;
3474
3475 err = rtnl_fill_ifinfo(nskb, dev, net,
3476 RTM_NEWLINK, NETLINK_CB(skb).portid,
3477 nlh->nlmsg_seq, 0, 0, ext_filter_mask,
3478 0, NULL, 0, netnsid, GFP_KERNEL);
3479 if (err < 0) {
3480
3481 WARN_ON(err == -EMSGSIZE);
3482 kfree_skb(nskb);
3483 } else
3484 err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid);
3485out:
3486 if (netnsid >= 0)
3487 put_net(tgt_net);
3488
3489 return err;
3490}
3491
3492static int rtnl_alt_ifname(int cmd, struct net_device *dev, struct nlattr *attr,
3493 bool *changed, struct netlink_ext_ack *extack)
3494{
3495 char *alt_ifname;
3496 int err;
3497
3498 err = nla_validate(attr, attr->nla_len, IFLA_MAX, ifla_policy, extack);
3499 if (err)
3500 return err;
3501
3502 alt_ifname = nla_data(attr);
3503 if (cmd == RTM_NEWLINKPROP) {
3504 alt_ifname = kstrdup(alt_ifname, GFP_KERNEL);
3505 if (!alt_ifname)
3506 return -ENOMEM;
3507 err = netdev_name_node_alt_create(dev, alt_ifname);
3508 if (err) {
3509 kfree(alt_ifname);
3510 return err;
3511 }
3512 } else if (cmd == RTM_DELLINKPROP) {
3513 err = netdev_name_node_alt_destroy(dev, alt_ifname);
3514 if (err)
3515 return err;
3516 } else {
3517 WARN_ON(1);
3518 return 0;
3519 }
3520
3521 *changed = true;
3522 return 0;
3523}
3524
3525static int rtnl_linkprop(int cmd, struct sk_buff *skb, struct nlmsghdr *nlh,
3526 struct netlink_ext_ack *extack)
3527{
3528 struct net *net = sock_net(skb->sk);
3529 struct nlattr *tb[IFLA_MAX + 1];
3530 struct net_device *dev;
3531 struct ifinfomsg *ifm;
3532 bool changed = false;
3533 struct nlattr *attr;
3534 int err, rem;
3535
3536 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy, extack);
3537 if (err)
3538 return err;
3539
3540 err = rtnl_ensure_unique_netns(tb, extack, true);
3541 if (err)
3542 return err;
3543
3544 ifm = nlmsg_data(nlh);
3545 if (ifm->ifi_index > 0)
3546 dev = __dev_get_by_index(net, ifm->ifi_index);
3547 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
3548 dev = rtnl_dev_get(net, tb[IFLA_IFNAME],
3549 tb[IFLA_ALT_IFNAME], NULL);
3550 else
3551 return -EINVAL;
3552
3553 if (!dev)
3554 return -ENODEV;
3555
3556 if (!tb[IFLA_PROP_LIST])
3557 return 0;
3558
3559 nla_for_each_nested(attr, tb[IFLA_PROP_LIST], rem) {
3560 switch (nla_type(attr)) {
3561 case IFLA_ALT_IFNAME:
3562 err = rtnl_alt_ifname(cmd, dev, attr, &changed, extack);
3563 if (err)
3564 return err;
3565 break;
3566 }
3567 }
3568
3569 if (changed)
3570 netdev_state_change(dev);
3571 return 0;
3572}
3573
3574static int rtnl_newlinkprop(struct sk_buff *skb, struct nlmsghdr *nlh,
3575 struct netlink_ext_ack *extack)
3576{
3577 return rtnl_linkprop(RTM_NEWLINKPROP, skb, nlh, extack);
3578}
3579
3580static int rtnl_dellinkprop(struct sk_buff *skb, struct nlmsghdr *nlh,
3581 struct netlink_ext_ack *extack)
3582{
3583 return rtnl_linkprop(RTM_DELLINKPROP, skb, nlh, extack);
3584}
3585
3586static u16 rtnl_calcit(struct sk_buff *skb, struct nlmsghdr *nlh)
3587{
3588 struct net *net = sock_net(skb->sk);
3589 struct net_device *dev;
3590 struct nlattr *tb[IFLA_MAX+1];
3591 u32 ext_filter_mask = 0;
3592 u16 min_ifinfo_dump_size = 0;
3593 int hdrlen;
3594
3595
3596 hdrlen = nlmsg_len(nlh) < sizeof(struct ifinfomsg) ?
3597 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg);
3598
3599 if (nlmsg_parse_deprecated(nlh, hdrlen, tb, IFLA_MAX, ifla_policy, NULL) >= 0) {
3600 if (tb[IFLA_EXT_MASK])
3601 ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
3602 }
3603
3604 if (!ext_filter_mask)
3605 return NLMSG_GOODSIZE;
3606
3607
3608
3609
3610 rcu_read_lock();
3611 for_each_netdev_rcu(net, dev) {
3612 min_ifinfo_dump_size = max_t(u16, min_ifinfo_dump_size,
3613 if_nlmsg_size(dev,
3614 ext_filter_mask));
3615 }
3616 rcu_read_unlock();
3617
3618 return nlmsg_total_size(min_ifinfo_dump_size);
3619}
3620
3621static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb)
3622{
3623 int idx;
3624 int s_idx = cb->family;
3625 int type = cb->nlh->nlmsg_type - RTM_BASE;
3626 int ret = 0;
3627
3628 if (s_idx == 0)
3629 s_idx = 1;
3630
3631 for (idx = 1; idx <= RTNL_FAMILY_MAX; idx++) {
3632 struct rtnl_link **tab;
3633 struct rtnl_link *link;
3634 rtnl_dumpit_func dumpit;
3635
3636 if (idx < s_idx || idx == PF_PACKET)
3637 continue;
3638
3639 if (type < 0 || type >= RTM_NR_MSGTYPES)
3640 continue;
3641
3642 tab = rcu_dereference_rtnl(rtnl_msg_handlers[idx]);
3643 if (!tab)
3644 continue;
3645
3646 link = tab[type];
3647 if (!link)
3648 continue;
3649
3650 dumpit = link->dumpit;
3651 if (!dumpit)
3652 continue;
3653
3654 if (idx > s_idx) {
3655 memset(&cb->args[0], 0, sizeof(cb->args));
3656 cb->prev_seq = 0;
3657 cb->seq = 0;
3658 }
3659 ret = dumpit(skb, cb);
3660 if (ret)
3661 break;
3662 }
3663 cb->family = idx;
3664
3665 return skb->len ? : ret;
3666}
3667
3668struct sk_buff *rtmsg_ifinfo_build_skb(int type, struct net_device *dev,
3669 unsigned int change,
3670 u32 event, gfp_t flags, int *new_nsid,
3671 int new_ifindex)
3672{
3673 struct net *net = dev_net(dev);
3674 struct sk_buff *skb;
3675 int err = -ENOBUFS;
3676 size_t if_info_size;
3677
3678 skb = nlmsg_new((if_info_size = if_nlmsg_size(dev, 0)), flags);
3679 if (skb == NULL)
3680 goto errout;
3681
3682 err = rtnl_fill_ifinfo(skb, dev, dev_net(dev),
3683 type, 0, 0, change, 0, 0, event,
3684 new_nsid, new_ifindex, -1, flags);
3685 if (err < 0) {
3686
3687 WARN_ON(err == -EMSGSIZE);
3688 kfree_skb(skb);
3689 goto errout;
3690 }
3691 return skb;
3692errout:
3693 if (err < 0)
3694 rtnl_set_sk_err(net, RTNLGRP_LINK, err);
3695 return NULL;
3696}
3697
3698void rtmsg_ifinfo_send(struct sk_buff *skb, struct net_device *dev, gfp_t flags)
3699{
3700 struct net *net = dev_net(dev);
3701
3702 rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, flags);
3703}
3704
3705static void rtmsg_ifinfo_event(int type, struct net_device *dev,
3706 unsigned int change, u32 event,
3707 gfp_t flags, int *new_nsid, int new_ifindex)
3708{
3709 struct sk_buff *skb;
3710
3711 if (dev->reg_state != NETREG_REGISTERED)
3712 return;
3713
3714 skb = rtmsg_ifinfo_build_skb(type, dev, change, event, flags, new_nsid,
3715 new_ifindex);
3716 if (skb)
3717 rtmsg_ifinfo_send(skb, dev, flags);
3718}
3719
3720void rtmsg_ifinfo(int type, struct net_device *dev, unsigned int change,
3721 gfp_t flags)
3722{
3723 rtmsg_ifinfo_event(type, dev, change, rtnl_get_event(0), flags,
3724 NULL, 0);
3725}
3726
3727void rtmsg_ifinfo_newnet(int type, struct net_device *dev, unsigned int change,
3728 gfp_t flags, int *new_nsid, int new_ifindex)
3729{
3730 rtmsg_ifinfo_event(type, dev, change, rtnl_get_event(0), flags,
3731 new_nsid, new_ifindex);
3732}
3733
3734static int nlmsg_populate_fdb_fill(struct sk_buff *skb,
3735 struct net_device *dev,
3736 u8 *addr, u16 vid, u32 pid, u32 seq,
3737 int type, unsigned int flags,
3738 int nlflags, u16 ndm_state)
3739{
3740 struct nlmsghdr *nlh;
3741 struct ndmsg *ndm;
3742
3743 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), nlflags);
3744 if (!nlh)
3745 return -EMSGSIZE;
3746
3747 ndm = nlmsg_data(nlh);
3748 ndm->ndm_family = AF_BRIDGE;
3749 ndm->ndm_pad1 = 0;
3750 ndm->ndm_pad2 = 0;
3751 ndm->ndm_flags = flags;
3752 ndm->ndm_type = 0;
3753 ndm->ndm_ifindex = dev->ifindex;
3754 ndm->ndm_state = ndm_state;
3755
3756 if (nla_put(skb, NDA_LLADDR, ETH_ALEN, addr))
3757 goto nla_put_failure;
3758 if (vid)
3759 if (nla_put(skb, NDA_VLAN, sizeof(u16), &vid))
3760 goto nla_put_failure;
3761
3762 nlmsg_end(skb, nlh);
3763 return 0;
3764
3765nla_put_failure:
3766 nlmsg_cancel(skb, nlh);
3767 return -EMSGSIZE;
3768}
3769
3770static inline size_t rtnl_fdb_nlmsg_size(void)
3771{
3772 return NLMSG_ALIGN(sizeof(struct ndmsg)) +
3773 nla_total_size(ETH_ALEN) +
3774 nla_total_size(sizeof(u16)) +
3775 0;
3776}
3777
3778static void rtnl_fdb_notify(struct net_device *dev, u8 *addr, u16 vid, int type,
3779 u16 ndm_state)
3780{
3781 struct net *net = dev_net(dev);
3782 struct sk_buff *skb;
3783 int err = -ENOBUFS;
3784
3785 skb = nlmsg_new(rtnl_fdb_nlmsg_size(), GFP_ATOMIC);
3786 if (!skb)
3787 goto errout;
3788
3789 err = nlmsg_populate_fdb_fill(skb, dev, addr, vid,
3790 0, 0, type, NTF_SELF, 0, ndm_state);
3791 if (err < 0) {
3792 kfree_skb(skb);
3793 goto errout;
3794 }
3795
3796 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
3797 return;
3798errout:
3799 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
3800}
3801
3802
3803
3804
3805int ndo_dflt_fdb_add(struct ndmsg *ndm,
3806 struct nlattr *tb[],
3807 struct net_device *dev,
3808 const unsigned char *addr, u16 vid,
3809 u16 flags)
3810{
3811 int err = -EINVAL;
3812
3813
3814
3815
3816 if (ndm->ndm_state && !(ndm->ndm_state & NUD_PERMANENT)) {
3817 pr_info("%s: FDB only supports static addresses\n", dev->name);
3818 return err;
3819 }
3820
3821 if (vid) {
3822 pr_info("%s: vlans aren't supported yet for dev_uc|mc_add()\n", dev->name);
3823 return err;
3824 }
3825
3826 if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr))
3827 err = dev_uc_add_excl(dev, addr);
3828 else if (is_multicast_ether_addr(addr))
3829 err = dev_mc_add_excl(dev, addr);
3830
3831
3832 if (err == -EEXIST && !(flags & NLM_F_EXCL))
3833 err = 0;
3834
3835 return err;
3836}
3837EXPORT_SYMBOL(ndo_dflt_fdb_add);
3838
3839static int fdb_vid_parse(struct nlattr *vlan_attr, u16 *p_vid,
3840 struct netlink_ext_ack *extack)
3841{
3842 u16 vid = 0;
3843
3844 if (vlan_attr) {
3845 if (nla_len(vlan_attr) != sizeof(u16)) {
3846 NL_SET_ERR_MSG(extack, "invalid vlan attribute size");
3847 return -EINVAL;
3848 }
3849
3850 vid = nla_get_u16(vlan_attr);
3851
3852 if (!vid || vid >= VLAN_VID_MASK) {
3853 NL_SET_ERR_MSG(extack, "invalid vlan id");
3854 return -EINVAL;
3855 }
3856 }
3857 *p_vid = vid;
3858 return 0;
3859}
3860
3861static int rtnl_fdb_add(struct sk_buff *skb, struct nlmsghdr *nlh,
3862 struct netlink_ext_ack *extack)
3863{
3864 struct net *net = sock_net(skb->sk);
3865 struct ndmsg *ndm;
3866 struct nlattr *tb[NDA_MAX+1];
3867 struct net_device *dev;
3868 u8 *addr;
3869 u16 vid;
3870 int err;
3871
3872 err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX, NULL,
3873 extack);
3874 if (err < 0)
3875 return err;
3876
3877 ndm = nlmsg_data(nlh);
3878 if (ndm->ndm_ifindex == 0) {
3879 NL_SET_ERR_MSG(extack, "invalid ifindex");
3880 return -EINVAL;
3881 }
3882
3883 dev = __dev_get_by_index(net, ndm->ndm_ifindex);
3884 if (dev == NULL) {
3885 NL_SET_ERR_MSG(extack, "unknown ifindex");
3886 return -ENODEV;
3887 }
3888
3889 if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
3890 NL_SET_ERR_MSG(extack, "invalid address");
3891 return -EINVAL;
3892 }
3893
3894 if (dev->type != ARPHRD_ETHER) {
3895 NL_SET_ERR_MSG(extack, "FDB add only supported for Ethernet devices");
3896 return -EINVAL;
3897 }
3898
3899 addr = nla_data(tb[NDA_LLADDR]);
3900
3901 err = fdb_vid_parse(tb[NDA_VLAN], &vid, extack);
3902 if (err)
3903 return err;
3904
3905 err = -EOPNOTSUPP;
3906
3907
3908 if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) &&
3909 (dev->priv_flags & IFF_BRIDGE_PORT)) {
3910 struct net_device *br_dev = netdev_master_upper_dev_get(dev);
3911 const struct net_device_ops *ops = br_dev->netdev_ops;
3912
3913 err = ops->ndo_fdb_add(ndm, tb, dev, addr, vid,
3914 nlh->nlmsg_flags, extack);
3915 if (err)
3916 goto out;
3917 else
3918 ndm->ndm_flags &= ~NTF_MASTER;
3919 }
3920
3921
3922 if ((ndm->ndm_flags & NTF_SELF)) {
3923 if (dev->netdev_ops->ndo_fdb_add)
3924 err = dev->netdev_ops->ndo_fdb_add(ndm, tb, dev, addr,
3925 vid,
3926 nlh->nlmsg_flags,
3927 extack);
3928 else
3929 err = ndo_dflt_fdb_add(ndm, tb, dev, addr, vid,
3930 nlh->nlmsg_flags);
3931
3932 if (!err) {
3933 rtnl_fdb_notify(dev, addr, vid, RTM_NEWNEIGH,
3934 ndm->ndm_state);
3935 ndm->ndm_flags &= ~NTF_SELF;
3936 }
3937 }
3938out:
3939 return err;
3940}
3941
3942
3943
3944
3945int ndo_dflt_fdb_del(struct ndmsg *ndm,
3946 struct nlattr *tb[],
3947 struct net_device *dev,
3948 const unsigned char *addr, u16 vid)
3949{
3950 int err = -EINVAL;
3951
3952
3953
3954
3955 if (!(ndm->ndm_state & NUD_PERMANENT)) {
3956 pr_info("%s: FDB only supports static addresses\n", dev->name);
3957 return err;
3958 }
3959
3960 if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr))
3961 err = dev_uc_del(dev, addr);
3962 else if (is_multicast_ether_addr(addr))
3963 err = dev_mc_del(dev, addr);
3964
3965 return err;
3966}
3967EXPORT_SYMBOL(ndo_dflt_fdb_del);
3968
3969static int rtnl_fdb_del(struct sk_buff *skb, struct nlmsghdr *nlh,
3970 struct netlink_ext_ack *extack)
3971{
3972 struct net *net = sock_net(skb->sk);
3973 struct ndmsg *ndm;
3974 struct nlattr *tb[NDA_MAX+1];
3975 struct net_device *dev;
3976 int err = -EINVAL;
3977 __u8 *addr;
3978 u16 vid;
3979
3980 if (!netlink_capable(skb, CAP_NET_ADMIN))
3981 return -EPERM;
3982
3983 err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX, NULL,
3984 extack);
3985 if (err < 0)
3986 return err;
3987
3988 ndm = nlmsg_data(nlh);
3989 if (ndm->ndm_ifindex == 0) {
3990 NL_SET_ERR_MSG(extack, "invalid ifindex");
3991 return -EINVAL;
3992 }
3993
3994 dev = __dev_get_by_index(net, ndm->ndm_ifindex);
3995 if (dev == NULL) {
3996 NL_SET_ERR_MSG(extack, "unknown ifindex");
3997 return -ENODEV;
3998 }
3999
4000 if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
4001 NL_SET_ERR_MSG(extack, "invalid address");
4002 return -EINVAL;
4003 }
4004
4005 if (dev->type != ARPHRD_ETHER) {
4006 NL_SET_ERR_MSG(extack, "FDB delete only supported for Ethernet devices");
4007 return -EINVAL;
4008 }
4009
4010 addr = nla_data(tb[NDA_LLADDR]);
4011
4012 err = fdb_vid_parse(tb[NDA_VLAN], &vid, extack);
4013 if (err)
4014 return err;
4015
4016 err = -EOPNOTSUPP;
4017
4018
4019 if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) &&
4020 (dev->priv_flags & IFF_BRIDGE_PORT)) {
4021 struct net_device *br_dev = netdev_master_upper_dev_get(dev);
4022 const struct net_device_ops *ops = br_dev->netdev_ops;
4023
4024 if (ops->ndo_fdb_del)
4025 err = ops->ndo_fdb_del(ndm, tb, dev, addr, vid);
4026
4027 if (err)
4028 goto out;
4029 else
4030 ndm->ndm_flags &= ~NTF_MASTER;
4031 }
4032
4033
4034 if (ndm->ndm_flags & NTF_SELF) {
4035 if (dev->netdev_ops->ndo_fdb_del)
4036 err = dev->netdev_ops->ndo_fdb_del(ndm, tb, dev, addr,
4037 vid);
4038 else
4039 err = ndo_dflt_fdb_del(ndm, tb, dev, addr, vid);
4040
4041 if (!err) {
4042 rtnl_fdb_notify(dev, addr, vid, RTM_DELNEIGH,
4043 ndm->ndm_state);
4044 ndm->ndm_flags &= ~NTF_SELF;
4045 }
4046 }
4047out:
4048 return err;
4049}
4050
4051static int nlmsg_populate_fdb(struct sk_buff *skb,
4052 struct netlink_callback *cb,
4053 struct net_device *dev,
4054 int *idx,
4055 struct netdev_hw_addr_list *list)
4056{
4057 struct netdev_hw_addr *ha;
4058 int err;
4059 u32 portid, seq;
4060
4061 portid = NETLINK_CB(cb->skb).portid;
4062 seq = cb->nlh->nlmsg_seq;
4063
4064 list_for_each_entry(ha, &list->list, list) {
4065 if (*idx < cb->args[2])
4066 goto skip;
4067
4068 err = nlmsg_populate_fdb_fill(skb, dev, ha->addr, 0,
4069 portid, seq,
4070 RTM_NEWNEIGH, NTF_SELF,
4071 NLM_F_MULTI, NUD_PERMANENT);
4072 if (err < 0)
4073 return err;
4074skip:
4075 *idx += 1;
4076 }
4077 return 0;
4078}
4079
4080
4081
4082
4083
4084
4085
4086
4087
4088
4089
4090
4091int ndo_dflt_fdb_dump(struct sk_buff *skb,
4092 struct netlink_callback *cb,
4093 struct net_device *dev,
4094 struct net_device *filter_dev,
4095 int *idx)
4096{
4097 int err;
4098
4099 if (dev->type != ARPHRD_ETHER)
4100 return -EINVAL;
4101
4102 netif_addr_lock_bh(dev);
4103 err = nlmsg_populate_fdb(skb, cb, dev, idx, &dev->uc);
4104 if (err)
4105 goto out;
4106 err = nlmsg_populate_fdb(skb, cb, dev, idx, &dev->mc);
4107out:
4108 netif_addr_unlock_bh(dev);
4109 return err;
4110}
4111EXPORT_SYMBOL(ndo_dflt_fdb_dump);
4112
4113static int valid_fdb_dump_strict(const struct nlmsghdr *nlh,
4114 int *br_idx, int *brport_idx,
4115 struct netlink_ext_ack *extack)
4116{
4117 struct nlattr *tb[NDA_MAX + 1];
4118 struct ndmsg *ndm;
4119 int err, i;
4120
4121 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ndm))) {
4122 NL_SET_ERR_MSG(extack, "Invalid header for fdb dump request");
4123 return -EINVAL;
4124 }
4125
4126 ndm = nlmsg_data(nlh);
4127 if (ndm->ndm_pad1 || ndm->ndm_pad2 || ndm->ndm_state ||
4128 ndm->ndm_flags || ndm->ndm_type) {
4129 NL_SET_ERR_MSG(extack, "Invalid values in header for fdb dump request");
4130 return -EINVAL;
4131 }
4132
4133 err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct ndmsg), tb,
4134 NDA_MAX, NULL, extack);
4135 if (err < 0)
4136 return err;
4137
4138 *brport_idx = ndm->ndm_ifindex;
4139 for (i = 0; i <= NDA_MAX; ++i) {
4140 if (!tb[i])
4141 continue;
4142
4143 switch (i) {
4144 case NDA_IFINDEX:
4145 if (nla_len(tb[i]) != sizeof(u32)) {
4146 NL_SET_ERR_MSG(extack, "Invalid IFINDEX attribute in fdb dump request");
4147 return -EINVAL;
4148 }
4149 *brport_idx = nla_get_u32(tb[NDA_IFINDEX]);
4150 break;
4151 case NDA_MASTER:
4152 if (nla_len(tb[i]) != sizeof(u32)) {
4153 NL_SET_ERR_MSG(extack, "Invalid MASTER attribute in fdb dump request");
4154 return -EINVAL;
4155 }
4156 *br_idx = nla_get_u32(tb[NDA_MASTER]);
4157 break;
4158 default:
4159 NL_SET_ERR_MSG(extack, "Unsupported attribute in fdb dump request");
4160 return -EINVAL;
4161 }
4162 }
4163
4164 return 0;
4165}
4166
4167static int valid_fdb_dump_legacy(const struct nlmsghdr *nlh,
4168 int *br_idx, int *brport_idx,
4169 struct netlink_ext_ack *extack)
4170{
4171 struct nlattr *tb[IFLA_MAX+1];
4172 int err;
4173
4174
4175
4176
4177
4178
4179
4180
4181 if (nlmsg_len(nlh) != sizeof(struct ndmsg) &&
4182 (nlmsg_len(nlh) != sizeof(struct ndmsg) +
4183 nla_attr_size(sizeof(u32)))) {
4184 struct ifinfomsg *ifm;
4185
4186 err = nlmsg_parse_deprecated(nlh, sizeof(struct ifinfomsg),
4187 tb, IFLA_MAX, ifla_policy,
4188 extack);
4189 if (err < 0) {
4190 return -EINVAL;
4191 } else if (err == 0) {
4192 if (tb[IFLA_MASTER])
4193 *br_idx = nla_get_u32(tb[IFLA_MASTER]);
4194 }
4195
4196 ifm = nlmsg_data(nlh);
4197 *brport_idx = ifm->ifi_index;
4198 }
4199 return 0;
4200}
4201
4202static int rtnl_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb)
4203{
4204 struct net_device *dev;
4205 struct net_device *br_dev = NULL;
4206 const struct net_device_ops *ops = NULL;
4207 const struct net_device_ops *cops = NULL;
4208 struct net *net = sock_net(skb->sk);
4209 struct hlist_head *head;
4210 int brport_idx = 0;
4211 int br_idx = 0;
4212 int h, s_h;
4213 int idx = 0, s_idx;
4214 int err = 0;
4215 int fidx = 0;
4216
4217 if (cb->strict_check)
4218 err = valid_fdb_dump_strict(cb->nlh, &br_idx, &brport_idx,
4219 cb->extack);
4220 else
4221 err = valid_fdb_dump_legacy(cb->nlh, &br_idx, &brport_idx,
4222 cb->extack);
4223 if (err < 0)
4224 return err;
4225
4226 if (br_idx) {
4227 br_dev = __dev_get_by_index(net, br_idx);
4228 if (!br_dev)
4229 return -ENODEV;
4230
4231 ops = br_dev->netdev_ops;
4232 }
4233
4234 s_h = cb->args[0];
4235 s_idx = cb->args[1];
4236
4237 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
4238 idx = 0;
4239 head = &net->dev_index_head[h];
4240 hlist_for_each_entry(dev, head, index_hlist) {
4241
4242 if (brport_idx && (dev->ifindex != brport_idx))
4243 continue;
4244
4245 if (!br_idx) {
4246 if (dev->priv_flags & IFF_BRIDGE_PORT) {
4247 br_dev = netdev_master_upper_dev_get(dev);
4248 cops = br_dev->netdev_ops;
4249 }
4250 } else {
4251 if (dev != br_dev &&
4252 !(dev->priv_flags & IFF_BRIDGE_PORT))
4253 continue;
4254
4255 if (br_dev != netdev_master_upper_dev_get(dev) &&
4256 !(dev->priv_flags & IFF_EBRIDGE))
4257 continue;
4258 cops = ops;
4259 }
4260
4261 if (idx < s_idx)
4262 goto cont;
4263
4264 if (dev->priv_flags & IFF_BRIDGE_PORT) {
4265 if (cops && cops->ndo_fdb_dump) {
4266 err = cops->ndo_fdb_dump(skb, cb,
4267 br_dev, dev,
4268 &fidx);
4269 if (err == -EMSGSIZE)
4270 goto out;
4271 }
4272 }
4273
4274 if (dev->netdev_ops->ndo_fdb_dump)
4275 err = dev->netdev_ops->ndo_fdb_dump(skb, cb,
4276 dev, NULL,
4277 &fidx);
4278 else
4279 err = ndo_dflt_fdb_dump(skb, cb, dev, NULL,
4280 &fidx);
4281 if (err == -EMSGSIZE)
4282 goto out;
4283
4284 cops = NULL;
4285
4286
4287 cb->args[2] = 0;
4288 fidx = 0;
4289cont:
4290 idx++;
4291 }
4292 }
4293
4294out:
4295 cb->args[0] = h;
4296 cb->args[1] = idx;
4297 cb->args[2] = fidx;
4298
4299 return skb->len;
4300}
4301
4302static int valid_fdb_get_strict(const struct nlmsghdr *nlh,
4303 struct nlattr **tb, u8 *ndm_flags,
4304 int *br_idx, int *brport_idx, u8 **addr,
4305 u16 *vid, struct netlink_ext_ack *extack)
4306{
4307 struct ndmsg *ndm;
4308 int err, i;
4309
4310 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ndm))) {
4311 NL_SET_ERR_MSG(extack, "Invalid header for fdb get request");
4312 return -EINVAL;
4313 }
4314
4315 ndm = nlmsg_data(nlh);
4316 if (ndm->ndm_pad1 || ndm->ndm_pad2 || ndm->ndm_state ||
4317 ndm->ndm_type) {
4318 NL_SET_ERR_MSG(extack, "Invalid values in header for fdb get request");
4319 return -EINVAL;
4320 }
4321
4322 if (ndm->ndm_flags & ~(NTF_MASTER | NTF_SELF)) {
4323 NL_SET_ERR_MSG(extack, "Invalid flags in header for fdb get request");
4324 return -EINVAL;
4325 }
4326
4327 err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct ndmsg), tb,
4328 NDA_MAX, nda_policy, extack);
4329 if (err < 0)
4330 return err;
4331
4332 *ndm_flags = ndm->ndm_flags;
4333 *brport_idx = ndm->ndm_ifindex;
4334 for (i = 0; i <= NDA_MAX; ++i) {
4335 if (!tb[i])
4336 continue;
4337
4338 switch (i) {
4339 case NDA_MASTER:
4340 *br_idx = nla_get_u32(tb[i]);
4341 break;
4342 case NDA_LLADDR:
4343 if (nla_len(tb[i]) != ETH_ALEN) {
4344 NL_SET_ERR_MSG(extack, "Invalid address in fdb get request");
4345 return -EINVAL;
4346 }
4347 *addr = nla_data(tb[i]);
4348 break;
4349 case NDA_VLAN:
4350 err = fdb_vid_parse(tb[i], vid, extack);
4351 if (err)
4352 return err;
4353 break;
4354 case NDA_VNI:
4355 break;
4356 default:
4357 NL_SET_ERR_MSG(extack, "Unsupported attribute in fdb get request");
4358 return -EINVAL;
4359 }
4360 }
4361
4362 return 0;
4363}
4364
4365static int rtnl_fdb_get(struct sk_buff *in_skb, struct nlmsghdr *nlh,
4366 struct netlink_ext_ack *extack)
4367{
4368 struct net_device *dev = NULL, *br_dev = NULL;
4369 const struct net_device_ops *ops = NULL;
4370 struct net *net = sock_net(in_skb->sk);
4371 struct nlattr *tb[NDA_MAX + 1];
4372 struct sk_buff *skb;
4373 int brport_idx = 0;
4374 u8 ndm_flags = 0;
4375 int br_idx = 0;
4376 u8 *addr = NULL;
4377 u16 vid = 0;
4378 int err;
4379
4380 err = valid_fdb_get_strict(nlh, tb, &ndm_flags, &br_idx,
4381 &brport_idx, &addr, &vid, extack);
4382 if (err < 0)
4383 return err;
4384
4385 if (!addr) {
4386 NL_SET_ERR_MSG(extack, "Missing lookup address for fdb get request");
4387 return -EINVAL;
4388 }
4389
4390 if (brport_idx) {
4391 dev = __dev_get_by_index(net, brport_idx);
4392 if (!dev) {
4393 NL_SET_ERR_MSG(extack, "Unknown device ifindex");
4394 return -ENODEV;
4395 }
4396 }
4397
4398 if (br_idx) {
4399 if (dev) {
4400 NL_SET_ERR_MSG(extack, "Master and device are mutually exclusive");
4401 return -EINVAL;
4402 }
4403
4404 br_dev = __dev_get_by_index(net, br_idx);
4405 if (!br_dev) {
4406 NL_SET_ERR_MSG(extack, "Invalid master ifindex");
4407 return -EINVAL;
4408 }
4409 ops = br_dev->netdev_ops;
4410 }
4411
4412 if (dev) {
4413 if (!ndm_flags || (ndm_flags & NTF_MASTER)) {
4414 if (!(dev->priv_flags & IFF_BRIDGE_PORT)) {
4415 NL_SET_ERR_MSG(extack, "Device is not a bridge port");
4416 return -EINVAL;
4417 }
4418 br_dev = netdev_master_upper_dev_get(dev);
4419 if (!br_dev) {
4420 NL_SET_ERR_MSG(extack, "Master of device not found");
4421 return -EINVAL;
4422 }
4423 ops = br_dev->netdev_ops;
4424 } else {
4425 if (!(ndm_flags & NTF_SELF)) {
4426 NL_SET_ERR_MSG(extack, "Missing NTF_SELF");
4427 return -EINVAL;
4428 }
4429 ops = dev->netdev_ops;
4430 }
4431 }
4432
4433 if (!br_dev && !dev) {
4434 NL_SET_ERR_MSG(extack, "No device specified");
4435 return -ENODEV;
4436 }
4437
4438 if (!ops || !ops->ndo_fdb_get) {
4439 NL_SET_ERR_MSG(extack, "Fdb get operation not supported by device");
4440 return -EOPNOTSUPP;
4441 }
4442
4443 skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
4444 if (!skb)
4445 return -ENOBUFS;
4446
4447 if (br_dev)
4448 dev = br_dev;
4449 err = ops->ndo_fdb_get(skb, tb, dev, addr, vid,
4450 NETLINK_CB(in_skb).portid,
4451 nlh->nlmsg_seq, extack);
4452 if (err)
4453 goto out;
4454
4455 return rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
4456out:
4457 kfree_skb(skb);
4458 return err;
4459}
4460
4461static int brport_nla_put_flag(struct sk_buff *skb, u32 flags, u32 mask,
4462 unsigned int attrnum, unsigned int flag)
4463{
4464 if (mask & flag)
4465 return nla_put_u8(skb, attrnum, !!(flags & flag));
4466 return 0;
4467}
4468
4469int ndo_dflt_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
4470 struct net_device *dev, u16 mode,
4471 u32 flags, u32 mask, int nlflags,
4472 u32 filter_mask,
4473 int (*vlan_fill)(struct sk_buff *skb,
4474 struct net_device *dev,
4475 u32 filter_mask))
4476{
4477 struct nlmsghdr *nlh;
4478 struct ifinfomsg *ifm;
4479 struct nlattr *br_afspec;
4480 struct nlattr *protinfo;
4481 u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN;
4482 struct net_device *br_dev = netdev_master_upper_dev_get(dev);
4483 int err = 0;
4484
4485 nlh = nlmsg_put(skb, pid, seq, RTM_NEWLINK, sizeof(*ifm), nlflags);
4486 if (nlh == NULL)
4487 return -EMSGSIZE;
4488
4489 ifm = nlmsg_data(nlh);
4490 ifm->ifi_family = AF_BRIDGE;
4491 ifm->__ifi_pad = 0;
4492 ifm->ifi_type = dev->type;
4493 ifm->ifi_index = dev->ifindex;
4494 ifm->ifi_flags = dev_get_flags(dev);
4495 ifm->ifi_change = 0;
4496
4497
4498 if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
4499 nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
4500 nla_put_u8(skb, IFLA_OPERSTATE, operstate) ||
4501 (br_dev &&
4502 nla_put_u32(skb, IFLA_MASTER, br_dev->ifindex)) ||
4503 (dev->addr_len &&
4504 nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
4505 (dev->ifindex != dev_get_iflink(dev) &&
4506 nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))))
4507 goto nla_put_failure;
4508
4509 br_afspec = nla_nest_start_noflag(skb, IFLA_AF_SPEC);
4510 if (!br_afspec)
4511 goto nla_put_failure;
4512
4513 if (nla_put_u16(skb, IFLA_BRIDGE_FLAGS, BRIDGE_FLAGS_SELF)) {
4514 nla_nest_cancel(skb, br_afspec);
4515 goto nla_put_failure;
4516 }
4517
4518 if (mode != BRIDGE_MODE_UNDEF) {
4519 if (nla_put_u16(skb, IFLA_BRIDGE_MODE, mode)) {
4520 nla_nest_cancel(skb, br_afspec);
4521 goto nla_put_failure;
4522 }
4523 }
4524 if (vlan_fill) {
4525 err = vlan_fill(skb, dev, filter_mask);
4526 if (err) {
4527 nla_nest_cancel(skb, br_afspec);
4528 goto nla_put_failure;
4529 }
4530 }
4531 nla_nest_end(skb, br_afspec);
4532
4533 protinfo = nla_nest_start(skb, IFLA_PROTINFO);
4534 if (!protinfo)
4535 goto nla_put_failure;
4536
4537 if (brport_nla_put_flag(skb, flags, mask,
4538 IFLA_BRPORT_MODE, BR_HAIRPIN_MODE) ||
4539 brport_nla_put_flag(skb, flags, mask,
4540 IFLA_BRPORT_GUARD, BR_BPDU_GUARD) ||
4541 brport_nla_put_flag(skb, flags, mask,
4542 IFLA_BRPORT_FAST_LEAVE,
4543 BR_MULTICAST_FAST_LEAVE) ||
4544 brport_nla_put_flag(skb, flags, mask,
4545 IFLA_BRPORT_PROTECT, BR_ROOT_BLOCK) ||
4546 brport_nla_put_flag(skb, flags, mask,
4547 IFLA_BRPORT_LEARNING, BR_LEARNING) ||
4548 brport_nla_put_flag(skb, flags, mask,
4549 IFLA_BRPORT_LEARNING_SYNC, BR_LEARNING_SYNC) ||
4550 brport_nla_put_flag(skb, flags, mask,
4551 IFLA_BRPORT_UNICAST_FLOOD, BR_FLOOD) ||
4552 brport_nla_put_flag(skb, flags, mask,
4553 IFLA_BRPORT_PROXYARP, BR_PROXYARP)) {
4554 nla_nest_cancel(skb, protinfo);
4555 goto nla_put_failure;
4556 }
4557
4558 nla_nest_end(skb, protinfo);
4559
4560 nlmsg_end(skb, nlh);
4561 return 0;
4562nla_put_failure:
4563 nlmsg_cancel(skb, nlh);
4564 return err ? err : -EMSGSIZE;
4565}
4566EXPORT_SYMBOL_GPL(ndo_dflt_bridge_getlink);
4567
4568static int valid_bridge_getlink_req(const struct nlmsghdr *nlh,
4569 bool strict_check, u32 *filter_mask,
4570 struct netlink_ext_ack *extack)
4571{
4572 struct nlattr *tb[IFLA_MAX+1];
4573 int err, i;
4574
4575 if (strict_check) {
4576 struct ifinfomsg *ifm;
4577
4578 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
4579 NL_SET_ERR_MSG(extack, "Invalid header for bridge link dump");
4580 return -EINVAL;
4581 }
4582
4583 ifm = nlmsg_data(nlh);
4584 if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
4585 ifm->ifi_change || ifm->ifi_index) {
4586 NL_SET_ERR_MSG(extack, "Invalid values in header for bridge link dump request");
4587 return -EINVAL;
4588 }
4589
4590 err = nlmsg_parse_deprecated_strict(nlh,
4591 sizeof(struct ifinfomsg),
4592 tb, IFLA_MAX, ifla_policy,
4593 extack);
4594 } else {
4595 err = nlmsg_parse_deprecated(nlh, sizeof(struct ifinfomsg),
4596 tb, IFLA_MAX, ifla_policy,
4597 extack);
4598 }
4599 if (err < 0)
4600 return err;
4601
4602
4603 for (i = 0; i <= IFLA_MAX; ++i) {
4604 if (!tb[i])
4605 continue;
4606
4607 switch (i) {
4608 case IFLA_EXT_MASK:
4609 *filter_mask = nla_get_u32(tb[i]);
4610 break;
4611 default:
4612 if (strict_check) {
4613 NL_SET_ERR_MSG(extack, "Unsupported attribute in bridge link dump request");
4614 return -EINVAL;
4615 }
4616 }
4617 }
4618
4619 return 0;
4620}
4621
4622static int rtnl_bridge_getlink(struct sk_buff *skb, struct netlink_callback *cb)
4623{
4624 const struct nlmsghdr *nlh = cb->nlh;
4625 struct net *net = sock_net(skb->sk);
4626 struct net_device *dev;
4627 int idx = 0;
4628 u32 portid = NETLINK_CB(cb->skb).portid;
4629 u32 seq = nlh->nlmsg_seq;
4630 u32 filter_mask = 0;
4631 int err;
4632
4633 err = valid_bridge_getlink_req(nlh, cb->strict_check, &filter_mask,
4634 cb->extack);
4635 if (err < 0 && cb->strict_check)
4636 return err;
4637
4638 rcu_read_lock();
4639 for_each_netdev_rcu(net, dev) {
4640 const struct net_device_ops *ops = dev->netdev_ops;
4641 struct net_device *br_dev = netdev_master_upper_dev_get(dev);
4642
4643 if (br_dev && br_dev->netdev_ops->ndo_bridge_getlink) {
4644 if (idx >= cb->args[0]) {
4645 err = br_dev->netdev_ops->ndo_bridge_getlink(
4646 skb, portid, seq, dev,
4647 filter_mask, NLM_F_MULTI);
4648 if (err < 0 && err != -EOPNOTSUPP) {
4649 if (likely(skb->len))
4650 break;
4651
4652 goto out_err;
4653 }
4654 }
4655 idx++;
4656 }
4657
4658 if (ops->ndo_bridge_getlink) {
4659 if (idx >= cb->args[0]) {
4660 err = ops->ndo_bridge_getlink(skb, portid,
4661 seq, dev,
4662 filter_mask,
4663 NLM_F_MULTI);
4664 if (err < 0 && err != -EOPNOTSUPP) {
4665 if (likely(skb->len))
4666 break;
4667
4668 goto out_err;
4669 }
4670 }
4671 idx++;
4672 }
4673 }
4674 err = skb->len;
4675out_err:
4676 rcu_read_unlock();
4677 cb->args[0] = idx;
4678
4679 return err;
4680}
4681
4682static inline size_t bridge_nlmsg_size(void)
4683{
4684 return NLMSG_ALIGN(sizeof(struct ifinfomsg))
4685 + nla_total_size(IFNAMSIZ)
4686 + nla_total_size(MAX_ADDR_LEN)
4687 + nla_total_size(sizeof(u32))
4688 + nla_total_size(sizeof(u32))
4689 + nla_total_size(sizeof(u32))
4690 + nla_total_size(sizeof(u32))
4691 + nla_total_size(sizeof(u8))
4692 + nla_total_size(sizeof(struct nlattr))
4693 + nla_total_size(sizeof(u16))
4694 + nla_total_size(sizeof(u16));
4695}
4696
4697static int rtnl_bridge_notify(struct net_device *dev)
4698{
4699 struct net *net = dev_net(dev);
4700 struct sk_buff *skb;
4701 int err = -EOPNOTSUPP;
4702
4703 if (!dev->netdev_ops->ndo_bridge_getlink)
4704 return 0;
4705
4706 skb = nlmsg_new(bridge_nlmsg_size(), GFP_ATOMIC);
4707 if (!skb) {
4708 err = -ENOMEM;
4709 goto errout;
4710 }
4711
4712 err = dev->netdev_ops->ndo_bridge_getlink(skb, 0, 0, dev, 0, 0);
4713 if (err < 0)
4714 goto errout;
4715
4716 if (!skb->len)
4717 goto errout;
4718
4719 rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
4720 return 0;
4721errout:
4722 WARN_ON(err == -EMSGSIZE);
4723 kfree_skb(skb);
4724 if (err)
4725 rtnl_set_sk_err(net, RTNLGRP_LINK, err);
4726 return err;
4727}
4728
4729static int rtnl_bridge_setlink(struct sk_buff *skb, struct nlmsghdr *nlh,
4730 struct netlink_ext_ack *extack)
4731{
4732 struct net *net = sock_net(skb->sk);
4733 struct ifinfomsg *ifm;
4734 struct net_device *dev;
4735 struct nlattr *br_spec, *attr = NULL;
4736 int rem, err = -EOPNOTSUPP;
4737 u16 flags = 0;
4738 bool have_flags = false;
4739
4740 if (nlmsg_len(nlh) < sizeof(*ifm))
4741 return -EINVAL;
4742
4743 ifm = nlmsg_data(nlh);
4744 if (ifm->ifi_family != AF_BRIDGE)
4745 return -EPFNOSUPPORT;
4746
4747 dev = __dev_get_by_index(net, ifm->ifi_index);
4748 if (!dev) {
4749 NL_SET_ERR_MSG(extack, "unknown ifindex");
4750 return -ENODEV;
4751 }
4752
4753 br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
4754 if (br_spec) {
4755 nla_for_each_nested(attr, br_spec, rem) {
4756 if (nla_type(attr) == IFLA_BRIDGE_FLAGS) {
4757 if (nla_len(attr) < sizeof(flags))
4758 return -EINVAL;
4759
4760 have_flags = true;
4761 flags = nla_get_u16(attr);
4762 break;
4763 }
4764 }
4765 }
4766
4767 if (!flags || (flags & BRIDGE_FLAGS_MASTER)) {
4768 struct net_device *br_dev = netdev_master_upper_dev_get(dev);
4769
4770 if (!br_dev || !br_dev->netdev_ops->ndo_bridge_setlink) {
4771 err = -EOPNOTSUPP;
4772 goto out;
4773 }
4774
4775 err = br_dev->netdev_ops->ndo_bridge_setlink(dev, nlh, flags,
4776 extack);
4777 if (err)
4778 goto out;
4779
4780 flags &= ~BRIDGE_FLAGS_MASTER;
4781 }
4782
4783 if ((flags & BRIDGE_FLAGS_SELF)) {
4784 if (!dev->netdev_ops->ndo_bridge_setlink)
4785 err = -EOPNOTSUPP;
4786 else
4787 err = dev->netdev_ops->ndo_bridge_setlink(dev, nlh,
4788 flags,
4789 extack);
4790 if (!err) {
4791 flags &= ~BRIDGE_FLAGS_SELF;
4792
4793
4794
4795
4796 err = rtnl_bridge_notify(dev);
4797 }
4798 }
4799
4800 if (have_flags)
4801 memcpy(nla_data(attr), &flags, sizeof(flags));
4802out:
4803 return err;
4804}
4805
4806static int rtnl_bridge_dellink(struct sk_buff *skb, struct nlmsghdr *nlh,
4807 struct netlink_ext_ack *extack)
4808{
4809 struct net *net = sock_net(skb->sk);
4810 struct ifinfomsg *ifm;
4811 struct net_device *dev;
4812 struct nlattr *br_spec, *attr = NULL;
4813 int rem, err = -EOPNOTSUPP;
4814 u16 flags = 0;
4815 bool have_flags = false;
4816
4817 if (nlmsg_len(nlh) < sizeof(*ifm))
4818 return -EINVAL;
4819
4820 ifm = nlmsg_data(nlh);
4821 if (ifm->ifi_family != AF_BRIDGE)
4822 return -EPFNOSUPPORT;
4823
4824 dev = __dev_get_by_index(net, ifm->ifi_index);
4825 if (!dev) {
4826 NL_SET_ERR_MSG(extack, "unknown ifindex");
4827 return -ENODEV;
4828 }
4829
4830 br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
4831 if (br_spec) {
4832 nla_for_each_nested(attr, br_spec, rem) {
4833 if (nla_type(attr) == IFLA_BRIDGE_FLAGS) {
4834 if (nla_len(attr) < sizeof(flags))
4835 return -EINVAL;
4836
4837 have_flags = true;
4838 flags = nla_get_u16(attr);
4839 break;
4840 }
4841 }
4842 }
4843
4844 if (!flags || (flags & BRIDGE_FLAGS_MASTER)) {
4845 struct net_device *br_dev = netdev_master_upper_dev_get(dev);
4846
4847 if (!br_dev || !br_dev->netdev_ops->ndo_bridge_dellink) {
4848 err = -EOPNOTSUPP;
4849 goto out;
4850 }
4851
4852 err = br_dev->netdev_ops->ndo_bridge_dellink(dev, nlh, flags);
4853 if (err)
4854 goto out;
4855
4856 flags &= ~BRIDGE_FLAGS_MASTER;
4857 }
4858
4859 if ((flags & BRIDGE_FLAGS_SELF)) {
4860 if (!dev->netdev_ops->ndo_bridge_dellink)
4861 err = -EOPNOTSUPP;
4862 else
4863 err = dev->netdev_ops->ndo_bridge_dellink(dev, nlh,
4864 flags);
4865
4866 if (!err) {
4867 flags &= ~BRIDGE_FLAGS_SELF;
4868
4869
4870
4871
4872 err = rtnl_bridge_notify(dev);
4873 }
4874 }
4875
4876 if (have_flags)
4877 memcpy(nla_data(attr), &flags, sizeof(flags));
4878out:
4879 return err;
4880}
4881
4882static bool stats_attr_valid(unsigned int mask, int attrid, int idxattr)
4883{
4884 return (mask & IFLA_STATS_FILTER_BIT(attrid)) &&
4885 (!idxattr || idxattr == attrid);
4886}
4887
4888#define IFLA_OFFLOAD_XSTATS_FIRST (IFLA_OFFLOAD_XSTATS_UNSPEC + 1)
4889static int rtnl_get_offload_stats_attr_size(int attr_id)
4890{
4891 switch (attr_id) {
4892 case IFLA_OFFLOAD_XSTATS_CPU_HIT:
4893 return sizeof(struct rtnl_link_stats64);
4894 }
4895
4896 return 0;
4897}
4898
4899static int rtnl_get_offload_stats(struct sk_buff *skb, struct net_device *dev,
4900 int *prividx)
4901{
4902 struct nlattr *attr = NULL;
4903 int attr_id, size;
4904 void *attr_data;
4905 int err;
4906
4907 if (!(dev->netdev_ops && dev->netdev_ops->ndo_has_offload_stats &&
4908 dev->netdev_ops->ndo_get_offload_stats))
4909 return -ENODATA;
4910
4911 for (attr_id = IFLA_OFFLOAD_XSTATS_FIRST;
4912 attr_id <= IFLA_OFFLOAD_XSTATS_MAX; attr_id++) {
4913 if (attr_id < *prividx)
4914 continue;
4915
4916 size = rtnl_get_offload_stats_attr_size(attr_id);
4917 if (!size)
4918 continue;
4919
4920 if (!dev->netdev_ops->ndo_has_offload_stats(dev, attr_id))
4921 continue;
4922
4923 attr = nla_reserve_64bit(skb, attr_id, size,
4924 IFLA_OFFLOAD_XSTATS_UNSPEC);
4925 if (!attr)
4926 goto nla_put_failure;
4927
4928 attr_data = nla_data(attr);
4929 memset(attr_data, 0, size);
4930 err = dev->netdev_ops->ndo_get_offload_stats(attr_id, dev,
4931 attr_data);
4932 if (err)
4933 goto get_offload_stats_failure;
4934 }
4935
4936 if (!attr)
4937 return -ENODATA;
4938
4939 *prividx = 0;
4940 return 0;
4941
4942nla_put_failure:
4943 err = -EMSGSIZE;
4944get_offload_stats_failure:
4945 *prividx = attr_id;
4946 return err;
4947}
4948
4949static int rtnl_get_offload_stats_size(const struct net_device *dev)
4950{
4951 int nla_size = 0;
4952 int attr_id;
4953 int size;
4954
4955 if (!(dev->netdev_ops && dev->netdev_ops->ndo_has_offload_stats &&
4956 dev->netdev_ops->ndo_get_offload_stats))
4957 return 0;
4958
4959 for (attr_id = IFLA_OFFLOAD_XSTATS_FIRST;
4960 attr_id <= IFLA_OFFLOAD_XSTATS_MAX; attr_id++) {
4961 if (!dev->netdev_ops->ndo_has_offload_stats(dev, attr_id))
4962 continue;
4963 size = rtnl_get_offload_stats_attr_size(attr_id);
4964 nla_size += nla_total_size_64bit(size);
4965 }
4966
4967 if (nla_size != 0)
4968 nla_size += nla_total_size(0);
4969
4970 return nla_size;
4971}
4972
4973static int rtnl_fill_statsinfo(struct sk_buff *skb, struct net_device *dev,
4974 int type, u32 pid, u32 seq, u32 change,
4975 unsigned int flags, unsigned int filter_mask,
4976 int *idxattr, int *prividx)
4977{
4978 struct if_stats_msg *ifsm;
4979 struct nlmsghdr *nlh;
4980 struct nlattr *attr;
4981 int s_prividx = *prividx;
4982 int err;
4983
4984 ASSERT_RTNL();
4985
4986 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifsm), flags);
4987 if (!nlh)
4988 return -EMSGSIZE;
4989
4990 ifsm = nlmsg_data(nlh);
4991 ifsm->family = PF_UNSPEC;
4992 ifsm->pad1 = 0;
4993 ifsm->pad2 = 0;
4994 ifsm->ifindex = dev->ifindex;
4995 ifsm->filter_mask = filter_mask;
4996
4997 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_64, *idxattr)) {
4998 struct rtnl_link_stats64 *sp;
4999
5000 attr = nla_reserve_64bit(skb, IFLA_STATS_LINK_64,
5001 sizeof(struct rtnl_link_stats64),
5002 IFLA_STATS_UNSPEC);
5003 if (!attr)
5004 goto nla_put_failure;
5005
5006 sp = nla_data(attr);
5007 dev_get_stats(dev, sp);
5008 }
5009
5010 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS, *idxattr)) {
5011 const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
5012
5013 if (ops && ops->fill_linkxstats) {
5014 *idxattr = IFLA_STATS_LINK_XSTATS;
5015 attr = nla_nest_start_noflag(skb,
5016 IFLA_STATS_LINK_XSTATS);
5017 if (!attr)
5018 goto nla_put_failure;
5019
5020 err = ops->fill_linkxstats(skb, dev, prividx, *idxattr);
5021 nla_nest_end(skb, attr);
5022 if (err)
5023 goto nla_put_failure;
5024 *idxattr = 0;
5025 }
5026 }
5027
5028 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS_SLAVE,
5029 *idxattr)) {
5030 const struct rtnl_link_ops *ops = NULL;
5031 const struct net_device *master;
5032
5033 master = netdev_master_upper_dev_get(dev);
5034 if (master)
5035 ops = master->rtnl_link_ops;
5036 if (ops && ops->fill_linkxstats) {
5037 *idxattr = IFLA_STATS_LINK_XSTATS_SLAVE;
5038 attr = nla_nest_start_noflag(skb,
5039 IFLA_STATS_LINK_XSTATS_SLAVE);
5040 if (!attr)
5041 goto nla_put_failure;
5042
5043 err = ops->fill_linkxstats(skb, dev, prividx, *idxattr);
5044 nla_nest_end(skb, attr);
5045 if (err)
5046 goto nla_put_failure;
5047 *idxattr = 0;
5048 }
5049 }
5050
5051 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_OFFLOAD_XSTATS,
5052 *idxattr)) {
5053 *idxattr = IFLA_STATS_LINK_OFFLOAD_XSTATS;
5054 attr = nla_nest_start_noflag(skb,
5055 IFLA_STATS_LINK_OFFLOAD_XSTATS);
5056 if (!attr)
5057 goto nla_put_failure;
5058
5059 err = rtnl_get_offload_stats(skb, dev, prividx);
5060 if (err == -ENODATA)
5061 nla_nest_cancel(skb, attr);
5062 else
5063 nla_nest_end(skb, attr);
5064
5065 if (err && err != -ENODATA)
5066 goto nla_put_failure;
5067 *idxattr = 0;
5068 }
5069
5070 if (stats_attr_valid(filter_mask, IFLA_STATS_AF_SPEC, *idxattr)) {
5071 struct rtnl_af_ops *af_ops;
5072
5073 *idxattr = IFLA_STATS_AF_SPEC;
5074 attr = nla_nest_start_noflag(skb, IFLA_STATS_AF_SPEC);
5075 if (!attr)
5076 goto nla_put_failure;
5077
5078 rcu_read_lock();
5079 list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
5080 if (af_ops->fill_stats_af) {
5081 struct nlattr *af;
5082 int err;
5083
5084 af = nla_nest_start_noflag(skb,
5085 af_ops->family);
5086 if (!af) {
5087 rcu_read_unlock();
5088 goto nla_put_failure;
5089 }
5090 err = af_ops->fill_stats_af(skb, dev);
5091
5092 if (err == -ENODATA) {
5093 nla_nest_cancel(skb, af);
5094 } else if (err < 0) {
5095 rcu_read_unlock();
5096 goto nla_put_failure;
5097 }
5098
5099 nla_nest_end(skb, af);
5100 }
5101 }
5102 rcu_read_unlock();
5103
5104 nla_nest_end(skb, attr);
5105
5106 *idxattr = 0;
5107 }
5108
5109 nlmsg_end(skb, nlh);
5110
5111 return 0;
5112
5113nla_put_failure:
5114
5115 if (!(flags & NLM_F_MULTI) || s_prividx == *prividx)
5116 nlmsg_cancel(skb, nlh);
5117 else
5118 nlmsg_end(skb, nlh);
5119
5120 return -EMSGSIZE;
5121}
5122
5123static size_t if_nlmsg_stats_size(const struct net_device *dev,
5124 u32 filter_mask)
5125{
5126 size_t size = 0;
5127
5128 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_64, 0))
5129 size += nla_total_size_64bit(sizeof(struct rtnl_link_stats64));
5130
5131 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS, 0)) {
5132 const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
5133 int attr = IFLA_STATS_LINK_XSTATS;
5134
5135 if (ops && ops->get_linkxstats_size) {
5136 size += nla_total_size(ops->get_linkxstats_size(dev,
5137 attr));
5138
5139 size += nla_total_size(0);
5140 }
5141 }
5142
5143 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS_SLAVE, 0)) {
5144 struct net_device *_dev = (struct net_device *)dev;
5145 const struct rtnl_link_ops *ops = NULL;
5146 const struct net_device *master;
5147
5148
5149 master = netdev_master_upper_dev_get(_dev);
5150 if (master)
5151 ops = master->rtnl_link_ops;
5152 if (ops && ops->get_linkxstats_size) {
5153 int attr = IFLA_STATS_LINK_XSTATS_SLAVE;
5154
5155 size += nla_total_size(ops->get_linkxstats_size(dev,
5156 attr));
5157
5158 size += nla_total_size(0);
5159 }
5160 }
5161
5162 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_OFFLOAD_XSTATS, 0))
5163 size += rtnl_get_offload_stats_size(dev);
5164
5165 if (stats_attr_valid(filter_mask, IFLA_STATS_AF_SPEC, 0)) {
5166 struct rtnl_af_ops *af_ops;
5167
5168
5169 size += nla_total_size(0);
5170
5171 rcu_read_lock();
5172 list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
5173 if (af_ops->get_stats_af_size) {
5174 size += nla_total_size(
5175 af_ops->get_stats_af_size(dev));
5176
5177
5178 size += nla_total_size(0);
5179 }
5180 }
5181 rcu_read_unlock();
5182 }
5183
5184 return size;
5185}
5186
5187static int rtnl_valid_stats_req(const struct nlmsghdr *nlh, bool strict_check,
5188 bool is_dump, struct netlink_ext_ack *extack)
5189{
5190 struct if_stats_msg *ifsm;
5191
5192 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifsm))) {
5193 NL_SET_ERR_MSG(extack, "Invalid header for stats dump");
5194 return -EINVAL;
5195 }
5196
5197 if (!strict_check)
5198 return 0;
5199
5200 ifsm = nlmsg_data(nlh);
5201
5202
5203
5204
5205 if (ifsm->pad1 || ifsm->pad2 || (is_dump && ifsm->ifindex)) {
5206 NL_SET_ERR_MSG(extack, "Invalid values in header for stats dump request");
5207 return -EINVAL;
5208 }
5209 if (nlmsg_attrlen(nlh, sizeof(*ifsm))) {
5210 NL_SET_ERR_MSG(extack, "Invalid attributes after stats header");
5211 return -EINVAL;
5212 }
5213 if (ifsm->filter_mask >= IFLA_STATS_FILTER_BIT(IFLA_STATS_MAX + 1)) {
5214 NL_SET_ERR_MSG(extack, "Invalid stats requested through filter mask");
5215 return -EINVAL;
5216 }
5217
5218 return 0;
5219}
5220
5221static int rtnl_stats_get(struct sk_buff *skb, struct nlmsghdr *nlh,
5222 struct netlink_ext_ack *extack)
5223{
5224 struct net *net = sock_net(skb->sk);
5225 struct net_device *dev = NULL;
5226 int idxattr = 0, prividx = 0;
5227 struct if_stats_msg *ifsm;
5228 struct sk_buff *nskb;
5229 u32 filter_mask;
5230 int err;
5231
5232 err = rtnl_valid_stats_req(nlh, netlink_strict_get_check(skb),
5233 false, extack);
5234 if (err)
5235 return err;
5236
5237 ifsm = nlmsg_data(nlh);
5238 if (ifsm->ifindex > 0)
5239 dev = __dev_get_by_index(net, ifsm->ifindex);
5240 else
5241 return -EINVAL;
5242
5243 if (!dev)
5244 return -ENODEV;
5245
5246 filter_mask = ifsm->filter_mask;
5247 if (!filter_mask)
5248 return -EINVAL;
5249
5250 nskb = nlmsg_new(if_nlmsg_stats_size(dev, filter_mask), GFP_KERNEL);
5251 if (!nskb)
5252 return -ENOBUFS;
5253
5254 err = rtnl_fill_statsinfo(nskb, dev, RTM_NEWSTATS,
5255 NETLINK_CB(skb).portid, nlh->nlmsg_seq, 0,
5256 0, filter_mask, &idxattr, &prividx);
5257 if (err < 0) {
5258
5259 WARN_ON(err == -EMSGSIZE);
5260 kfree_skb(nskb);
5261 } else {
5262 err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid);
5263 }
5264
5265 return err;
5266}
5267
5268static int rtnl_stats_dump(struct sk_buff *skb, struct netlink_callback *cb)
5269{
5270 struct netlink_ext_ack *extack = cb->extack;
5271 int h, s_h, err, s_idx, s_idxattr, s_prividx;
5272 struct net *net = sock_net(skb->sk);
5273 unsigned int flags = NLM_F_MULTI;
5274 struct if_stats_msg *ifsm;
5275 struct hlist_head *head;
5276 struct net_device *dev;
5277 u32 filter_mask = 0;
5278 int idx = 0;
5279
5280 s_h = cb->args[0];
5281 s_idx = cb->args[1];
5282 s_idxattr = cb->args[2];
5283 s_prividx = cb->args[3];
5284
5285 cb->seq = net->dev_base_seq;
5286
5287 err = rtnl_valid_stats_req(cb->nlh, cb->strict_check, true, extack);
5288 if (err)
5289 return err;
5290
5291 ifsm = nlmsg_data(cb->nlh);
5292 filter_mask = ifsm->filter_mask;
5293 if (!filter_mask) {
5294 NL_SET_ERR_MSG(extack, "Filter mask must be set for stats dump");
5295 return -EINVAL;
5296 }
5297
5298 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
5299 idx = 0;
5300 head = &net->dev_index_head[h];
5301 hlist_for_each_entry(dev, head, index_hlist) {
5302 if (idx < s_idx)
5303 goto cont;
5304 err = rtnl_fill_statsinfo(skb, dev, RTM_NEWSTATS,
5305 NETLINK_CB(cb->skb).portid,
5306 cb->nlh->nlmsg_seq, 0,
5307 flags, filter_mask,
5308 &s_idxattr, &s_prividx);
5309
5310
5311
5312 WARN_ON((err == -EMSGSIZE) && (skb->len == 0));
5313
5314 if (err < 0)
5315 goto out;
5316 s_prividx = 0;
5317 s_idxattr = 0;
5318 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
5319cont:
5320 idx++;
5321 }
5322 }
5323out:
5324 cb->args[3] = s_prividx;
5325 cb->args[2] = s_idxattr;
5326 cb->args[1] = idx;
5327 cb->args[0] = h;
5328
5329 return skb->len;
5330}
5331
5332
5333
5334static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
5335 struct netlink_ext_ack *extack)
5336{
5337 struct net *net = sock_net(skb->sk);
5338 struct rtnl_link *link;
5339 struct module *owner;
5340 int err = -EOPNOTSUPP;
5341 rtnl_doit_func doit;
5342 unsigned int flags;
5343 int kind;
5344 int family;
5345 int type;
5346
5347 type = nlh->nlmsg_type;
5348 if (type > RTM_MAX)
5349 return -EOPNOTSUPP;
5350
5351 type -= RTM_BASE;
5352
5353
5354 if (nlmsg_len(nlh) < sizeof(struct rtgenmsg))
5355 return 0;
5356
5357 family = ((struct rtgenmsg *)nlmsg_data(nlh))->rtgen_family;
5358 kind = type&3;
5359
5360 if (kind != 2 && !netlink_net_capable(skb, CAP_NET_ADMIN))
5361 return -EPERM;
5362
5363 rcu_read_lock();
5364 if (kind == 2 && nlh->nlmsg_flags&NLM_F_DUMP) {
5365 struct sock *rtnl;
5366 rtnl_dumpit_func dumpit;
5367 u16 min_dump_alloc = 0;
5368
5369 link = rtnl_get_link(family, type);
5370 if (!link || !link->dumpit) {
5371 family = PF_UNSPEC;
5372 link = rtnl_get_link(family, type);
5373 if (!link || !link->dumpit)
5374 goto err_unlock;
5375 }
5376 owner = link->owner;
5377 dumpit = link->dumpit;
5378
5379 if (type == RTM_GETLINK - RTM_BASE)
5380 min_dump_alloc = rtnl_calcit(skb, nlh);
5381
5382 err = 0;
5383
5384 if (!try_module_get(owner))
5385 err = -EPROTONOSUPPORT;
5386
5387 rcu_read_unlock();
5388
5389 rtnl = net->rtnl;
5390 if (err == 0) {
5391 struct netlink_dump_control c = {
5392 .dump = dumpit,
5393 .min_dump_alloc = min_dump_alloc,
5394 .module = owner,
5395 };
5396 err = netlink_dump_start(rtnl, skb, nlh, &c);
5397
5398
5399
5400 module_put(owner);
5401 }
5402 return err;
5403 }
5404
5405 link = rtnl_get_link(family, type);
5406 if (!link || !link->doit) {
5407 family = PF_UNSPEC;
5408 link = rtnl_get_link(PF_UNSPEC, type);
5409 if (!link || !link->doit)
5410 goto out_unlock;
5411 }
5412
5413 owner = link->owner;
5414 if (!try_module_get(owner)) {
5415 err = -EPROTONOSUPPORT;
5416 goto out_unlock;
5417 }
5418
5419 flags = link->flags;
5420 if (flags & RTNL_FLAG_DOIT_UNLOCKED) {
5421 doit = link->doit;
5422 rcu_read_unlock();
5423 if (doit)
5424 err = doit(skb, nlh, extack);
5425 module_put(owner);
5426 return err;
5427 }
5428 rcu_read_unlock();
5429
5430 rtnl_lock();
5431 link = rtnl_get_link(family, type);
5432 if (link && link->doit)
5433 err = link->doit(skb, nlh, extack);
5434 rtnl_unlock();
5435
5436 module_put(owner);
5437
5438 return err;
5439
5440out_unlock:
5441 rcu_read_unlock();
5442 return err;
5443
5444err_unlock:
5445 rcu_read_unlock();
5446 return -EOPNOTSUPP;
5447}
5448
5449static void rtnetlink_rcv(struct sk_buff *skb)
5450{
5451 netlink_rcv_skb(skb, &rtnetlink_rcv_msg);
5452}
5453
5454static int rtnetlink_bind(struct net *net, int group)
5455{
5456 switch (group) {
5457 case RTNLGRP_IPV4_MROUTE_R:
5458 case RTNLGRP_IPV6_MROUTE_R:
5459 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
5460 return -EPERM;
5461 break;
5462 }
5463 return 0;
5464}
5465
5466static int rtnetlink_event(struct notifier_block *this, unsigned long event, void *ptr)
5467{
5468 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
5469
5470 switch (event) {
5471 case NETDEV_REBOOT:
5472 case NETDEV_CHANGEMTU:
5473 case NETDEV_CHANGEADDR:
5474 case NETDEV_CHANGENAME:
5475 case NETDEV_FEAT_CHANGE:
5476 case NETDEV_BONDING_FAILOVER:
5477 case NETDEV_POST_TYPE_CHANGE:
5478 case NETDEV_NOTIFY_PEERS:
5479 case NETDEV_CHANGEUPPER:
5480 case NETDEV_RESEND_IGMP:
5481 case NETDEV_CHANGEINFODATA:
5482 case NETDEV_CHANGELOWERSTATE:
5483 case NETDEV_CHANGE_TX_QUEUE_LEN:
5484 rtmsg_ifinfo_event(RTM_NEWLINK, dev, 0, rtnl_get_event(event),
5485 GFP_KERNEL, NULL, 0);
5486 break;
5487 default:
5488 break;
5489 }
5490 return NOTIFY_DONE;
5491}
5492
5493static struct notifier_block rtnetlink_dev_notifier = {
5494 .notifier_call = rtnetlink_event,
5495};
5496
5497
5498static int __net_init rtnetlink_net_init(struct net *net)
5499{
5500 struct sock *sk;
5501 struct netlink_kernel_cfg cfg = {
5502 .groups = RTNLGRP_MAX,
5503 .input = rtnetlink_rcv,
5504 .cb_mutex = &rtnl_mutex,
5505 .flags = NL_CFG_F_NONROOT_RECV,
5506 .bind = rtnetlink_bind,
5507 };
5508
5509 sk = netlink_kernel_create(net, NETLINK_ROUTE, &cfg);
5510 if (!sk)
5511 return -ENOMEM;
5512 net->rtnl = sk;
5513 return 0;
5514}
5515
5516static void __net_exit rtnetlink_net_exit(struct net *net)
5517{
5518 netlink_kernel_release(net->rtnl);
5519 net->rtnl = NULL;
5520}
5521
5522static struct pernet_operations rtnetlink_net_ops = {
5523 .init = rtnetlink_net_init,
5524 .exit = rtnetlink_net_exit,
5525};
5526
5527void __init rtnetlink_init(void)
5528{
5529 if (register_pernet_subsys(&rtnetlink_net_ops))
5530 panic("rtnetlink_init: cannot initialize rtnetlink\n");
5531
5532 register_netdevice_notifier(&rtnetlink_dev_notifier);
5533
5534 rtnl_register(PF_UNSPEC, RTM_GETLINK, rtnl_getlink,
5535 rtnl_dump_ifinfo, 0);
5536 rtnl_register(PF_UNSPEC, RTM_SETLINK, rtnl_setlink, NULL, 0);
5537 rtnl_register(PF_UNSPEC, RTM_NEWLINK, rtnl_newlink, NULL, 0);
5538 rtnl_register(PF_UNSPEC, RTM_DELLINK, rtnl_dellink, NULL, 0);
5539
5540 rtnl_register(PF_UNSPEC, RTM_GETADDR, NULL, rtnl_dump_all, 0);
5541 rtnl_register(PF_UNSPEC, RTM_GETROUTE, NULL, rtnl_dump_all, 0);
5542 rtnl_register(PF_UNSPEC, RTM_GETNETCONF, NULL, rtnl_dump_all, 0);
5543
5544 rtnl_register(PF_UNSPEC, RTM_NEWLINKPROP, rtnl_newlinkprop, NULL, 0);
5545 rtnl_register(PF_UNSPEC, RTM_DELLINKPROP, rtnl_dellinkprop, NULL, 0);
5546
5547 rtnl_register(PF_BRIDGE, RTM_NEWNEIGH, rtnl_fdb_add, NULL, 0);
5548 rtnl_register(PF_BRIDGE, RTM_DELNEIGH, rtnl_fdb_del, NULL, 0);
5549 rtnl_register(PF_BRIDGE, RTM_GETNEIGH, rtnl_fdb_get, rtnl_fdb_dump, 0);
5550
5551 rtnl_register(PF_BRIDGE, RTM_GETLINK, NULL, rtnl_bridge_getlink, 0);
5552 rtnl_register(PF_BRIDGE, RTM_DELLINK, rtnl_bridge_dellink, NULL, 0);
5553 rtnl_register(PF_BRIDGE, RTM_SETLINK, rtnl_bridge_setlink, NULL, 0);
5554
5555 rtnl_register(PF_UNSPEC, RTM_GETSTATS, rtnl_stats_get, rtnl_stats_dump,
5556 0);
5557}
5558