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 static struct net_device *vif_dev_read(const struct vif_device *vif)
69 return rcu_dereference_check(vif->dev,
70 lockdep_is_held(&mrt_lock));
73 /* Multicast router control variables */
75 /* Special spinlock for queue of unresolved entries */
76 static DEFINE_SPINLOCK(mfc_unres_lock);
78 /* We return to original Alan's scheme. Hash table of resolved
79 entries is changed only in process context and protected
80 with weak lock mrt_lock. Queue of unresolved entries is protected
81 with strong spinlock mfc_unres_lock.
83 In this case data path is free of exclusive locks at all.
86 static struct kmem_cache *mrt_cachep __read_mostly;
88 static struct mr_table *ip6mr_new_table(struct net *net, u32 id);
89 static void ip6mr_free_table(struct mr_table *mrt);
91 static void ip6_mr_forward(struct net *net, struct mr_table *mrt,
92 struct net_device *dev, struct sk_buff *skb,
93 struct mfc6_cache *cache);
94 static int ip6mr_cache_report(const struct mr_table *mrt, struct sk_buff *pkt,
95 mifi_t mifi, int assert);
96 static void mr6_netlink_event(struct mr_table *mrt, struct mfc6_cache *mfc,
98 static void mrt6msg_netlink_event(const struct mr_table *mrt, struct sk_buff *pkt);
99 static int ip6mr_rtm_dumproute(struct sk_buff *skb,
100 struct netlink_callback *cb);
101 static void mroute_clean_tables(struct mr_table *mrt, int flags);
102 static void ipmr_expire_process(struct timer_list *t);
104 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
105 #define ip6mr_for_each_table(mrt, net) \
106 list_for_each_entry_rcu(mrt, &net->ipv6.mr6_tables, list, \
107 lockdep_rtnl_is_held() || \
108 list_empty(&net->ipv6.mr6_tables))
110 static struct mr_table *ip6mr_mr_table_iter(struct net *net,
111 struct mr_table *mrt)
113 struct mr_table *ret;
116 ret = list_entry_rcu(net->ipv6.mr6_tables.next,
117 struct mr_table, list);
119 ret = list_entry_rcu(mrt->list.next,
120 struct mr_table, list);
122 if (&ret->list == &net->ipv6.mr6_tables)
127 static struct mr_table *ip6mr_get_table(struct net *net, u32 id)
129 struct mr_table *mrt;
131 ip6mr_for_each_table(mrt, net) {
138 static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
139 struct mr_table **mrt)
142 struct ip6mr_result res;
143 struct fib_lookup_arg arg = {
145 .flags = FIB_LOOKUP_NOREF,
148 /* update flow if oif or iif point to device enslaved to l3mdev */
149 l3mdev_update_flow(net, flowi6_to_flowi(flp6));
151 err = fib_rules_lookup(net->ipv6.mr6_rules_ops,
152 flowi6_to_flowi(flp6), 0, &arg);
159 static int ip6mr_rule_action(struct fib_rule *rule, struct flowi *flp,
160 int flags, struct fib_lookup_arg *arg)
162 struct ip6mr_result *res = arg->result;
163 struct mr_table *mrt;
165 switch (rule->action) {
168 case FR_ACT_UNREACHABLE:
170 case FR_ACT_PROHIBIT:
172 case FR_ACT_BLACKHOLE:
177 arg->table = fib_rule_get_table(rule, arg);
179 mrt = ip6mr_get_table(rule->fr_net, arg->table);
186 static int ip6mr_rule_match(struct fib_rule *rule, struct flowi *flp, int flags)
191 static int ip6mr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
192 struct fib_rule_hdr *frh, struct nlattr **tb,
193 struct netlink_ext_ack *extack)
198 static int ip6mr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
204 static int ip6mr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
205 struct fib_rule_hdr *frh)
213 static const struct fib_rules_ops __net_initconst ip6mr_rules_ops_template = {
214 .family = RTNL_FAMILY_IP6MR,
215 .rule_size = sizeof(struct ip6mr_rule),
216 .addr_size = sizeof(struct in6_addr),
217 .action = ip6mr_rule_action,
218 .match = ip6mr_rule_match,
219 .configure = ip6mr_rule_configure,
220 .compare = ip6mr_rule_compare,
221 .fill = ip6mr_rule_fill,
222 .nlgroup = RTNLGRP_IPV6_RULE,
223 .owner = THIS_MODULE,
226 static int __net_init ip6mr_rules_init(struct net *net)
228 struct fib_rules_ops *ops;
229 struct mr_table *mrt;
232 ops = fib_rules_register(&ip6mr_rules_ops_template, net);
236 INIT_LIST_HEAD(&net->ipv6.mr6_tables);
238 mrt = ip6mr_new_table(net, RT6_TABLE_DFLT);
244 err = fib_default_rule_add(ops, 0x7fff, RT6_TABLE_DFLT, 0);
248 net->ipv6.mr6_rules_ops = ops;
253 ip6mr_free_table(mrt);
256 fib_rules_unregister(ops);
260 static void __net_exit ip6mr_rules_exit(struct net *net)
262 struct mr_table *mrt, *next;
265 list_for_each_entry_safe(mrt, next, &net->ipv6.mr6_tables, list) {
266 list_del(&mrt->list);
267 ip6mr_free_table(mrt);
269 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;
331 static int ip6mr_rules_dump(struct net *net, struct notifier_block *nb,
332 struct netlink_ext_ack *extack)
337 static unsigned int ip6mr_rules_seq_read(struct net *net)
343 static int ip6mr_hash_cmp(struct rhashtable_compare_arg *arg,
346 const struct mfc6_cache_cmp_arg *cmparg = arg->key;
347 struct mfc6_cache *c = (struct mfc6_cache *)ptr;
349 return !ipv6_addr_equal(&c->mf6c_mcastgrp, &cmparg->mf6c_mcastgrp) ||
350 !ipv6_addr_equal(&c->mf6c_origin, &cmparg->mf6c_origin);
353 static const struct rhashtable_params ip6mr_rht_params = {
354 .head_offset = offsetof(struct mr_mfc, mnode),
355 .key_offset = offsetof(struct mfc6_cache, cmparg),
356 .key_len = sizeof(struct mfc6_cache_cmp_arg),
358 .obj_cmpfn = ip6mr_hash_cmp,
359 .automatic_shrinking = true,
362 static void ip6mr_new_table_set(struct mr_table *mrt,
365 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
366 list_add_tail_rcu(&mrt->list, &net->ipv6.mr6_tables);
370 static struct mfc6_cache_cmp_arg ip6mr_mr_table_ops_cmparg_any = {
371 .mf6c_origin = IN6ADDR_ANY_INIT,
372 .mf6c_mcastgrp = IN6ADDR_ANY_INIT,
375 static struct mr_table_ops ip6mr_mr_table_ops = {
376 .rht_params = &ip6mr_rht_params,
377 .cmparg_any = &ip6mr_mr_table_ops_cmparg_any,
380 static struct mr_table *ip6mr_new_table(struct net *net, u32 id)
382 struct mr_table *mrt;
384 mrt = ip6mr_get_table(net, id);
388 return mr_table_alloc(net, id, &ip6mr_mr_table_ops,
389 ipmr_expire_process, ip6mr_new_table_set);
392 static void ip6mr_free_table(struct mr_table *mrt)
394 del_timer_sync(&mrt->ipmr_expire_timer);
395 mroute_clean_tables(mrt, MRT6_FLUSH_MIFS | MRT6_FLUSH_MIFS_STATIC |
396 MRT6_FLUSH_MFC | MRT6_FLUSH_MFC_STATIC);
397 rhltable_destroy(&mrt->mfc_hash);
401 #ifdef CONFIG_PROC_FS
402 /* The /proc interfaces to multicast routing
403 * /proc/ip6_mr_cache /proc/ip6_mr_vif
406 static void *ip6mr_vif_seq_start(struct seq_file *seq, loff_t *pos)
409 struct mr_vif_iter *iter = seq->private;
410 struct net *net = seq_file_net(seq);
411 struct mr_table *mrt;
413 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
415 return ERR_PTR(-ENOENT);
419 read_lock(&mrt_lock);
420 return mr_vif_seq_start(seq, pos);
423 static void ip6mr_vif_seq_stop(struct seq_file *seq, void *v)
426 read_unlock(&mrt_lock);
429 static int ip6mr_vif_seq_show(struct seq_file *seq, void *v)
431 struct mr_vif_iter *iter = seq->private;
432 struct mr_table *mrt = iter->mrt;
434 if (v == SEQ_START_TOKEN) {
436 "Interface BytesIn PktsIn BytesOut PktsOut Flags\n");
438 const struct vif_device *vif = v;
439 const struct net_device *vif_dev;
442 vif_dev = vif_dev_read(vif);
443 name = vif_dev ? vif_dev->name : "none";
446 "%2td %-10s %8ld %7ld %8ld %7ld %05X\n",
447 vif - mrt->vif_table,
448 name, vif->bytes_in, vif->pkt_in,
449 vif->bytes_out, vif->pkt_out,
455 static const struct seq_operations ip6mr_vif_seq_ops = {
456 .start = ip6mr_vif_seq_start,
457 .next = mr_vif_seq_next,
458 .stop = ip6mr_vif_seq_stop,
459 .show = ip6mr_vif_seq_show,
462 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
464 struct net *net = seq_file_net(seq);
465 struct mr_table *mrt;
467 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
469 return ERR_PTR(-ENOENT);
471 return mr_mfc_seq_start(seq, pos, mrt, &mfc_unres_lock);
474 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
478 if (v == SEQ_START_TOKEN) {
482 "Iif Pkts Bytes Wrong Oifs\n");
484 const struct mfc6_cache *mfc = v;
485 const struct mr_mfc_iter *it = seq->private;
486 struct mr_table *mrt = it->mrt;
488 seq_printf(seq, "%pI6 %pI6 %-3hd",
489 &mfc->mf6c_mcastgrp, &mfc->mf6c_origin,
492 if (it->cache != &mrt->mfc_unres_queue) {
493 seq_printf(seq, " %8lu %8lu %8lu",
494 mfc->_c.mfc_un.res.pkt,
495 mfc->_c.mfc_un.res.bytes,
496 mfc->_c.mfc_un.res.wrong_if);
497 for (n = mfc->_c.mfc_un.res.minvif;
498 n < mfc->_c.mfc_un.res.maxvif; n++) {
499 if (VIF_EXISTS(mrt, n) &&
500 mfc->_c.mfc_un.res.ttls[n] < 255)
503 mfc->_c.mfc_un.res.ttls[n]);
506 /* unresolved mfc_caches don't contain
507 * pkt, bytes and wrong_if values
509 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
516 static const struct seq_operations ipmr_mfc_seq_ops = {
517 .start = ipmr_mfc_seq_start,
518 .next = mr_mfc_seq_next,
519 .stop = mr_mfc_seq_stop,
520 .show = ipmr_mfc_seq_show,
524 #ifdef CONFIG_IPV6_PIMSM_V2
526 static int pim6_rcv(struct sk_buff *skb)
528 struct pimreghdr *pim;
529 struct ipv6hdr *encap;
530 struct net_device *reg_dev = NULL;
531 struct net *net = dev_net(skb->dev);
532 struct mr_table *mrt;
533 struct flowi6 fl6 = {
534 .flowi6_iif = skb->dev->ifindex,
535 .flowi6_mark = skb->mark,
539 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
542 pim = (struct pimreghdr *)skb_transport_header(skb);
543 if (pim->type != ((PIM_VERSION << 4) | PIM_TYPE_REGISTER) ||
544 (pim->flags & PIM_NULL_REGISTER) ||
545 (csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
546 sizeof(*pim), IPPROTO_PIM,
547 csum_partial((void *)pim, sizeof(*pim), 0)) &&
548 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
551 /* check if the inner packet is destined to mcast group */
552 encap = (struct ipv6hdr *)(skb_transport_header(skb) +
555 if (!ipv6_addr_is_multicast(&encap->daddr) ||
556 encap->payload_len == 0 ||
557 ntohs(encap->payload_len) + sizeof(*pim) > skb->len)
560 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
563 /* Pairs with WRITE_ONCE() in mif6_add()/mif6_delete() */
564 reg_vif_num = READ_ONCE(mrt->mroute_reg_vif_num);
565 if (reg_vif_num >= 0)
566 reg_dev = vif_dev_read(&mrt->vif_table[reg_vif_num]);
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));
587 static const struct inet6_protocol pim6_protocol = {
591 /* Service routines creating virtual interfaces: PIMREG */
593 static netdev_tx_t reg_vif_xmit(struct sk_buff *skb,
594 struct net_device *dev)
596 struct net *net = dev_net(dev);
597 struct mr_table *mrt;
598 struct flowi6 fl6 = {
599 .flowi6_oif = dev->ifindex,
600 .flowi6_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
601 .flowi6_mark = skb->mark,
604 if (!pskb_inet_may_pull(skb))
607 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
610 dev->stats.tx_bytes += skb->len;
611 dev->stats.tx_packets++;
613 ip6mr_cache_report(mrt, skb, READ_ONCE(mrt->mroute_reg_vif_num),
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 struct net_device *vif_dev,
682 mifi_t vif_index, u32 tb_id)
684 return mr_call_vif_notifiers(net, RTNL_FAMILY_IP6MR, event_type,
685 vif, vif_dev, vif_index, tb_id,
686 &net->ipv6.ipmr_seq);
689 static int call_ip6mr_mfc_entry_notifiers(struct net *net,
690 enum fib_event_type event_type,
691 struct mfc6_cache *mfc, u32 tb_id)
693 return mr_call_mfc_notifiers(net, RTNL_FAMILY_IP6MR, event_type,
694 &mfc->_c, tb_id, &net->ipv6.ipmr_seq);
697 /* Delete a VIF entry */
698 static int mif6_delete(struct mr_table *mrt, int vifi, int notify,
699 struct list_head *head)
701 struct vif_device *v;
702 struct net_device *dev;
703 struct inet6_dev *in6_dev;
705 if (vifi < 0 || vifi >= mrt->maxvif)
706 return -EADDRNOTAVAIL;
708 v = &mrt->vif_table[vifi];
710 dev = rtnl_dereference(v->dev);
712 return -EADDRNOTAVAIL;
714 call_ip6mr_vif_entry_notifiers(read_pnet(&mrt->net),
715 FIB_EVENT_VIF_DEL, v, dev,
717 write_lock_bh(&mrt_lock);
718 RCU_INIT_POINTER(v->dev, NULL);
720 #ifdef CONFIG_IPV6_PIMSM_V2
721 if (vifi == mrt->mroute_reg_vif_num) {
722 /* Pairs with READ_ONCE() in ip6mr_cache_report() and reg_vif_xmit() */
723 WRITE_ONCE(mrt->mroute_reg_vif_num, -1);
727 if (vifi + 1 == mrt->maxvif) {
729 for (tmp = vifi - 1; tmp >= 0; tmp--) {
730 if (VIF_EXISTS(mrt, tmp))
733 WRITE_ONCE(mrt->maxvif, tmp + 1);
736 write_unlock_bh(&mrt_lock);
738 dev_set_allmulti(dev, -1);
740 in6_dev = __in6_dev_get(dev);
742 atomic_dec(&in6_dev->cnf.mc_forwarding);
743 inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
744 NETCONFA_MC_FORWARDING,
745 dev->ifindex, &in6_dev->cnf);
748 if ((v->flags & MIFF_REGISTER) && !notify)
749 unregister_netdevice_queue(dev, head);
751 netdev_put(dev, &v->dev_tracker);
755 static inline void ip6mr_cache_free_rcu(struct rcu_head *head)
757 struct mr_mfc *c = container_of(head, struct mr_mfc, rcu);
759 kmem_cache_free(mrt_cachep, (struct mfc6_cache *)c);
762 static inline void ip6mr_cache_free(struct mfc6_cache *c)
764 call_rcu(&c->_c.rcu, ip6mr_cache_free_rcu);
767 /* Destroy an unresolved cache entry, killing queued skbs
768 and reporting error to netlink readers.
771 static void ip6mr_destroy_unres(struct mr_table *mrt, struct mfc6_cache *c)
773 struct net *net = read_pnet(&mrt->net);
776 atomic_dec(&mrt->cache_resolve_queue_len);
778 while ((skb = skb_dequeue(&c->_c.mfc_un.unres.unresolved)) != NULL) {
779 if (ipv6_hdr(skb)->version == 0) {
780 struct nlmsghdr *nlh = skb_pull(skb,
781 sizeof(struct ipv6hdr));
782 nlh->nlmsg_type = NLMSG_ERROR;
783 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
784 skb_trim(skb, nlh->nlmsg_len);
785 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -ETIMEDOUT;
786 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
795 /* Timer process for all the unresolved queue. */
797 static void ipmr_do_expire_process(struct mr_table *mrt)
799 unsigned long now = jiffies;
800 unsigned long expires = 10 * HZ;
801 struct mr_mfc *c, *next;
803 list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
804 if (time_after(c->mfc_un.unres.expires, now)) {
806 unsigned long interval = c->mfc_un.unres.expires - now;
807 if (interval < expires)
813 mr6_netlink_event(mrt, (struct mfc6_cache *)c, RTM_DELROUTE);
814 ip6mr_destroy_unres(mrt, (struct mfc6_cache *)c);
817 if (!list_empty(&mrt->mfc_unres_queue))
818 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
821 static void ipmr_expire_process(struct timer_list *t)
823 struct mr_table *mrt = from_timer(mrt, t, ipmr_expire_timer);
825 if (!spin_trylock(&mfc_unres_lock)) {
826 mod_timer(&mrt->ipmr_expire_timer, jiffies + 1);
830 if (!list_empty(&mrt->mfc_unres_queue))
831 ipmr_do_expire_process(mrt);
833 spin_unlock(&mfc_unres_lock);
836 /* Fill oifs list. It is called under write locked mrt_lock. */
838 static void ip6mr_update_thresholds(struct mr_table *mrt,
839 struct mr_mfc *cache,
844 cache->mfc_un.res.minvif = MAXMIFS;
845 cache->mfc_un.res.maxvif = 0;
846 memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
848 for (vifi = 0; vifi < mrt->maxvif; vifi++) {
849 if (VIF_EXISTS(mrt, vifi) &&
850 ttls[vifi] && ttls[vifi] < 255) {
851 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
852 if (cache->mfc_un.res.minvif > vifi)
853 cache->mfc_un.res.minvif = vifi;
854 if (cache->mfc_un.res.maxvif <= vifi)
855 cache->mfc_un.res.maxvif = vifi + 1;
858 cache->mfc_un.res.lastuse = jiffies;
861 static int mif6_add(struct net *net, struct mr_table *mrt,
862 struct mif6ctl *vifc, int mrtsock)
864 int vifi = vifc->mif6c_mifi;
865 struct vif_device *v = &mrt->vif_table[vifi];
866 struct net_device *dev;
867 struct inet6_dev *in6_dev;
871 if (VIF_EXISTS(mrt, vifi))
874 switch (vifc->mif6c_flags) {
875 #ifdef CONFIG_IPV6_PIMSM_V2
878 * Special Purpose VIF in PIM
879 * All the packets will be sent to the daemon
881 if (mrt->mroute_reg_vif_num >= 0)
883 dev = ip6mr_reg_vif(net, mrt);
886 err = dev_set_allmulti(dev, 1);
888 unregister_netdevice(dev);
895 dev = dev_get_by_index(net, vifc->mif6c_pifi);
897 return -EADDRNOTAVAIL;
898 err = dev_set_allmulti(dev, 1);
908 in6_dev = __in6_dev_get(dev);
910 atomic_inc(&in6_dev->cnf.mc_forwarding);
911 inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
912 NETCONFA_MC_FORWARDING,
913 dev->ifindex, &in6_dev->cnf);
916 /* Fill in the VIF structures */
917 vif_device_init(v, dev, vifc->vifc_rate_limit, vifc->vifc_threshold,
918 vifc->mif6c_flags | (!mrtsock ? VIFF_STATIC : 0),
921 /* And finish update writing critical data */
922 write_lock_bh(&mrt_lock);
923 rcu_assign_pointer(v->dev, dev);
924 netdev_tracker_alloc(dev, &v->dev_tracker, GFP_ATOMIC);
925 #ifdef CONFIG_IPV6_PIMSM_V2
926 if (v->flags & MIFF_REGISTER)
927 WRITE_ONCE(mrt->mroute_reg_vif_num, vifi);
929 if (vifi + 1 > mrt->maxvif)
930 WRITE_ONCE(mrt->maxvif, vifi + 1);
931 write_unlock_bh(&mrt_lock);
932 call_ip6mr_vif_entry_notifiers(net, FIB_EVENT_VIF_ADD,
933 v, dev, vifi, mrt->id);
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 rcu_read_lock()
1041 static int ip6mr_cache_report(const 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 || assert == MRT6MSG_WRMIFWHOLE)
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 || assert == MRT6MSG_WRMIFWHOLE) {
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_push(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 = assert;
1079 if (assert == MRT6MSG_WRMIFWHOLE)
1080 msg->im6_mif = mifi;
1082 msg->im6_mif = READ_ONCE(mrt->mroute_reg_vif_num);
1084 msg->im6_src = ipv6_hdr(pkt)->saddr;
1085 msg->im6_dst = ipv6_hdr(pkt)->daddr;
1087 skb->ip_summed = CHECKSUM_UNNECESSARY;
1092 * Copy the IP header
1095 skb_put(skb, sizeof(struct ipv6hdr));
1096 skb_reset_network_header(skb);
1097 skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
1102 skb_put(skb, sizeof(*msg));
1103 skb_reset_transport_header(skb);
1104 msg = (struct mrt6msg *)skb_transport_header(skb);
1107 msg->im6_msgtype = assert;
1108 msg->im6_mif = mifi;
1110 msg->im6_src = ipv6_hdr(pkt)->saddr;
1111 msg->im6_dst = ipv6_hdr(pkt)->daddr;
1113 skb_dst_set(skb, dst_clone(skb_dst(pkt)));
1114 skb->ip_summed = CHECKSUM_UNNECESSARY;
1117 mroute6_sk = rcu_dereference(mrt->mroute_sk);
1123 mrt6msg_netlink_event(mrt, skb);
1125 /* Deliver to user space multicast routing algorithms */
1126 ret = sock_queue_rcv_skb(mroute6_sk, skb);
1129 net_warn_ratelimited("mroute6: pending queue full, dropping entries\n");
1136 /* Queue a packet for resolution. It gets locked cache entry! */
1137 static int ip6mr_cache_unresolved(struct mr_table *mrt, mifi_t mifi,
1138 struct sk_buff *skb, struct net_device *dev)
1140 struct mfc6_cache *c;
1144 spin_lock_bh(&mfc_unres_lock);
1145 list_for_each_entry(c, &mrt->mfc_unres_queue, _c.list) {
1146 if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
1147 ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr)) {
1155 * Create a new entry if allowable
1158 c = ip6mr_cache_alloc_unres();
1160 spin_unlock_bh(&mfc_unres_lock);
1166 /* Fill in the new cache entry */
1167 c->_c.mfc_parent = -1;
1168 c->mf6c_origin = ipv6_hdr(skb)->saddr;
1169 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
1172 * Reflect first query at pim6sd
1174 err = ip6mr_cache_report(mrt, skb, mifi, MRT6MSG_NOCACHE);
1176 /* If the report failed throw the cache entry
1179 spin_unlock_bh(&mfc_unres_lock);
1181 ip6mr_cache_free(c);
1186 atomic_inc(&mrt->cache_resolve_queue_len);
1187 list_add(&c->_c.list, &mrt->mfc_unres_queue);
1188 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1190 ipmr_do_expire_process(mrt);
1193 /* See if we can append the packet */
1194 if (c->_c.mfc_un.unres.unresolved.qlen > 3) {
1200 skb->skb_iif = dev->ifindex;
1202 skb_queue_tail(&c->_c.mfc_un.unres.unresolved, skb);
1206 spin_unlock_bh(&mfc_unres_lock);
1211 * MFC6 cache manipulation by user space
1214 static int ip6mr_mfc_delete(struct mr_table *mrt, struct mf6cctl *mfc,
1217 struct mfc6_cache *c;
1219 /* The entries are added/deleted only under RTNL */
1221 c = ip6mr_cache_find_parent(mrt, &mfc->mf6cc_origin.sin6_addr,
1222 &mfc->mf6cc_mcastgrp.sin6_addr, parent);
1226 rhltable_remove(&mrt->mfc_hash, &c->_c.mnode, ip6mr_rht_params);
1227 list_del_rcu(&c->_c.list);
1229 call_ip6mr_mfc_entry_notifiers(read_pnet(&mrt->net),
1230 FIB_EVENT_ENTRY_DEL, c, mrt->id);
1231 mr6_netlink_event(mrt, c, RTM_DELROUTE);
1232 mr_cache_put(&c->_c);
1236 static int ip6mr_device_event(struct notifier_block *this,
1237 unsigned long event, void *ptr)
1239 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1240 struct net *net = dev_net(dev);
1241 struct mr_table *mrt;
1242 struct vif_device *v;
1245 if (event != NETDEV_UNREGISTER)
1248 ip6mr_for_each_table(mrt, net) {
1249 v = &mrt->vif_table[0];
1250 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1251 if (rcu_access_pointer(v->dev) == dev)
1252 mif6_delete(mrt, ct, 1, NULL);
1259 static unsigned int ip6mr_seq_read(struct net *net)
1263 return net->ipv6.ipmr_seq + ip6mr_rules_seq_read(net);
1266 static int ip6mr_dump(struct net *net, struct notifier_block *nb,
1267 struct netlink_ext_ack *extack)
1269 return mr_dump(net, nb, RTNL_FAMILY_IP6MR, ip6mr_rules_dump,
1270 ip6mr_mr_table_iter, &mrt_lock, extack);
1273 static struct notifier_block ip6_mr_notifier = {
1274 .notifier_call = ip6mr_device_event
1277 static const struct fib_notifier_ops ip6mr_notifier_ops_template = {
1278 .family = RTNL_FAMILY_IP6MR,
1279 .fib_seq_read = ip6mr_seq_read,
1280 .fib_dump = ip6mr_dump,
1281 .owner = THIS_MODULE,
1284 static int __net_init ip6mr_notifier_init(struct net *net)
1286 struct fib_notifier_ops *ops;
1288 net->ipv6.ipmr_seq = 0;
1290 ops = fib_notifier_ops_register(&ip6mr_notifier_ops_template, net);
1292 return PTR_ERR(ops);
1294 net->ipv6.ip6mr_notifier_ops = ops;
1299 static void __net_exit ip6mr_notifier_exit(struct net *net)
1301 fib_notifier_ops_unregister(net->ipv6.ip6mr_notifier_ops);
1302 net->ipv6.ip6mr_notifier_ops = NULL;
1305 /* Setup for IP multicast routing */
1306 static int __net_init ip6mr_net_init(struct net *net)
1310 err = ip6mr_notifier_init(net);
1314 err = ip6mr_rules_init(net);
1316 goto ip6mr_rules_fail;
1318 #ifdef CONFIG_PROC_FS
1320 if (!proc_create_net("ip6_mr_vif", 0, net->proc_net, &ip6mr_vif_seq_ops,
1321 sizeof(struct mr_vif_iter)))
1323 if (!proc_create_net("ip6_mr_cache", 0, net->proc_net, &ipmr_mfc_seq_ops,
1324 sizeof(struct mr_mfc_iter)))
1325 goto proc_cache_fail;
1330 #ifdef CONFIG_PROC_FS
1332 remove_proc_entry("ip6_mr_vif", net->proc_net);
1335 ip6mr_rules_exit(net);
1339 ip6mr_notifier_exit(net);
1343 static void __net_exit ip6mr_net_exit(struct net *net)
1345 #ifdef CONFIG_PROC_FS
1346 remove_proc_entry("ip6_mr_cache", net->proc_net);
1347 remove_proc_entry("ip6_mr_vif", net->proc_net);
1349 ip6mr_notifier_exit(net);
1352 static void __net_exit ip6mr_net_exit_batch(struct list_head *net_list)
1357 list_for_each_entry(net, net_list, exit_list)
1358 ip6mr_rules_exit(net);
1362 static struct pernet_operations ip6mr_net_ops = {
1363 .init = ip6mr_net_init,
1364 .exit = ip6mr_net_exit,
1365 .exit_batch = ip6mr_net_exit_batch,
1368 int __init ip6_mr_init(void)
1372 mrt_cachep = kmem_cache_create("ip6_mrt_cache",
1373 sizeof(struct mfc6_cache),
1374 0, SLAB_HWCACHE_ALIGN,
1379 err = register_pernet_subsys(&ip6mr_net_ops);
1381 goto reg_pernet_fail;
1383 err = register_netdevice_notifier(&ip6_mr_notifier);
1385 goto reg_notif_fail;
1386 #ifdef CONFIG_IPV6_PIMSM_V2
1387 if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
1388 pr_err("%s: can't add PIM protocol\n", __func__);
1390 goto add_proto_fail;
1393 err = rtnl_register_module(THIS_MODULE, RTNL_FAMILY_IP6MR, RTM_GETROUTE,
1394 NULL, ip6mr_rtm_dumproute, 0);
1398 #ifdef CONFIG_IPV6_PIMSM_V2
1399 inet6_del_protocol(&pim6_protocol, IPPROTO_PIM);
1401 unregister_netdevice_notifier(&ip6_mr_notifier);
1404 unregister_pernet_subsys(&ip6mr_net_ops);
1406 kmem_cache_destroy(mrt_cachep);
1410 void ip6_mr_cleanup(void)
1412 rtnl_unregister(RTNL_FAMILY_IP6MR, RTM_GETROUTE);
1413 #ifdef CONFIG_IPV6_PIMSM_V2
1414 inet6_del_protocol(&pim6_protocol, IPPROTO_PIM);
1416 unregister_netdevice_notifier(&ip6_mr_notifier);
1417 unregister_pernet_subsys(&ip6mr_net_ops);
1418 kmem_cache_destroy(mrt_cachep);
1421 static int ip6mr_mfc_add(struct net *net, struct mr_table *mrt,
1422 struct mf6cctl *mfc, int mrtsock, int parent)
1424 unsigned char ttls[MAXMIFS];
1425 struct mfc6_cache *uc, *c;
1430 if (mfc->mf6cc_parent >= MAXMIFS)
1433 memset(ttls, 255, MAXMIFS);
1434 for (i = 0; i < MAXMIFS; i++) {
1435 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1439 /* The entries are added/deleted only under RTNL */
1441 c = ip6mr_cache_find_parent(mrt, &mfc->mf6cc_origin.sin6_addr,
1442 &mfc->mf6cc_mcastgrp.sin6_addr, parent);
1445 write_lock_bh(&mrt_lock);
1446 c->_c.mfc_parent = mfc->mf6cc_parent;
1447 ip6mr_update_thresholds(mrt, &c->_c, ttls);
1449 c->_c.mfc_flags |= MFC_STATIC;
1450 write_unlock_bh(&mrt_lock);
1451 call_ip6mr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_REPLACE,
1453 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1457 if (!ipv6_addr_any(&mfc->mf6cc_mcastgrp.sin6_addr) &&
1458 !ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
1461 c = ip6mr_cache_alloc();
1465 c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1466 c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
1467 c->_c.mfc_parent = mfc->mf6cc_parent;
1468 ip6mr_update_thresholds(mrt, &c->_c, ttls);
1470 c->_c.mfc_flags |= MFC_STATIC;
1472 err = rhltable_insert_key(&mrt->mfc_hash, &c->cmparg, &c->_c.mnode,
1475 pr_err("ip6mr: rhtable insert error %d\n", err);
1476 ip6mr_cache_free(c);
1479 list_add_tail_rcu(&c->_c.list, &mrt->mfc_cache_list);
1481 /* Check to see if we resolved a queued list. If so we
1482 * need to send on the frames and tidy up.
1485 spin_lock_bh(&mfc_unres_lock);
1486 list_for_each_entry(_uc, &mrt->mfc_unres_queue, list) {
1487 uc = (struct mfc6_cache *)_uc;
1488 if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
1489 ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
1490 list_del(&_uc->list);
1491 atomic_dec(&mrt->cache_resolve_queue_len);
1496 if (list_empty(&mrt->mfc_unres_queue))
1497 del_timer(&mrt->ipmr_expire_timer);
1498 spin_unlock_bh(&mfc_unres_lock);
1501 ip6mr_cache_resolve(net, mrt, uc, c);
1502 ip6mr_cache_free(uc);
1504 call_ip6mr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_ADD,
1506 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1511 * Close the multicast socket, and clear the vif tables etc
1514 static void mroute_clean_tables(struct mr_table *mrt, int flags)
1516 struct mr_mfc *c, *tmp;
1520 /* Shut down all active vif entries */
1521 if (flags & (MRT6_FLUSH_MIFS | MRT6_FLUSH_MIFS_STATIC)) {
1522 for (i = 0; i < mrt->maxvif; i++) {
1523 if (((mrt->vif_table[i].flags & VIFF_STATIC) &&
1524 !(flags & MRT6_FLUSH_MIFS_STATIC)) ||
1525 (!(mrt->vif_table[i].flags & VIFF_STATIC) && !(flags & MRT6_FLUSH_MIFS)))
1527 mif6_delete(mrt, i, 0, &list);
1529 unregister_netdevice_many(&list);
1532 /* Wipe the cache */
1533 if (flags & (MRT6_FLUSH_MFC | MRT6_FLUSH_MFC_STATIC)) {
1534 list_for_each_entry_safe(c, tmp, &mrt->mfc_cache_list, list) {
1535 if (((c->mfc_flags & MFC_STATIC) && !(flags & MRT6_FLUSH_MFC_STATIC)) ||
1536 (!(c->mfc_flags & MFC_STATIC) && !(flags & MRT6_FLUSH_MFC)))
1538 rhltable_remove(&mrt->mfc_hash, &c->mnode, ip6mr_rht_params);
1539 list_del_rcu(&c->list);
1540 call_ip6mr_mfc_entry_notifiers(read_pnet(&mrt->net),
1541 FIB_EVENT_ENTRY_DEL,
1542 (struct mfc6_cache *)c, mrt->id);
1543 mr6_netlink_event(mrt, (struct mfc6_cache *)c, RTM_DELROUTE);
1548 if (flags & MRT6_FLUSH_MFC) {
1549 if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
1550 spin_lock_bh(&mfc_unres_lock);
1551 list_for_each_entry_safe(c, tmp, &mrt->mfc_unres_queue, list) {
1553 mr6_netlink_event(mrt, (struct mfc6_cache *)c,
1555 ip6mr_destroy_unres(mrt, (struct mfc6_cache *)c);
1557 spin_unlock_bh(&mfc_unres_lock);
1562 static int ip6mr_sk_init(struct mr_table *mrt, struct sock *sk)
1565 struct net *net = sock_net(sk);
1568 write_lock_bh(&mrt_lock);
1569 if (rtnl_dereference(mrt->mroute_sk)) {
1572 rcu_assign_pointer(mrt->mroute_sk, sk);
1573 sock_set_flag(sk, SOCK_RCU_FREE);
1574 atomic_inc(&net->ipv6.devconf_all->mc_forwarding);
1576 write_unlock_bh(&mrt_lock);
1579 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
1580 NETCONFA_MC_FORWARDING,
1581 NETCONFA_IFINDEX_ALL,
1582 net->ipv6.devconf_all);
1588 int ip6mr_sk_done(struct sock *sk)
1590 struct net *net = sock_net(sk);
1591 struct ipv6_devconf *devconf;
1592 struct mr_table *mrt;
1595 if (sk->sk_type != SOCK_RAW ||
1596 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1599 devconf = net->ipv6.devconf_all;
1600 if (!devconf || !atomic_read(&devconf->mc_forwarding))
1604 ip6mr_for_each_table(mrt, net) {
1605 if (sk == rtnl_dereference(mrt->mroute_sk)) {
1606 write_lock_bh(&mrt_lock);
1607 RCU_INIT_POINTER(mrt->mroute_sk, NULL);
1608 /* Note that mroute_sk had SOCK_RCU_FREE set,
1609 * so the RCU grace period before sk freeing
1610 * is guaranteed by sk_destruct()
1612 atomic_dec(&devconf->mc_forwarding);
1613 write_unlock_bh(&mrt_lock);
1614 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
1615 NETCONFA_MC_FORWARDING,
1616 NETCONFA_IFINDEX_ALL,
1617 net->ipv6.devconf_all);
1619 mroute_clean_tables(mrt, MRT6_FLUSH_MIFS | MRT6_FLUSH_MFC);
1629 bool mroute6_is_socket(struct net *net, struct sk_buff *skb)
1631 struct mr_table *mrt;
1632 struct flowi6 fl6 = {
1633 .flowi6_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
1634 .flowi6_oif = skb->dev->ifindex,
1635 .flowi6_mark = skb->mark,
1638 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
1641 return rcu_access_pointer(mrt->mroute_sk);
1643 EXPORT_SYMBOL(mroute6_is_socket);
1646 * Socket options and virtual interface manipulation. The whole
1647 * virtual interface system is a complete heap, but unfortunately
1648 * that's how BSD mrouted happens to think. Maybe one day with a proper
1649 * MOSPF/PIM router set up we can clean this up.
1652 int ip6_mroute_setsockopt(struct sock *sk, int optname, sockptr_t optval,
1653 unsigned int optlen)
1655 int ret, parent = 0;
1659 struct net *net = sock_net(sk);
1660 struct mr_table *mrt;
1662 if (sk->sk_type != SOCK_RAW ||
1663 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1666 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1670 if (optname != MRT6_INIT) {
1671 if (sk != rcu_access_pointer(mrt->mroute_sk) &&
1672 !ns_capable(net->user_ns, CAP_NET_ADMIN))
1678 if (optlen < sizeof(int))
1681 return ip6mr_sk_init(mrt, sk);
1684 return ip6mr_sk_done(sk);
1687 if (optlen < sizeof(vif))
1689 if (copy_from_sockptr(&vif, optval, sizeof(vif)))
1691 if (vif.mif6c_mifi >= MAXMIFS)
1694 ret = mif6_add(net, mrt, &vif,
1695 sk == rtnl_dereference(mrt->mroute_sk));
1700 if (optlen < sizeof(mifi_t))
1702 if (copy_from_sockptr(&mifi, optval, sizeof(mifi_t)))
1705 ret = mif6_delete(mrt, mifi, 0, NULL);
1710 * Manipulate the forwarding caches. These live
1711 * in a sort of kernel/user symbiosis.
1717 case MRT6_ADD_MFC_PROXY:
1718 case MRT6_DEL_MFC_PROXY:
1719 if (optlen < sizeof(mfc))
1721 if (copy_from_sockptr(&mfc, optval, sizeof(mfc)))
1724 parent = mfc.mf6cc_parent;
1726 if (optname == MRT6_DEL_MFC || optname == MRT6_DEL_MFC_PROXY)
1727 ret = ip6mr_mfc_delete(mrt, &mfc, parent);
1729 ret = ip6mr_mfc_add(net, mrt, &mfc,
1731 rtnl_dereference(mrt->mroute_sk),
1740 if (optlen != sizeof(flags))
1742 if (copy_from_sockptr(&flags, optval, sizeof(flags)))
1745 mroute_clean_tables(mrt, flags);
1751 * Control PIM assert (to activate pim will activate assert)
1757 if (optlen != sizeof(v))
1759 if (copy_from_sockptr(&v, optval, sizeof(v)))
1761 mrt->mroute_do_assert = v;
1765 #ifdef CONFIG_IPV6_PIMSM_V2
1771 if (optlen != sizeof(v))
1773 if (copy_from_sockptr(&v, optval, sizeof(v)))
1776 do_wrmifwhole = (v == MRT6MSG_WRMIFWHOLE);
1780 if (v != mrt->mroute_do_pim) {
1781 mrt->mroute_do_pim = v;
1782 mrt->mroute_do_assert = v;
1783 mrt->mroute_do_wrvifwhole = do_wrmifwhole;
1790 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
1795 if (optlen != sizeof(u32))
1797 if (copy_from_sockptr(&v, optval, sizeof(v)))
1799 /* "pim6reg%u" should not exceed 16 bytes (IFNAMSIZ) */
1800 if (v != RT_TABLE_DEFAULT && v >= 100000000)
1802 if (sk == rcu_access_pointer(mrt->mroute_sk))
1807 mrt = ip6mr_new_table(net, v);
1811 raw6_sk(sk)->ip6mr_table = v;
1817 * Spurious command, or MRT6_VERSION which you cannot
1821 return -ENOPROTOOPT;
1826 * Getsock opt support for the multicast routing system.
1829 int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1834 struct net *net = sock_net(sk);
1835 struct mr_table *mrt;
1837 if (sk->sk_type != SOCK_RAW ||
1838 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1841 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1849 #ifdef CONFIG_IPV6_PIMSM_V2
1851 val = mrt->mroute_do_pim;
1855 val = mrt->mroute_do_assert;
1858 return -ENOPROTOOPT;
1861 if (get_user(olr, optlen))
1864 olr = min_t(int, olr, sizeof(int));
1868 if (put_user(olr, optlen))
1870 if (copy_to_user(optval, &val, olr))
1876 * The IP multicast ioctl support routines.
1879 int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1881 struct sioc_sg_req6 sr;
1882 struct sioc_mif_req6 vr;
1883 struct vif_device *vif;
1884 struct mfc6_cache *c;
1885 struct net *net = sock_net(sk);
1886 struct mr_table *mrt;
1888 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1893 case SIOCGETMIFCNT_IN6:
1894 if (copy_from_user(&vr, arg, sizeof(vr)))
1896 if (vr.mifi >= mrt->maxvif)
1898 vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
1900 vif = &mrt->vif_table[vr.mifi];
1901 if (VIF_EXISTS(mrt, vr.mifi)) {
1902 vr.icount = READ_ONCE(vif->pkt_in);
1903 vr.ocount = READ_ONCE(vif->pkt_out);
1904 vr.ibytes = READ_ONCE(vif->bytes_in);
1905 vr.obytes = READ_ONCE(vif->bytes_out);
1908 if (copy_to_user(arg, &vr, sizeof(vr)))
1913 return -EADDRNOTAVAIL;
1914 case SIOCGETSGCNT_IN6:
1915 if (copy_from_user(&sr, arg, sizeof(sr)))
1919 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1921 sr.pktcnt = c->_c.mfc_un.res.pkt;
1922 sr.bytecnt = c->_c.mfc_un.res.bytes;
1923 sr.wrong_if = c->_c.mfc_un.res.wrong_if;
1926 if (copy_to_user(arg, &sr, sizeof(sr)))
1931 return -EADDRNOTAVAIL;
1933 return -ENOIOCTLCMD;
1937 #ifdef CONFIG_COMPAT
1938 struct compat_sioc_sg_req6 {
1939 struct sockaddr_in6 src;
1940 struct sockaddr_in6 grp;
1941 compat_ulong_t pktcnt;
1942 compat_ulong_t bytecnt;
1943 compat_ulong_t wrong_if;
1946 struct compat_sioc_mif_req6 {
1948 compat_ulong_t icount;
1949 compat_ulong_t ocount;
1950 compat_ulong_t ibytes;
1951 compat_ulong_t obytes;
1954 int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1956 struct compat_sioc_sg_req6 sr;
1957 struct compat_sioc_mif_req6 vr;
1958 struct vif_device *vif;
1959 struct mfc6_cache *c;
1960 struct net *net = sock_net(sk);
1961 struct mr_table *mrt;
1963 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1968 case SIOCGETMIFCNT_IN6:
1969 if (copy_from_user(&vr, arg, sizeof(vr)))
1971 if (vr.mifi >= mrt->maxvif)
1973 vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
1975 vif = &mrt->vif_table[vr.mifi];
1976 if (VIF_EXISTS(mrt, vr.mifi)) {
1977 vr.icount = READ_ONCE(vif->pkt_in);
1978 vr.ocount = READ_ONCE(vif->pkt_out);
1979 vr.ibytes = READ_ONCE(vif->bytes_in);
1980 vr.obytes = READ_ONCE(vif->bytes_out);
1983 if (copy_to_user(arg, &vr, sizeof(vr)))
1988 return -EADDRNOTAVAIL;
1989 case SIOCGETSGCNT_IN6:
1990 if (copy_from_user(&sr, arg, sizeof(sr)))
1994 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1996 sr.pktcnt = c->_c.mfc_un.res.pkt;
1997 sr.bytecnt = c->_c.mfc_un.res.bytes;
1998 sr.wrong_if = c->_c.mfc_un.res.wrong_if;
2001 if (copy_to_user(arg, &sr, sizeof(sr)))
2006 return -EADDRNOTAVAIL;
2008 return -ENOIOCTLCMD;
2013 static inline int ip6mr_forward2_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
2015 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
2016 IPSTATS_MIB_OUTFORWDATAGRAMS);
2017 IP6_ADD_STATS(net, ip6_dst_idev(skb_dst(skb)),
2018 IPSTATS_MIB_OUTOCTETS, skb->len);
2019 return dst_output(net, sk, skb);
2023 * Processing handlers for ip6mr_forward
2026 static int ip6mr_forward2(struct net *net, struct mr_table *mrt,
2027 struct sk_buff *skb, int vifi)
2029 struct vif_device *vif = &mrt->vif_table[vifi];
2030 struct net_device *vif_dev;
2031 struct ipv6hdr *ipv6h;
2032 struct dst_entry *dst;
2035 vif_dev = vif_dev_read(vif);
2039 #ifdef CONFIG_IPV6_PIMSM_V2
2040 if (vif->flags & MIFF_REGISTER) {
2041 WRITE_ONCE(vif->pkt_out, vif->pkt_out + 1);
2042 WRITE_ONCE(vif->bytes_out, vif->bytes_out + skb->len);
2043 vif_dev->stats.tx_bytes += skb->len;
2044 vif_dev->stats.tx_packets++;
2045 ip6mr_cache_report(mrt, skb, vifi, MRT6MSG_WHOLEPKT);
2050 ipv6h = ipv6_hdr(skb);
2052 fl6 = (struct flowi6) {
2053 .flowi6_oif = vif->link,
2054 .daddr = ipv6h->daddr,
2057 dst = ip6_route_output(net, NULL, &fl6);
2064 skb_dst_set(skb, dst);
2067 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
2068 * not only before forwarding, but after forwarding on all output
2069 * interfaces. It is clear, if mrouter runs a multicasting
2070 * program, it should receive packets not depending to what interface
2071 * program is joined.
2072 * If we will not make it, the program will have to join on all
2073 * interfaces. On the other hand, multihoming host (or router, but
2074 * not mrouter) cannot join to more than one interface - it will
2075 * result in receiving multiple packets.
2078 WRITE_ONCE(vif->pkt_out, vif->pkt_out + 1);
2079 WRITE_ONCE(vif->bytes_out, vif->bytes_out + skb->len);
2081 /* We are about to write */
2082 /* XXX: extension headers? */
2083 if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(vif_dev)))
2086 ipv6h = ipv6_hdr(skb);
2089 IP6CB(skb)->flags |= IP6SKB_FORWARDED;
2091 return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD,
2092 net, NULL, skb, skb->dev, vif_dev,
2093 ip6mr_forward2_finish);
2100 /* Called with mrt_lock or rcu_read_lock() */
2101 static int ip6mr_find_vif(struct mr_table *mrt, struct net_device *dev)
2105 /* Pairs with WRITE_ONCE() in mif6_delete()/mif6_add() */
2106 for (ct = READ_ONCE(mrt->maxvif) - 1; ct >= 0; ct--) {
2107 if (rcu_access_pointer(mrt->vif_table[ct].dev) == dev)
2113 /* Called under rcu_read_lock() */
2114 static void ip6_mr_forward(struct net *net, struct mr_table *mrt,
2115 struct net_device *dev, struct sk_buff *skb,
2116 struct mfc6_cache *c)
2120 int true_vifi = ip6mr_find_vif(mrt, dev);
2122 vif = c->_c.mfc_parent;
2123 c->_c.mfc_un.res.pkt++;
2124 c->_c.mfc_un.res.bytes += skb->len;
2125 c->_c.mfc_un.res.lastuse = jiffies;
2127 if (ipv6_addr_any(&c->mf6c_origin) && true_vifi >= 0) {
2128 struct mfc6_cache *cache_proxy;
2130 /* For an (*,G) entry, we only check that the incoming
2131 * interface is part of the static tree.
2133 cache_proxy = mr_mfc_find_any_parent(mrt, vif);
2135 cache_proxy->_c.mfc_un.res.ttls[true_vifi] < 255) {
2142 * Wrong interface: drop packet and (maybe) send PIM assert.
2144 if (rcu_access_pointer(mrt->vif_table[vif].dev) != dev) {
2145 c->_c.mfc_un.res.wrong_if++;
2147 if (true_vifi >= 0 && mrt->mroute_do_assert &&
2148 /* pimsm uses asserts, when switching from RPT to SPT,
2149 so that we cannot check that packet arrived on an oif.
2150 It is bad, but otherwise we would need to move pretty
2151 large chunk of pimd to kernel. Ough... --ANK
2153 (mrt->mroute_do_pim ||
2154 c->_c.mfc_un.res.ttls[true_vifi] < 255) &&
2156 c->_c.mfc_un.res.last_assert +
2157 MFC_ASSERT_THRESH)) {
2158 c->_c.mfc_un.res.last_assert = jiffies;
2159 ip6mr_cache_report(mrt, skb, true_vifi, MRT6MSG_WRONGMIF);
2160 if (mrt->mroute_do_wrvifwhole)
2161 ip6mr_cache_report(mrt, skb, true_vifi,
2162 MRT6MSG_WRMIFWHOLE);
2168 WRITE_ONCE(mrt->vif_table[vif].pkt_in,
2169 mrt->vif_table[vif].pkt_in + 1);
2170 WRITE_ONCE(mrt->vif_table[vif].bytes_in,
2171 mrt->vif_table[vif].bytes_in + skb->len);
2176 if (ipv6_addr_any(&c->mf6c_origin) &&
2177 ipv6_addr_any(&c->mf6c_mcastgrp)) {
2178 if (true_vifi >= 0 &&
2179 true_vifi != c->_c.mfc_parent &&
2180 ipv6_hdr(skb)->hop_limit >
2181 c->_c.mfc_un.res.ttls[c->_c.mfc_parent]) {
2182 /* It's an (*,*) entry and the packet is not coming from
2183 * the upstream: forward the packet to the upstream
2186 psend = c->_c.mfc_parent;
2191 for (ct = c->_c.mfc_un.res.maxvif - 1;
2192 ct >= c->_c.mfc_un.res.minvif; ct--) {
2193 /* For (*,G) entry, don't forward to the incoming interface */
2194 if ((!ipv6_addr_any(&c->mf6c_origin) || ct != true_vifi) &&
2195 ipv6_hdr(skb)->hop_limit > c->_c.mfc_un.res.ttls[ct]) {
2197 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2199 ip6mr_forward2(net, mrt, skb2, psend);
2206 ip6mr_forward2(net, mrt, skb, psend);
2216 * Multicast packets for forwarding arrive here
2219 int ip6_mr_input(struct sk_buff *skb)
2221 struct mfc6_cache *cache;
2222 struct net *net = dev_net(skb->dev);
2223 struct mr_table *mrt;
2224 struct flowi6 fl6 = {
2225 .flowi6_iif = skb->dev->ifindex,
2226 .flowi6_mark = skb->mark,
2229 struct net_device *dev;
2231 /* skb->dev passed in is the master dev for vrfs.
2232 * Get the proper interface that does have a vif associated with it.
2235 if (netif_is_l3_master(skb->dev)) {
2236 dev = dev_get_by_index_rcu(net, IPCB(skb)->iif);
2243 err = ip6mr_fib_lookup(net, &fl6, &mrt);
2249 cache = ip6mr_cache_find(mrt,
2250 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
2252 int vif = ip6mr_find_vif(mrt, dev);
2255 cache = ip6mr_cache_find_any(mrt,
2256 &ipv6_hdr(skb)->daddr,
2261 * No usable cache entry
2266 vif = ip6mr_find_vif(mrt, dev);
2268 int err = ip6mr_cache_unresolved(mrt, vif, skb, dev);
2276 ip6_mr_forward(net, mrt, dev, skb, cache);
2281 int ip6mr_get_route(struct net *net, struct sk_buff *skb, struct rtmsg *rtm,
2285 struct mr_table *mrt;
2286 struct mfc6_cache *cache;
2287 struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
2289 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
2294 cache = ip6mr_cache_find(mrt, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
2295 if (!cache && skb->dev) {
2296 int vif = ip6mr_find_vif(mrt, skb->dev);
2299 cache = ip6mr_cache_find_any(mrt, &rt->rt6i_dst.addr,
2304 struct sk_buff *skb2;
2305 struct ipv6hdr *iph;
2306 struct net_device *dev;
2310 if (!dev || (vif = ip6mr_find_vif(mrt, dev)) < 0) {
2315 /* really correct? */
2316 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
2322 NETLINK_CB(skb2).portid = portid;
2323 skb_reset_transport_header(skb2);
2325 skb_put(skb2, sizeof(struct ipv6hdr));
2326 skb_reset_network_header(skb2);
2328 iph = ipv6_hdr(skb2);
2331 iph->flow_lbl[0] = 0;
2332 iph->flow_lbl[1] = 0;
2333 iph->flow_lbl[2] = 0;
2334 iph->payload_len = 0;
2335 iph->nexthdr = IPPROTO_NONE;
2337 iph->saddr = rt->rt6i_src.addr;
2338 iph->daddr = rt->rt6i_dst.addr;
2340 err = ip6mr_cache_unresolved(mrt, vif, skb2, dev);
2346 err = mr_fill_mroute(mrt, skb, &cache->_c, rtm);
2351 static int ip6mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
2352 u32 portid, u32 seq, struct mfc6_cache *c, int cmd,
2355 struct nlmsghdr *nlh;
2359 nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
2363 rtm = nlmsg_data(nlh);
2364 rtm->rtm_family = RTNL_FAMILY_IP6MR;
2365 rtm->rtm_dst_len = 128;
2366 rtm->rtm_src_len = 128;
2368 rtm->rtm_table = mrt->id;
2369 if (nla_put_u32(skb, RTA_TABLE, mrt->id))
2370 goto nla_put_failure;
2371 rtm->rtm_type = RTN_MULTICAST;
2372 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2373 if (c->_c.mfc_flags & MFC_STATIC)
2374 rtm->rtm_protocol = RTPROT_STATIC;
2376 rtm->rtm_protocol = RTPROT_MROUTED;
2379 if (nla_put_in6_addr(skb, RTA_SRC, &c->mf6c_origin) ||
2380 nla_put_in6_addr(skb, RTA_DST, &c->mf6c_mcastgrp))
2381 goto nla_put_failure;
2382 err = mr_fill_mroute(mrt, skb, &c->_c, rtm);
2383 /* do not break the dump if cache is unresolved */
2384 if (err < 0 && err != -ENOENT)
2385 goto nla_put_failure;
2387 nlmsg_end(skb, nlh);
2391 nlmsg_cancel(skb, nlh);
2395 static int _ip6mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
2396 u32 portid, u32 seq, struct mr_mfc *c,
2399 return ip6mr_fill_mroute(mrt, skb, portid, seq, (struct mfc6_cache *)c,
2403 static int mr6_msgsize(bool unresolved, int maxvif)
2406 NLMSG_ALIGN(sizeof(struct rtmsg))
2407 + nla_total_size(4) /* RTA_TABLE */
2408 + nla_total_size(sizeof(struct in6_addr)) /* RTA_SRC */
2409 + nla_total_size(sizeof(struct in6_addr)) /* RTA_DST */
2414 + nla_total_size(4) /* RTA_IIF */
2415 + nla_total_size(0) /* RTA_MULTIPATH */
2416 + maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
2418 + nla_total_size_64bit(sizeof(struct rta_mfc_stats))
2424 static void mr6_netlink_event(struct mr_table *mrt, struct mfc6_cache *mfc,
2427 struct net *net = read_pnet(&mrt->net);
2428 struct sk_buff *skb;
2431 skb = nlmsg_new(mr6_msgsize(mfc->_c.mfc_parent >= MAXMIFS, mrt->maxvif),
2436 err = ip6mr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
2440 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE, NULL, GFP_ATOMIC);
2446 rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE, err);
2449 static size_t mrt6msg_netlink_msgsize(size_t payloadlen)
2452 NLMSG_ALIGN(sizeof(struct rtgenmsg))
2453 + nla_total_size(1) /* IP6MRA_CREPORT_MSGTYPE */
2454 + nla_total_size(4) /* IP6MRA_CREPORT_MIF_ID */
2455 /* IP6MRA_CREPORT_SRC_ADDR */
2456 + nla_total_size(sizeof(struct in6_addr))
2457 /* IP6MRA_CREPORT_DST_ADDR */
2458 + nla_total_size(sizeof(struct in6_addr))
2459 /* IP6MRA_CREPORT_PKT */
2460 + nla_total_size(payloadlen)
2466 static void mrt6msg_netlink_event(const struct mr_table *mrt, struct sk_buff *pkt)
2468 struct net *net = read_pnet(&mrt->net);
2469 struct nlmsghdr *nlh;
2470 struct rtgenmsg *rtgenm;
2471 struct mrt6msg *msg;
2472 struct sk_buff *skb;
2476 payloadlen = pkt->len - sizeof(struct mrt6msg);
2477 msg = (struct mrt6msg *)skb_transport_header(pkt);
2479 skb = nlmsg_new(mrt6msg_netlink_msgsize(payloadlen), GFP_ATOMIC);
2483 nlh = nlmsg_put(skb, 0, 0, RTM_NEWCACHEREPORT,
2484 sizeof(struct rtgenmsg), 0);
2487 rtgenm = nlmsg_data(nlh);
2488 rtgenm->rtgen_family = RTNL_FAMILY_IP6MR;
2489 if (nla_put_u8(skb, IP6MRA_CREPORT_MSGTYPE, msg->im6_msgtype) ||
2490 nla_put_u32(skb, IP6MRA_CREPORT_MIF_ID, msg->im6_mif) ||
2491 nla_put_in6_addr(skb, IP6MRA_CREPORT_SRC_ADDR,
2493 nla_put_in6_addr(skb, IP6MRA_CREPORT_DST_ADDR,
2495 goto nla_put_failure;
2497 nla = nla_reserve(skb, IP6MRA_CREPORT_PKT, payloadlen);
2498 if (!nla || skb_copy_bits(pkt, sizeof(struct mrt6msg),
2499 nla_data(nla), payloadlen))
2500 goto nla_put_failure;
2502 nlmsg_end(skb, nlh);
2504 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE_R, NULL, GFP_ATOMIC);
2508 nlmsg_cancel(skb, nlh);
2511 rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE_R, -ENOBUFS);
2514 static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2516 const struct nlmsghdr *nlh = cb->nlh;
2517 struct fib_dump_filter filter = {};
2520 if (cb->strict_check) {
2521 err = ip_valid_fib_dump_req(sock_net(skb->sk), nlh,
2527 if (filter.table_id) {
2528 struct mr_table *mrt;
2530 mrt = ip6mr_get_table(sock_net(skb->sk), filter.table_id);
2532 if (rtnl_msg_family(cb->nlh) != RTNL_FAMILY_IP6MR)
2535 NL_SET_ERR_MSG_MOD(cb->extack, "MR table does not exist");
2538 err = mr_table_dump(mrt, skb, cb, _ip6mr_fill_mroute,
2539 &mfc_unres_lock, &filter);
2540 return skb->len ? : err;
2543 return mr_rtm_dumproute(skb, cb, ip6mr_mr_table_iter,
2544 _ip6mr_fill_mroute, &mfc_unres_lock, &filter);