1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Linux IPv6 multicast routing support for BSD pim6sd
4 * Based on net/ipv4/ipmr.c.
6 * (c) 2004 Mickael Hoerdt, <hoerdt@clarinet.u-strasbg.fr>
7 * LSIIT Laboratory, Strasbourg, France
8 * (c) 2004 Jean-Philippe Andriot, <jean-philippe.andriot@6WIND.com>
10 * Copyright (C)2007,2008 USAGI/WIDE Project
11 * YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
14 #include <linux/uaccess.h>
15 #include <linux/types.h>
16 #include <linux/sched.h>
17 #include <linux/errno.h>
19 #include <linux/kernel.h>
20 #include <linux/fcntl.h>
21 #include <linux/stat.h>
22 #include <linux/socket.h>
23 #include <linux/inet.h>
24 #include <linux/netdevice.h>
25 #include <linux/inetdevice.h>
26 #include <linux/proc_fs.h>
27 #include <linux/seq_file.h>
28 #include <linux/init.h>
29 #include <linux/compat.h>
30 #include <linux/rhashtable.h>
31 #include <net/protocol.h>
32 #include <linux/skbuff.h>
34 #include <linux/notifier.h>
35 #include <linux/if_arp.h>
36 #include <net/checksum.h>
37 #include <net/netlink.h>
38 #include <net/fib_rules.h>
41 #include <net/ip6_route.h>
42 #include <linux/mroute6.h>
43 #include <linux/pim.h>
44 #include <net/addrconf.h>
45 #include <linux/netfilter_ipv6.h>
46 #include <linux/export.h>
47 #include <net/ip6_checksum.h>
48 #include <linux/netconf.h>
49 #include <net/ip_tunnels.h>
51 #include <linux/nospec.h>
54 struct fib_rule common;
61 /* Big lock, protecting vif table, mrt cache and mroute socket state.
62 Note that the changes are semaphored via rtnl_lock.
65 static DEFINE_RWLOCK(mrt_lock);
67 /* Multicast router control variables */
69 /* Special spinlock for queue of unresolved entries */
70 static DEFINE_SPINLOCK(mfc_unres_lock);
72 /* We return to original Alan's scheme. Hash table of resolved
73 entries is changed only in process context and protected
74 with weak lock mrt_lock. Queue of unresolved entries is protected
75 with strong spinlock mfc_unres_lock.
77 In this case data path is free of exclusive locks at all.
80 static struct kmem_cache *mrt_cachep __read_mostly;
82 static struct mr_table *ip6mr_new_table(struct net *net, u32 id);
83 static void ip6mr_free_table(struct mr_table *mrt);
85 static void ip6_mr_forward(struct net *net, struct mr_table *mrt,
86 struct net_device *dev, struct sk_buff *skb,
87 struct mfc6_cache *cache);
88 static int ip6mr_cache_report(struct mr_table *mrt, struct sk_buff *pkt,
89 mifi_t mifi, int assert);
90 static void mr6_netlink_event(struct mr_table *mrt, struct mfc6_cache *mfc,
92 static void mrt6msg_netlink_event(struct mr_table *mrt, struct sk_buff *pkt);
93 static int ip6mr_rtm_dumproute(struct sk_buff *skb,
94 struct netlink_callback *cb);
95 static void mroute_clean_tables(struct mr_table *mrt, int flags);
96 static void ipmr_expire_process(struct timer_list *t);
98 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
99 #define ip6mr_for_each_table(mrt, net) \
100 list_for_each_entry_rcu(mrt, &net->ipv6.mr6_tables, list, \
101 lockdep_rtnl_is_held() || \
102 list_empty(&net->ipv6.mr6_tables))
104 static struct mr_table *ip6mr_mr_table_iter(struct net *net,
105 struct mr_table *mrt)
107 struct mr_table *ret;
110 ret = list_entry_rcu(net->ipv6.mr6_tables.next,
111 struct mr_table, list);
113 ret = list_entry_rcu(mrt->list.next,
114 struct mr_table, list);
116 if (&ret->list == &net->ipv6.mr6_tables)
121 static struct mr_table *ip6mr_get_table(struct net *net, u32 id)
123 struct mr_table *mrt;
125 ip6mr_for_each_table(mrt, net) {
132 static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
133 struct mr_table **mrt)
136 struct ip6mr_result res;
137 struct fib_lookup_arg arg = {
139 .flags = FIB_LOOKUP_NOREF,
142 /* update flow if oif or iif point to device enslaved to l3mdev */
143 l3mdev_update_flow(net, flowi6_to_flowi(flp6));
145 err = fib_rules_lookup(net->ipv6.mr6_rules_ops,
146 flowi6_to_flowi(flp6), 0, &arg);
153 static int ip6mr_rule_action(struct fib_rule *rule, struct flowi *flp,
154 int flags, struct fib_lookup_arg *arg)
156 struct ip6mr_result *res = arg->result;
157 struct mr_table *mrt;
159 switch (rule->action) {
162 case FR_ACT_UNREACHABLE:
164 case FR_ACT_PROHIBIT:
166 case FR_ACT_BLACKHOLE:
171 arg->table = fib_rule_get_table(rule, arg);
173 mrt = ip6mr_get_table(rule->fr_net, arg->table);
180 static int ip6mr_rule_match(struct fib_rule *rule, struct flowi *flp, int flags)
185 static const struct nla_policy ip6mr_rule_policy[FRA_MAX + 1] = {
189 static int ip6mr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
190 struct fib_rule_hdr *frh, struct nlattr **tb,
191 struct netlink_ext_ack *extack)
196 static int ip6mr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
202 static int ip6mr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
203 struct fib_rule_hdr *frh)
211 static const struct fib_rules_ops __net_initconst ip6mr_rules_ops_template = {
212 .family = RTNL_FAMILY_IP6MR,
213 .rule_size = sizeof(struct ip6mr_rule),
214 .addr_size = sizeof(struct in6_addr),
215 .action = ip6mr_rule_action,
216 .match = ip6mr_rule_match,
217 .configure = ip6mr_rule_configure,
218 .compare = ip6mr_rule_compare,
219 .fill = ip6mr_rule_fill,
220 .nlgroup = RTNLGRP_IPV6_RULE,
221 .policy = ip6mr_rule_policy,
222 .owner = THIS_MODULE,
225 static int __net_init ip6mr_rules_init(struct net *net)
227 struct fib_rules_ops *ops;
228 struct mr_table *mrt;
231 ops = fib_rules_register(&ip6mr_rules_ops_template, net);
235 INIT_LIST_HEAD(&net->ipv6.mr6_tables);
237 mrt = ip6mr_new_table(net, RT6_TABLE_DFLT);
243 err = fib_default_rule_add(ops, 0x7fff, RT6_TABLE_DFLT, 0);
247 net->ipv6.mr6_rules_ops = ops;
252 ip6mr_free_table(mrt);
255 fib_rules_unregister(ops);
259 static void __net_exit ip6mr_rules_exit(struct net *net)
261 struct mr_table *mrt, *next;
264 list_for_each_entry_safe(mrt, next, &net->ipv6.mr6_tables, list) {
265 list_del(&mrt->list);
266 ip6mr_free_table(mrt);
268 fib_rules_unregister(net->ipv6.mr6_rules_ops);
272 static int ip6mr_rules_dump(struct net *net, struct notifier_block *nb,
273 struct netlink_ext_ack *extack)
275 return fib_rules_dump(net, nb, RTNL_FAMILY_IP6MR, extack);
278 static unsigned int ip6mr_rules_seq_read(struct net *net)
280 return fib_rules_seq_read(net, RTNL_FAMILY_IP6MR);
283 bool ip6mr_rule_default(const struct fib_rule *rule)
285 return fib_rule_matchall(rule) && rule->action == FR_ACT_TO_TBL &&
286 rule->table == RT6_TABLE_DFLT && !rule->l3mdev;
288 EXPORT_SYMBOL(ip6mr_rule_default);
290 #define ip6mr_for_each_table(mrt, net) \
291 for (mrt = net->ipv6.mrt6; mrt; mrt = NULL)
293 static struct mr_table *ip6mr_mr_table_iter(struct net *net,
294 struct mr_table *mrt)
297 return net->ipv6.mrt6;
301 static struct mr_table *ip6mr_get_table(struct net *net, u32 id)
303 return net->ipv6.mrt6;
306 static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
307 struct mr_table **mrt)
309 *mrt = net->ipv6.mrt6;
313 static int __net_init ip6mr_rules_init(struct net *net)
315 struct mr_table *mrt;
317 mrt = ip6mr_new_table(net, RT6_TABLE_DFLT);
320 net->ipv6.mrt6 = mrt;
324 static void __net_exit ip6mr_rules_exit(struct net *net)
327 ip6mr_free_table(net->ipv6.mrt6);
328 net->ipv6.mrt6 = NULL;
332 static int ip6mr_rules_dump(struct net *net, struct notifier_block *nb,
333 struct netlink_ext_ack *extack)
338 static unsigned int ip6mr_rules_seq_read(struct net *net)
344 static int ip6mr_hash_cmp(struct rhashtable_compare_arg *arg,
347 const struct mfc6_cache_cmp_arg *cmparg = arg->key;
348 struct mfc6_cache *c = (struct mfc6_cache *)ptr;
350 return !ipv6_addr_equal(&c->mf6c_mcastgrp, &cmparg->mf6c_mcastgrp) ||
351 !ipv6_addr_equal(&c->mf6c_origin, &cmparg->mf6c_origin);
354 static const struct rhashtable_params ip6mr_rht_params = {
355 .head_offset = offsetof(struct mr_mfc, mnode),
356 .key_offset = offsetof(struct mfc6_cache, cmparg),
357 .key_len = sizeof(struct mfc6_cache_cmp_arg),
359 .obj_cmpfn = ip6mr_hash_cmp,
360 .automatic_shrinking = true,
363 static void ip6mr_new_table_set(struct mr_table *mrt,
366 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
367 list_add_tail_rcu(&mrt->list, &net->ipv6.mr6_tables);
371 static struct mfc6_cache_cmp_arg ip6mr_mr_table_ops_cmparg_any = {
372 .mf6c_origin = IN6ADDR_ANY_INIT,
373 .mf6c_mcastgrp = IN6ADDR_ANY_INIT,
376 static struct mr_table_ops ip6mr_mr_table_ops = {
377 .rht_params = &ip6mr_rht_params,
378 .cmparg_any = &ip6mr_mr_table_ops_cmparg_any,
381 static struct mr_table *ip6mr_new_table(struct net *net, u32 id)
383 struct mr_table *mrt;
385 mrt = ip6mr_get_table(net, id);
389 return mr_table_alloc(net, id, &ip6mr_mr_table_ops,
390 ipmr_expire_process, ip6mr_new_table_set);
393 static void ip6mr_free_table(struct mr_table *mrt)
395 del_timer_sync(&mrt->ipmr_expire_timer);
396 mroute_clean_tables(mrt, MRT6_FLUSH_MIFS | MRT6_FLUSH_MIFS_STATIC |
397 MRT6_FLUSH_MFC | MRT6_FLUSH_MFC_STATIC);
398 rhltable_destroy(&mrt->mfc_hash);
402 #ifdef CONFIG_PROC_FS
403 /* The /proc interfaces to multicast routing
404 * /proc/ip6_mr_cache /proc/ip6_mr_vif
407 static void *ip6mr_vif_seq_start(struct seq_file *seq, loff_t *pos)
410 struct mr_vif_iter *iter = seq->private;
411 struct net *net = seq_file_net(seq);
412 struct mr_table *mrt;
414 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
416 return ERR_PTR(-ENOENT);
420 read_lock(&mrt_lock);
421 return mr_vif_seq_start(seq, pos);
424 static void ip6mr_vif_seq_stop(struct seq_file *seq, void *v)
427 read_unlock(&mrt_lock);
430 static int ip6mr_vif_seq_show(struct seq_file *seq, void *v)
432 struct mr_vif_iter *iter = seq->private;
433 struct mr_table *mrt = iter->mrt;
435 if (v == SEQ_START_TOKEN) {
437 "Interface BytesIn PktsIn BytesOut PktsOut Flags\n");
439 const struct vif_device *vif = v;
440 const char *name = vif->dev ? vif->dev->name : "none";
443 "%2td %-10s %8ld %7ld %8ld %7ld %05X\n",
444 vif - mrt->vif_table,
445 name, vif->bytes_in, vif->pkt_in,
446 vif->bytes_out, vif->pkt_out,
452 static const struct seq_operations ip6mr_vif_seq_ops = {
453 .start = ip6mr_vif_seq_start,
454 .next = mr_vif_seq_next,
455 .stop = ip6mr_vif_seq_stop,
456 .show = ip6mr_vif_seq_show,
459 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
461 struct net *net = seq_file_net(seq);
462 struct mr_table *mrt;
464 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
466 return ERR_PTR(-ENOENT);
468 return mr_mfc_seq_start(seq, pos, mrt, &mfc_unres_lock);
471 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
475 if (v == SEQ_START_TOKEN) {
479 "Iif Pkts Bytes Wrong Oifs\n");
481 const struct mfc6_cache *mfc = v;
482 const struct mr_mfc_iter *it = seq->private;
483 struct mr_table *mrt = it->mrt;
485 seq_printf(seq, "%pI6 %pI6 %-3hd",
486 &mfc->mf6c_mcastgrp, &mfc->mf6c_origin,
489 if (it->cache != &mrt->mfc_unres_queue) {
490 seq_printf(seq, " %8lu %8lu %8lu",
491 mfc->_c.mfc_un.res.pkt,
492 mfc->_c.mfc_un.res.bytes,
493 mfc->_c.mfc_un.res.wrong_if);
494 for (n = mfc->_c.mfc_un.res.minvif;
495 n < mfc->_c.mfc_un.res.maxvif; n++) {
496 if (VIF_EXISTS(mrt, n) &&
497 mfc->_c.mfc_un.res.ttls[n] < 255)
500 mfc->_c.mfc_un.res.ttls[n]);
503 /* unresolved mfc_caches don't contain
504 * pkt, bytes and wrong_if values
506 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
513 static const struct seq_operations ipmr_mfc_seq_ops = {
514 .start = ipmr_mfc_seq_start,
515 .next = mr_mfc_seq_next,
516 .stop = mr_mfc_seq_stop,
517 .show = ipmr_mfc_seq_show,
521 #ifdef CONFIG_IPV6_PIMSM_V2
523 static int pim6_rcv(struct sk_buff *skb)
525 struct pimreghdr *pim;
526 struct ipv6hdr *encap;
527 struct net_device *reg_dev = NULL;
528 struct net *net = dev_net(skb->dev);
529 struct mr_table *mrt;
530 struct flowi6 fl6 = {
531 .flowi6_iif = skb->dev->ifindex,
532 .flowi6_mark = skb->mark,
536 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
539 pim = (struct pimreghdr *)skb_transport_header(skb);
540 if (pim->type != ((PIM_VERSION << 4) | PIM_TYPE_REGISTER) ||
541 (pim->flags & PIM_NULL_REGISTER) ||
542 (csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
543 sizeof(*pim), IPPROTO_PIM,
544 csum_partial((void *)pim, sizeof(*pim), 0)) &&
545 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
548 /* check if the inner packet is destined to mcast group */
549 encap = (struct ipv6hdr *)(skb_transport_header(skb) +
552 if (!ipv6_addr_is_multicast(&encap->daddr) ||
553 encap->payload_len == 0 ||
554 ntohs(encap->payload_len) + sizeof(*pim) > skb->len)
557 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
559 reg_vif_num = mrt->mroute_reg_vif_num;
561 read_lock(&mrt_lock);
562 if (reg_vif_num >= 0)
563 reg_dev = mrt->vif_table[reg_vif_num].dev;
566 read_unlock(&mrt_lock);
571 skb->mac_header = skb->network_header;
572 skb_pull(skb, (u8 *)encap - skb->data);
573 skb_reset_network_header(skb);
574 skb->protocol = htons(ETH_P_IPV6);
575 skb->ip_summed = CHECKSUM_NONE;
577 skb_tunnel_rx(skb, reg_dev, dev_net(reg_dev));
588 static const struct inet6_protocol pim6_protocol = {
592 /* Service routines creating virtual interfaces: PIMREG */
594 static netdev_tx_t reg_vif_xmit(struct sk_buff *skb,
595 struct net_device *dev)
597 struct net *net = dev_net(dev);
598 struct mr_table *mrt;
599 struct flowi6 fl6 = {
600 .flowi6_oif = dev->ifindex,
601 .flowi6_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
602 .flowi6_mark = skb->mark,
605 if (!pskb_inet_may_pull(skb))
608 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
611 read_lock(&mrt_lock);
612 dev->stats.tx_bytes += skb->len;
613 dev->stats.tx_packets++;
614 ip6mr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, MRT6MSG_WHOLEPKT);
615 read_unlock(&mrt_lock);
620 dev->stats.tx_errors++;
625 static int reg_vif_get_iflink(const struct net_device *dev)
630 static const struct net_device_ops reg_vif_netdev_ops = {
631 .ndo_start_xmit = reg_vif_xmit,
632 .ndo_get_iflink = reg_vif_get_iflink,
635 static void reg_vif_setup(struct net_device *dev)
637 dev->type = ARPHRD_PIMREG;
638 dev->mtu = 1500 - sizeof(struct ipv6hdr) - 8;
639 dev->flags = IFF_NOARP;
640 dev->netdev_ops = ®_vif_netdev_ops;
641 dev->needs_free_netdev = true;
642 dev->features |= NETIF_F_NETNS_LOCAL;
645 static struct net_device *ip6mr_reg_vif(struct net *net, struct mr_table *mrt)
647 struct net_device *dev;
650 if (mrt->id == RT6_TABLE_DFLT)
651 sprintf(name, "pim6reg");
653 sprintf(name, "pim6reg%u", mrt->id);
655 dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, reg_vif_setup);
659 dev_net_set(dev, net);
661 if (register_netdevice(dev)) {
666 if (dev_open(dev, NULL))
673 unregister_netdevice(dev);
678 static int call_ip6mr_vif_entry_notifiers(struct net *net,
679 enum fib_event_type event_type,
680 struct vif_device *vif,
681 mifi_t vif_index, u32 tb_id)
683 return mr_call_vif_notifiers(net, RTNL_FAMILY_IP6MR, event_type,
684 vif, vif_index, tb_id,
685 &net->ipv6.ipmr_seq);
688 static int call_ip6mr_mfc_entry_notifiers(struct net *net,
689 enum fib_event_type event_type,
690 struct mfc6_cache *mfc, u32 tb_id)
692 return mr_call_mfc_notifiers(net, RTNL_FAMILY_IP6MR, event_type,
693 &mfc->_c, tb_id, &net->ipv6.ipmr_seq);
696 /* Delete a VIF entry */
697 static int mif6_delete(struct mr_table *mrt, int vifi, int notify,
698 struct list_head *head)
700 struct vif_device *v;
701 struct net_device *dev;
702 struct inet6_dev *in6_dev;
704 if (vifi < 0 || vifi >= mrt->maxvif)
705 return -EADDRNOTAVAIL;
707 v = &mrt->vif_table[vifi];
709 if (VIF_EXISTS(mrt, vifi))
710 call_ip6mr_vif_entry_notifiers(read_pnet(&mrt->net),
711 FIB_EVENT_VIF_DEL, v, vifi,
714 write_lock_bh(&mrt_lock);
719 write_unlock_bh(&mrt_lock);
720 return -EADDRNOTAVAIL;
723 #ifdef CONFIG_IPV6_PIMSM_V2
724 if (vifi == mrt->mroute_reg_vif_num)
725 mrt->mroute_reg_vif_num = -1;
728 if (vifi + 1 == mrt->maxvif) {
730 for (tmp = vifi - 1; tmp >= 0; tmp--) {
731 if (VIF_EXISTS(mrt, tmp))
734 mrt->maxvif = tmp + 1;
737 write_unlock_bh(&mrt_lock);
739 dev_set_allmulti(dev, -1);
741 in6_dev = __in6_dev_get(dev);
743 atomic_dec(&in6_dev->cnf.mc_forwarding);
744 inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
745 NETCONFA_MC_FORWARDING,
746 dev->ifindex, &in6_dev->cnf);
749 if ((v->flags & MIFF_REGISTER) && !notify)
750 unregister_netdevice_queue(dev, head);
756 static inline void ip6mr_cache_free_rcu(struct rcu_head *head)
758 struct mr_mfc *c = container_of(head, struct mr_mfc, rcu);
760 kmem_cache_free(mrt_cachep, (struct mfc6_cache *)c);
763 static inline void ip6mr_cache_free(struct mfc6_cache *c)
765 call_rcu(&c->_c.rcu, ip6mr_cache_free_rcu);
768 /* Destroy an unresolved cache entry, killing queued skbs
769 and reporting error to netlink readers.
772 static void ip6mr_destroy_unres(struct mr_table *mrt, struct mfc6_cache *c)
774 struct net *net = read_pnet(&mrt->net);
777 atomic_dec(&mrt->cache_resolve_queue_len);
779 while ((skb = skb_dequeue(&c->_c.mfc_un.unres.unresolved)) != NULL) {
780 if (ipv6_hdr(skb)->version == 0) {
781 struct nlmsghdr *nlh = skb_pull(skb,
782 sizeof(struct ipv6hdr));
783 nlh->nlmsg_type = NLMSG_ERROR;
784 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
785 skb_trim(skb, nlh->nlmsg_len);
786 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -ETIMEDOUT;
787 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
796 /* Timer process for all the unresolved queue. */
798 static void ipmr_do_expire_process(struct mr_table *mrt)
800 unsigned long now = jiffies;
801 unsigned long expires = 10 * HZ;
802 struct mr_mfc *c, *next;
804 list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
805 if (time_after(c->mfc_un.unres.expires, now)) {
807 unsigned long interval = c->mfc_un.unres.expires - now;
808 if (interval < expires)
814 mr6_netlink_event(mrt, (struct mfc6_cache *)c, RTM_DELROUTE);
815 ip6mr_destroy_unres(mrt, (struct mfc6_cache *)c);
818 if (!list_empty(&mrt->mfc_unres_queue))
819 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
822 static void ipmr_expire_process(struct timer_list *t)
824 struct mr_table *mrt = from_timer(mrt, t, ipmr_expire_timer);
826 if (!spin_trylock(&mfc_unres_lock)) {
827 mod_timer(&mrt->ipmr_expire_timer, jiffies + 1);
831 if (!list_empty(&mrt->mfc_unres_queue))
832 ipmr_do_expire_process(mrt);
834 spin_unlock(&mfc_unres_lock);
837 /* Fill oifs list. It is called under write locked mrt_lock. */
839 static void ip6mr_update_thresholds(struct mr_table *mrt,
840 struct mr_mfc *cache,
845 cache->mfc_un.res.minvif = MAXMIFS;
846 cache->mfc_un.res.maxvif = 0;
847 memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
849 for (vifi = 0; vifi < mrt->maxvif; vifi++) {
850 if (VIF_EXISTS(mrt, vifi) &&
851 ttls[vifi] && ttls[vifi] < 255) {
852 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
853 if (cache->mfc_un.res.minvif > vifi)
854 cache->mfc_un.res.minvif = vifi;
855 if (cache->mfc_un.res.maxvif <= vifi)
856 cache->mfc_un.res.maxvif = vifi + 1;
859 cache->mfc_un.res.lastuse = jiffies;
862 static int mif6_add(struct net *net, struct mr_table *mrt,
863 struct mif6ctl *vifc, int mrtsock)
865 int vifi = vifc->mif6c_mifi;
866 struct vif_device *v = &mrt->vif_table[vifi];
867 struct net_device *dev;
868 struct inet6_dev *in6_dev;
872 if (VIF_EXISTS(mrt, vifi))
875 switch (vifc->mif6c_flags) {
876 #ifdef CONFIG_IPV6_PIMSM_V2
879 * Special Purpose VIF in PIM
880 * All the packets will be sent to the daemon
882 if (mrt->mroute_reg_vif_num >= 0)
884 dev = ip6mr_reg_vif(net, mrt);
887 err = dev_set_allmulti(dev, 1);
889 unregister_netdevice(dev);
896 dev = dev_get_by_index(net, vifc->mif6c_pifi);
898 return -EADDRNOTAVAIL;
899 err = dev_set_allmulti(dev, 1);
909 in6_dev = __in6_dev_get(dev);
911 atomic_inc(&in6_dev->cnf.mc_forwarding);
912 inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
913 NETCONFA_MC_FORWARDING,
914 dev->ifindex, &in6_dev->cnf);
917 /* Fill in the VIF structures */
918 vif_device_init(v, dev, vifc->vifc_rate_limit, vifc->vifc_threshold,
919 vifc->mif6c_flags | (!mrtsock ? VIFF_STATIC : 0),
922 /* And finish update writing critical data */
923 write_lock_bh(&mrt_lock);
925 #ifdef CONFIG_IPV6_PIMSM_V2
926 if (v->flags & MIFF_REGISTER)
927 mrt->mroute_reg_vif_num = vifi;
929 if (vifi + 1 > mrt->maxvif)
930 mrt->maxvif = vifi + 1;
931 write_unlock_bh(&mrt_lock);
932 call_ip6mr_vif_entry_notifiers(net, FIB_EVENT_VIF_ADD,
937 static struct mfc6_cache *ip6mr_cache_find(struct mr_table *mrt,
938 const struct in6_addr *origin,
939 const struct in6_addr *mcastgrp)
941 struct mfc6_cache_cmp_arg arg = {
942 .mf6c_origin = *origin,
943 .mf6c_mcastgrp = *mcastgrp,
946 return mr_mfc_find(mrt, &arg);
949 /* Look for a (*,G) entry */
950 static struct mfc6_cache *ip6mr_cache_find_any(struct mr_table *mrt,
951 struct in6_addr *mcastgrp,
954 struct mfc6_cache_cmp_arg arg = {
955 .mf6c_origin = in6addr_any,
956 .mf6c_mcastgrp = *mcastgrp,
959 if (ipv6_addr_any(mcastgrp))
960 return mr_mfc_find_any_parent(mrt, mifi);
961 return mr_mfc_find_any(mrt, mifi, &arg);
964 /* Look for a (S,G,iif) entry if parent != -1 */
965 static struct mfc6_cache *
966 ip6mr_cache_find_parent(struct mr_table *mrt,
967 const struct in6_addr *origin,
968 const struct in6_addr *mcastgrp,
971 struct mfc6_cache_cmp_arg arg = {
972 .mf6c_origin = *origin,
973 .mf6c_mcastgrp = *mcastgrp,
976 return mr_mfc_find_parent(mrt, &arg, parent);
979 /* Allocate a multicast cache entry */
980 static struct mfc6_cache *ip6mr_cache_alloc(void)
982 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
985 c->_c.mfc_un.res.last_assert = jiffies - MFC_ASSERT_THRESH - 1;
986 c->_c.mfc_un.res.minvif = MAXMIFS;
987 c->_c.free = ip6mr_cache_free_rcu;
988 refcount_set(&c->_c.mfc_un.res.refcount, 1);
992 static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
994 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
997 skb_queue_head_init(&c->_c.mfc_un.unres.unresolved);
998 c->_c.mfc_un.unres.expires = jiffies + 10 * HZ;
1003 * A cache entry has gone into a resolved state from queued
1006 static void ip6mr_cache_resolve(struct net *net, struct mr_table *mrt,
1007 struct mfc6_cache *uc, struct mfc6_cache *c)
1009 struct sk_buff *skb;
1012 * Play the pending entries through our router
1015 while ((skb = __skb_dequeue(&uc->_c.mfc_un.unres.unresolved))) {
1016 if (ipv6_hdr(skb)->version == 0) {
1017 struct nlmsghdr *nlh = skb_pull(skb,
1018 sizeof(struct ipv6hdr));
1020 if (mr_fill_mroute(mrt, skb, &c->_c,
1021 nlmsg_data(nlh)) > 0) {
1022 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
1024 nlh->nlmsg_type = NLMSG_ERROR;
1025 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
1026 skb_trim(skb, nlh->nlmsg_len);
1027 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -EMSGSIZE;
1029 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
1031 ip6_mr_forward(net, mrt, skb->dev, skb, c);
1036 * Bounce a cache query up to pim6sd and netlink.
1038 * Called under mrt_lock.
1041 static int ip6mr_cache_report(struct mr_table *mrt, struct sk_buff *pkt,
1042 mifi_t mifi, int assert)
1044 struct sock *mroute6_sk;
1045 struct sk_buff *skb;
1046 struct mrt6msg *msg;
1049 #ifdef CONFIG_IPV6_PIMSM_V2
1050 if (assert == MRT6MSG_WHOLEPKT)
1051 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
1055 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
1060 /* I suppose that internal messages
1061 * do not require checksums */
1063 skb->ip_summed = CHECKSUM_UNNECESSARY;
1065 #ifdef CONFIG_IPV6_PIMSM_V2
1066 if (assert == MRT6MSG_WHOLEPKT) {
1067 /* Ugly, but we have no choice with this interface.
1068 Duplicate old header, fix length etc.
1069 And all this only to mangle msg->im6_msgtype and
1070 to set msg->im6_mbz to "mbz" :-)
1072 __skb_pull(skb, skb_network_offset(pkt));
1074 skb_push(skb, sizeof(*msg));
1075 skb_reset_transport_header(skb);
1076 msg = (struct mrt6msg *)skb_transport_header(skb);
1078 msg->im6_msgtype = MRT6MSG_WHOLEPKT;
1079 msg->im6_mif = mrt->mroute_reg_vif_num;
1081 msg->im6_src = ipv6_hdr(pkt)->saddr;
1082 msg->im6_dst = ipv6_hdr(pkt)->daddr;
1084 skb->ip_summed = CHECKSUM_UNNECESSARY;
1089 * Copy the IP header
1092 skb_put(skb, sizeof(struct ipv6hdr));
1093 skb_reset_network_header(skb);
1094 skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
1099 skb_put(skb, sizeof(*msg));
1100 skb_reset_transport_header(skb);
1101 msg = (struct mrt6msg *)skb_transport_header(skb);
1104 msg->im6_msgtype = assert;
1105 msg->im6_mif = mifi;
1107 msg->im6_src = ipv6_hdr(pkt)->saddr;
1108 msg->im6_dst = ipv6_hdr(pkt)->daddr;
1110 skb_dst_set(skb, dst_clone(skb_dst(pkt)));
1111 skb->ip_summed = CHECKSUM_UNNECESSARY;
1115 mroute6_sk = rcu_dereference(mrt->mroute_sk);
1122 mrt6msg_netlink_event(mrt, skb);
1124 /* Deliver to user space multicast routing algorithms */
1125 ret = sock_queue_rcv_skb(mroute6_sk, skb);
1128 net_warn_ratelimited("mroute6: pending queue full, dropping entries\n");
1135 /* Queue a packet for resolution. It gets locked cache entry! */
1136 static int ip6mr_cache_unresolved(struct mr_table *mrt, mifi_t mifi,
1137 struct sk_buff *skb, struct net_device *dev)
1139 struct mfc6_cache *c;
1143 spin_lock_bh(&mfc_unres_lock);
1144 list_for_each_entry(c, &mrt->mfc_unres_queue, _c.list) {
1145 if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
1146 ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr)) {
1154 * Create a new entry if allowable
1157 c = ip6mr_cache_alloc_unres();
1159 spin_unlock_bh(&mfc_unres_lock);
1165 /* Fill in the new cache entry */
1166 c->_c.mfc_parent = -1;
1167 c->mf6c_origin = ipv6_hdr(skb)->saddr;
1168 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
1171 * Reflect first query at pim6sd
1173 err = ip6mr_cache_report(mrt, skb, mifi, MRT6MSG_NOCACHE);
1175 /* If the report failed throw the cache entry
1178 spin_unlock_bh(&mfc_unres_lock);
1180 ip6mr_cache_free(c);
1185 atomic_inc(&mrt->cache_resolve_queue_len);
1186 list_add(&c->_c.list, &mrt->mfc_unres_queue);
1187 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1189 ipmr_do_expire_process(mrt);
1192 /* See if we can append the packet */
1193 if (c->_c.mfc_un.unres.unresolved.qlen > 3) {
1199 skb->skb_iif = dev->ifindex;
1201 skb_queue_tail(&c->_c.mfc_un.unres.unresolved, skb);
1205 spin_unlock_bh(&mfc_unres_lock);
1210 * MFC6 cache manipulation by user space
1213 static int ip6mr_mfc_delete(struct mr_table *mrt, struct mf6cctl *mfc,
1216 struct mfc6_cache *c;
1218 /* The entries are added/deleted only under RTNL */
1220 c = ip6mr_cache_find_parent(mrt, &mfc->mf6cc_origin.sin6_addr,
1221 &mfc->mf6cc_mcastgrp.sin6_addr, parent);
1225 rhltable_remove(&mrt->mfc_hash, &c->_c.mnode, ip6mr_rht_params);
1226 list_del_rcu(&c->_c.list);
1228 call_ip6mr_mfc_entry_notifiers(read_pnet(&mrt->net),
1229 FIB_EVENT_ENTRY_DEL, c, mrt->id);
1230 mr6_netlink_event(mrt, c, RTM_DELROUTE);
1231 mr_cache_put(&c->_c);
1235 static int ip6mr_device_event(struct notifier_block *this,
1236 unsigned long event, void *ptr)
1238 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1239 struct net *net = dev_net(dev);
1240 struct mr_table *mrt;
1241 struct vif_device *v;
1244 if (event != NETDEV_UNREGISTER)
1247 ip6mr_for_each_table(mrt, net) {
1248 v = &mrt->vif_table[0];
1249 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1251 mif6_delete(mrt, ct, 1, NULL);
1258 static unsigned int ip6mr_seq_read(struct net *net)
1262 return net->ipv6.ipmr_seq + ip6mr_rules_seq_read(net);
1265 static int ip6mr_dump(struct net *net, struct notifier_block *nb,
1266 struct netlink_ext_ack *extack)
1268 return mr_dump(net, nb, RTNL_FAMILY_IP6MR, ip6mr_rules_dump,
1269 ip6mr_mr_table_iter, &mrt_lock, extack);
1272 static struct notifier_block ip6_mr_notifier = {
1273 .notifier_call = ip6mr_device_event
1276 static const struct fib_notifier_ops ip6mr_notifier_ops_template = {
1277 .family = RTNL_FAMILY_IP6MR,
1278 .fib_seq_read = ip6mr_seq_read,
1279 .fib_dump = ip6mr_dump,
1280 .owner = THIS_MODULE,
1283 static int __net_init ip6mr_notifier_init(struct net *net)
1285 struct fib_notifier_ops *ops;
1287 net->ipv6.ipmr_seq = 0;
1289 ops = fib_notifier_ops_register(&ip6mr_notifier_ops_template, net);
1291 return PTR_ERR(ops);
1293 net->ipv6.ip6mr_notifier_ops = ops;
1298 static void __net_exit ip6mr_notifier_exit(struct net *net)
1300 fib_notifier_ops_unregister(net->ipv6.ip6mr_notifier_ops);
1301 net->ipv6.ip6mr_notifier_ops = NULL;
1304 /* Setup for IP multicast routing */
1305 static int __net_init ip6mr_net_init(struct net *net)
1309 err = ip6mr_notifier_init(net);
1313 err = ip6mr_rules_init(net);
1315 goto ip6mr_rules_fail;
1317 #ifdef CONFIG_PROC_FS
1319 if (!proc_create_net("ip6_mr_vif", 0, net->proc_net, &ip6mr_vif_seq_ops,
1320 sizeof(struct mr_vif_iter)))
1322 if (!proc_create_net("ip6_mr_cache", 0, net->proc_net, &ipmr_mfc_seq_ops,
1323 sizeof(struct mr_mfc_iter)))
1324 goto proc_cache_fail;
1329 #ifdef CONFIG_PROC_FS
1331 remove_proc_entry("ip6_mr_vif", net->proc_net);
1333 ip6mr_rules_exit(net);
1336 ip6mr_notifier_exit(net);
1340 static void __net_exit ip6mr_net_exit(struct net *net)
1342 #ifdef CONFIG_PROC_FS
1343 remove_proc_entry("ip6_mr_cache", net->proc_net);
1344 remove_proc_entry("ip6_mr_vif", net->proc_net);
1346 ip6mr_rules_exit(net);
1347 ip6mr_notifier_exit(net);
1350 static struct pernet_operations ip6mr_net_ops = {
1351 .init = ip6mr_net_init,
1352 .exit = ip6mr_net_exit,
1355 int __init ip6_mr_init(void)
1359 mrt_cachep = kmem_cache_create("ip6_mrt_cache",
1360 sizeof(struct mfc6_cache),
1361 0, SLAB_HWCACHE_ALIGN,
1366 err = register_pernet_subsys(&ip6mr_net_ops);
1368 goto reg_pernet_fail;
1370 err = register_netdevice_notifier(&ip6_mr_notifier);
1372 goto reg_notif_fail;
1373 #ifdef CONFIG_IPV6_PIMSM_V2
1374 if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
1375 pr_err("%s: can't add PIM protocol\n", __func__);
1377 goto add_proto_fail;
1380 err = rtnl_register_module(THIS_MODULE, RTNL_FAMILY_IP6MR, RTM_GETROUTE,
1381 NULL, ip6mr_rtm_dumproute, 0);
1385 #ifdef CONFIG_IPV6_PIMSM_V2
1386 inet6_del_protocol(&pim6_protocol, IPPROTO_PIM);
1388 unregister_netdevice_notifier(&ip6_mr_notifier);
1391 unregister_pernet_subsys(&ip6mr_net_ops);
1393 kmem_cache_destroy(mrt_cachep);
1397 void ip6_mr_cleanup(void)
1399 rtnl_unregister(RTNL_FAMILY_IP6MR, RTM_GETROUTE);
1400 #ifdef CONFIG_IPV6_PIMSM_V2
1401 inet6_del_protocol(&pim6_protocol, IPPROTO_PIM);
1403 unregister_netdevice_notifier(&ip6_mr_notifier);
1404 unregister_pernet_subsys(&ip6mr_net_ops);
1405 kmem_cache_destroy(mrt_cachep);
1408 static int ip6mr_mfc_add(struct net *net, struct mr_table *mrt,
1409 struct mf6cctl *mfc, int mrtsock, int parent)
1411 unsigned char ttls[MAXMIFS];
1412 struct mfc6_cache *uc, *c;
1417 if (mfc->mf6cc_parent >= MAXMIFS)
1420 memset(ttls, 255, MAXMIFS);
1421 for (i = 0; i < MAXMIFS; i++) {
1422 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1426 /* The entries are added/deleted only under RTNL */
1428 c = ip6mr_cache_find_parent(mrt, &mfc->mf6cc_origin.sin6_addr,
1429 &mfc->mf6cc_mcastgrp.sin6_addr, parent);
1432 write_lock_bh(&mrt_lock);
1433 c->_c.mfc_parent = mfc->mf6cc_parent;
1434 ip6mr_update_thresholds(mrt, &c->_c, ttls);
1436 c->_c.mfc_flags |= MFC_STATIC;
1437 write_unlock_bh(&mrt_lock);
1438 call_ip6mr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_REPLACE,
1440 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1444 if (!ipv6_addr_any(&mfc->mf6cc_mcastgrp.sin6_addr) &&
1445 !ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
1448 c = ip6mr_cache_alloc();
1452 c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1453 c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
1454 c->_c.mfc_parent = mfc->mf6cc_parent;
1455 ip6mr_update_thresholds(mrt, &c->_c, ttls);
1457 c->_c.mfc_flags |= MFC_STATIC;
1459 err = rhltable_insert_key(&mrt->mfc_hash, &c->cmparg, &c->_c.mnode,
1462 pr_err("ip6mr: rhtable insert error %d\n", err);
1463 ip6mr_cache_free(c);
1466 list_add_tail_rcu(&c->_c.list, &mrt->mfc_cache_list);
1468 /* Check to see if we resolved a queued list. If so we
1469 * need to send on the frames and tidy up.
1472 spin_lock_bh(&mfc_unres_lock);
1473 list_for_each_entry(_uc, &mrt->mfc_unres_queue, list) {
1474 uc = (struct mfc6_cache *)_uc;
1475 if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
1476 ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
1477 list_del(&_uc->list);
1478 atomic_dec(&mrt->cache_resolve_queue_len);
1483 if (list_empty(&mrt->mfc_unres_queue))
1484 del_timer(&mrt->ipmr_expire_timer);
1485 spin_unlock_bh(&mfc_unres_lock);
1488 ip6mr_cache_resolve(net, mrt, uc, c);
1489 ip6mr_cache_free(uc);
1491 call_ip6mr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_ADD,
1493 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1498 * Close the multicast socket, and clear the vif tables etc
1501 static void mroute_clean_tables(struct mr_table *mrt, int flags)
1503 struct mr_mfc *c, *tmp;
1507 /* Shut down all active vif entries */
1508 if (flags & (MRT6_FLUSH_MIFS | MRT6_FLUSH_MIFS_STATIC)) {
1509 for (i = 0; i < mrt->maxvif; i++) {
1510 if (((mrt->vif_table[i].flags & VIFF_STATIC) &&
1511 !(flags & MRT6_FLUSH_MIFS_STATIC)) ||
1512 (!(mrt->vif_table[i].flags & VIFF_STATIC) && !(flags & MRT6_FLUSH_MIFS)))
1514 mif6_delete(mrt, i, 0, &list);
1516 unregister_netdevice_many(&list);
1519 /* Wipe the cache */
1520 if (flags & (MRT6_FLUSH_MFC | MRT6_FLUSH_MFC_STATIC)) {
1521 list_for_each_entry_safe(c, tmp, &mrt->mfc_cache_list, list) {
1522 if (((c->mfc_flags & MFC_STATIC) && !(flags & MRT6_FLUSH_MFC_STATIC)) ||
1523 (!(c->mfc_flags & MFC_STATIC) && !(flags & MRT6_FLUSH_MFC)))
1525 rhltable_remove(&mrt->mfc_hash, &c->mnode, ip6mr_rht_params);
1526 list_del_rcu(&c->list);
1527 call_ip6mr_mfc_entry_notifiers(read_pnet(&mrt->net),
1528 FIB_EVENT_ENTRY_DEL,
1529 (struct mfc6_cache *)c, mrt->id);
1530 mr6_netlink_event(mrt, (struct mfc6_cache *)c, RTM_DELROUTE);
1535 if (flags & MRT6_FLUSH_MFC) {
1536 if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
1537 spin_lock_bh(&mfc_unres_lock);
1538 list_for_each_entry_safe(c, tmp, &mrt->mfc_unres_queue, list) {
1540 mr6_netlink_event(mrt, (struct mfc6_cache *)c,
1542 ip6mr_destroy_unres(mrt, (struct mfc6_cache *)c);
1544 spin_unlock_bh(&mfc_unres_lock);
1549 static int ip6mr_sk_init(struct mr_table *mrt, struct sock *sk)
1552 struct net *net = sock_net(sk);
1555 write_lock_bh(&mrt_lock);
1556 if (rtnl_dereference(mrt->mroute_sk)) {
1559 rcu_assign_pointer(mrt->mroute_sk, sk);
1560 sock_set_flag(sk, SOCK_RCU_FREE);
1561 atomic_inc(&net->ipv6.devconf_all->mc_forwarding);
1563 write_unlock_bh(&mrt_lock);
1566 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
1567 NETCONFA_MC_FORWARDING,
1568 NETCONFA_IFINDEX_ALL,
1569 net->ipv6.devconf_all);
1575 int ip6mr_sk_done(struct sock *sk)
1578 struct net *net = sock_net(sk);
1579 struct mr_table *mrt;
1581 if (sk->sk_type != SOCK_RAW ||
1582 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1586 ip6mr_for_each_table(mrt, net) {
1587 if (sk == rtnl_dereference(mrt->mroute_sk)) {
1588 write_lock_bh(&mrt_lock);
1589 RCU_INIT_POINTER(mrt->mroute_sk, NULL);
1590 /* Note that mroute_sk had SOCK_RCU_FREE set,
1591 * so the RCU grace period before sk freeing
1592 * is guaranteed by sk_destruct()
1594 atomic_dec(&net->ipv6.devconf_all->mc_forwarding);
1595 write_unlock_bh(&mrt_lock);
1596 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
1597 NETCONFA_MC_FORWARDING,
1598 NETCONFA_IFINDEX_ALL,
1599 net->ipv6.devconf_all);
1601 mroute_clean_tables(mrt, MRT6_FLUSH_MIFS | MRT6_FLUSH_MFC);
1611 bool mroute6_is_socket(struct net *net, struct sk_buff *skb)
1613 struct mr_table *mrt;
1614 struct flowi6 fl6 = {
1615 .flowi6_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
1616 .flowi6_oif = skb->dev->ifindex,
1617 .flowi6_mark = skb->mark,
1620 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
1623 return rcu_access_pointer(mrt->mroute_sk);
1625 EXPORT_SYMBOL(mroute6_is_socket);
1628 * Socket options and virtual interface manipulation. The whole
1629 * virtual interface system is a complete heap, but unfortunately
1630 * that's how BSD mrouted happens to think. Maybe one day with a proper
1631 * MOSPF/PIM router set up we can clean this up.
1634 int ip6_mroute_setsockopt(struct sock *sk, int optname, sockptr_t optval,
1635 unsigned int optlen)
1637 int ret, parent = 0;
1641 struct net *net = sock_net(sk);
1642 struct mr_table *mrt;
1644 if (sk->sk_type != SOCK_RAW ||
1645 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1648 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1652 if (optname != MRT6_INIT) {
1653 if (sk != rcu_access_pointer(mrt->mroute_sk) &&
1654 !ns_capable(net->user_ns, CAP_NET_ADMIN))
1660 if (optlen < sizeof(int))
1663 return ip6mr_sk_init(mrt, sk);
1666 return ip6mr_sk_done(sk);
1669 if (optlen < sizeof(vif))
1671 if (copy_from_sockptr(&vif, optval, sizeof(vif)))
1673 if (vif.mif6c_mifi >= MAXMIFS)
1676 ret = mif6_add(net, mrt, &vif,
1677 sk == rtnl_dereference(mrt->mroute_sk));
1682 if (optlen < sizeof(mifi_t))
1684 if (copy_from_sockptr(&mifi, optval, sizeof(mifi_t)))
1687 ret = mif6_delete(mrt, mifi, 0, NULL);
1692 * Manipulate the forwarding caches. These live
1693 * in a sort of kernel/user symbiosis.
1699 case MRT6_ADD_MFC_PROXY:
1700 case MRT6_DEL_MFC_PROXY:
1701 if (optlen < sizeof(mfc))
1703 if (copy_from_sockptr(&mfc, optval, sizeof(mfc)))
1706 parent = mfc.mf6cc_parent;
1708 if (optname == MRT6_DEL_MFC || optname == MRT6_DEL_MFC_PROXY)
1709 ret = ip6mr_mfc_delete(mrt, &mfc, parent);
1711 ret = ip6mr_mfc_add(net, mrt, &mfc,
1713 rtnl_dereference(mrt->mroute_sk),
1722 if (optlen != sizeof(flags))
1724 if (copy_from_sockptr(&flags, optval, sizeof(flags)))
1727 mroute_clean_tables(mrt, flags);
1733 * Control PIM assert (to activate pim will activate assert)
1739 if (optlen != sizeof(v))
1741 if (copy_from_sockptr(&v, optval, sizeof(v)))
1743 mrt->mroute_do_assert = v;
1747 #ifdef CONFIG_IPV6_PIMSM_V2
1752 if (optlen != sizeof(v))
1754 if (copy_from_sockptr(&v, optval, sizeof(v)))
1759 if (v != mrt->mroute_do_pim) {
1760 mrt->mroute_do_pim = v;
1761 mrt->mroute_do_assert = v;
1768 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
1773 if (optlen != sizeof(u32))
1775 if (copy_from_sockptr(&v, optval, sizeof(v)))
1777 /* "pim6reg%u" should not exceed 16 bytes (IFNAMSIZ) */
1778 if (v != RT_TABLE_DEFAULT && v >= 100000000)
1780 if (sk == rcu_access_pointer(mrt->mroute_sk))
1785 mrt = ip6mr_new_table(net, v);
1789 raw6_sk(sk)->ip6mr_table = v;
1795 * Spurious command, or MRT6_VERSION which you cannot
1799 return -ENOPROTOOPT;
1804 * Getsock opt support for the multicast routing system.
1807 int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1812 struct net *net = sock_net(sk);
1813 struct mr_table *mrt;
1815 if (sk->sk_type != SOCK_RAW ||
1816 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1819 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1827 #ifdef CONFIG_IPV6_PIMSM_V2
1829 val = mrt->mroute_do_pim;
1833 val = mrt->mroute_do_assert;
1836 return -ENOPROTOOPT;
1839 if (get_user(olr, optlen))
1842 olr = min_t(int, olr, sizeof(int));
1846 if (put_user(olr, optlen))
1848 if (copy_to_user(optval, &val, olr))
1854 * The IP multicast ioctl support routines.
1857 int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1859 struct sioc_sg_req6 sr;
1860 struct sioc_mif_req6 vr;
1861 struct vif_device *vif;
1862 struct mfc6_cache *c;
1863 struct net *net = sock_net(sk);
1864 struct mr_table *mrt;
1866 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1871 case SIOCGETMIFCNT_IN6:
1872 if (copy_from_user(&vr, arg, sizeof(vr)))
1874 if (vr.mifi >= mrt->maxvif)
1876 vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
1877 read_lock(&mrt_lock);
1878 vif = &mrt->vif_table[vr.mifi];
1879 if (VIF_EXISTS(mrt, vr.mifi)) {
1880 vr.icount = vif->pkt_in;
1881 vr.ocount = vif->pkt_out;
1882 vr.ibytes = vif->bytes_in;
1883 vr.obytes = vif->bytes_out;
1884 read_unlock(&mrt_lock);
1886 if (copy_to_user(arg, &vr, sizeof(vr)))
1890 read_unlock(&mrt_lock);
1891 return -EADDRNOTAVAIL;
1892 case SIOCGETSGCNT_IN6:
1893 if (copy_from_user(&sr, arg, sizeof(sr)))
1897 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1899 sr.pktcnt = c->_c.mfc_un.res.pkt;
1900 sr.bytecnt = c->_c.mfc_un.res.bytes;
1901 sr.wrong_if = c->_c.mfc_un.res.wrong_if;
1904 if (copy_to_user(arg, &sr, sizeof(sr)))
1909 return -EADDRNOTAVAIL;
1911 return -ENOIOCTLCMD;
1915 #ifdef CONFIG_COMPAT
1916 struct compat_sioc_sg_req6 {
1917 struct sockaddr_in6 src;
1918 struct sockaddr_in6 grp;
1919 compat_ulong_t pktcnt;
1920 compat_ulong_t bytecnt;
1921 compat_ulong_t wrong_if;
1924 struct compat_sioc_mif_req6 {
1926 compat_ulong_t icount;
1927 compat_ulong_t ocount;
1928 compat_ulong_t ibytes;
1929 compat_ulong_t obytes;
1932 int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1934 struct compat_sioc_sg_req6 sr;
1935 struct compat_sioc_mif_req6 vr;
1936 struct vif_device *vif;
1937 struct mfc6_cache *c;
1938 struct net *net = sock_net(sk);
1939 struct mr_table *mrt;
1941 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1946 case SIOCGETMIFCNT_IN6:
1947 if (copy_from_user(&vr, arg, sizeof(vr)))
1949 if (vr.mifi >= mrt->maxvif)
1951 vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
1952 read_lock(&mrt_lock);
1953 vif = &mrt->vif_table[vr.mifi];
1954 if (VIF_EXISTS(mrt, vr.mifi)) {
1955 vr.icount = vif->pkt_in;
1956 vr.ocount = vif->pkt_out;
1957 vr.ibytes = vif->bytes_in;
1958 vr.obytes = vif->bytes_out;
1959 read_unlock(&mrt_lock);
1961 if (copy_to_user(arg, &vr, sizeof(vr)))
1965 read_unlock(&mrt_lock);
1966 return -EADDRNOTAVAIL;
1967 case SIOCGETSGCNT_IN6:
1968 if (copy_from_user(&sr, arg, sizeof(sr)))
1972 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1974 sr.pktcnt = c->_c.mfc_un.res.pkt;
1975 sr.bytecnt = c->_c.mfc_un.res.bytes;
1976 sr.wrong_if = c->_c.mfc_un.res.wrong_if;
1979 if (copy_to_user(arg, &sr, sizeof(sr)))
1984 return -EADDRNOTAVAIL;
1986 return -ENOIOCTLCMD;
1991 static inline int ip6mr_forward2_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
1993 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
1994 IPSTATS_MIB_OUTFORWDATAGRAMS);
1995 IP6_ADD_STATS(net, ip6_dst_idev(skb_dst(skb)),
1996 IPSTATS_MIB_OUTOCTETS, skb->len);
1997 return dst_output(net, sk, skb);
2001 * Processing handlers for ip6mr_forward
2004 static int ip6mr_forward2(struct net *net, struct mr_table *mrt,
2005 struct sk_buff *skb, int vifi)
2007 struct ipv6hdr *ipv6h;
2008 struct vif_device *vif = &mrt->vif_table[vifi];
2009 struct net_device *dev;
2010 struct dst_entry *dst;
2016 #ifdef CONFIG_IPV6_PIMSM_V2
2017 if (vif->flags & MIFF_REGISTER) {
2019 vif->bytes_out += skb->len;
2020 vif->dev->stats.tx_bytes += skb->len;
2021 vif->dev->stats.tx_packets++;
2022 ip6mr_cache_report(mrt, skb, vifi, MRT6MSG_WHOLEPKT);
2027 ipv6h = ipv6_hdr(skb);
2029 fl6 = (struct flowi6) {
2030 .flowi6_oif = vif->link,
2031 .daddr = ipv6h->daddr,
2034 dst = ip6_route_output(net, NULL, &fl6);
2041 skb_dst_set(skb, dst);
2044 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
2045 * not only before forwarding, but after forwarding on all output
2046 * interfaces. It is clear, if mrouter runs a multicasting
2047 * program, it should receive packets not depending to what interface
2048 * program is joined.
2049 * If we will not make it, the program will have to join on all
2050 * interfaces. On the other hand, multihoming host (or router, but
2051 * not mrouter) cannot join to more than one interface - it will
2052 * result in receiving multiple packets.
2057 vif->bytes_out += skb->len;
2059 /* We are about to write */
2060 /* XXX: extension headers? */
2061 if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
2064 ipv6h = ipv6_hdr(skb);
2067 IP6CB(skb)->flags |= IP6SKB_FORWARDED;
2069 return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD,
2070 net, NULL, skb, skb->dev, dev,
2071 ip6mr_forward2_finish);
2078 static int ip6mr_find_vif(struct mr_table *mrt, struct net_device *dev)
2082 for (ct = mrt->maxvif - 1; ct >= 0; ct--) {
2083 if (mrt->vif_table[ct].dev == dev)
2089 static void ip6_mr_forward(struct net *net, struct mr_table *mrt,
2090 struct net_device *dev, struct sk_buff *skb,
2091 struct mfc6_cache *c)
2095 int true_vifi = ip6mr_find_vif(mrt, dev);
2097 vif = c->_c.mfc_parent;
2098 c->_c.mfc_un.res.pkt++;
2099 c->_c.mfc_un.res.bytes += skb->len;
2100 c->_c.mfc_un.res.lastuse = jiffies;
2102 if (ipv6_addr_any(&c->mf6c_origin) && true_vifi >= 0) {
2103 struct mfc6_cache *cache_proxy;
2105 /* For an (*,G) entry, we only check that the incoming
2106 * interface is part of the static tree.
2109 cache_proxy = mr_mfc_find_any_parent(mrt, vif);
2111 cache_proxy->_c.mfc_un.res.ttls[true_vifi] < 255) {
2119 * Wrong interface: drop packet and (maybe) send PIM assert.
2121 if (mrt->vif_table[vif].dev != dev) {
2122 c->_c.mfc_un.res.wrong_if++;
2124 if (true_vifi >= 0 && mrt->mroute_do_assert &&
2125 /* pimsm uses asserts, when switching from RPT to SPT,
2126 so that we cannot check that packet arrived on an oif.
2127 It is bad, but otherwise we would need to move pretty
2128 large chunk of pimd to kernel. Ough... --ANK
2130 (mrt->mroute_do_pim ||
2131 c->_c.mfc_un.res.ttls[true_vifi] < 255) &&
2133 c->_c.mfc_un.res.last_assert +
2134 MFC_ASSERT_THRESH)) {
2135 c->_c.mfc_un.res.last_assert = jiffies;
2136 ip6mr_cache_report(mrt, skb, true_vifi, MRT6MSG_WRONGMIF);
2142 mrt->vif_table[vif].pkt_in++;
2143 mrt->vif_table[vif].bytes_in += skb->len;
2148 if (ipv6_addr_any(&c->mf6c_origin) &&
2149 ipv6_addr_any(&c->mf6c_mcastgrp)) {
2150 if (true_vifi >= 0 &&
2151 true_vifi != c->_c.mfc_parent &&
2152 ipv6_hdr(skb)->hop_limit >
2153 c->_c.mfc_un.res.ttls[c->_c.mfc_parent]) {
2154 /* It's an (*,*) entry and the packet is not coming from
2155 * the upstream: forward the packet to the upstream
2158 psend = c->_c.mfc_parent;
2163 for (ct = c->_c.mfc_un.res.maxvif - 1;
2164 ct >= c->_c.mfc_un.res.minvif; ct--) {
2165 /* For (*,G) entry, don't forward to the incoming interface */
2166 if ((!ipv6_addr_any(&c->mf6c_origin) || ct != true_vifi) &&
2167 ipv6_hdr(skb)->hop_limit > c->_c.mfc_un.res.ttls[ct]) {
2169 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2171 ip6mr_forward2(net, mrt, skb2, psend);
2178 ip6mr_forward2(net, mrt, skb, psend);
2188 * Multicast packets for forwarding arrive here
2191 int ip6_mr_input(struct sk_buff *skb)
2193 struct mfc6_cache *cache;
2194 struct net *net = dev_net(skb->dev);
2195 struct mr_table *mrt;
2196 struct flowi6 fl6 = {
2197 .flowi6_iif = skb->dev->ifindex,
2198 .flowi6_mark = skb->mark,
2201 struct net_device *dev;
2203 /* skb->dev passed in is the master dev for vrfs.
2204 * Get the proper interface that does have a vif associated with it.
2207 if (netif_is_l3_master(skb->dev)) {
2208 dev = dev_get_by_index_rcu(net, IPCB(skb)->iif);
2215 err = ip6mr_fib_lookup(net, &fl6, &mrt);
2221 read_lock(&mrt_lock);
2222 cache = ip6mr_cache_find(mrt,
2223 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
2225 int vif = ip6mr_find_vif(mrt, dev);
2228 cache = ip6mr_cache_find_any(mrt,
2229 &ipv6_hdr(skb)->daddr,
2234 * No usable cache entry
2239 vif = ip6mr_find_vif(mrt, dev);
2241 int err = ip6mr_cache_unresolved(mrt, vif, skb, dev);
2242 read_unlock(&mrt_lock);
2246 read_unlock(&mrt_lock);
2251 ip6_mr_forward(net, mrt, dev, skb, cache);
2253 read_unlock(&mrt_lock);
2258 int ip6mr_get_route(struct net *net, struct sk_buff *skb, struct rtmsg *rtm,
2262 struct mr_table *mrt;
2263 struct mfc6_cache *cache;
2264 struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
2266 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
2270 read_lock(&mrt_lock);
2271 cache = ip6mr_cache_find(mrt, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
2272 if (!cache && skb->dev) {
2273 int vif = ip6mr_find_vif(mrt, skb->dev);
2276 cache = ip6mr_cache_find_any(mrt, &rt->rt6i_dst.addr,
2281 struct sk_buff *skb2;
2282 struct ipv6hdr *iph;
2283 struct net_device *dev;
2287 if (!dev || (vif = ip6mr_find_vif(mrt, dev)) < 0) {
2288 read_unlock(&mrt_lock);
2292 /* really correct? */
2293 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
2295 read_unlock(&mrt_lock);
2299 NETLINK_CB(skb2).portid = portid;
2300 skb_reset_transport_header(skb2);
2302 skb_put(skb2, sizeof(struct ipv6hdr));
2303 skb_reset_network_header(skb2);
2305 iph = ipv6_hdr(skb2);
2308 iph->flow_lbl[0] = 0;
2309 iph->flow_lbl[1] = 0;
2310 iph->flow_lbl[2] = 0;
2311 iph->payload_len = 0;
2312 iph->nexthdr = IPPROTO_NONE;
2314 iph->saddr = rt->rt6i_src.addr;
2315 iph->daddr = rt->rt6i_dst.addr;
2317 err = ip6mr_cache_unresolved(mrt, vif, skb2, dev);
2318 read_unlock(&mrt_lock);
2323 err = mr_fill_mroute(mrt, skb, &cache->_c, rtm);
2324 read_unlock(&mrt_lock);
2328 static int ip6mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
2329 u32 portid, u32 seq, struct mfc6_cache *c, int cmd,
2332 struct nlmsghdr *nlh;
2336 nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
2340 rtm = nlmsg_data(nlh);
2341 rtm->rtm_family = RTNL_FAMILY_IP6MR;
2342 rtm->rtm_dst_len = 128;
2343 rtm->rtm_src_len = 128;
2345 rtm->rtm_table = mrt->id;
2346 if (nla_put_u32(skb, RTA_TABLE, mrt->id))
2347 goto nla_put_failure;
2348 rtm->rtm_type = RTN_MULTICAST;
2349 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2350 if (c->_c.mfc_flags & MFC_STATIC)
2351 rtm->rtm_protocol = RTPROT_STATIC;
2353 rtm->rtm_protocol = RTPROT_MROUTED;
2356 if (nla_put_in6_addr(skb, RTA_SRC, &c->mf6c_origin) ||
2357 nla_put_in6_addr(skb, RTA_DST, &c->mf6c_mcastgrp))
2358 goto nla_put_failure;
2359 err = mr_fill_mroute(mrt, skb, &c->_c, rtm);
2360 /* do not break the dump if cache is unresolved */
2361 if (err < 0 && err != -ENOENT)
2362 goto nla_put_failure;
2364 nlmsg_end(skb, nlh);
2368 nlmsg_cancel(skb, nlh);
2372 static int _ip6mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
2373 u32 portid, u32 seq, struct mr_mfc *c,
2376 return ip6mr_fill_mroute(mrt, skb, portid, seq, (struct mfc6_cache *)c,
2380 static int mr6_msgsize(bool unresolved, int maxvif)
2383 NLMSG_ALIGN(sizeof(struct rtmsg))
2384 + nla_total_size(4) /* RTA_TABLE */
2385 + nla_total_size(sizeof(struct in6_addr)) /* RTA_SRC */
2386 + nla_total_size(sizeof(struct in6_addr)) /* RTA_DST */
2391 + nla_total_size(4) /* RTA_IIF */
2392 + nla_total_size(0) /* RTA_MULTIPATH */
2393 + maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
2395 + nla_total_size_64bit(sizeof(struct rta_mfc_stats))
2401 static void mr6_netlink_event(struct mr_table *mrt, struct mfc6_cache *mfc,
2404 struct net *net = read_pnet(&mrt->net);
2405 struct sk_buff *skb;
2408 skb = nlmsg_new(mr6_msgsize(mfc->_c.mfc_parent >= MAXMIFS, mrt->maxvif),
2413 err = ip6mr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
2417 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE, NULL, GFP_ATOMIC);
2423 rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE, err);
2426 static size_t mrt6msg_netlink_msgsize(size_t payloadlen)
2429 NLMSG_ALIGN(sizeof(struct rtgenmsg))
2430 + nla_total_size(1) /* IP6MRA_CREPORT_MSGTYPE */
2431 + nla_total_size(4) /* IP6MRA_CREPORT_MIF_ID */
2432 /* IP6MRA_CREPORT_SRC_ADDR */
2433 + nla_total_size(sizeof(struct in6_addr))
2434 /* IP6MRA_CREPORT_DST_ADDR */
2435 + nla_total_size(sizeof(struct in6_addr))
2436 /* IP6MRA_CREPORT_PKT */
2437 + nla_total_size(payloadlen)
2443 static void mrt6msg_netlink_event(struct mr_table *mrt, struct sk_buff *pkt)
2445 struct net *net = read_pnet(&mrt->net);
2446 struct nlmsghdr *nlh;
2447 struct rtgenmsg *rtgenm;
2448 struct mrt6msg *msg;
2449 struct sk_buff *skb;
2453 payloadlen = pkt->len - sizeof(struct mrt6msg);
2454 msg = (struct mrt6msg *)skb_transport_header(pkt);
2456 skb = nlmsg_new(mrt6msg_netlink_msgsize(payloadlen), GFP_ATOMIC);
2460 nlh = nlmsg_put(skb, 0, 0, RTM_NEWCACHEREPORT,
2461 sizeof(struct rtgenmsg), 0);
2464 rtgenm = nlmsg_data(nlh);
2465 rtgenm->rtgen_family = RTNL_FAMILY_IP6MR;
2466 if (nla_put_u8(skb, IP6MRA_CREPORT_MSGTYPE, msg->im6_msgtype) ||
2467 nla_put_u32(skb, IP6MRA_CREPORT_MIF_ID, msg->im6_mif) ||
2468 nla_put_in6_addr(skb, IP6MRA_CREPORT_SRC_ADDR,
2470 nla_put_in6_addr(skb, IP6MRA_CREPORT_DST_ADDR,
2472 goto nla_put_failure;
2474 nla = nla_reserve(skb, IP6MRA_CREPORT_PKT, payloadlen);
2475 if (!nla || skb_copy_bits(pkt, sizeof(struct mrt6msg),
2476 nla_data(nla), payloadlen))
2477 goto nla_put_failure;
2479 nlmsg_end(skb, nlh);
2481 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE_R, NULL, GFP_ATOMIC);
2485 nlmsg_cancel(skb, nlh);
2488 rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE_R, -ENOBUFS);
2491 static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2493 const struct nlmsghdr *nlh = cb->nlh;
2494 struct fib_dump_filter filter = {};
2497 if (cb->strict_check) {
2498 err = ip_valid_fib_dump_req(sock_net(skb->sk), nlh,
2504 if (filter.table_id) {
2505 struct mr_table *mrt;
2507 mrt = ip6mr_get_table(sock_net(skb->sk), filter.table_id);
2509 if (rtnl_msg_family(cb->nlh) != RTNL_FAMILY_IP6MR)
2512 NL_SET_ERR_MSG_MOD(cb->extack, "MR table does not exist");
2515 err = mr_table_dump(mrt, skb, cb, _ip6mr_fill_mroute,
2516 &mfc_unres_lock, &filter);
2517 return skb->len ? : err;
2520 return mr_rtm_dumproute(skb, cb, ip6mr_mr_table_iter,
2521 _ip6mr_fill_mroute, &mfc_unres_lock, &filter);