1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * IP multicast routing support for mrouted 3.6/3.8
5 * (c) 1995 Alan Cox, <alan@lxorguk.ukuu.org.uk>
6 * Linux Consultancy and Custom Driver Development
9 * Michael Chastain : Incorrect size of copying.
10 * Alan Cox : Added the cache manager code
11 * Alan Cox : Fixed the clone/copy bug and device race.
12 * Mike McLagan : Routing by source
13 * Malcolm Beattie : Buffer handling fixes.
14 * Alexey Kuznetsov : Double buffer free and other fixes.
15 * SVR Anand : Fixed several multicast bugs and problems.
16 * Alexey Kuznetsov : Status, optimisations and more.
17 * Brad Parker : Better behaviour on mrouted upcall
19 * Carlos Picoto : PIMv1 Support
20 * Pavlin Ivanov Radoslavov: PIMv2 Registers must checksum only PIM header
21 * Relax this requirement to work with older peers.
24 #include <linux/uaccess.h>
25 #include <linux/types.h>
26 #include <linux/cache.h>
27 #include <linux/capability.h>
28 #include <linux/errno.h>
30 #include <linux/kernel.h>
31 #include <linux/fcntl.h>
32 #include <linux/stat.h>
33 #include <linux/socket.h>
35 #include <linux/inet.h>
36 #include <linux/netdevice.h>
37 #include <linux/inetdevice.h>
38 #include <linux/igmp.h>
39 #include <linux/proc_fs.h>
40 #include <linux/seq_file.h>
41 #include <linux/mroute.h>
42 #include <linux/init.h>
43 #include <linux/if_ether.h>
44 #include <linux/slab.h>
45 #include <net/net_namespace.h>
47 #include <net/protocol.h>
48 #include <linux/skbuff.h>
49 #include <net/route.h>
53 #include <linux/notifier.h>
54 #include <linux/if_arp.h>
55 #include <linux/netfilter_ipv4.h>
56 #include <linux/compat.h>
57 #include <linux/export.h>
58 #include <linux/rhashtable.h>
59 #include <net/ip_tunnels.h>
60 #include <net/checksum.h>
61 #include <net/netlink.h>
62 #include <net/fib_rules.h>
63 #include <linux/netconf.h>
66 #include <linux/nospec.h>
69 struct fib_rule common
;
76 /* Big lock, protecting vif table, mrt cache and mroute socket state.
77 * Note that the changes are semaphored via rtnl_lock.
80 static DEFINE_RWLOCK(mrt_lock
);
82 /* Multicast router control variables */
84 /* Special spinlock for queue of unresolved entries */
85 static DEFINE_SPINLOCK(mfc_unres_lock
);
87 /* We return to original Alan's scheme. Hash table of resolved
88 * entries is changed only in process context and protected
89 * with weak lock mrt_lock. Queue of unresolved entries is protected
90 * with strong spinlock mfc_unres_lock.
92 * In this case data path is free of exclusive locks at all.
95 static struct kmem_cache
*mrt_cachep __ro_after_init
;
97 static struct mr_table
*ipmr_new_table(struct net
*net
, u32 id
);
98 static void ipmr_free_table(struct mr_table
*mrt
);
100 static void ip_mr_forward(struct net
*net
, struct mr_table
*mrt
,
101 struct net_device
*dev
, struct sk_buff
*skb
,
102 struct mfc_cache
*cache
, int local
);
103 static int ipmr_cache_report(struct mr_table
*mrt
,
104 struct sk_buff
*pkt
, vifi_t vifi
, int assert);
105 static void mroute_netlink_event(struct mr_table
*mrt
, struct mfc_cache
*mfc
,
107 static void igmpmsg_netlink_event(struct mr_table
*mrt
, struct sk_buff
*pkt
);
108 static void mroute_clean_tables(struct mr_table
*mrt
, int flags
);
109 static void ipmr_expire_process(struct timer_list
*t
);
111 #ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
112 #define ipmr_for_each_table(mrt, net) \
113 list_for_each_entry_rcu(mrt, &net->ipv4.mr_tables, list, \
114 lockdep_rtnl_is_held() || \
115 list_empty(&net->ipv4.mr_tables))
117 static struct mr_table
*ipmr_mr_table_iter(struct net
*net
,
118 struct mr_table
*mrt
)
120 struct mr_table
*ret
;
123 ret
= list_entry_rcu(net
->ipv4
.mr_tables
.next
,
124 struct mr_table
, list
);
126 ret
= list_entry_rcu(mrt
->list
.next
,
127 struct mr_table
, list
);
129 if (&ret
->list
== &net
->ipv4
.mr_tables
)
134 static struct mr_table
*ipmr_get_table(struct net
*net
, u32 id
)
136 struct mr_table
*mrt
;
138 ipmr_for_each_table(mrt
, net
) {
145 static int ipmr_fib_lookup(struct net
*net
, struct flowi4
*flp4
,
146 struct mr_table
**mrt
)
149 struct ipmr_result res
;
150 struct fib_lookup_arg arg
= {
152 .flags
= FIB_LOOKUP_NOREF
,
155 /* update flow if oif or iif point to device enslaved to l3mdev */
156 l3mdev_update_flow(net
, flowi4_to_flowi(flp4
));
158 err
= fib_rules_lookup(net
->ipv4
.mr_rules_ops
,
159 flowi4_to_flowi(flp4
), 0, &arg
);
166 static int ipmr_rule_action(struct fib_rule
*rule
, struct flowi
*flp
,
167 int flags
, struct fib_lookup_arg
*arg
)
169 struct ipmr_result
*res
= arg
->result
;
170 struct mr_table
*mrt
;
172 switch (rule
->action
) {
175 case FR_ACT_UNREACHABLE
:
177 case FR_ACT_PROHIBIT
:
179 case FR_ACT_BLACKHOLE
:
184 arg
->table
= fib_rule_get_table(rule
, arg
);
186 mrt
= ipmr_get_table(rule
->fr_net
, arg
->table
);
193 static int ipmr_rule_match(struct fib_rule
*rule
, struct flowi
*fl
, int flags
)
198 static const struct nla_policy ipmr_rule_policy
[FRA_MAX
+ 1] = {
202 static int ipmr_rule_configure(struct fib_rule
*rule
, struct sk_buff
*skb
,
203 struct fib_rule_hdr
*frh
, struct nlattr
**tb
,
204 struct netlink_ext_ack
*extack
)
209 static int ipmr_rule_compare(struct fib_rule
*rule
, struct fib_rule_hdr
*frh
,
215 static int ipmr_rule_fill(struct fib_rule
*rule
, struct sk_buff
*skb
,
216 struct fib_rule_hdr
*frh
)
224 static const struct fib_rules_ops __net_initconst ipmr_rules_ops_template
= {
225 .family
= RTNL_FAMILY_IPMR
,
226 .rule_size
= sizeof(struct ipmr_rule
),
227 .addr_size
= sizeof(u32
),
228 .action
= ipmr_rule_action
,
229 .match
= ipmr_rule_match
,
230 .configure
= ipmr_rule_configure
,
231 .compare
= ipmr_rule_compare
,
232 .fill
= ipmr_rule_fill
,
233 .nlgroup
= RTNLGRP_IPV4_RULE
,
234 .policy
= ipmr_rule_policy
,
235 .owner
= THIS_MODULE
,
238 static int __net_init
ipmr_rules_init(struct net
*net
)
240 struct fib_rules_ops
*ops
;
241 struct mr_table
*mrt
;
244 ops
= fib_rules_register(&ipmr_rules_ops_template
, net
);
248 INIT_LIST_HEAD(&net
->ipv4
.mr_tables
);
250 mrt
= ipmr_new_table(net
, RT_TABLE_DEFAULT
);
256 err
= fib_default_rule_add(ops
, 0x7fff, RT_TABLE_DEFAULT
, 0);
260 net
->ipv4
.mr_rules_ops
= ops
;
264 ipmr_free_table(mrt
);
266 fib_rules_unregister(ops
);
270 static void __net_exit
ipmr_rules_exit(struct net
*net
)
272 struct mr_table
*mrt
, *next
;
275 list_for_each_entry_safe(mrt
, next
, &net
->ipv4
.mr_tables
, list
) {
276 list_del(&mrt
->list
);
277 ipmr_free_table(mrt
);
279 fib_rules_unregister(net
->ipv4
.mr_rules_ops
);
283 static int ipmr_rules_dump(struct net
*net
, struct notifier_block
*nb
,
284 struct netlink_ext_ack
*extack
)
286 return fib_rules_dump(net
, nb
, RTNL_FAMILY_IPMR
, extack
);
289 static unsigned int ipmr_rules_seq_read(struct net
*net
)
291 return fib_rules_seq_read(net
, RTNL_FAMILY_IPMR
);
294 bool ipmr_rule_default(const struct fib_rule
*rule
)
296 return fib_rule_matchall(rule
) && rule
->table
== RT_TABLE_DEFAULT
;
298 EXPORT_SYMBOL(ipmr_rule_default
);
300 #define ipmr_for_each_table(mrt, net) \
301 for (mrt = net->ipv4.mrt; mrt; mrt = NULL)
303 static struct mr_table
*ipmr_mr_table_iter(struct net
*net
,
304 struct mr_table
*mrt
)
307 return net
->ipv4
.mrt
;
311 static struct mr_table
*ipmr_get_table(struct net
*net
, u32 id
)
313 return net
->ipv4
.mrt
;
316 static int ipmr_fib_lookup(struct net
*net
, struct flowi4
*flp4
,
317 struct mr_table
**mrt
)
319 *mrt
= net
->ipv4
.mrt
;
323 static int __net_init
ipmr_rules_init(struct net
*net
)
325 struct mr_table
*mrt
;
327 mrt
= ipmr_new_table(net
, RT_TABLE_DEFAULT
);
334 static void __net_exit
ipmr_rules_exit(struct net
*net
)
337 ipmr_free_table(net
->ipv4
.mrt
);
338 net
->ipv4
.mrt
= NULL
;
342 static int ipmr_rules_dump(struct net
*net
, struct notifier_block
*nb
,
343 struct netlink_ext_ack
*extack
)
348 static unsigned int ipmr_rules_seq_read(struct net
*net
)
353 bool ipmr_rule_default(const struct fib_rule
*rule
)
357 EXPORT_SYMBOL(ipmr_rule_default
);
360 static inline int ipmr_hash_cmp(struct rhashtable_compare_arg
*arg
,
363 const struct mfc_cache_cmp_arg
*cmparg
= arg
->key
;
364 struct mfc_cache
*c
= (struct mfc_cache
*)ptr
;
366 return cmparg
->mfc_mcastgrp
!= c
->mfc_mcastgrp
||
367 cmparg
->mfc_origin
!= c
->mfc_origin
;
370 static const struct rhashtable_params ipmr_rht_params
= {
371 .head_offset
= offsetof(struct mr_mfc
, mnode
),
372 .key_offset
= offsetof(struct mfc_cache
, cmparg
),
373 .key_len
= sizeof(struct mfc_cache_cmp_arg
),
375 .obj_cmpfn
= ipmr_hash_cmp
,
376 .automatic_shrinking
= true,
379 static void ipmr_new_table_set(struct mr_table
*mrt
,
382 #ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
383 list_add_tail_rcu(&mrt
->list
, &net
->ipv4
.mr_tables
);
387 static struct mfc_cache_cmp_arg ipmr_mr_table_ops_cmparg_any
= {
388 .mfc_mcastgrp
= htonl(INADDR_ANY
),
389 .mfc_origin
= htonl(INADDR_ANY
),
392 static struct mr_table_ops ipmr_mr_table_ops
= {
393 .rht_params
= &ipmr_rht_params
,
394 .cmparg_any
= &ipmr_mr_table_ops_cmparg_any
,
397 static struct mr_table
*ipmr_new_table(struct net
*net
, u32 id
)
399 struct mr_table
*mrt
;
401 /* "pimreg%u" should not exceed 16 bytes (IFNAMSIZ) */
402 if (id
!= RT_TABLE_DEFAULT
&& id
>= 1000000000)
403 return ERR_PTR(-EINVAL
);
405 mrt
= ipmr_get_table(net
, id
);
409 return mr_table_alloc(net
, id
, &ipmr_mr_table_ops
,
410 ipmr_expire_process
, ipmr_new_table_set
);
413 static void ipmr_free_table(struct mr_table
*mrt
)
415 del_timer_sync(&mrt
->ipmr_expire_timer
);
416 mroute_clean_tables(mrt
, MRT_FLUSH_VIFS
| MRT_FLUSH_VIFS_STATIC
|
417 MRT_FLUSH_MFC
| MRT_FLUSH_MFC_STATIC
);
418 rhltable_destroy(&mrt
->mfc_hash
);
422 /* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
424 static void ipmr_del_tunnel(struct net_device
*dev
, struct vifctl
*v
)
426 struct net
*net
= dev_net(dev
);
430 dev
= __dev_get_by_name(net
, "tunl0");
432 const struct net_device_ops
*ops
= dev
->netdev_ops
;
434 struct ip_tunnel_parm p
;
436 memset(&p
, 0, sizeof(p
));
437 p
.iph
.daddr
= v
->vifc_rmt_addr
.s_addr
;
438 p
.iph
.saddr
= v
->vifc_lcl_addr
.s_addr
;
441 p
.iph
.protocol
= IPPROTO_IPIP
;
442 sprintf(p
.name
, "dvmrp%d", v
->vifc_vifi
);
443 ifr
.ifr_ifru
.ifru_data
= (__force
void __user
*)&p
;
445 if (ops
->ndo_do_ioctl
) {
446 mm_segment_t oldfs
= get_fs();
449 ops
->ndo_do_ioctl(dev
, &ifr
, SIOCDELTUNNEL
);
455 /* Initialize ipmr pimreg/tunnel in_device */
456 static bool ipmr_init_vif_indev(const struct net_device
*dev
)
458 struct in_device
*in_dev
;
462 in_dev
= __in_dev_get_rtnl(dev
);
465 ipv4_devconf_setall(in_dev
);
466 neigh_parms_data_state_setall(in_dev
->arp_parms
);
467 IPV4_DEVCONF(in_dev
->cnf
, RP_FILTER
) = 0;
472 static struct net_device
*ipmr_new_tunnel(struct net
*net
, struct vifctl
*v
)
474 struct net_device
*dev
;
476 dev
= __dev_get_by_name(net
, "tunl0");
479 const struct net_device_ops
*ops
= dev
->netdev_ops
;
482 struct ip_tunnel_parm p
;
484 memset(&p
, 0, sizeof(p
));
485 p
.iph
.daddr
= v
->vifc_rmt_addr
.s_addr
;
486 p
.iph
.saddr
= v
->vifc_lcl_addr
.s_addr
;
489 p
.iph
.protocol
= IPPROTO_IPIP
;
490 sprintf(p
.name
, "dvmrp%d", v
->vifc_vifi
);
491 ifr
.ifr_ifru
.ifru_data
= (__force
void __user
*)&p
;
493 if (ops
->ndo_do_ioctl
) {
494 mm_segment_t oldfs
= get_fs();
497 err
= ops
->ndo_do_ioctl(dev
, &ifr
, SIOCADDTUNNEL
);
505 (dev
= __dev_get_by_name(net
, p
.name
)) != NULL
) {
506 dev
->flags
|= IFF_MULTICAST
;
507 if (!ipmr_init_vif_indev(dev
))
509 if (dev_open(dev
, NULL
))
517 unregister_netdevice(dev
);
521 #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
522 static netdev_tx_t
reg_vif_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
524 struct net
*net
= dev_net(dev
);
525 struct mr_table
*mrt
;
526 struct flowi4 fl4
= {
527 .flowi4_oif
= dev
->ifindex
,
528 .flowi4_iif
= skb
->skb_iif
? : LOOPBACK_IFINDEX
,
529 .flowi4_mark
= skb
->mark
,
533 err
= ipmr_fib_lookup(net
, &fl4
, &mrt
);
539 read_lock(&mrt_lock
);
540 dev
->stats
.tx_bytes
+= skb
->len
;
541 dev
->stats
.tx_packets
++;
542 ipmr_cache_report(mrt
, skb
, mrt
->mroute_reg_vif_num
, IGMPMSG_WHOLEPKT
);
543 read_unlock(&mrt_lock
);
548 static int reg_vif_get_iflink(const struct net_device
*dev
)
553 static const struct net_device_ops reg_vif_netdev_ops
= {
554 .ndo_start_xmit
= reg_vif_xmit
,
555 .ndo_get_iflink
= reg_vif_get_iflink
,
558 static void reg_vif_setup(struct net_device
*dev
)
560 dev
->type
= ARPHRD_PIMREG
;
561 dev
->mtu
= ETH_DATA_LEN
- sizeof(struct iphdr
) - 8;
562 dev
->flags
= IFF_NOARP
;
563 dev
->netdev_ops
= ®_vif_netdev_ops
;
564 dev
->needs_free_netdev
= true;
565 dev
->features
|= NETIF_F_NETNS_LOCAL
;
568 static struct net_device
*ipmr_reg_vif(struct net
*net
, struct mr_table
*mrt
)
570 struct net_device
*dev
;
573 if (mrt
->id
== RT_TABLE_DEFAULT
)
574 sprintf(name
, "pimreg");
576 sprintf(name
, "pimreg%u", mrt
->id
);
578 dev
= alloc_netdev(0, name
, NET_NAME_UNKNOWN
, reg_vif_setup
);
583 dev_net_set(dev
, net
);
585 if (register_netdevice(dev
)) {
590 if (!ipmr_init_vif_indev(dev
))
592 if (dev_open(dev
, NULL
))
600 unregister_netdevice(dev
);
604 /* called with rcu_read_lock() */
605 static int __pim_rcv(struct mr_table
*mrt
, struct sk_buff
*skb
,
608 struct net_device
*reg_dev
= NULL
;
611 encap
= (struct iphdr
*)(skb_transport_header(skb
) + pimlen
);
613 * a. packet is really sent to a multicast group
614 * b. packet is not a NULL-REGISTER
615 * c. packet is not truncated
617 if (!ipv4_is_multicast(encap
->daddr
) ||
618 encap
->tot_len
== 0 ||
619 ntohs(encap
->tot_len
) + pimlen
> skb
->len
)
622 read_lock(&mrt_lock
);
623 if (mrt
->mroute_reg_vif_num
>= 0)
624 reg_dev
= mrt
->vif_table
[mrt
->mroute_reg_vif_num
].dev
;
625 read_unlock(&mrt_lock
);
630 skb
->mac_header
= skb
->network_header
;
631 skb_pull(skb
, (u8
*)encap
- skb
->data
);
632 skb_reset_network_header(skb
);
633 skb
->protocol
= htons(ETH_P_IP
);
634 skb
->ip_summed
= CHECKSUM_NONE
;
636 skb_tunnel_rx(skb
, reg_dev
, dev_net(reg_dev
));
640 return NET_RX_SUCCESS
;
643 static struct net_device
*ipmr_reg_vif(struct net
*net
, struct mr_table
*mrt
)
649 static int call_ipmr_vif_entry_notifiers(struct net
*net
,
650 enum fib_event_type event_type
,
651 struct vif_device
*vif
,
652 vifi_t vif_index
, u32 tb_id
)
654 return mr_call_vif_notifiers(net
, RTNL_FAMILY_IPMR
, event_type
,
655 vif
, vif_index
, tb_id
,
656 &net
->ipv4
.ipmr_seq
);
659 static int call_ipmr_mfc_entry_notifiers(struct net
*net
,
660 enum fib_event_type event_type
,
661 struct mfc_cache
*mfc
, u32 tb_id
)
663 return mr_call_mfc_notifiers(net
, RTNL_FAMILY_IPMR
, event_type
,
664 &mfc
->_c
, tb_id
, &net
->ipv4
.ipmr_seq
);
668 * vif_delete - Delete a VIF entry
669 * @notify: Set to 1, if the caller is a notifier_call
671 static int vif_delete(struct mr_table
*mrt
, int vifi
, int notify
,
672 struct list_head
*head
)
674 struct net
*net
= read_pnet(&mrt
->net
);
675 struct vif_device
*v
;
676 struct net_device
*dev
;
677 struct in_device
*in_dev
;
679 if (vifi
< 0 || vifi
>= mrt
->maxvif
)
680 return -EADDRNOTAVAIL
;
682 v
= &mrt
->vif_table
[vifi
];
684 if (VIF_EXISTS(mrt
, vifi
))
685 call_ipmr_vif_entry_notifiers(net
, FIB_EVENT_VIF_DEL
, v
, vifi
,
688 write_lock_bh(&mrt_lock
);
693 write_unlock_bh(&mrt_lock
);
694 return -EADDRNOTAVAIL
;
697 if (vifi
== mrt
->mroute_reg_vif_num
)
698 mrt
->mroute_reg_vif_num
= -1;
700 if (vifi
+ 1 == mrt
->maxvif
) {
703 for (tmp
= vifi
- 1; tmp
>= 0; tmp
--) {
704 if (VIF_EXISTS(mrt
, tmp
))
710 write_unlock_bh(&mrt_lock
);
712 dev_set_allmulti(dev
, -1);
714 in_dev
= __in_dev_get_rtnl(dev
);
716 IPV4_DEVCONF(in_dev
->cnf
, MC_FORWARDING
)--;
717 inet_netconf_notify_devconf(dev_net(dev
), RTM_NEWNETCONF
,
718 NETCONFA_MC_FORWARDING
,
719 dev
->ifindex
, &in_dev
->cnf
);
720 ip_rt_multicast_event(in_dev
);
723 if (v
->flags
& (VIFF_TUNNEL
| VIFF_REGISTER
) && !notify
)
724 unregister_netdevice_queue(dev
, head
);
730 static void ipmr_cache_free_rcu(struct rcu_head
*head
)
732 struct mr_mfc
*c
= container_of(head
, struct mr_mfc
, rcu
);
734 kmem_cache_free(mrt_cachep
, (struct mfc_cache
*)c
);
737 static void ipmr_cache_free(struct mfc_cache
*c
)
739 call_rcu(&c
->_c
.rcu
, ipmr_cache_free_rcu
);
742 /* Destroy an unresolved cache entry, killing queued skbs
743 * and reporting error to netlink readers.
745 static void ipmr_destroy_unres(struct mr_table
*mrt
, struct mfc_cache
*c
)
747 struct net
*net
= read_pnet(&mrt
->net
);
751 atomic_dec(&mrt
->cache_resolve_queue_len
);
753 while ((skb
= skb_dequeue(&c
->_c
.mfc_un
.unres
.unresolved
))) {
754 if (ip_hdr(skb
)->version
== 0) {
755 struct nlmsghdr
*nlh
= skb_pull(skb
,
756 sizeof(struct iphdr
));
757 nlh
->nlmsg_type
= NLMSG_ERROR
;
758 nlh
->nlmsg_len
= nlmsg_msg_size(sizeof(struct nlmsgerr
));
759 skb_trim(skb
, nlh
->nlmsg_len
);
761 e
->error
= -ETIMEDOUT
;
762 memset(&e
->msg
, 0, sizeof(e
->msg
));
764 rtnl_unicast(skb
, net
, NETLINK_CB(skb
).portid
);
773 /* Timer process for the unresolved queue. */
774 static void ipmr_expire_process(struct timer_list
*t
)
776 struct mr_table
*mrt
= from_timer(mrt
, t
, ipmr_expire_timer
);
777 struct mr_mfc
*c
, *next
;
778 unsigned long expires
;
781 if (!spin_trylock(&mfc_unres_lock
)) {
782 mod_timer(&mrt
->ipmr_expire_timer
, jiffies
+HZ
/10);
786 if (list_empty(&mrt
->mfc_unres_queue
))
792 list_for_each_entry_safe(c
, next
, &mrt
->mfc_unres_queue
, list
) {
793 if (time_after(c
->mfc_un
.unres
.expires
, now
)) {
794 unsigned long interval
= c
->mfc_un
.unres
.expires
- now
;
795 if (interval
< expires
)
801 mroute_netlink_event(mrt
, (struct mfc_cache
*)c
, RTM_DELROUTE
);
802 ipmr_destroy_unres(mrt
, (struct mfc_cache
*)c
);
805 if (!list_empty(&mrt
->mfc_unres_queue
))
806 mod_timer(&mrt
->ipmr_expire_timer
, jiffies
+ expires
);
809 spin_unlock(&mfc_unres_lock
);
812 /* Fill oifs list. It is called under write locked mrt_lock. */
813 static void ipmr_update_thresholds(struct mr_table
*mrt
, struct mr_mfc
*cache
,
818 cache
->mfc_un
.res
.minvif
= MAXVIFS
;
819 cache
->mfc_un
.res
.maxvif
= 0;
820 memset(cache
->mfc_un
.res
.ttls
, 255, MAXVIFS
);
822 for (vifi
= 0; vifi
< mrt
->maxvif
; vifi
++) {
823 if (VIF_EXISTS(mrt
, vifi
) &&
824 ttls
[vifi
] && ttls
[vifi
] < 255) {
825 cache
->mfc_un
.res
.ttls
[vifi
] = ttls
[vifi
];
826 if (cache
->mfc_un
.res
.minvif
> vifi
)
827 cache
->mfc_un
.res
.minvif
= vifi
;
828 if (cache
->mfc_un
.res
.maxvif
<= vifi
)
829 cache
->mfc_un
.res
.maxvif
= vifi
+ 1;
832 cache
->mfc_un
.res
.lastuse
= jiffies
;
835 static int vif_add(struct net
*net
, struct mr_table
*mrt
,
836 struct vifctl
*vifc
, int mrtsock
)
838 struct netdev_phys_item_id ppid
= { };
839 int vifi
= vifc
->vifc_vifi
;
840 struct vif_device
*v
= &mrt
->vif_table
[vifi
];
841 struct net_device
*dev
;
842 struct in_device
*in_dev
;
846 if (VIF_EXISTS(mrt
, vifi
))
849 switch (vifc
->vifc_flags
) {
851 if (!ipmr_pimsm_enabled())
853 /* Special Purpose VIF in PIM
854 * All the packets will be sent to the daemon
856 if (mrt
->mroute_reg_vif_num
>= 0)
858 dev
= ipmr_reg_vif(net
, mrt
);
861 err
= dev_set_allmulti(dev
, 1);
863 unregister_netdevice(dev
);
869 dev
= ipmr_new_tunnel(net
, vifc
);
872 err
= dev_set_allmulti(dev
, 1);
874 ipmr_del_tunnel(dev
, vifc
);
879 case VIFF_USE_IFINDEX
:
881 if (vifc
->vifc_flags
== VIFF_USE_IFINDEX
) {
882 dev
= dev_get_by_index(net
, vifc
->vifc_lcl_ifindex
);
883 if (dev
&& !__in_dev_get_rtnl(dev
)) {
885 return -EADDRNOTAVAIL
;
888 dev
= ip_dev_find(net
, vifc
->vifc_lcl_addr
.s_addr
);
891 return -EADDRNOTAVAIL
;
892 err
= dev_set_allmulti(dev
, 1);
902 in_dev
= __in_dev_get_rtnl(dev
);
905 return -EADDRNOTAVAIL
;
907 IPV4_DEVCONF(in_dev
->cnf
, MC_FORWARDING
)++;
908 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
, NETCONFA_MC_FORWARDING
,
909 dev
->ifindex
, &in_dev
->cnf
);
910 ip_rt_multicast_event(in_dev
);
912 /* Fill in the VIF structures */
913 vif_device_init(v
, dev
, vifc
->vifc_rate_limit
,
914 vifc
->vifc_threshold
,
915 vifc
->vifc_flags
| (!mrtsock
? VIFF_STATIC
: 0),
916 (VIFF_TUNNEL
| VIFF_REGISTER
));
918 err
= dev_get_port_parent_id(dev
, &ppid
, true);
920 memcpy(v
->dev_parent_id
.id
, ppid
.id
, ppid
.id_len
);
921 v
->dev_parent_id
.id_len
= ppid
.id_len
;
923 v
->dev_parent_id
.id_len
= 0;
926 v
->local
= vifc
->vifc_lcl_addr
.s_addr
;
927 v
->remote
= vifc
->vifc_rmt_addr
.s_addr
;
929 /* And finish update writing critical data */
930 write_lock_bh(&mrt_lock
);
932 if (v
->flags
& VIFF_REGISTER
)
933 mrt
->mroute_reg_vif_num
= vifi
;
934 if (vifi
+1 > mrt
->maxvif
)
935 mrt
->maxvif
= vifi
+1;
936 write_unlock_bh(&mrt_lock
);
937 call_ipmr_vif_entry_notifiers(net
, FIB_EVENT_VIF_ADD
, v
, vifi
, mrt
->id
);
941 /* called with rcu_read_lock() */
942 static struct mfc_cache
*ipmr_cache_find(struct mr_table
*mrt
,
946 struct mfc_cache_cmp_arg arg
= {
947 .mfc_mcastgrp
= mcastgrp
,
951 return mr_mfc_find(mrt
, &arg
);
954 /* Look for a (*,G) entry */
955 static struct mfc_cache
*ipmr_cache_find_any(struct mr_table
*mrt
,
956 __be32 mcastgrp
, int vifi
)
958 struct mfc_cache_cmp_arg arg
= {
959 .mfc_mcastgrp
= mcastgrp
,
960 .mfc_origin
= htonl(INADDR_ANY
)
963 if (mcastgrp
== htonl(INADDR_ANY
))
964 return mr_mfc_find_any_parent(mrt
, vifi
);
965 return mr_mfc_find_any(mrt
, vifi
, &arg
);
968 /* Look for a (S,G,iif) entry if parent != -1 */
969 static struct mfc_cache
*ipmr_cache_find_parent(struct mr_table
*mrt
,
970 __be32 origin
, __be32 mcastgrp
,
973 struct mfc_cache_cmp_arg arg
= {
974 .mfc_mcastgrp
= mcastgrp
,
975 .mfc_origin
= origin
,
978 return mr_mfc_find_parent(mrt
, &arg
, parent
);
981 /* Allocate a multicast cache entry */
982 static struct mfc_cache
*ipmr_cache_alloc(void)
984 struct mfc_cache
*c
= kmem_cache_zalloc(mrt_cachep
, GFP_KERNEL
);
987 c
->_c
.mfc_un
.res
.last_assert
= jiffies
- MFC_ASSERT_THRESH
- 1;
988 c
->_c
.mfc_un
.res
.minvif
= MAXVIFS
;
989 c
->_c
.free
= ipmr_cache_free_rcu
;
990 refcount_set(&c
->_c
.mfc_un
.res
.refcount
, 1);
995 static struct mfc_cache
*ipmr_cache_alloc_unres(void)
997 struct mfc_cache
*c
= kmem_cache_zalloc(mrt_cachep
, GFP_ATOMIC
);
1000 skb_queue_head_init(&c
->_c
.mfc_un
.unres
.unresolved
);
1001 c
->_c
.mfc_un
.unres
.expires
= jiffies
+ 10 * HZ
;
1006 /* A cache entry has gone into a resolved state from queued */
1007 static void ipmr_cache_resolve(struct net
*net
, struct mr_table
*mrt
,
1008 struct mfc_cache
*uc
, struct mfc_cache
*c
)
1010 struct sk_buff
*skb
;
1013 /* Play the pending entries through our router */
1014 while ((skb
= __skb_dequeue(&uc
->_c
.mfc_un
.unres
.unresolved
))) {
1015 if (ip_hdr(skb
)->version
== 0) {
1016 struct nlmsghdr
*nlh
= skb_pull(skb
,
1017 sizeof(struct iphdr
));
1019 if (mr_fill_mroute(mrt
, skb
, &c
->_c
,
1020 nlmsg_data(nlh
)) > 0) {
1021 nlh
->nlmsg_len
= skb_tail_pointer(skb
) -
1024 nlh
->nlmsg_type
= NLMSG_ERROR
;
1025 nlh
->nlmsg_len
= nlmsg_msg_size(sizeof(struct nlmsgerr
));
1026 skb_trim(skb
, nlh
->nlmsg_len
);
1027 e
= nlmsg_data(nlh
);
1028 e
->error
= -EMSGSIZE
;
1029 memset(&e
->msg
, 0, sizeof(e
->msg
));
1032 rtnl_unicast(skb
, net
, NETLINK_CB(skb
).portid
);
1034 ip_mr_forward(net
, mrt
, skb
->dev
, skb
, c
, 0);
1039 /* Bounce a cache query up to mrouted and netlink.
1041 * Called under mrt_lock.
1043 static int ipmr_cache_report(struct mr_table
*mrt
,
1044 struct sk_buff
*pkt
, vifi_t vifi
, int assert)
1046 const int ihl
= ip_hdrlen(pkt
);
1047 struct sock
*mroute_sk
;
1048 struct igmphdr
*igmp
;
1049 struct igmpmsg
*msg
;
1050 struct sk_buff
*skb
;
1053 if (assert == IGMPMSG_WHOLEPKT
|| assert == IGMPMSG_WRVIFWHOLE
)
1054 skb
= skb_realloc_headroom(pkt
, sizeof(struct iphdr
));
1056 skb
= alloc_skb(128, GFP_ATOMIC
);
1061 if (assert == IGMPMSG_WHOLEPKT
|| assert == IGMPMSG_WRVIFWHOLE
) {
1062 /* Ugly, but we have no choice with this interface.
1063 * Duplicate old header, fix ihl, length etc.
1064 * And all this only to mangle msg->im_msgtype and
1065 * to set msg->im_mbz to "mbz" :-)
1067 skb_push(skb
, sizeof(struct iphdr
));
1068 skb_reset_network_header(skb
);
1069 skb_reset_transport_header(skb
);
1070 msg
= (struct igmpmsg
*)skb_network_header(skb
);
1071 memcpy(msg
, skb_network_header(pkt
), sizeof(struct iphdr
));
1072 msg
->im_msgtype
= assert;
1074 if (assert == IGMPMSG_WRVIFWHOLE
)
1077 msg
->im_vif
= mrt
->mroute_reg_vif_num
;
1078 ip_hdr(skb
)->ihl
= sizeof(struct iphdr
) >> 2;
1079 ip_hdr(skb
)->tot_len
= htons(ntohs(ip_hdr(pkt
)->tot_len
) +
1080 sizeof(struct iphdr
));
1082 /* Copy the IP header */
1083 skb_set_network_header(skb
, skb
->len
);
1085 skb_copy_to_linear_data(skb
, pkt
->data
, ihl
);
1086 /* Flag to the kernel this is a route add */
1087 ip_hdr(skb
)->protocol
= 0;
1088 msg
= (struct igmpmsg
*)skb_network_header(skb
);
1090 skb_dst_set(skb
, dst_clone(skb_dst(pkt
)));
1091 /* Add our header */
1092 igmp
= skb_put(skb
, sizeof(struct igmphdr
));
1093 igmp
->type
= assert;
1094 msg
->im_msgtype
= assert;
1096 ip_hdr(skb
)->tot_len
= htons(skb
->len
); /* Fix the length */
1097 skb
->transport_header
= skb
->network_header
;
1101 mroute_sk
= rcu_dereference(mrt
->mroute_sk
);
1108 igmpmsg_netlink_event(mrt
, skb
);
1110 /* Deliver to mrouted */
1111 ret
= sock_queue_rcv_skb(mroute_sk
, skb
);
1114 net_warn_ratelimited("mroute: pending queue full, dropping entries\n");
1121 /* Queue a packet for resolution. It gets locked cache entry! */
1122 static int ipmr_cache_unresolved(struct mr_table
*mrt
, vifi_t vifi
,
1123 struct sk_buff
*skb
, struct net_device
*dev
)
1125 const struct iphdr
*iph
= ip_hdr(skb
);
1126 struct mfc_cache
*c
;
1130 spin_lock_bh(&mfc_unres_lock
);
1131 list_for_each_entry(c
, &mrt
->mfc_unres_queue
, _c
.list
) {
1132 if (c
->mfc_mcastgrp
== iph
->daddr
&&
1133 c
->mfc_origin
== iph
->saddr
) {
1140 /* Create a new entry if allowable */
1141 c
= ipmr_cache_alloc_unres();
1143 spin_unlock_bh(&mfc_unres_lock
);
1149 /* Fill in the new cache entry */
1150 c
->_c
.mfc_parent
= -1;
1151 c
->mfc_origin
= iph
->saddr
;
1152 c
->mfc_mcastgrp
= iph
->daddr
;
1154 /* Reflect first query at mrouted. */
1155 err
= ipmr_cache_report(mrt
, skb
, vifi
, IGMPMSG_NOCACHE
);
1158 /* If the report failed throw the cache entry
1161 spin_unlock_bh(&mfc_unres_lock
);
1168 atomic_inc(&mrt
->cache_resolve_queue_len
);
1169 list_add(&c
->_c
.list
, &mrt
->mfc_unres_queue
);
1170 mroute_netlink_event(mrt
, c
, RTM_NEWROUTE
);
1172 if (atomic_read(&mrt
->cache_resolve_queue_len
) == 1)
1173 mod_timer(&mrt
->ipmr_expire_timer
,
1174 c
->_c
.mfc_un
.unres
.expires
);
1177 /* See if we can append the packet */
1178 if (c
->_c
.mfc_un
.unres
.unresolved
.qlen
> 3) {
1184 skb
->skb_iif
= dev
->ifindex
;
1186 skb_queue_tail(&c
->_c
.mfc_un
.unres
.unresolved
, skb
);
1190 spin_unlock_bh(&mfc_unres_lock
);
1194 /* MFC cache manipulation by user space mroute daemon */
1196 static int ipmr_mfc_delete(struct mr_table
*mrt
, struct mfcctl
*mfc
, int parent
)
1198 struct net
*net
= read_pnet(&mrt
->net
);
1199 struct mfc_cache
*c
;
1201 /* The entries are added/deleted only under RTNL */
1203 c
= ipmr_cache_find_parent(mrt
, mfc
->mfcc_origin
.s_addr
,
1204 mfc
->mfcc_mcastgrp
.s_addr
, parent
);
1208 rhltable_remove(&mrt
->mfc_hash
, &c
->_c
.mnode
, ipmr_rht_params
);
1209 list_del_rcu(&c
->_c
.list
);
1210 call_ipmr_mfc_entry_notifiers(net
, FIB_EVENT_ENTRY_DEL
, c
, mrt
->id
);
1211 mroute_netlink_event(mrt
, c
, RTM_DELROUTE
);
1212 mr_cache_put(&c
->_c
);
1217 static int ipmr_mfc_add(struct net
*net
, struct mr_table
*mrt
,
1218 struct mfcctl
*mfc
, int mrtsock
, int parent
)
1220 struct mfc_cache
*uc
, *c
;
1225 if (mfc
->mfcc_parent
>= MAXVIFS
)
1228 /* The entries are added/deleted only under RTNL */
1230 c
= ipmr_cache_find_parent(mrt
, mfc
->mfcc_origin
.s_addr
,
1231 mfc
->mfcc_mcastgrp
.s_addr
, parent
);
1234 write_lock_bh(&mrt_lock
);
1235 c
->_c
.mfc_parent
= mfc
->mfcc_parent
;
1236 ipmr_update_thresholds(mrt
, &c
->_c
, mfc
->mfcc_ttls
);
1238 c
->_c
.mfc_flags
|= MFC_STATIC
;
1239 write_unlock_bh(&mrt_lock
);
1240 call_ipmr_mfc_entry_notifiers(net
, FIB_EVENT_ENTRY_REPLACE
, c
,
1242 mroute_netlink_event(mrt
, c
, RTM_NEWROUTE
);
1246 if (mfc
->mfcc_mcastgrp
.s_addr
!= htonl(INADDR_ANY
) &&
1247 !ipv4_is_multicast(mfc
->mfcc_mcastgrp
.s_addr
))
1250 c
= ipmr_cache_alloc();
1254 c
->mfc_origin
= mfc
->mfcc_origin
.s_addr
;
1255 c
->mfc_mcastgrp
= mfc
->mfcc_mcastgrp
.s_addr
;
1256 c
->_c
.mfc_parent
= mfc
->mfcc_parent
;
1257 ipmr_update_thresholds(mrt
, &c
->_c
, mfc
->mfcc_ttls
);
1259 c
->_c
.mfc_flags
|= MFC_STATIC
;
1261 ret
= rhltable_insert_key(&mrt
->mfc_hash
, &c
->cmparg
, &c
->_c
.mnode
,
1264 pr_err("ipmr: rhtable insert error %d\n", ret
);
1268 list_add_tail_rcu(&c
->_c
.list
, &mrt
->mfc_cache_list
);
1269 /* Check to see if we resolved a queued list. If so we
1270 * need to send on the frames and tidy up.
1273 spin_lock_bh(&mfc_unres_lock
);
1274 list_for_each_entry(_uc
, &mrt
->mfc_unres_queue
, list
) {
1275 uc
= (struct mfc_cache
*)_uc
;
1276 if (uc
->mfc_origin
== c
->mfc_origin
&&
1277 uc
->mfc_mcastgrp
== c
->mfc_mcastgrp
) {
1278 list_del(&_uc
->list
);
1279 atomic_dec(&mrt
->cache_resolve_queue_len
);
1284 if (list_empty(&mrt
->mfc_unres_queue
))
1285 del_timer(&mrt
->ipmr_expire_timer
);
1286 spin_unlock_bh(&mfc_unres_lock
);
1289 ipmr_cache_resolve(net
, mrt
, uc
, c
);
1290 ipmr_cache_free(uc
);
1292 call_ipmr_mfc_entry_notifiers(net
, FIB_EVENT_ENTRY_ADD
, c
, mrt
->id
);
1293 mroute_netlink_event(mrt
, c
, RTM_NEWROUTE
);
1297 /* Close the multicast socket, and clear the vif tables etc */
1298 static void mroute_clean_tables(struct mr_table
*mrt
, int flags
)
1300 struct net
*net
= read_pnet(&mrt
->net
);
1301 struct mr_mfc
*c
, *tmp
;
1302 struct mfc_cache
*cache
;
1306 /* Shut down all active vif entries */
1307 if (flags
& (MRT_FLUSH_VIFS
| MRT_FLUSH_VIFS_STATIC
)) {
1308 for (i
= 0; i
< mrt
->maxvif
; i
++) {
1309 if (((mrt
->vif_table
[i
].flags
& VIFF_STATIC
) &&
1310 !(flags
& MRT_FLUSH_VIFS_STATIC
)) ||
1311 (!(mrt
->vif_table
[i
].flags
& VIFF_STATIC
) && !(flags
& MRT_FLUSH_VIFS
)))
1313 vif_delete(mrt
, i
, 0, &list
);
1315 unregister_netdevice_many(&list
);
1318 /* Wipe the cache */
1319 if (flags
& (MRT_FLUSH_MFC
| MRT_FLUSH_MFC_STATIC
)) {
1320 list_for_each_entry_safe(c
, tmp
, &mrt
->mfc_cache_list
, list
) {
1321 if (((c
->mfc_flags
& MFC_STATIC
) && !(flags
& MRT_FLUSH_MFC_STATIC
)) ||
1322 (!(c
->mfc_flags
& MFC_STATIC
) && !(flags
& MRT_FLUSH_MFC
)))
1324 rhltable_remove(&mrt
->mfc_hash
, &c
->mnode
, ipmr_rht_params
);
1325 list_del_rcu(&c
->list
);
1326 cache
= (struct mfc_cache
*)c
;
1327 call_ipmr_mfc_entry_notifiers(net
, FIB_EVENT_ENTRY_DEL
, cache
,
1329 mroute_netlink_event(mrt
, cache
, RTM_DELROUTE
);
1334 if (flags
& MRT_FLUSH_MFC
) {
1335 if (atomic_read(&mrt
->cache_resolve_queue_len
) != 0) {
1336 spin_lock_bh(&mfc_unres_lock
);
1337 list_for_each_entry_safe(c
, tmp
, &mrt
->mfc_unres_queue
, list
) {
1339 cache
= (struct mfc_cache
*)c
;
1340 mroute_netlink_event(mrt
, cache
, RTM_DELROUTE
);
1341 ipmr_destroy_unres(mrt
, cache
);
1343 spin_unlock_bh(&mfc_unres_lock
);
1348 /* called from ip_ra_control(), before an RCU grace period,
1349 * we dont need to call synchronize_rcu() here
1351 static void mrtsock_destruct(struct sock
*sk
)
1353 struct net
*net
= sock_net(sk
);
1354 struct mr_table
*mrt
;
1357 ipmr_for_each_table(mrt
, net
) {
1358 if (sk
== rtnl_dereference(mrt
->mroute_sk
)) {
1359 IPV4_DEVCONF_ALL(net
, MC_FORWARDING
)--;
1360 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
1361 NETCONFA_MC_FORWARDING
,
1362 NETCONFA_IFINDEX_ALL
,
1363 net
->ipv4
.devconf_all
);
1364 RCU_INIT_POINTER(mrt
->mroute_sk
, NULL
);
1365 mroute_clean_tables(mrt
, MRT_FLUSH_VIFS
| MRT_FLUSH_MFC
);
1371 /* Socket options and virtual interface manipulation. The whole
1372 * virtual interface system is a complete heap, but unfortunately
1373 * that's how BSD mrouted happens to think. Maybe one day with a proper
1374 * MOSPF/PIM router set up we can clean this up.
1377 int ip_mroute_setsockopt(struct sock
*sk
, int optname
, char __user
*optval
,
1378 unsigned int optlen
)
1380 struct net
*net
= sock_net(sk
);
1381 int val
, ret
= 0, parent
= 0;
1382 struct mr_table
*mrt
;
1388 /* There's one exception to the lock - MRT_DONE which needs to unlock */
1390 if (sk
->sk_type
!= SOCK_RAW
||
1391 inet_sk(sk
)->inet_num
!= IPPROTO_IGMP
) {
1396 mrt
= ipmr_get_table(net
, raw_sk(sk
)->ipmr_table
? : RT_TABLE_DEFAULT
);
1401 if (optname
!= MRT_INIT
) {
1402 if (sk
!= rcu_access_pointer(mrt
->mroute_sk
) &&
1403 !ns_capable(net
->user_ns
, CAP_NET_ADMIN
)) {
1411 if (optlen
!= sizeof(int)) {
1415 if (rtnl_dereference(mrt
->mroute_sk
)) {
1420 ret
= ip_ra_control(sk
, 1, mrtsock_destruct
);
1422 rcu_assign_pointer(mrt
->mroute_sk
, sk
);
1423 IPV4_DEVCONF_ALL(net
, MC_FORWARDING
)++;
1424 inet_netconf_notify_devconf(net
, RTM_NEWNETCONF
,
1425 NETCONFA_MC_FORWARDING
,
1426 NETCONFA_IFINDEX_ALL
,
1427 net
->ipv4
.devconf_all
);
1431 if (sk
!= rcu_access_pointer(mrt
->mroute_sk
)) {
1434 /* We need to unlock here because mrtsock_destruct takes
1435 * care of rtnl itself and we can't change that due to
1436 * the IP_ROUTER_ALERT setsockopt which runs without it.
1439 ret
= ip_ra_control(sk
, 0, NULL
);
1445 if (optlen
!= sizeof(vif
)) {
1449 if (copy_from_user(&vif
, optval
, sizeof(vif
))) {
1453 if (vif
.vifc_vifi
>= MAXVIFS
) {
1457 if (optname
== MRT_ADD_VIF
) {
1458 ret
= vif_add(net
, mrt
, &vif
,
1459 sk
== rtnl_dereference(mrt
->mroute_sk
));
1461 ret
= vif_delete(mrt
, vif
.vifc_vifi
, 0, NULL
);
1464 /* Manipulate the forwarding caches. These live
1465 * in a sort of kernel/user symbiosis.
1471 case MRT_ADD_MFC_PROXY
:
1472 case MRT_DEL_MFC_PROXY
:
1473 if (optlen
!= sizeof(mfc
)) {
1477 if (copy_from_user(&mfc
, optval
, sizeof(mfc
))) {
1482 parent
= mfc
.mfcc_parent
;
1483 if (optname
== MRT_DEL_MFC
|| optname
== MRT_DEL_MFC_PROXY
)
1484 ret
= ipmr_mfc_delete(mrt
, &mfc
, parent
);
1486 ret
= ipmr_mfc_add(net
, mrt
, &mfc
,
1487 sk
== rtnl_dereference(mrt
->mroute_sk
),
1491 if (optlen
!= sizeof(val
)) {
1495 if (get_user(val
, (int __user
*)optval
)) {
1499 mroute_clean_tables(mrt
, val
);
1501 /* Control PIM assert. */
1503 if (optlen
!= sizeof(val
)) {
1507 if (get_user(val
, (int __user
*)optval
)) {
1511 mrt
->mroute_do_assert
= val
;
1514 if (!ipmr_pimsm_enabled()) {
1518 if (optlen
!= sizeof(val
)) {
1522 if (get_user(val
, (int __user
*)optval
)) {
1527 do_wrvifwhole
= (val
== IGMPMSG_WRVIFWHOLE
);
1529 if (val
!= mrt
->mroute_do_pim
) {
1530 mrt
->mroute_do_pim
= val
;
1531 mrt
->mroute_do_assert
= val
;
1532 mrt
->mroute_do_wrvifwhole
= do_wrvifwhole
;
1536 if (!IS_BUILTIN(CONFIG_IP_MROUTE_MULTIPLE_TABLES
)) {
1540 if (optlen
!= sizeof(uval
)) {
1544 if (get_user(uval
, (u32 __user
*)optval
)) {
1549 if (sk
== rtnl_dereference(mrt
->mroute_sk
)) {
1552 mrt
= ipmr_new_table(net
, uval
);
1556 raw_sk(sk
)->ipmr_table
= uval
;
1559 /* Spurious command, or MRT_VERSION which you cannot set. */
1569 /* Getsock opt support for the multicast routing system. */
1570 int ip_mroute_getsockopt(struct sock
*sk
, int optname
, char __user
*optval
, int __user
*optlen
)
1574 struct net
*net
= sock_net(sk
);
1575 struct mr_table
*mrt
;
1577 if (sk
->sk_type
!= SOCK_RAW
||
1578 inet_sk(sk
)->inet_num
!= IPPROTO_IGMP
)
1581 mrt
= ipmr_get_table(net
, raw_sk(sk
)->ipmr_table
? : RT_TABLE_DEFAULT
);
1590 if (!ipmr_pimsm_enabled())
1591 return -ENOPROTOOPT
;
1592 val
= mrt
->mroute_do_pim
;
1595 val
= mrt
->mroute_do_assert
;
1598 return -ENOPROTOOPT
;
1601 if (get_user(olr
, optlen
))
1603 olr
= min_t(unsigned int, olr
, sizeof(int));
1606 if (put_user(olr
, optlen
))
1608 if (copy_to_user(optval
, &val
, olr
))
1613 /* The IP multicast ioctl support routines. */
1614 int ipmr_ioctl(struct sock
*sk
, int cmd
, void __user
*arg
)
1616 struct sioc_sg_req sr
;
1617 struct sioc_vif_req vr
;
1618 struct vif_device
*vif
;
1619 struct mfc_cache
*c
;
1620 struct net
*net
= sock_net(sk
);
1621 struct mr_table
*mrt
;
1623 mrt
= ipmr_get_table(net
, raw_sk(sk
)->ipmr_table
? : RT_TABLE_DEFAULT
);
1629 if (copy_from_user(&vr
, arg
, sizeof(vr
)))
1631 if (vr
.vifi
>= mrt
->maxvif
)
1633 vr
.vifi
= array_index_nospec(vr
.vifi
, mrt
->maxvif
);
1634 read_lock(&mrt_lock
);
1635 vif
= &mrt
->vif_table
[vr
.vifi
];
1636 if (VIF_EXISTS(mrt
, vr
.vifi
)) {
1637 vr
.icount
= vif
->pkt_in
;
1638 vr
.ocount
= vif
->pkt_out
;
1639 vr
.ibytes
= vif
->bytes_in
;
1640 vr
.obytes
= vif
->bytes_out
;
1641 read_unlock(&mrt_lock
);
1643 if (copy_to_user(arg
, &vr
, sizeof(vr
)))
1647 read_unlock(&mrt_lock
);
1648 return -EADDRNOTAVAIL
;
1650 if (copy_from_user(&sr
, arg
, sizeof(sr
)))
1654 c
= ipmr_cache_find(mrt
, sr
.src
.s_addr
, sr
.grp
.s_addr
);
1656 sr
.pktcnt
= c
->_c
.mfc_un
.res
.pkt
;
1657 sr
.bytecnt
= c
->_c
.mfc_un
.res
.bytes
;
1658 sr
.wrong_if
= c
->_c
.mfc_un
.res
.wrong_if
;
1661 if (copy_to_user(arg
, &sr
, sizeof(sr
)))
1666 return -EADDRNOTAVAIL
;
1668 return -ENOIOCTLCMD
;
1672 #ifdef CONFIG_COMPAT
1673 struct compat_sioc_sg_req
{
1676 compat_ulong_t pktcnt
;
1677 compat_ulong_t bytecnt
;
1678 compat_ulong_t wrong_if
;
1681 struct compat_sioc_vif_req
{
1682 vifi_t vifi
; /* Which iface */
1683 compat_ulong_t icount
;
1684 compat_ulong_t ocount
;
1685 compat_ulong_t ibytes
;
1686 compat_ulong_t obytes
;
1689 int ipmr_compat_ioctl(struct sock
*sk
, unsigned int cmd
, void __user
*arg
)
1691 struct compat_sioc_sg_req sr
;
1692 struct compat_sioc_vif_req vr
;
1693 struct vif_device
*vif
;
1694 struct mfc_cache
*c
;
1695 struct net
*net
= sock_net(sk
);
1696 struct mr_table
*mrt
;
1698 mrt
= ipmr_get_table(net
, raw_sk(sk
)->ipmr_table
? : RT_TABLE_DEFAULT
);
1704 if (copy_from_user(&vr
, arg
, sizeof(vr
)))
1706 if (vr
.vifi
>= mrt
->maxvif
)
1708 vr
.vifi
= array_index_nospec(vr
.vifi
, mrt
->maxvif
);
1709 read_lock(&mrt_lock
);
1710 vif
= &mrt
->vif_table
[vr
.vifi
];
1711 if (VIF_EXISTS(mrt
, vr
.vifi
)) {
1712 vr
.icount
= vif
->pkt_in
;
1713 vr
.ocount
= vif
->pkt_out
;
1714 vr
.ibytes
= vif
->bytes_in
;
1715 vr
.obytes
= vif
->bytes_out
;
1716 read_unlock(&mrt_lock
);
1718 if (copy_to_user(arg
, &vr
, sizeof(vr
)))
1722 read_unlock(&mrt_lock
);
1723 return -EADDRNOTAVAIL
;
1725 if (copy_from_user(&sr
, arg
, sizeof(sr
)))
1729 c
= ipmr_cache_find(mrt
, sr
.src
.s_addr
, sr
.grp
.s_addr
);
1731 sr
.pktcnt
= c
->_c
.mfc_un
.res
.pkt
;
1732 sr
.bytecnt
= c
->_c
.mfc_un
.res
.bytes
;
1733 sr
.wrong_if
= c
->_c
.mfc_un
.res
.wrong_if
;
1736 if (copy_to_user(arg
, &sr
, sizeof(sr
)))
1741 return -EADDRNOTAVAIL
;
1743 return -ENOIOCTLCMD
;
1748 static int ipmr_device_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
1750 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
1751 struct net
*net
= dev_net(dev
);
1752 struct mr_table
*mrt
;
1753 struct vif_device
*v
;
1756 if (event
!= NETDEV_UNREGISTER
)
1759 ipmr_for_each_table(mrt
, net
) {
1760 v
= &mrt
->vif_table
[0];
1761 for (ct
= 0; ct
< mrt
->maxvif
; ct
++, v
++) {
1763 vif_delete(mrt
, ct
, 1, NULL
);
1769 static struct notifier_block ip_mr_notifier
= {
1770 .notifier_call
= ipmr_device_event
,
1773 /* Encapsulate a packet by attaching a valid IPIP header to it.
1774 * This avoids tunnel drivers and other mess and gives us the speed so
1775 * important for multicast video.
1777 static void ip_encap(struct net
*net
, struct sk_buff
*skb
,
1778 __be32 saddr
, __be32 daddr
)
1781 const struct iphdr
*old_iph
= ip_hdr(skb
);
1783 skb_push(skb
, sizeof(struct iphdr
));
1784 skb
->transport_header
= skb
->network_header
;
1785 skb_reset_network_header(skb
);
1789 iph
->tos
= old_iph
->tos
;
1790 iph
->ttl
= old_iph
->ttl
;
1794 iph
->protocol
= IPPROTO_IPIP
;
1796 iph
->tot_len
= htons(skb
->len
);
1797 ip_select_ident(net
, skb
, NULL
);
1800 memset(&(IPCB(skb
)->opt
), 0, sizeof(IPCB(skb
)->opt
));
1804 static inline int ipmr_forward_finish(struct net
*net
, struct sock
*sk
,
1805 struct sk_buff
*skb
)
1807 struct ip_options
*opt
= &(IPCB(skb
)->opt
);
1809 IP_INC_STATS(net
, IPSTATS_MIB_OUTFORWDATAGRAMS
);
1810 IP_ADD_STATS(net
, IPSTATS_MIB_OUTOCTETS
, skb
->len
);
1812 if (unlikely(opt
->optlen
))
1813 ip_forward_options(skb
);
1815 return dst_output(net
, sk
, skb
);
1818 #ifdef CONFIG_NET_SWITCHDEV
1819 static bool ipmr_forward_offloaded(struct sk_buff
*skb
, struct mr_table
*mrt
,
1820 int in_vifi
, int out_vifi
)
1822 struct vif_device
*out_vif
= &mrt
->vif_table
[out_vifi
];
1823 struct vif_device
*in_vif
= &mrt
->vif_table
[in_vifi
];
1825 if (!skb
->offload_l3_fwd_mark
)
1827 if (!out_vif
->dev_parent_id
.id_len
|| !in_vif
->dev_parent_id
.id_len
)
1829 return netdev_phys_item_id_same(&out_vif
->dev_parent_id
,
1830 &in_vif
->dev_parent_id
);
1833 static bool ipmr_forward_offloaded(struct sk_buff
*skb
, struct mr_table
*mrt
,
1834 int in_vifi
, int out_vifi
)
1840 /* Processing handlers for ipmr_forward */
1842 static void ipmr_queue_xmit(struct net
*net
, struct mr_table
*mrt
,
1843 int in_vifi
, struct sk_buff
*skb
, int vifi
)
1845 const struct iphdr
*iph
= ip_hdr(skb
);
1846 struct vif_device
*vif
= &mrt
->vif_table
[vifi
];
1847 struct net_device
*dev
;
1855 if (vif
->flags
& VIFF_REGISTER
) {
1857 vif
->bytes_out
+= skb
->len
;
1858 vif
->dev
->stats
.tx_bytes
+= skb
->len
;
1859 vif
->dev
->stats
.tx_packets
++;
1860 ipmr_cache_report(mrt
, skb
, vifi
, IGMPMSG_WHOLEPKT
);
1864 if (ipmr_forward_offloaded(skb
, mrt
, in_vifi
, vifi
))
1867 if (vif
->flags
& VIFF_TUNNEL
) {
1868 rt
= ip_route_output_ports(net
, &fl4
, NULL
,
1869 vif
->remote
, vif
->local
,
1872 RT_TOS(iph
->tos
), vif
->link
);
1875 encap
= sizeof(struct iphdr
);
1877 rt
= ip_route_output_ports(net
, &fl4
, NULL
, iph
->daddr
, 0,
1880 RT_TOS(iph
->tos
), vif
->link
);
1887 if (skb
->len
+encap
> dst_mtu(&rt
->dst
) && (ntohs(iph
->frag_off
) & IP_DF
)) {
1888 /* Do not fragment multicasts. Alas, IPv4 does not
1889 * allow to send ICMP, so that packets will disappear
1892 IP_INC_STATS(net
, IPSTATS_MIB_FRAGFAILS
);
1897 encap
+= LL_RESERVED_SPACE(dev
) + rt
->dst
.header_len
;
1899 if (skb_cow(skb
, encap
)) {
1905 vif
->bytes_out
+= skb
->len
;
1908 skb_dst_set(skb
, &rt
->dst
);
1909 ip_decrease_ttl(ip_hdr(skb
));
1911 /* FIXME: forward and output firewalls used to be called here.
1912 * What do we do with netfilter? -- RR
1914 if (vif
->flags
& VIFF_TUNNEL
) {
1915 ip_encap(net
, skb
, vif
->local
, vif
->remote
);
1916 /* FIXME: extra output firewall step used to be here. --RR */
1917 vif
->dev
->stats
.tx_packets
++;
1918 vif
->dev
->stats
.tx_bytes
+= skb
->len
;
1921 IPCB(skb
)->flags
|= IPSKB_FORWARDED
;
1923 /* RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1924 * not only before forwarding, but after forwarding on all output
1925 * interfaces. It is clear, if mrouter runs a multicasting
1926 * program, it should receive packets not depending to what interface
1927 * program is joined.
1928 * If we will not make it, the program will have to join on all
1929 * interfaces. On the other hand, multihoming host (or router, but
1930 * not mrouter) cannot join to more than one interface - it will
1931 * result in receiving multiple packets.
1933 NF_HOOK(NFPROTO_IPV4
, NF_INET_FORWARD
,
1934 net
, NULL
, skb
, skb
->dev
, dev
,
1935 ipmr_forward_finish
);
1942 static int ipmr_find_vif(struct mr_table
*mrt
, struct net_device
*dev
)
1946 for (ct
= mrt
->maxvif
-1; ct
>= 0; ct
--) {
1947 if (mrt
->vif_table
[ct
].dev
== dev
)
1953 /* "local" means that we should preserve one skb (for local delivery) */
1954 static void ip_mr_forward(struct net
*net
, struct mr_table
*mrt
,
1955 struct net_device
*dev
, struct sk_buff
*skb
,
1956 struct mfc_cache
*c
, int local
)
1958 int true_vifi
= ipmr_find_vif(mrt
, dev
);
1962 vif
= c
->_c
.mfc_parent
;
1963 c
->_c
.mfc_un
.res
.pkt
++;
1964 c
->_c
.mfc_un
.res
.bytes
+= skb
->len
;
1965 c
->_c
.mfc_un
.res
.lastuse
= jiffies
;
1967 if (c
->mfc_origin
== htonl(INADDR_ANY
) && true_vifi
>= 0) {
1968 struct mfc_cache
*cache_proxy
;
1970 /* For an (*,G) entry, we only check that the incomming
1971 * interface is part of the static tree.
1973 cache_proxy
= mr_mfc_find_any_parent(mrt
, vif
);
1975 cache_proxy
->_c
.mfc_un
.res
.ttls
[true_vifi
] < 255)
1979 /* Wrong interface: drop packet and (maybe) send PIM assert. */
1980 if (mrt
->vif_table
[vif
].dev
!= dev
) {
1981 if (rt_is_output_route(skb_rtable(skb
))) {
1982 /* It is our own packet, looped back.
1983 * Very complicated situation...
1985 * The best workaround until routing daemons will be
1986 * fixed is not to redistribute packet, if it was
1987 * send through wrong interface. It means, that
1988 * multicast applications WILL NOT work for
1989 * (S,G), which have default multicast route pointing
1990 * to wrong oif. In any case, it is not a good
1991 * idea to use multicasting applications on router.
1996 c
->_c
.mfc_un
.res
.wrong_if
++;
1998 if (true_vifi
>= 0 && mrt
->mroute_do_assert
&&
1999 /* pimsm uses asserts, when switching from RPT to SPT,
2000 * so that we cannot check that packet arrived on an oif.
2001 * It is bad, but otherwise we would need to move pretty
2002 * large chunk of pimd to kernel. Ough... --ANK
2004 (mrt
->mroute_do_pim
||
2005 c
->_c
.mfc_un
.res
.ttls
[true_vifi
] < 255) &&
2007 c
->_c
.mfc_un
.res
.last_assert
+
2008 MFC_ASSERT_THRESH
)) {
2009 c
->_c
.mfc_un
.res
.last_assert
= jiffies
;
2010 ipmr_cache_report(mrt
, skb
, true_vifi
, IGMPMSG_WRONGVIF
);
2011 if (mrt
->mroute_do_wrvifwhole
)
2012 ipmr_cache_report(mrt
, skb
, true_vifi
,
2013 IGMPMSG_WRVIFWHOLE
);
2019 mrt
->vif_table
[vif
].pkt_in
++;
2020 mrt
->vif_table
[vif
].bytes_in
+= skb
->len
;
2022 /* Forward the frame */
2023 if (c
->mfc_origin
== htonl(INADDR_ANY
) &&
2024 c
->mfc_mcastgrp
== htonl(INADDR_ANY
)) {
2025 if (true_vifi
>= 0 &&
2026 true_vifi
!= c
->_c
.mfc_parent
&&
2028 c
->_c
.mfc_un
.res
.ttls
[c
->_c
.mfc_parent
]) {
2029 /* It's an (*,*) entry and the packet is not coming from
2030 * the upstream: forward the packet to the upstream
2033 psend
= c
->_c
.mfc_parent
;
2038 for (ct
= c
->_c
.mfc_un
.res
.maxvif
- 1;
2039 ct
>= c
->_c
.mfc_un
.res
.minvif
; ct
--) {
2040 /* For (*,G) entry, don't forward to the incoming interface */
2041 if ((c
->mfc_origin
!= htonl(INADDR_ANY
) ||
2043 ip_hdr(skb
)->ttl
> c
->_c
.mfc_un
.res
.ttls
[ct
]) {
2045 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
2048 ipmr_queue_xmit(net
, mrt
, true_vifi
,
2057 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
2060 ipmr_queue_xmit(net
, mrt
, true_vifi
, skb2
,
2063 ipmr_queue_xmit(net
, mrt
, true_vifi
, skb
, psend
);
2073 static struct mr_table
*ipmr_rt_fib_lookup(struct net
*net
, struct sk_buff
*skb
)
2075 struct rtable
*rt
= skb_rtable(skb
);
2076 struct iphdr
*iph
= ip_hdr(skb
);
2077 struct flowi4 fl4
= {
2078 .daddr
= iph
->daddr
,
2079 .saddr
= iph
->saddr
,
2080 .flowi4_tos
= RT_TOS(iph
->tos
),
2081 .flowi4_oif
= (rt_is_output_route(rt
) ?
2082 skb
->dev
->ifindex
: 0),
2083 .flowi4_iif
= (rt_is_output_route(rt
) ?
2086 .flowi4_mark
= skb
->mark
,
2088 struct mr_table
*mrt
;
2091 err
= ipmr_fib_lookup(net
, &fl4
, &mrt
);
2093 return ERR_PTR(err
);
2097 /* Multicast packets for forwarding arrive here
2098 * Called with rcu_read_lock();
2100 int ip_mr_input(struct sk_buff
*skb
)
2102 struct mfc_cache
*cache
;
2103 struct net
*net
= dev_net(skb
->dev
);
2104 int local
= skb_rtable(skb
)->rt_flags
& RTCF_LOCAL
;
2105 struct mr_table
*mrt
;
2106 struct net_device
*dev
;
2108 /* skb->dev passed in is the loX master dev for vrfs.
2109 * As there are no vifs associated with loopback devices,
2110 * get the proper interface that does have a vif associated with it.
2113 if (netif_is_l3_master(skb
->dev
)) {
2114 dev
= dev_get_by_index_rcu(net
, IPCB(skb
)->iif
);
2121 /* Packet is looped back after forward, it should not be
2122 * forwarded second time, but still can be delivered locally.
2124 if (IPCB(skb
)->flags
& IPSKB_FORWARDED
)
2127 mrt
= ipmr_rt_fib_lookup(net
, skb
);
2130 return PTR_ERR(mrt
);
2133 if (IPCB(skb
)->opt
.router_alert
) {
2134 if (ip_call_ra_chain(skb
))
2136 } else if (ip_hdr(skb
)->protocol
== IPPROTO_IGMP
) {
2137 /* IGMPv1 (and broken IGMPv2 implementations sort of
2138 * Cisco IOS <= 11.2(8)) do not put router alert
2139 * option to IGMP packets destined to routable
2140 * groups. It is very bad, because it means
2141 * that we can forward NO IGMP messages.
2143 struct sock
*mroute_sk
;
2145 mroute_sk
= rcu_dereference(mrt
->mroute_sk
);
2148 raw_rcv(mroute_sk
, skb
);
2154 /* already under rcu_read_lock() */
2155 cache
= ipmr_cache_find(mrt
, ip_hdr(skb
)->saddr
, ip_hdr(skb
)->daddr
);
2157 int vif
= ipmr_find_vif(mrt
, dev
);
2160 cache
= ipmr_cache_find_any(mrt
, ip_hdr(skb
)->daddr
,
2164 /* No usable cache entry */
2169 struct sk_buff
*skb2
= skb_clone(skb
, GFP_ATOMIC
);
2170 ip_local_deliver(skb
);
2176 read_lock(&mrt_lock
);
2177 vif
= ipmr_find_vif(mrt
, dev
);
2179 int err2
= ipmr_cache_unresolved(mrt
, vif
, skb
, dev
);
2180 read_unlock(&mrt_lock
);
2184 read_unlock(&mrt_lock
);
2189 read_lock(&mrt_lock
);
2190 ip_mr_forward(net
, mrt
, dev
, skb
, cache
, local
);
2191 read_unlock(&mrt_lock
);
2194 return ip_local_deliver(skb
);
2200 return ip_local_deliver(skb
);
2205 #ifdef CONFIG_IP_PIMSM_V1
2206 /* Handle IGMP messages of PIMv1 */
2207 int pim_rcv_v1(struct sk_buff
*skb
)
2209 struct igmphdr
*pim
;
2210 struct net
*net
= dev_net(skb
->dev
);
2211 struct mr_table
*mrt
;
2213 if (!pskb_may_pull(skb
, sizeof(*pim
) + sizeof(struct iphdr
)))
2216 pim
= igmp_hdr(skb
);
2218 mrt
= ipmr_rt_fib_lookup(net
, skb
);
2221 if (!mrt
->mroute_do_pim
||
2222 pim
->group
!= PIM_V1_VERSION
|| pim
->code
!= PIM_V1_REGISTER
)
2225 if (__pim_rcv(mrt
, skb
, sizeof(*pim
))) {
2233 #ifdef CONFIG_IP_PIMSM_V2
2234 static int pim_rcv(struct sk_buff
*skb
)
2236 struct pimreghdr
*pim
;
2237 struct net
*net
= dev_net(skb
->dev
);
2238 struct mr_table
*mrt
;
2240 if (!pskb_may_pull(skb
, sizeof(*pim
) + sizeof(struct iphdr
)))
2243 pim
= (struct pimreghdr
*)skb_transport_header(skb
);
2244 if (pim
->type
!= ((PIM_VERSION
<< 4) | (PIM_TYPE_REGISTER
)) ||
2245 (pim
->flags
& PIM_NULL_REGISTER
) ||
2246 (ip_compute_csum((void *)pim
, sizeof(*pim
)) != 0 &&
2247 csum_fold(skb_checksum(skb
, 0, skb
->len
, 0))))
2250 mrt
= ipmr_rt_fib_lookup(net
, skb
);
2253 if (__pim_rcv(mrt
, skb
, sizeof(*pim
))) {
2261 int ipmr_get_route(struct net
*net
, struct sk_buff
*skb
,
2262 __be32 saddr
, __be32 daddr
,
2263 struct rtmsg
*rtm
, u32 portid
)
2265 struct mfc_cache
*cache
;
2266 struct mr_table
*mrt
;
2269 mrt
= ipmr_get_table(net
, RT_TABLE_DEFAULT
);
2274 cache
= ipmr_cache_find(mrt
, saddr
, daddr
);
2275 if (!cache
&& skb
->dev
) {
2276 int vif
= ipmr_find_vif(mrt
, skb
->dev
);
2279 cache
= ipmr_cache_find_any(mrt
, daddr
, vif
);
2282 struct sk_buff
*skb2
;
2284 struct net_device
*dev
;
2288 read_lock(&mrt_lock
);
2290 vif
= ipmr_find_vif(mrt
, dev
);
2292 read_unlock(&mrt_lock
);
2297 skb2
= skb_realloc_headroom(skb
, sizeof(struct iphdr
));
2299 read_unlock(&mrt_lock
);
2304 NETLINK_CB(skb2
).portid
= portid
;
2305 skb_push(skb2
, sizeof(struct iphdr
));
2306 skb_reset_network_header(skb2
);
2308 iph
->ihl
= sizeof(struct iphdr
) >> 2;
2312 err
= ipmr_cache_unresolved(mrt
, vif
, skb2
, dev
);
2313 read_unlock(&mrt_lock
);
2318 read_lock(&mrt_lock
);
2319 err
= mr_fill_mroute(mrt
, skb
, &cache
->_c
, rtm
);
2320 read_unlock(&mrt_lock
);
2325 static int ipmr_fill_mroute(struct mr_table
*mrt
, struct sk_buff
*skb
,
2326 u32 portid
, u32 seq
, struct mfc_cache
*c
, int cmd
,
2329 struct nlmsghdr
*nlh
;
2333 nlh
= nlmsg_put(skb
, portid
, seq
, cmd
, sizeof(*rtm
), flags
);
2337 rtm
= nlmsg_data(nlh
);
2338 rtm
->rtm_family
= RTNL_FAMILY_IPMR
;
2339 rtm
->rtm_dst_len
= 32;
2340 rtm
->rtm_src_len
= 32;
2342 rtm
->rtm_table
= mrt
->id
;
2343 if (nla_put_u32(skb
, RTA_TABLE
, mrt
->id
))
2344 goto nla_put_failure
;
2345 rtm
->rtm_type
= RTN_MULTICAST
;
2346 rtm
->rtm_scope
= RT_SCOPE_UNIVERSE
;
2347 if (c
->_c
.mfc_flags
& MFC_STATIC
)
2348 rtm
->rtm_protocol
= RTPROT_STATIC
;
2350 rtm
->rtm_protocol
= RTPROT_MROUTED
;
2353 if (nla_put_in_addr(skb
, RTA_SRC
, c
->mfc_origin
) ||
2354 nla_put_in_addr(skb
, RTA_DST
, c
->mfc_mcastgrp
))
2355 goto nla_put_failure
;
2356 err
= mr_fill_mroute(mrt
, skb
, &c
->_c
, rtm
);
2357 /* do not break the dump if cache is unresolved */
2358 if (err
< 0 && err
!= -ENOENT
)
2359 goto nla_put_failure
;
2361 nlmsg_end(skb
, nlh
);
2365 nlmsg_cancel(skb
, nlh
);
2369 static int _ipmr_fill_mroute(struct mr_table
*mrt
, struct sk_buff
*skb
,
2370 u32 portid
, u32 seq
, struct mr_mfc
*c
, int cmd
,
2373 return ipmr_fill_mroute(mrt
, skb
, portid
, seq
, (struct mfc_cache
*)c
,
2377 static size_t mroute_msgsize(bool unresolved
, int maxvif
)
2380 NLMSG_ALIGN(sizeof(struct rtmsg
))
2381 + nla_total_size(4) /* RTA_TABLE */
2382 + nla_total_size(4) /* RTA_SRC */
2383 + nla_total_size(4) /* RTA_DST */
2388 + nla_total_size(4) /* RTA_IIF */
2389 + nla_total_size(0) /* RTA_MULTIPATH */
2390 + maxvif
* NLA_ALIGN(sizeof(struct rtnexthop
))
2392 + nla_total_size_64bit(sizeof(struct rta_mfc_stats
))
2398 static void mroute_netlink_event(struct mr_table
*mrt
, struct mfc_cache
*mfc
,
2401 struct net
*net
= read_pnet(&mrt
->net
);
2402 struct sk_buff
*skb
;
2405 skb
= nlmsg_new(mroute_msgsize(mfc
->_c
.mfc_parent
>= MAXVIFS
,
2411 err
= ipmr_fill_mroute(mrt
, skb
, 0, 0, mfc
, cmd
, 0);
2415 rtnl_notify(skb
, net
, 0, RTNLGRP_IPV4_MROUTE
, NULL
, GFP_ATOMIC
);
2421 rtnl_set_sk_err(net
, RTNLGRP_IPV4_MROUTE
, err
);
2424 static size_t igmpmsg_netlink_msgsize(size_t payloadlen
)
2427 NLMSG_ALIGN(sizeof(struct rtgenmsg
))
2428 + nla_total_size(1) /* IPMRA_CREPORT_MSGTYPE */
2429 + nla_total_size(4) /* IPMRA_CREPORT_VIF_ID */
2430 + nla_total_size(4) /* IPMRA_CREPORT_SRC_ADDR */
2431 + nla_total_size(4) /* IPMRA_CREPORT_DST_ADDR */
2432 /* IPMRA_CREPORT_PKT */
2433 + nla_total_size(payloadlen
)
2439 static void igmpmsg_netlink_event(struct mr_table
*mrt
, struct sk_buff
*pkt
)
2441 struct net
*net
= read_pnet(&mrt
->net
);
2442 struct nlmsghdr
*nlh
;
2443 struct rtgenmsg
*rtgenm
;
2444 struct igmpmsg
*msg
;
2445 struct sk_buff
*skb
;
2449 payloadlen
= pkt
->len
- sizeof(struct igmpmsg
);
2450 msg
= (struct igmpmsg
*)skb_network_header(pkt
);
2452 skb
= nlmsg_new(igmpmsg_netlink_msgsize(payloadlen
), GFP_ATOMIC
);
2456 nlh
= nlmsg_put(skb
, 0, 0, RTM_NEWCACHEREPORT
,
2457 sizeof(struct rtgenmsg
), 0);
2460 rtgenm
= nlmsg_data(nlh
);
2461 rtgenm
->rtgen_family
= RTNL_FAMILY_IPMR
;
2462 if (nla_put_u8(skb
, IPMRA_CREPORT_MSGTYPE
, msg
->im_msgtype
) ||
2463 nla_put_u32(skb
, IPMRA_CREPORT_VIF_ID
, msg
->im_vif
) ||
2464 nla_put_in_addr(skb
, IPMRA_CREPORT_SRC_ADDR
,
2465 msg
->im_src
.s_addr
) ||
2466 nla_put_in_addr(skb
, IPMRA_CREPORT_DST_ADDR
,
2467 msg
->im_dst
.s_addr
))
2468 goto nla_put_failure
;
2470 nla
= nla_reserve(skb
, IPMRA_CREPORT_PKT
, payloadlen
);
2471 if (!nla
|| skb_copy_bits(pkt
, sizeof(struct igmpmsg
),
2472 nla_data(nla
), payloadlen
))
2473 goto nla_put_failure
;
2475 nlmsg_end(skb
, nlh
);
2477 rtnl_notify(skb
, net
, 0, RTNLGRP_IPV4_MROUTE_R
, NULL
, GFP_ATOMIC
);
2481 nlmsg_cancel(skb
, nlh
);
2484 rtnl_set_sk_err(net
, RTNLGRP_IPV4_MROUTE_R
, -ENOBUFS
);
2487 static int ipmr_rtm_valid_getroute_req(struct sk_buff
*skb
,
2488 const struct nlmsghdr
*nlh
,
2490 struct netlink_ext_ack
*extack
)
2495 if (nlh
->nlmsg_len
< nlmsg_msg_size(sizeof(*rtm
))) {
2496 NL_SET_ERR_MSG(extack
, "ipv4: Invalid header for multicast route get request");
2500 if (!netlink_strict_get_check(skb
))
2501 return nlmsg_parse_deprecated(nlh
, sizeof(*rtm
), tb
, RTA_MAX
,
2502 rtm_ipv4_policy
, extack
);
2504 rtm
= nlmsg_data(nlh
);
2505 if ((rtm
->rtm_src_len
&& rtm
->rtm_src_len
!= 32) ||
2506 (rtm
->rtm_dst_len
&& rtm
->rtm_dst_len
!= 32) ||
2507 rtm
->rtm_tos
|| rtm
->rtm_table
|| rtm
->rtm_protocol
||
2508 rtm
->rtm_scope
|| rtm
->rtm_type
|| rtm
->rtm_flags
) {
2509 NL_SET_ERR_MSG(extack
, "ipv4: Invalid values in header for multicast route get request");
2513 err
= nlmsg_parse_deprecated_strict(nlh
, sizeof(*rtm
), tb
, RTA_MAX
,
2514 rtm_ipv4_policy
, extack
);
2518 if ((tb
[RTA_SRC
] && !rtm
->rtm_src_len
) ||
2519 (tb
[RTA_DST
] && !rtm
->rtm_dst_len
)) {
2520 NL_SET_ERR_MSG(extack
, "ipv4: rtm_src_len and rtm_dst_len must be 32 for IPv4");
2524 for (i
= 0; i
<= RTA_MAX
; i
++) {
2534 NL_SET_ERR_MSG(extack
, "ipv4: Unsupported attribute in multicast route get request");
2542 static int ipmr_rtm_getroute(struct sk_buff
*in_skb
, struct nlmsghdr
*nlh
,
2543 struct netlink_ext_ack
*extack
)
2545 struct net
*net
= sock_net(in_skb
->sk
);
2546 struct nlattr
*tb
[RTA_MAX
+ 1];
2547 struct sk_buff
*skb
= NULL
;
2548 struct mfc_cache
*cache
;
2549 struct mr_table
*mrt
;
2554 err
= ipmr_rtm_valid_getroute_req(in_skb
, nlh
, tb
, extack
);
2558 src
= tb
[RTA_SRC
] ? nla_get_in_addr(tb
[RTA_SRC
]) : 0;
2559 grp
= tb
[RTA_DST
] ? nla_get_in_addr(tb
[RTA_DST
]) : 0;
2560 tableid
= tb
[RTA_TABLE
] ? nla_get_u32(tb
[RTA_TABLE
]) : 0;
2562 mrt
= ipmr_get_table(net
, tableid
? tableid
: RT_TABLE_DEFAULT
);
2568 /* entries are added/deleted only under RTNL */
2570 cache
= ipmr_cache_find(mrt
, src
, grp
);
2577 skb
= nlmsg_new(mroute_msgsize(false, mrt
->maxvif
), GFP_KERNEL
);
2583 err
= ipmr_fill_mroute(mrt
, skb
, NETLINK_CB(in_skb
).portid
,
2584 nlh
->nlmsg_seq
, cache
,
2589 err
= rtnl_unicast(skb
, net
, NETLINK_CB(in_skb
).portid
);
2599 static int ipmr_rtm_dumproute(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2601 struct fib_dump_filter filter
= {};
2604 if (cb
->strict_check
) {
2605 err
= ip_valid_fib_dump_req(sock_net(skb
->sk
), cb
->nlh
,
2611 if (filter
.table_id
) {
2612 struct mr_table
*mrt
;
2614 mrt
= ipmr_get_table(sock_net(skb
->sk
), filter
.table_id
);
2616 if (filter
.dump_all_families
)
2619 NL_SET_ERR_MSG(cb
->extack
, "ipv4: MR table does not exist");
2622 err
= mr_table_dump(mrt
, skb
, cb
, _ipmr_fill_mroute
,
2623 &mfc_unres_lock
, &filter
);
2624 return skb
->len
? : err
;
2627 return mr_rtm_dumproute(skb
, cb
, ipmr_mr_table_iter
,
2628 _ipmr_fill_mroute
, &mfc_unres_lock
, &filter
);
2631 static const struct nla_policy rtm_ipmr_policy
[RTA_MAX
+ 1] = {
2632 [RTA_SRC
] = { .type
= NLA_U32
},
2633 [RTA_DST
] = { .type
= NLA_U32
},
2634 [RTA_IIF
] = { .type
= NLA_U32
},
2635 [RTA_TABLE
] = { .type
= NLA_U32
},
2636 [RTA_MULTIPATH
] = { .len
= sizeof(struct rtnexthop
) },
2639 static bool ipmr_rtm_validate_proto(unsigned char rtm_protocol
)
2641 switch (rtm_protocol
) {
2643 case RTPROT_MROUTED
:
2649 static int ipmr_nla_get_ttls(const struct nlattr
*nla
, struct mfcctl
*mfcc
)
2651 struct rtnexthop
*rtnh
= nla_data(nla
);
2652 int remaining
= nla_len(nla
), vifi
= 0;
2654 while (rtnh_ok(rtnh
, remaining
)) {
2655 mfcc
->mfcc_ttls
[vifi
] = rtnh
->rtnh_hops
;
2656 if (++vifi
== MAXVIFS
)
2658 rtnh
= rtnh_next(rtnh
, &remaining
);
2661 return remaining
> 0 ? -EINVAL
: vifi
;
2664 /* returns < 0 on error, 0 for ADD_MFC and 1 for ADD_MFC_PROXY */
2665 static int rtm_to_ipmr_mfcc(struct net
*net
, struct nlmsghdr
*nlh
,
2666 struct mfcctl
*mfcc
, int *mrtsock
,
2667 struct mr_table
**mrtret
,
2668 struct netlink_ext_ack
*extack
)
2670 struct net_device
*dev
= NULL
;
2671 u32 tblid
= RT_TABLE_DEFAULT
;
2672 struct mr_table
*mrt
;
2673 struct nlattr
*attr
;
2677 ret
= nlmsg_validate_deprecated(nlh
, sizeof(*rtm
), RTA_MAX
,
2678 rtm_ipmr_policy
, extack
);
2681 rtm
= nlmsg_data(nlh
);
2684 if (rtm
->rtm_family
!= RTNL_FAMILY_IPMR
|| rtm
->rtm_dst_len
!= 32 ||
2685 rtm
->rtm_type
!= RTN_MULTICAST
||
2686 rtm
->rtm_scope
!= RT_SCOPE_UNIVERSE
||
2687 !ipmr_rtm_validate_proto(rtm
->rtm_protocol
))
2690 memset(mfcc
, 0, sizeof(*mfcc
));
2691 mfcc
->mfcc_parent
= -1;
2693 nlmsg_for_each_attr(attr
, nlh
, sizeof(struct rtmsg
), rem
) {
2694 switch (nla_type(attr
)) {
2696 mfcc
->mfcc_origin
.s_addr
= nla_get_be32(attr
);
2699 mfcc
->mfcc_mcastgrp
.s_addr
= nla_get_be32(attr
);
2702 dev
= __dev_get_by_index(net
, nla_get_u32(attr
));
2709 if (ipmr_nla_get_ttls(attr
, mfcc
) < 0) {
2718 tblid
= nla_get_u32(attr
);
2722 mrt
= ipmr_get_table(net
, tblid
);
2728 *mrtsock
= rtm
->rtm_protocol
== RTPROT_MROUTED
? 1 : 0;
2730 mfcc
->mfcc_parent
= ipmr_find_vif(mrt
, dev
);
2736 /* takes care of both newroute and delroute */
2737 static int ipmr_rtm_route(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
2738 struct netlink_ext_ack
*extack
)
2740 struct net
*net
= sock_net(skb
->sk
);
2741 int ret
, mrtsock
, parent
;
2742 struct mr_table
*tbl
;
2747 ret
= rtm_to_ipmr_mfcc(net
, nlh
, &mfcc
, &mrtsock
, &tbl
, extack
);
2751 parent
= ret
? mfcc
.mfcc_parent
: -1;
2752 if (nlh
->nlmsg_type
== RTM_NEWROUTE
)
2753 return ipmr_mfc_add(net
, tbl
, &mfcc
, mrtsock
, parent
);
2755 return ipmr_mfc_delete(tbl
, &mfcc
, parent
);
2758 static bool ipmr_fill_table(struct mr_table
*mrt
, struct sk_buff
*skb
)
2760 u32 queue_len
= atomic_read(&mrt
->cache_resolve_queue_len
);
2762 if (nla_put_u32(skb
, IPMRA_TABLE_ID
, mrt
->id
) ||
2763 nla_put_u32(skb
, IPMRA_TABLE_CACHE_RES_QUEUE_LEN
, queue_len
) ||
2764 nla_put_s32(skb
, IPMRA_TABLE_MROUTE_REG_VIF_NUM
,
2765 mrt
->mroute_reg_vif_num
) ||
2766 nla_put_u8(skb
, IPMRA_TABLE_MROUTE_DO_ASSERT
,
2767 mrt
->mroute_do_assert
) ||
2768 nla_put_u8(skb
, IPMRA_TABLE_MROUTE_DO_PIM
, mrt
->mroute_do_pim
) ||
2769 nla_put_u8(skb
, IPMRA_TABLE_MROUTE_DO_WRVIFWHOLE
,
2770 mrt
->mroute_do_wrvifwhole
))
2776 static bool ipmr_fill_vif(struct mr_table
*mrt
, u32 vifid
, struct sk_buff
*skb
)
2778 struct nlattr
*vif_nest
;
2779 struct vif_device
*vif
;
2781 /* if the VIF doesn't exist just continue */
2782 if (!VIF_EXISTS(mrt
, vifid
))
2785 vif
= &mrt
->vif_table
[vifid
];
2786 vif_nest
= nla_nest_start_noflag(skb
, IPMRA_VIF
);
2789 if (nla_put_u32(skb
, IPMRA_VIFA_IFINDEX
, vif
->dev
->ifindex
) ||
2790 nla_put_u32(skb
, IPMRA_VIFA_VIF_ID
, vifid
) ||
2791 nla_put_u16(skb
, IPMRA_VIFA_FLAGS
, vif
->flags
) ||
2792 nla_put_u64_64bit(skb
, IPMRA_VIFA_BYTES_IN
, vif
->bytes_in
,
2794 nla_put_u64_64bit(skb
, IPMRA_VIFA_BYTES_OUT
, vif
->bytes_out
,
2796 nla_put_u64_64bit(skb
, IPMRA_VIFA_PACKETS_IN
, vif
->pkt_in
,
2798 nla_put_u64_64bit(skb
, IPMRA_VIFA_PACKETS_OUT
, vif
->pkt_out
,
2800 nla_put_be32(skb
, IPMRA_VIFA_LOCAL_ADDR
, vif
->local
) ||
2801 nla_put_be32(skb
, IPMRA_VIFA_REMOTE_ADDR
, vif
->remote
)) {
2802 nla_nest_cancel(skb
, vif_nest
);
2805 nla_nest_end(skb
, vif_nest
);
2810 static int ipmr_valid_dumplink(const struct nlmsghdr
*nlh
,
2811 struct netlink_ext_ack
*extack
)
2813 struct ifinfomsg
*ifm
;
2815 if (nlh
->nlmsg_len
< nlmsg_msg_size(sizeof(*ifm
))) {
2816 NL_SET_ERR_MSG(extack
, "ipv4: Invalid header for ipmr link dump");
2820 if (nlmsg_attrlen(nlh
, sizeof(*ifm
))) {
2821 NL_SET_ERR_MSG(extack
, "Invalid data after header in ipmr link dump");
2825 ifm
= nlmsg_data(nlh
);
2826 if (ifm
->__ifi_pad
|| ifm
->ifi_type
|| ifm
->ifi_flags
||
2827 ifm
->ifi_change
|| ifm
->ifi_index
) {
2828 NL_SET_ERR_MSG(extack
, "Invalid values in header for ipmr link dump request");
2835 static int ipmr_rtm_dumplink(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2837 struct net
*net
= sock_net(skb
->sk
);
2838 struct nlmsghdr
*nlh
= NULL
;
2839 unsigned int t
= 0, s_t
;
2840 unsigned int e
= 0, s_e
;
2841 struct mr_table
*mrt
;
2843 if (cb
->strict_check
) {
2844 int err
= ipmr_valid_dumplink(cb
->nlh
, cb
->extack
);
2853 ipmr_for_each_table(mrt
, net
) {
2854 struct nlattr
*vifs
, *af
;
2855 struct ifinfomsg
*hdr
;
2860 nlh
= nlmsg_put(skb
, NETLINK_CB(cb
->skb
).portid
,
2861 cb
->nlh
->nlmsg_seq
, RTM_NEWLINK
,
2862 sizeof(*hdr
), NLM_F_MULTI
);
2866 hdr
= nlmsg_data(nlh
);
2867 memset(hdr
, 0, sizeof(*hdr
));
2868 hdr
->ifi_family
= RTNL_FAMILY_IPMR
;
2870 af
= nla_nest_start_noflag(skb
, IFLA_AF_SPEC
);
2872 nlmsg_cancel(skb
, nlh
);
2876 if (!ipmr_fill_table(mrt
, skb
)) {
2877 nlmsg_cancel(skb
, nlh
);
2881 vifs
= nla_nest_start_noflag(skb
, IPMRA_TABLE_VIFS
);
2883 nla_nest_end(skb
, af
);
2884 nlmsg_end(skb
, nlh
);
2887 for (i
= 0; i
< mrt
->maxvif
; i
++) {
2890 if (!ipmr_fill_vif(mrt
, i
, skb
)) {
2891 nla_nest_end(skb
, vifs
);
2892 nla_nest_end(skb
, af
);
2893 nlmsg_end(skb
, nlh
);
2901 nla_nest_end(skb
, vifs
);
2902 nla_nest_end(skb
, af
);
2903 nlmsg_end(skb
, nlh
);
2915 #ifdef CONFIG_PROC_FS
2916 /* The /proc interfaces to multicast routing :
2917 * /proc/net/ip_mr_cache & /proc/net/ip_mr_vif
2920 static void *ipmr_vif_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2921 __acquires(mrt_lock
)
2923 struct mr_vif_iter
*iter
= seq
->private;
2924 struct net
*net
= seq_file_net(seq
);
2925 struct mr_table
*mrt
;
2927 mrt
= ipmr_get_table(net
, RT_TABLE_DEFAULT
);
2929 return ERR_PTR(-ENOENT
);
2933 read_lock(&mrt_lock
);
2934 return mr_vif_seq_start(seq
, pos
);
2937 static void ipmr_vif_seq_stop(struct seq_file
*seq
, void *v
)
2938 __releases(mrt_lock
)
2940 read_unlock(&mrt_lock
);
2943 static int ipmr_vif_seq_show(struct seq_file
*seq
, void *v
)
2945 struct mr_vif_iter
*iter
= seq
->private;
2946 struct mr_table
*mrt
= iter
->mrt
;
2948 if (v
== SEQ_START_TOKEN
) {
2950 "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
2952 const struct vif_device
*vif
= v
;
2953 const char *name
= vif
->dev
?
2954 vif
->dev
->name
: "none";
2957 "%2td %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
2958 vif
- mrt
->vif_table
,
2959 name
, vif
->bytes_in
, vif
->pkt_in
,
2960 vif
->bytes_out
, vif
->pkt_out
,
2961 vif
->flags
, vif
->local
, vif
->remote
);
2966 static const struct seq_operations ipmr_vif_seq_ops
= {
2967 .start
= ipmr_vif_seq_start
,
2968 .next
= mr_vif_seq_next
,
2969 .stop
= ipmr_vif_seq_stop
,
2970 .show
= ipmr_vif_seq_show
,
2973 static void *ipmr_mfc_seq_start(struct seq_file
*seq
, loff_t
*pos
)
2975 struct net
*net
= seq_file_net(seq
);
2976 struct mr_table
*mrt
;
2978 mrt
= ipmr_get_table(net
, RT_TABLE_DEFAULT
);
2980 return ERR_PTR(-ENOENT
);
2982 return mr_mfc_seq_start(seq
, pos
, mrt
, &mfc_unres_lock
);
2985 static int ipmr_mfc_seq_show(struct seq_file
*seq
, void *v
)
2989 if (v
== SEQ_START_TOKEN
) {
2991 "Group Origin Iif Pkts Bytes Wrong Oifs\n");
2993 const struct mfc_cache
*mfc
= v
;
2994 const struct mr_mfc_iter
*it
= seq
->private;
2995 const struct mr_table
*mrt
= it
->mrt
;
2997 seq_printf(seq
, "%08X %08X %-3hd",
2998 (__force u32
) mfc
->mfc_mcastgrp
,
2999 (__force u32
) mfc
->mfc_origin
,
3000 mfc
->_c
.mfc_parent
);
3002 if (it
->cache
!= &mrt
->mfc_unres_queue
) {
3003 seq_printf(seq
, " %8lu %8lu %8lu",
3004 mfc
->_c
.mfc_un
.res
.pkt
,
3005 mfc
->_c
.mfc_un
.res
.bytes
,
3006 mfc
->_c
.mfc_un
.res
.wrong_if
);
3007 for (n
= mfc
->_c
.mfc_un
.res
.minvif
;
3008 n
< mfc
->_c
.mfc_un
.res
.maxvif
; n
++) {
3009 if (VIF_EXISTS(mrt
, n
) &&
3010 mfc
->_c
.mfc_un
.res
.ttls
[n
] < 255)
3013 n
, mfc
->_c
.mfc_un
.res
.ttls
[n
]);
3016 /* unresolved mfc_caches don't contain
3017 * pkt, bytes and wrong_if values
3019 seq_printf(seq
, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
3021 seq_putc(seq
, '\n');
3026 static const struct seq_operations ipmr_mfc_seq_ops
= {
3027 .start
= ipmr_mfc_seq_start
,
3028 .next
= mr_mfc_seq_next
,
3029 .stop
= mr_mfc_seq_stop
,
3030 .show
= ipmr_mfc_seq_show
,
3034 #ifdef CONFIG_IP_PIMSM_V2
3035 static const struct net_protocol pim_protocol
= {
3041 static unsigned int ipmr_seq_read(struct net
*net
)
3045 return net
->ipv4
.ipmr_seq
+ ipmr_rules_seq_read(net
);
3048 static int ipmr_dump(struct net
*net
, struct notifier_block
*nb
,
3049 struct netlink_ext_ack
*extack
)
3051 return mr_dump(net
, nb
, RTNL_FAMILY_IPMR
, ipmr_rules_dump
,
3052 ipmr_mr_table_iter
, &mrt_lock
, extack
);
3055 static const struct fib_notifier_ops ipmr_notifier_ops_template
= {
3056 .family
= RTNL_FAMILY_IPMR
,
3057 .fib_seq_read
= ipmr_seq_read
,
3058 .fib_dump
= ipmr_dump
,
3059 .owner
= THIS_MODULE
,
3062 static int __net_init
ipmr_notifier_init(struct net
*net
)
3064 struct fib_notifier_ops
*ops
;
3066 net
->ipv4
.ipmr_seq
= 0;
3068 ops
= fib_notifier_ops_register(&ipmr_notifier_ops_template
, net
);
3070 return PTR_ERR(ops
);
3071 net
->ipv4
.ipmr_notifier_ops
= ops
;
3076 static void __net_exit
ipmr_notifier_exit(struct net
*net
)
3078 fib_notifier_ops_unregister(net
->ipv4
.ipmr_notifier_ops
);
3079 net
->ipv4
.ipmr_notifier_ops
= NULL
;
3082 /* Setup for IP multicast routing */
3083 static int __net_init
ipmr_net_init(struct net
*net
)
3087 err
= ipmr_notifier_init(net
);
3089 goto ipmr_notifier_fail
;
3091 err
= ipmr_rules_init(net
);
3093 goto ipmr_rules_fail
;
3095 #ifdef CONFIG_PROC_FS
3097 if (!proc_create_net("ip_mr_vif", 0, net
->proc_net
, &ipmr_vif_seq_ops
,
3098 sizeof(struct mr_vif_iter
)))
3100 if (!proc_create_net("ip_mr_cache", 0, net
->proc_net
, &ipmr_mfc_seq_ops
,
3101 sizeof(struct mr_mfc_iter
)))
3102 goto proc_cache_fail
;
3106 #ifdef CONFIG_PROC_FS
3108 remove_proc_entry("ip_mr_vif", net
->proc_net
);
3110 ipmr_rules_exit(net
);
3113 ipmr_notifier_exit(net
);
3118 static void __net_exit
ipmr_net_exit(struct net
*net
)
3120 #ifdef CONFIG_PROC_FS
3121 remove_proc_entry("ip_mr_cache", net
->proc_net
);
3122 remove_proc_entry("ip_mr_vif", net
->proc_net
);
3124 ipmr_notifier_exit(net
);
3125 ipmr_rules_exit(net
);
3128 static struct pernet_operations ipmr_net_ops
= {
3129 .init
= ipmr_net_init
,
3130 .exit
= ipmr_net_exit
,
3133 int __init
ip_mr_init(void)
3137 mrt_cachep
= kmem_cache_create("ip_mrt_cache",
3138 sizeof(struct mfc_cache
),
3139 0, SLAB_HWCACHE_ALIGN
| SLAB_PANIC
,
3142 err
= register_pernet_subsys(&ipmr_net_ops
);
3144 goto reg_pernet_fail
;
3146 err
= register_netdevice_notifier(&ip_mr_notifier
);
3148 goto reg_notif_fail
;
3149 #ifdef CONFIG_IP_PIMSM_V2
3150 if (inet_add_protocol(&pim_protocol
, IPPROTO_PIM
) < 0) {
3151 pr_err("%s: can't add PIM protocol\n", __func__
);
3153 goto add_proto_fail
;
3156 rtnl_register(RTNL_FAMILY_IPMR
, RTM_GETROUTE
,
3157 ipmr_rtm_getroute
, ipmr_rtm_dumproute
, 0);
3158 rtnl_register(RTNL_FAMILY_IPMR
, RTM_NEWROUTE
,
3159 ipmr_rtm_route
, NULL
, 0);
3160 rtnl_register(RTNL_FAMILY_IPMR
, RTM_DELROUTE
,
3161 ipmr_rtm_route
, NULL
, 0);
3163 rtnl_register(RTNL_FAMILY_IPMR
, RTM_GETLINK
,
3164 NULL
, ipmr_rtm_dumplink
, 0);
3167 #ifdef CONFIG_IP_PIMSM_V2
3169 unregister_netdevice_notifier(&ip_mr_notifier
);
3172 unregister_pernet_subsys(&ipmr_net_ops
);
3174 kmem_cache_destroy(mrt_cachep
);