projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'io_uring-6.4-2023-06-15' of git://git.kernel.dk/linux
[linux-2.6-block.git] / net / ipv6 / ip6mr.c
CommitLineData
2874c5fd 1// SPDX-License-Identifier: GPL-2.0-or-later
7bc570c8
YH		 2/*
3 * Linux IPv6 multicast routing support for BSD pim6sd
4 * Based on net/ipv4/ipmr.c.
5 *
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>
9 * 6WIND, Paris, France
10 * Copyright (C)2007,2008 USAGI/WIDE Project
11 * YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
7bc570c8
YH		 12 */
13
7c0f6ba6 14#include <linux/uaccess.h>
7bc570c8
YH		 15#include <linux/types.h>
16#include <linux/sched.h>
17#include <linux/errno.h>
7bc570c8
YH		 18#include <linux/mm.h>
19#include <linux/kernel.h>
20#include <linux/fcntl.h>
21#include <linux/stat.h>
22#include <linux/socket.h>
7bc570c8
YH		 23#include <linux/inet.h>
24#include <linux/netdevice.h>
25#include <linux/inetdevice.h>
7bc570c8
YH		 26#include <linux/proc_fs.h>
27#include <linux/seq_file.h>
7bc570c8 28#include <linux/init.h>
e2d57766 29#include <linux/compat.h>
0eb71a9d 30#include <linux/rhashtable.h>
7bc570c8
YH		 31#include <net/protocol.h>
32#include <linux/skbuff.h>
7bc570c8 33#include <net/raw.h>
7bc570c8
YH		 34#include <linux/notifier.h>
35#include <linux/if_arp.h>
7bc570c8
YH		 36#include <net/checksum.h>
37#include <net/netlink.h>
d1db275d 38#include <net/fib_rules.h>
7bc570c8
YH		 39
40#include <net/ipv6.h>
41#include <net/ip6_route.h>
42#include <linux/mroute6.h>
14fb64e1 43#include <linux/pim.h>
7bc570c8
YH		 44#include <net/addrconf.h>
45#include <linux/netfilter_ipv6.h>
bc3b2d7f 46#include <linux/export.h>
5d6e430d 47#include <net/ip6_checksum.h>
d67b8c61 48#include <linux/netconf.h>
cb9f1b78 49#include <net/ip_tunnels.h>
7bc570c8 50
69d2c867
GS		 51#include <linux/nospec.h>
52
d1db275d
PM		 53struct ip6mr_rule {
54 struct fib_rule common;
55};
56
57struct ip6mr_result {
b70432f7 58 struct mr_table *mrt;
d1db275d
PM		 59};
60
7bc570c8
YH		 61/* Big lock, protecting vif table, mrt cache and mroute socket state.
62 Note that the changes are semaphored via rtnl_lock.
63 */
64
a96f7a6a 65static DEFINE_SPINLOCK(mrt_lock);
7bc570c8 66
ebc31979
ED		 67static struct net_device *vif_dev_read(const struct vif_device *vif)
68{
a96f7a6a 69 return rcu_dereference(vif->dev);
ebc31979
ED		 70}
71
b70432f7 72/* Multicast router control variables */
7bc570c8 73
7bc570c8
YH		 74/* Special spinlock for queue of unresolved entries */
75static DEFINE_SPINLOCK(mfc_unres_lock);
76
77/* We return to original Alan's scheme. Hash table of resolved
78 entries is changed only in process context and protected
79 with weak lock mrt_lock. Queue of unresolved entries is protected
80 with strong spinlock mfc_unres_lock.
81
82 In this case data path is free of exclusive locks at all.
83 */
84
85static struct kmem_cache *mrt_cachep __read_mostly;
86
b70432f7
YM		 87static struct mr_table *ip6mr_new_table(struct net *net, u32 id);
88static void ip6mr_free_table(struct mr_table *mrt);
d1db275d 89
b70432f7 90static void ip6_mr_forward(struct net *net, struct mr_table *mrt,
e4a38c0c
PR		 91 struct net_device *dev, struct sk_buff *skb,
92 struct mfc6_cache *cache);
3493a5b7 93static int ip6mr_cache_report(const struct mr_table *mrt, struct sk_buff *pkt,
8229efda 94 mifi_t mifi, int assert);
b70432f7 95static void mr6_netlink_event(struct mr_table *mrt, struct mfc6_cache *mfc,
812e44dd 96 int cmd);
3493a5b7 97static void mrt6msg_netlink_event(const struct mr_table *mrt, struct sk_buff *pkt);
d7c31cbd
DL		 98static int ip6mr_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh,
99 struct netlink_ext_ack *extack);
5b285cac
PM		 100static int ip6mr_rtm_dumproute(struct sk_buff *skb,
101 struct netlink_callback *cb);
ca8d4794 102static void mroute_clean_tables(struct mr_table *mrt, int flags);
e99e88a9 103static void ipmr_expire_process(struct timer_list *t);
d1db275d
PM		 104
105#ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
8ffb335e 106#define ip6mr_for_each_table(mrt, net) \
28b380e2 107 list_for_each_entry_rcu(mrt, &net->ipv6.mr6_tables, list, \
b6dd5acd
MB		 108 lockdep_rtnl_is_held() || \
109 list_empty(&net->ipv6.mr6_tables))
d1db275d 110
7b0db857
YM		 111static struct mr_table *ip6mr_mr_table_iter(struct net *net,
112 struct mr_table *mrt)
113{
114 struct mr_table *ret;
115
116 if (!mrt)
117 ret = list_entry_rcu(net->ipv6.mr6_tables.next,
118 struct mr_table, list);
119 else
120 ret = list_entry_rcu(mrt->list.next,
121 struct mr_table, list);
122
123 if (&ret->list == &net->ipv6.mr6_tables)
124 return NULL;
125 return ret;
126}
127
b70432f7 128static struct mr_table *ip6mr_get_table(struct net *net, u32 id)
d1db275d 129{
b70432f7 130 struct mr_table *mrt;
d1db275d
PM		 131
132 ip6mr_for_each_table(mrt, net) {
133 if (mrt->id == id)
134 return mrt;
135 }
136 return NULL;
137}
138
4c9483b2 139static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
b70432f7 140 struct mr_table **mrt)
d1db275d 141{
d1db275d 142 int err;
95f4a45d
HFS		 143 struct ip6mr_result res;
144 struct fib_lookup_arg arg = {
145 .result = &res,
146 .flags = FIB_LOOKUP_NOREF,
147 };
d1db275d 148
e4a38c0c
PR		 149 /* update flow if oif or iif point to device enslaved to l3mdev */
150 l3mdev_update_flow(net, flowi6_to_flowi(flp6));
151
4c9483b2
DM		 152 err = fib_rules_lookup(net->ipv6.mr6_rules_ops,
153 flowi6_to_flowi(flp6), 0, &arg);
d1db275d
PM		 154 if (err < 0)
155 return err;
156 *mrt = res.mrt;
157 return 0;
158}
159
160static int ip6mr_rule_action(struct fib_rule *rule, struct flowi *flp,
161 int flags, struct fib_lookup_arg *arg)
162{
163 struct ip6mr_result *res = arg->result;
b70432f7 164 struct mr_table *mrt;
d1db275d
PM		 165
166 switch (rule->action) {
167 case FR_ACT_TO_TBL:
168 break;
169 case FR_ACT_UNREACHABLE:
170 return -ENETUNREACH;
171 case FR_ACT_PROHIBIT:
172 return -EACCES;
173 case FR_ACT_BLACKHOLE:
174 default:
175 return -EINVAL;
176 }
177
e4a38c0c
PR		 178 arg->table = fib_rule_get_table(rule, arg);
179
180 mrt = ip6mr_get_table(rule->fr_net, arg->table);
63159f29 181 if (!mrt)
d1db275d
PM		 182 return -EAGAIN;
183 res->mrt = mrt;
184 return 0;
185}
186
187static int ip6mr_rule_match(struct fib_rule *rule, struct flowi *flp, int flags)
188{
189 return 1;
190}
191
d1db275d 192static int ip6mr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
b16fb418
RP		 193 struct fib_rule_hdr *frh, struct nlattr **tb,
194 struct netlink_ext_ack *extack)
d1db275d
PM		 195{
196 return 0;
197}
198
199static int ip6mr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
200 struct nlattr **tb)
201{
202 return 1;
203}
204
205static int ip6mr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
206 struct fib_rule_hdr *frh)
207{
208 frh->dst_len = 0;
209 frh->src_len = 0;
210 frh->tos = 0;
211 return 0;
212}
213
04a6f82c 214static const struct fib_rules_ops __net_initconst ip6mr_rules_ops_template = {
d1db275d
PM		 215 .family = RTNL_FAMILY_IP6MR,
216 .rule_size = sizeof(struct ip6mr_rule),
217 .addr_size = sizeof(struct in6_addr),
218 .action = ip6mr_rule_action,
219 .match = ip6mr_rule_match,
220 .configure = ip6mr_rule_configure,
221 .compare = ip6mr_rule_compare,
d1db275d
PM		 222 .fill = ip6mr_rule_fill,
223 .nlgroup = RTNLGRP_IPV6_RULE,
d1db275d
PM		 224 .owner = THIS_MODULE,
225};
226
227static int __net_init ip6mr_rules_init(struct net *net)
228{
229 struct fib_rules_ops *ops;
b70432f7 230 struct mr_table *mrt;
d1db275d
PM		 231 int err;
232
233 ops = fib_rules_register(&ip6mr_rules_ops_template, net);
234 if (IS_ERR(ops))
235 return PTR_ERR(ops);
236
237 INIT_LIST_HEAD(&net->ipv6.mr6_tables);
238
239 mrt = ip6mr_new_table(net, RT6_TABLE_DFLT);
e783bb00
SD		 240 if (IS_ERR(mrt)) {
241 err = PTR_ERR(mrt);
d1db275d
PM		 242 goto err1;
243 }
244
245 err = fib_default_rule_add(ops, 0x7fff, RT6_TABLE_DFLT, 0);
246 if (err < 0)
247 goto err2;
248
249 net->ipv6.mr6_rules_ops = ops;
250 return 0;
251
252err2:
5611a006 253 rtnl_lock();
f243e5a7 254 ip6mr_free_table(mrt);
5611a006 255 rtnl_unlock();
d1db275d
PM		 256err1:
257 fib_rules_unregister(ops);
258 return err;
259}
260
261static void __net_exit ip6mr_rules_exit(struct net *net)
262{
b70432f7 263 struct mr_table *mrt, *next;
d1db275d 264
e2f736b7 265 ASSERT_RTNL();
035320d5
ED		 266 list_for_each_entry_safe(mrt, next, &net->ipv6.mr6_tables, list) {
267 list_del(&mrt->list);
d1db275d 268 ip6mr_free_table(mrt);
035320d5 269 }
d1db275d
PM		 270 fib_rules_unregister(net->ipv6.mr6_rules_ops);
271}
088aa3ee 272
b7a59557
JP		 273static int ip6mr_rules_dump(struct net *net, struct notifier_block *nb,
274 struct netlink_ext_ack *extack)
088aa3ee 275{
b7a59557 276 return fib_rules_dump(net, nb, RTNL_FAMILY_IP6MR, extack);
088aa3ee
YM		 277}
278
279static unsigned int ip6mr_rules_seq_read(struct net *net)
280{
281 return fib_rules_seq_read(net, RTNL_FAMILY_IP6MR);
282}
d3c07e5b
YM		 283
284bool ip6mr_rule_default(const struct fib_rule *rule)
285{
286 return fib_rule_matchall(rule) && rule->action == FR_ACT_TO_TBL &&
287 rule->table == RT6_TABLE_DFLT && !rule->l3mdev;
288}
289EXPORT_SYMBOL(ip6mr_rule_default);
d1db275d
PM		 290#else
291#define ip6mr_for_each_table(mrt, net) \
292 for (mrt = net->ipv6.mrt6; mrt; mrt = NULL)
293
7b0db857
YM		 294static struct mr_table *ip6mr_mr_table_iter(struct net *net,
295 struct mr_table *mrt)
296{
297 if (!mrt)
298 return net->ipv6.mrt6;
299 return NULL;
300}
301
b70432f7 302static struct mr_table *ip6mr_get_table(struct net *net, u32 id)
d1db275d
PM		 303{
304 return net->ipv6.mrt6;
305}
306
4c9483b2 307static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
b70432f7 308 struct mr_table **mrt)
d1db275d
PM		 309{
310 *mrt = net->ipv6.mrt6;
311 return 0;
312}
313
314static int __net_init ip6mr_rules_init(struct net *net)
315{
e783bb00
SD		 316 struct mr_table *mrt;
317
318 mrt = ip6mr_new_table(net, RT6_TABLE_DFLT);
319 if (IS_ERR(mrt))
320 return PTR_ERR(mrt);
321 net->ipv6.mrt6 = mrt;
322 return 0;
d1db275d
PM		 323}
324
325static void __net_exit ip6mr_rules_exit(struct net *net)
326{
e2f736b7 327 ASSERT_RTNL();
d1db275d 328 ip6mr_free_table(net->ipv6.mrt6);
905a6f96 329 net->ipv6.mrt6 = NULL;
d1db275d 330}
088aa3ee 331
b7a59557
JP		 332static int ip6mr_rules_dump(struct net *net, struct notifier_block *nb,
333 struct netlink_ext_ack *extack)
088aa3ee
YM		 334{
335 return 0;
336}
337
338static unsigned int ip6mr_rules_seq_read(struct net *net)
339{
340 return 0;
341}
d1db275d
PM		 342#endif
343
87c418bf
YM		 344static int ip6mr_hash_cmp(struct rhashtable_compare_arg *arg,
345 const void *ptr)
346{
347 const struct mfc6_cache_cmp_arg *cmparg = arg->key;
348 struct mfc6_cache *c = (struct mfc6_cache *)ptr;
349
350 return !ipv6_addr_equal(&c->mf6c_mcastgrp, &cmparg->mf6c_mcastgrp) ||
351 !ipv6_addr_equal(&c->mf6c_origin, &cmparg->mf6c_origin);
352}
353
354static const struct rhashtable_params ip6mr_rht_params = {
494fff56 355 .head_offset = offsetof(struct mr_mfc, mnode),
87c418bf
YM		 356 .key_offset = offsetof(struct mfc6_cache, cmparg),
357 .key_len = sizeof(struct mfc6_cache_cmp_arg),
358 .nelem_hint = 3,
87c418bf
YM		 359 .obj_cmpfn = ip6mr_hash_cmp,
360 .automatic_shrinking = true,
361};
362
0bbbf0e7
YM		 363static void ip6mr_new_table_set(struct mr_table *mrt,
364 struct net *net)
365{
366#ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
367 list_add_tail_rcu(&mrt->list, &net->ipv6.mr6_tables);
368#endif
369}
370
845c9a7a
YM		 371static struct mfc6_cache_cmp_arg ip6mr_mr_table_ops_cmparg_any = {
372 .mf6c_origin = IN6ADDR_ANY_INIT,
373 .mf6c_mcastgrp = IN6ADDR_ANY_INIT,
374};
375
376static struct mr_table_ops ip6mr_mr_table_ops = {
377 .rht_params = &ip6mr_rht_params,
378 .cmparg_any = &ip6mr_mr_table_ops_cmparg_any,
379};
380
b70432f7 381static struct mr_table *ip6mr_new_table(struct net *net, u32 id)
d1db275d 382{
b70432f7 383 struct mr_table *mrt;
d1db275d
PM		 384
385 mrt = ip6mr_get_table(net, id);
53b24b8f 386 if (mrt)
d1db275d
PM		 387 return mrt;
388
845c9a7a 389 return mr_table_alloc(net, id, &ip6mr_mr_table_ops,
0bbbf0e7 390 ipmr_expire_process, ip6mr_new_table_set);
d1db275d 391}
7bc570c8 392
b70432f7 393static void ip6mr_free_table(struct mr_table *mrt)
d1db275d 394{
292a089d 395 timer_shutdown_sync(&mrt->ipmr_expire_timer);
ca8d4794
CS		 396 mroute_clean_tables(mrt, MRT6_FLUSH_MIFS | MRT6_FLUSH_MIFS_STATIC |
397 MRT6_FLUSH_MFC | MRT6_FLUSH_MFC_STATIC);
b70432f7 398 rhltable_destroy(&mrt->mfc_hash);
d1db275d
PM		 399 kfree(mrt);
400}
7bc570c8
YH		 401
402#ifdef CONFIG_PROC_FS
c8d61968
YM		 403/* The /proc interfaces to multicast routing
404 * /proc/ip6_mr_cache /proc/ip6_mr_vif
7bc570c8
YH		 405 */
406
7bc570c8 407static void *ip6mr_vif_seq_start(struct seq_file *seq, loff_t *pos)
b96ef16d 408 __acquires(RCU)
7bc570c8 409{
3feda6b4 410 struct mr_vif_iter *iter = seq->private;
8b90fc7e 411 struct net *net = seq_file_net(seq);
b70432f7 412 struct mr_table *mrt;
d1db275d
PM		 413
414 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
63159f29 415 if (!mrt)
d1db275d
PM		 416 return ERR_PTR(-ENOENT);
417
418 iter->mrt = mrt;
8b90fc7e 419
b96ef16d 420 rcu_read_lock();
3feda6b4 421 return mr_vif_seq_start(seq, pos);
7bc570c8
YH		 422}
423
424static void ip6mr_vif_seq_stop(struct seq_file *seq, void *v)
b96ef16d 425 __releases(RCU)
7bc570c8 426{
b96ef16d 427 rcu_read_unlock();
7bc570c8
YH		 428}
429
430static int ip6mr_vif_seq_show(struct seq_file *seq, void *v)
431{
3feda6b4 432 struct mr_vif_iter *iter = seq->private;
b70432f7 433 struct mr_table *mrt = iter->mrt;
8b90fc7e 434
7bc570c8
YH		 435 if (v == SEQ_START_TOKEN) {
436 seq_puts(seq,
437 "Interface BytesIn PktsIn BytesOut PktsOut Flags\n");
438 } else {
6853f21f 439 const struct vif_device *vif = v;
ebc31979
ED		 440 const struct net_device *vif_dev;
441 const char *name;
442
443 vif_dev = vif_dev_read(vif);
444 name = vif_dev ? vif_dev->name : "none";
7bc570c8
YH		 445
446 seq_printf(seq,
d430a227 447 "%2td %-10s %8ld %7ld %8ld %7ld %05X\n",
b70432f7 448 vif - mrt->vif_table,
7bc570c8
YH		 449 name, vif->bytes_in, vif->pkt_in,
450 vif->bytes_out, vif->pkt_out,
451 vif->flags);
452 }
453 return 0;
454}
455
98147d52 456static const struct seq_operations ip6mr_vif_seq_ops = {
7bc570c8 457 .start = ip6mr_vif_seq_start,
3feda6b4 458 .next = mr_vif_seq_next,
7bc570c8
YH		 459 .stop = ip6mr_vif_seq_stop,
460 .show = ip6mr_vif_seq_show,
461};
462
7bc570c8
YH		 463static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
464{
8b90fc7e 465 struct net *net = seq_file_net(seq);
b70432f7 466 struct mr_table *mrt;
8b90fc7e 467
d1db275d 468 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
63159f29 469 if (!mrt)
d1db275d
PM		 470 return ERR_PTR(-ENOENT);
471
c8d61968 472 return mr_mfc_seq_start(seq, pos, mrt, &mfc_unres_lock);
7bc570c8
YH		 473}
474
475static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
476{
477 int n;
478
479 if (v == SEQ_START_TOKEN) {
480 seq_puts(seq,
481 "Group "
482 "Origin "
483 "Iif Pkts Bytes Wrong Oifs\n");
484 } else {
485 const struct mfc6_cache *mfc = v;
c8d61968 486 const struct mr_mfc_iter *it = seq->private;
b70432f7 487 struct mr_table *mrt = it->mrt;
7bc570c8 488
999890b2 489 seq_printf(seq, "%pI6 %pI6 %-3hd",
0c6ce78a 490 &mfc->mf6c_mcastgrp, &mfc->mf6c_origin,
494fff56 491 mfc->_c.mfc_parent);
7bc570c8 492
b70432f7 493 if (it->cache != &mrt->mfc_unres_queue) {
1ea472e2 494 seq_printf(seq, " %8lu %8lu %8lu",
494fff56
YM		 495 mfc->_c.mfc_un.res.pkt,
496 mfc->_c.mfc_un.res.bytes,
497 mfc->_c.mfc_un.res.wrong_if);
498 for (n = mfc->_c.mfc_un.res.minvif;
499 n < mfc->_c.mfc_un.res.maxvif; n++) {
b70432f7 500 if (VIF_EXISTS(mrt, n) &&
494fff56 501 mfc->_c.mfc_un.res.ttls[n] < 255)
7bc570c8 502 seq_printf(seq,
494fff56
YM		 503 " %2d:%-3d", n,
504 mfc->_c.mfc_un.res.ttls[n]);
7bc570c8 505 }
1ea472e2
BT		 506 } else {
507 /* unresolved mfc_caches don't contain
508 * pkt, bytes and wrong_if values
509 */
510 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
7bc570c8
YH		 511 }
512 seq_putc(seq, '\n');
513 }
514 return 0;
515}
516
88e9d34c 517static const struct seq_operations ipmr_mfc_seq_ops = {
7bc570c8 518 .start = ipmr_mfc_seq_start,
c8d61968
YM		 519 .next = mr_mfc_seq_next,
520 .stop = mr_mfc_seq_stop,
7bc570c8
YH		 521 .show = ipmr_mfc_seq_show,
522};
7bc570c8
YH		 523#endif
524
14fb64e1 525#ifdef CONFIG_IPV6_PIMSM_V2
14fb64e1
YH		 526
527static int pim6_rcv(struct sk_buff *skb)
528{
529 struct pimreghdr *pim;
530 struct ipv6hdr *encap;
531 struct net_device *reg_dev = NULL;
8229efda 532 struct net *net = dev_net(skb->dev);
b70432f7 533 struct mr_table *mrt;
4c9483b2
DM		 534 struct flowi6 fl6 = {
535 .flowi6_iif = skb->dev->ifindex,
536 .flowi6_mark = skb->mark,
d1db275d
PM		 537 };
538 int reg_vif_num;
14fb64e1
YH		 539
540 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
541 goto drop;
542
543 pim = (struct pimreghdr *)skb_transport_header(skb);
56245cae 544 if (pim->type != ((PIM_VERSION << 4) | PIM_TYPE_REGISTER) ||
14fb64e1 545 (pim->flags & PIM_NULL_REGISTER) ||
1d6e55f1
TG		 546 (csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
547 sizeof(*pim), IPPROTO_PIM,
548 csum_partial((void *)pim, sizeof(*pim), 0)) &&
ec6b486f 549 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
14fb64e1
YH		 550 goto drop;
551
552 /* check if the inner packet is destined to mcast group */
553 encap = (struct ipv6hdr *)(skb_transport_header(skb) +
554 sizeof(*pim));
555
556 if (!ipv6_addr_is_multicast(&encap->daddr) ||
557 encap->payload_len == 0 ||
558 ntohs(encap->payload_len) + sizeof(*pim) > skb->len)
559 goto drop;
560
4c9483b2 561 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
d1db275d 562 goto drop;
d1db275d 563
6d086587
ED		 564 /* Pairs with WRITE_ONCE() in mif6_add()/mif6_delete() */
565 reg_vif_num = READ_ONCE(mrt->mroute_reg_vif_num);
14fb64e1 566 if (reg_vif_num >= 0)
ebc31979 567 reg_dev = vif_dev_read(&mrt->vif_table[reg_vif_num]);
14fb64e1 568
63159f29 569 if (!reg_dev)
14fb64e1
YH		 570 goto drop;
571
572 skb->mac_header = skb->network_header;
573 skb_pull(skb, (u8 *)encap - skb->data);
574 skb_reset_network_header(skb);
1d6e55f1 575 skb->protocol = htons(ETH_P_IPV6);
3e49e6d5 576 skb->ip_summed = CHECKSUM_NONE;
d19d56dd 577
ea23192e 578 skb_tunnel_rx(skb, reg_dev, dev_net(reg_dev));
d19d56dd 579
caf586e5 580 netif_rx(skb);
8990f468 581
14fb64e1
YH		 582 return 0;
583 drop:
584 kfree_skb(skb);
585 return 0;
586}
587
41135cc8 588static const struct inet6_protocol pim6_protocol = {
14fb64e1
YH		 589 .handler = pim6_rcv,
590};
591
592/* Service routines creating virtual interfaces: PIMREG */
593
6fef4c0c
SH		 594static netdev_tx_t reg_vif_xmit(struct sk_buff *skb,
595 struct net_device *dev)
14fb64e1 596{
8229efda 597 struct net *net = dev_net(dev);
b70432f7 598 struct mr_table *mrt;
4c9483b2
DM		 599 struct flowi6 fl6 = {
600 .flowi6_oif = dev->ifindex,
6a662719 601 .flowi6_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
4c9483b2 602 .flowi6_mark = skb->mark,
d1db275d 603 };
d1db275d 604
cb9f1b78
WB		 605 if (!pskb_inet_may_pull(skb))
606 goto tx_err;
607
608 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
609 goto tx_err;
8229efda 610
2fad1ba3
ED		 611 DEV_STATS_ADD(dev, tx_bytes, skb->len);
612 DEV_STATS_INC(dev, tx_packets);
3493a5b7
ED		 613 rcu_read_lock();
614 ip6mr_cache_report(mrt, skb, READ_ONCE(mrt->mroute_reg_vif_num),
615 MRT6MSG_WHOLEPKT);
616 rcu_read_unlock();
14fb64e1 617 kfree_skb(skb);
6ed10654 618 return NETDEV_TX_OK;
cb9f1b78
WB		 619
620tx_err:
2fad1ba3 621 DEV_STATS_INC(dev, tx_errors);
cb9f1b78
WB		 622 kfree_skb(skb);
623 return NETDEV_TX_OK;
14fb64e1
YH		 624}
625
ee9b9596
ND		 626static int reg_vif_get_iflink(const struct net_device *dev)
627{
628 return 0;
629}
630
007c3838
SH		 631static const struct net_device_ops reg_vif_netdev_ops = {
632 .ndo_start_xmit = reg_vif_xmit,
ee9b9596 633 .ndo_get_iflink = reg_vif_get_iflink,
007c3838
SH		 634};
635
14fb64e1
YH		 636static void reg_vif_setup(struct net_device *dev)
637{
638 dev->type = ARPHRD_PIMREG;
639 dev->mtu = 1500 - sizeof(struct ipv6hdr) - 8;
640 dev->flags = IFF_NOARP;
007c3838 641 dev->netdev_ops = &reg_vif_netdev_ops;
cf124db5 642 dev->needs_free_netdev = true;
403dbb97 643 dev->features |= NETIF_F_NETNS_LOCAL;
14fb64e1
YH		 644}
645
b70432f7 646static struct net_device *ip6mr_reg_vif(struct net *net, struct mr_table *mrt)
14fb64e1
YH		 647{
648 struct net_device *dev;
d1db275d
PM		 649 char name[IFNAMSIZ];
650
651 if (mrt->id == RT6_TABLE_DFLT)
652 sprintf(name, "pim6reg");
653 else
654 sprintf(name, "pim6reg%u", mrt->id);
14fb64e1 655
c835a677 656 dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, reg_vif_setup);
63159f29 657 if (!dev)
14fb64e1
YH		 658 return NULL;
659
8229efda
BT		 660 dev_net_set(dev, net);
661
14fb64e1
YH		 662 if (register_netdevice(dev)) {
663 free_netdev(dev);
664 return NULL;
665 }
14fb64e1 666
00f54e68 667 if (dev_open(dev, NULL))
14fb64e1
YH		 668 goto failure;
669
7af3db78 670 dev_hold(dev);
14fb64e1
YH		 671 return dev;
672
673failure:
14fb64e1
YH		 674 unregister_netdevice(dev);
675 return NULL;
676}
677#endif
678
088aa3ee
YM		 679static int call_ip6mr_vif_entry_notifiers(struct net *net,
680 enum fib_event_type event_type,
681 struct vif_device *vif,
ebc31979 682 struct net_device *vif_dev,
088aa3ee
YM		 683 mifi_t vif_index, u32 tb_id)
684{
685 return mr_call_vif_notifiers(net, RTNL_FAMILY_IP6MR, event_type,
ebc31979 686 vif, vif_dev, vif_index, tb_id,
088aa3ee
YM		 687 &net->ipv6.ipmr_seq);
688}
7bc570c8 689
088aa3ee
YM		 690static int call_ip6mr_mfc_entry_notifiers(struct net *net,
691 enum fib_event_type event_type,
692 struct mfc6_cache *mfc, u32 tb_id)
693{
694 return mr_call_mfc_notifiers(net, RTNL_FAMILY_IP6MR, event_type,
695 &mfc->_c, tb_id, &net->ipv6.ipmr_seq);
696}
697
698/* Delete a VIF entry */
b70432f7 699static int mif6_delete(struct mr_table *mrt, int vifi, int notify,
723b929c 700 struct list_head *head)
7bc570c8 701{
6853f21f 702 struct vif_device *v;
7bc570c8 703 struct net_device *dev;
1d6e55f1 704 struct inet6_dev *in6_dev;
6bd52143
PM		 705
706 if (vifi < 0 || vifi >= mrt->maxvif)
7bc570c8
YH		 707 return -EADDRNOTAVAIL;
708
b70432f7 709 v = &mrt->vif_table[vifi];
7bc570c8 710
ebc31979
ED		 711 dev = rtnl_dereference(v->dev);
712 if (!dev)
713 return -EADDRNOTAVAIL;
088aa3ee 714
ebc31979
ED		 715 call_ip6mr_vif_entry_notifiers(read_pnet(&mrt->net),
716 FIB_EVENT_VIF_DEL, v, dev,
717 vifi, mrt->id);
a96f7a6a 718 spin_lock(&mrt_lock);
ebc31979 719 RCU_INIT_POINTER(v->dev, NULL);
7bc570c8 720
14fb64e1 721#ifdef CONFIG_IPV6_PIMSM_V2
3493a5b7
ED		 722 if (vifi == mrt->mroute_reg_vif_num) {
723 /* Pairs with READ_ONCE() in ip6mr_cache_report() and reg_vif_xmit() */
724 WRITE_ONCE(mrt->mroute_reg_vif_num, -1);
725 }
14fb64e1
YH		 726#endif
727
6bd52143 728 if (vifi + 1 == mrt->maxvif) {
7bc570c8
YH		 729 int tmp;
730 for (tmp = vifi - 1; tmp >= 0; tmp--) {
b70432f7 731 if (VIF_EXISTS(mrt, tmp))
7bc570c8
YH		 732 break;
733 }
db9eb7c8 734 WRITE_ONCE(mrt->maxvif, tmp + 1);
7bc570c8
YH		 735 }
736
a96f7a6a 737 spin_unlock(&mrt_lock);
7bc570c8
YH		 738
739 dev_set_allmulti(dev, -1);
740
1d6e55f1 741 in6_dev = __in6_dev_get(dev);
d67b8c61 742 if (in6_dev) {
145c7a79 743 atomic_dec(&in6_dev->cnf.mc_forwarding);
85b3daad 744 inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
d67b8c61
ND		 745 NETCONFA_MC_FORWARDING,
746 dev->ifindex, &in6_dev->cnf);
747 }
1d6e55f1 748
723b929c 749 if ((v->flags & MIFF_REGISTER) && !notify)
c871e664 750 unregister_netdevice_queue(dev, head);
7bc570c8 751
d62607c3 752 netdev_put(dev, &v->dev_tracker);
7bc570c8
YH		 753 return 0;
754}
755
87c418bf 756static inline void ip6mr_cache_free_rcu(struct rcu_head *head)
58701ad4 757{
494fff56 758 struct mr_mfc *c = container_of(head, struct mr_mfc, rcu);
87c418bf 759
494fff56 760 kmem_cache_free(mrt_cachep, (struct mfc6_cache *)c);
58701ad4
BT		 761}
762
87c418bf
YM		 763static inline void ip6mr_cache_free(struct mfc6_cache *c)
764{
494fff56 765 call_rcu(&c->_c.rcu, ip6mr_cache_free_rcu);
87c418bf
YM		 766}
767
7bc570c8
YH		 768/* Destroy an unresolved cache entry, killing queued skbs
769 and reporting error to netlink readers.
770 */
771
b70432f7 772static void ip6mr_destroy_unres(struct mr_table *mrt, struct mfc6_cache *c)
7bc570c8 773{
6bd52143 774 struct net *net = read_pnet(&mrt->net);
7bc570c8
YH		 775 struct sk_buff *skb;
776
6bd52143 777 atomic_dec(&mrt->cache_resolve_queue_len);
7bc570c8 778
494fff56 779 while ((skb = skb_dequeue(&c->_c.mfc_un.unres.unresolved)) != NULL) {
7bc570c8 780 if (ipv6_hdr(skb)->version == 0) {
af72868b
JB		 781 struct nlmsghdr *nlh = skb_pull(skb,
782 sizeof(struct ipv6hdr));
7bc570c8 783 nlh->nlmsg_type = NLMSG_ERROR;
573ce260 784 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
7bc570c8 785 skb_trim(skb, nlh->nlmsg_len);
573ce260 786 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -ETIMEDOUT;
15e47304 787 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
7bc570c8
YH		 788 } else
789 kfree_skb(skb);
790 }
791
58701ad4 792 ip6mr_cache_free(c);
7bc570c8
YH		 793}
794
795
c476efbc 796/* Timer process for all the unresolved queue. */
7bc570c8 797
b70432f7 798static void ipmr_do_expire_process(struct mr_table *mrt)
7bc570c8
YH		 799{
800 unsigned long now = jiffies;
801 unsigned long expires = 10 * HZ;
494fff56 802 struct mr_mfc *c, *next;
7bc570c8 803
b70432f7 804 list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
7bc570c8
YH		 805 if (time_after(c->mfc_un.unres.expires, now)) {
806 /* not yet... */
807 unsigned long interval = c->mfc_un.unres.expires - now;
808 if (interval < expires)
809 expires = interval;
7bc570c8
YH		 810 continue;
811 }
812
f30a7784 813 list_del(&c->list);
494fff56
YM		 814 mr6_netlink_event(mrt, (struct mfc6_cache *)c, RTM_DELROUTE);
815 ip6mr_destroy_unres(mrt, (struct mfc6_cache *)c);
7bc570c8
YH		 816 }
817
b70432f7 818 if (!list_empty(&mrt->mfc_unres_queue))
6bd52143 819 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
7bc570c8
YH		 820}
821
e99e88a9 822static void ipmr_expire_process(struct timer_list *t)
7bc570c8 823{
b70432f7 824 struct mr_table *mrt = from_timer(mrt, t, ipmr_expire_timer);
c476efbc 825
7bc570c8 826 if (!spin_trylock(&mfc_unres_lock)) {
6bd52143 827 mod_timer(&mrt->ipmr_expire_timer, jiffies + 1);
7bc570c8
YH		 828 return;
829 }
830
b70432f7 831 if (!list_empty(&mrt->mfc_unres_queue))
6bd52143 832 ipmr_do_expire_process(mrt);
7bc570c8
YH		 833
834 spin_unlock(&mfc_unres_lock);
835}
836
a96f7a6a 837/* Fill oifs list. It is called under locked mrt_lock. */
7bc570c8 838
b70432f7 839static void ip6mr_update_thresholds(struct mr_table *mrt,
494fff56 840 struct mr_mfc *cache,
b5aa30b1 841 unsigned char *ttls)
7bc570c8
YH		 842{
843 int vifi;
844
6ac7eb08 845 cache->mfc_un.res.minvif = MAXMIFS;
7bc570c8 846 cache->mfc_un.res.maxvif = 0;
6ac7eb08 847 memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
7bc570c8 848
6bd52143 849 for (vifi = 0; vifi < mrt->maxvif; vifi++) {
b70432f7 850 if (VIF_EXISTS(mrt, vifi) &&
4e16880c 851 ttls[vifi] && ttls[vifi] < 255) {
7bc570c8
YH		 852 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
853 if (cache->mfc_un.res.minvif > vifi)
854 cache->mfc_un.res.minvif = vifi;
855 if (cache->mfc_un.res.maxvif <= vifi)
856 cache->mfc_un.res.maxvif = vifi + 1;
857 }
858 }
90b5ca17 859 cache->mfc_un.res.lastuse = jiffies;
7bc570c8
YH		 860}
861
b70432f7 862static int mif6_add(struct net *net, struct mr_table *mrt,
6bd52143 863 struct mif6ctl *vifc, int mrtsock)
7bc570c8
YH		 864{
865 int vifi = vifc->mif6c_mifi;
b70432f7 866 struct vif_device *v = &mrt->vif_table[vifi];
7bc570c8 867 struct net_device *dev;
1d6e55f1 868 struct inet6_dev *in6_dev;
5ae7b444 869 int err;
7bc570c8
YH		 870
871 /* Is vif busy ? */
b70432f7 872 if (VIF_EXISTS(mrt, vifi))
7bc570c8
YH		 873 return -EADDRINUSE;
874
875 switch (vifc->mif6c_flags) {
14fb64e1
YH		 876#ifdef CONFIG_IPV6_PIMSM_V2
877 case MIFF_REGISTER:
878 /*
879 * Special Purpose VIF in PIM
880 * All the packets will be sent to the daemon
881 */
6bd52143 882 if (mrt->mroute_reg_vif_num >= 0)
14fb64e1 883 return -EADDRINUSE;
d1db275d 884 dev = ip6mr_reg_vif(net, mrt);
14fb64e1
YH		 885 if (!dev)
886 return -ENOBUFS;
5ae7b444
WC		 887 err = dev_set_allmulti(dev, 1);
888 if (err) {
889 unregister_netdevice(dev);
7af3db78 890 dev_put(dev);
5ae7b444
WC		 891 return err;
892 }
14fb64e1
YH		 893 break;
894#endif
7bc570c8 895 case 0:
8229efda 896 dev = dev_get_by_index(net, vifc->mif6c_pifi);
7bc570c8
YH		 897 if (!dev)
898 return -EADDRNOTAVAIL;
5ae7b444 899 err = dev_set_allmulti(dev, 1);
7af3db78
WC		 900 if (err) {
901 dev_put(dev);
5ae7b444 902 return err;
7af3db78 903 }
7bc570c8
YH		 904 break;
905 default:
906 return -EINVAL;
907 }
908
1d6e55f1 909 in6_dev = __in6_dev_get(dev);
d67b8c61 910 if (in6_dev) {
145c7a79 911 atomic_inc(&in6_dev->cnf.mc_forwarding);
85b3daad 912 inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
d67b8c61
ND		 913 NETCONFA_MC_FORWARDING,
914 dev->ifindex, &in6_dev->cnf);
915 }
1d6e55f1 916
6853f21f
YM		 917 /* Fill in the VIF structures */
918 vif_device_init(v, dev, vifc->vifc_rate_limit, vifc->vifc_threshold,
919 vifc->mif6c_flags | (!mrtsock ? VIFF_STATIC : 0),
920 MIFF_REGISTER);
7bc570c8
YH		 921
922 /* And finish update writing critical data */
a96f7a6a 923 spin_lock(&mrt_lock);
ebc31979 924 rcu_assign_pointer(v->dev, dev);
42120a86 925 netdev_tracker_alloc(dev, &v->dev_tracker, GFP_ATOMIC);
14fb64e1
YH		 926#ifdef CONFIG_IPV6_PIMSM_V2
927 if (v->flags & MIFF_REGISTER)
3493a5b7 928 WRITE_ONCE(mrt->mroute_reg_vif_num, vifi);
14fb64e1 929#endif
6bd52143 930 if (vifi + 1 > mrt->maxvif)
db9eb7c8 931 WRITE_ONCE(mrt->maxvif, vifi + 1);
a96f7a6a 932 spin_unlock(&mrt_lock);
088aa3ee 933 call_ip6mr_vif_entry_notifiers(net, FIB_EVENT_VIF_ADD,
ebc31979 934 v, dev, vifi, mrt->id);
7bc570c8
YH		 935 return 0;
936}
937
b70432f7 938static struct mfc6_cache *ip6mr_cache_find(struct mr_table *mrt,
b71d1d42
ED		 939 const struct in6_addr *origin,
940 const struct in6_addr *mcastgrp)
7bc570c8 941{
87c418bf
YM		 942 struct mfc6_cache_cmp_arg arg = {
943 .mf6c_origin = *origin,
944 .mf6c_mcastgrp = *mcastgrp,
945 };
87c418bf 946
845c9a7a 947 return mr_mfc_find(mrt, &arg);
660b26dc
ND		 948}
949
950/* Look for a (*,G) entry */
b70432f7 951static struct mfc6_cache *ip6mr_cache_find_any(struct mr_table *mrt,
660b26dc
ND		 952 struct in6_addr *mcastgrp,
953 mifi_t mifi)
954{
87c418bf
YM		 955 struct mfc6_cache_cmp_arg arg = {
956 .mf6c_origin = in6addr_any,
957 .mf6c_mcastgrp = *mcastgrp,
958 };
660b26dc
ND		 959
960 if (ipv6_addr_any(mcastgrp))
845c9a7a
YM		 961 return mr_mfc_find_any_parent(mrt, mifi);
962 return mr_mfc_find_any(mrt, mifi, &arg);
660b26dc
ND		 963}
964
87c418bf
YM		 965/* Look for a (S,G,iif) entry if parent != -1 */
966static struct mfc6_cache *
b70432f7 967ip6mr_cache_find_parent(struct mr_table *mrt,
87c418bf
YM		 968 const struct in6_addr *origin,
969 const struct in6_addr *mcastgrp,
970 int parent)
971{
972 struct mfc6_cache_cmp_arg arg = {
973 .mf6c_origin = *origin,
974 .mf6c_mcastgrp = *mcastgrp,
975 };
87c418bf 976
845c9a7a 977 return mr_mfc_find_parent(mrt, &arg, parent);
87c418bf
YM		 978}
979
845c9a7a 980/* Allocate a multicast cache entry */
b5aa30b1 981static struct mfc6_cache *ip6mr_cache_alloc(void)
7bc570c8 982{
36cbac59 983 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
63159f29 984 if (!c)
7bc570c8 985 return NULL;
494fff56
YM		 986 c->_c.mfc_un.res.last_assert = jiffies - MFC_ASSERT_THRESH - 1;
987 c->_c.mfc_un.res.minvif = MAXMIFS;
8c13af2a
YM		 988 c->_c.free = ip6mr_cache_free_rcu;
989 refcount_set(&c->_c.mfc_un.res.refcount, 1);
7bc570c8
YH		 990 return c;
991}
992
b5aa30b1 993static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
7bc570c8 994{
36cbac59 995 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
63159f29 996 if (!c)
7bc570c8 997 return NULL;
494fff56
YM		 998 skb_queue_head_init(&c->_c.mfc_un.unres.unresolved);
999 c->_c.mfc_un.unres.expires = jiffies + 10 * HZ;
7bc570c8
YH		 1000 return c;
1001}
1002
1003/*
1004 * A cache entry has gone into a resolved state from queued
1005 */
1006
b70432f7 1007static void ip6mr_cache_resolve(struct net *net, struct mr_table *mrt,
6bd52143 1008 struct mfc6_cache *uc, struct mfc6_cache *c)
7bc570c8
YH		 1009{
1010 struct sk_buff *skb;
1011
1012 /*
1013 * Play the pending entries through our router
1014 */
1015
494fff56 1016 while ((skb = __skb_dequeue(&uc->_c.mfc_un.unres.unresolved))) {
7bc570c8 1017 if (ipv6_hdr(skb)->version == 0) {
af72868b
JB		 1018 struct nlmsghdr *nlh = skb_pull(skb,
1019 sizeof(struct ipv6hdr));
7bc570c8 1020
7b0db857
YM		 1021 if (mr_fill_mroute(mrt, skb, &c->_c,
1022 nlmsg_data(nlh)) > 0) {
549e028d 1023 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
7bc570c8
YH		 1024 } else {
1025 nlh->nlmsg_type = NLMSG_ERROR;
573ce260 1026 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
7bc570c8 1027 skb_trim(skb, nlh->nlmsg_len);
573ce260 1028 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -EMSGSIZE;
7bc570c8 1029 }
15e47304 1030 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
b07a9b26
IS		 1031 } else {
1032 rcu_read_lock();
e4a38c0c 1033 ip6_mr_forward(net, mrt, skb->dev, skb, c);
b07a9b26
IS		 1034 rcu_read_unlock();
1035 }
7bc570c8
YH		 1036 }
1037}
1038
1039/*
dd12d15c 1040 * Bounce a cache query up to pim6sd and netlink.
7bc570c8 1041 *
3493a5b7 1042 * Called under rcu_read_lock()
7bc570c8
YH		 1043 */
1044
3493a5b7 1045static int ip6mr_cache_report(const struct mr_table *mrt, struct sk_buff *pkt,
6bd52143 1046 mifi_t mifi, int assert)
7bc570c8 1047{
8571ab47 1048 struct sock *mroute6_sk;
7bc570c8
YH		 1049 struct sk_buff *skb;
1050 struct mrt6msg *msg;
1051 int ret;
1052
14fb64e1 1053#ifdef CONFIG_IPV6_PIMSM_V2
4b340a5a 1054 if (assert == MRT6MSG_WHOLEPKT || assert == MRT6MSG_WRMIFWHOLE)
14fb64e1
YH		 1055 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
1056 +sizeof(*msg));
1057 else
1058#endif
1059 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
7bc570c8
YH		 1060
1061 if (!skb)
1062 return -ENOBUFS;
1063
1064 /* I suppose that internal messages
1065 * do not require checksums */
1066
1067 skb->ip_summed = CHECKSUM_UNNECESSARY;
1068
14fb64e1 1069#ifdef CONFIG_IPV6_PIMSM_V2
4b340a5a 1070 if (assert == MRT6MSG_WHOLEPKT || assert == MRT6MSG_WRMIFWHOLE) {
14fb64e1
YH		 1071 /* Ugly, but we have no choice with this interface.
1072 Duplicate old header, fix length etc.
1073 And all this only to mangle msg->im6_msgtype and
1074 to set msg->im6_mbz to "mbz" :-)
1075 */
1076 skb_push(skb, -skb_network_offset(pkt));
1077
1078 skb_push(skb, sizeof(*msg));
1079 skb_reset_transport_header(skb);
1080 msg = (struct mrt6msg *)skb_transport_header(skb);
1081 msg->im6_mbz = 0;
4b340a5a
MR		 1082 msg->im6_msgtype = assert;
1083 if (assert == MRT6MSG_WRMIFWHOLE)
1084 msg->im6_mif = mifi;
1085 else
3493a5b7 1086 msg->im6_mif = READ_ONCE(mrt->mroute_reg_vif_num);
14fb64e1 1087 msg->im6_pad = 0;
4e3fd7a0
AD		 1088 msg->im6_src = ipv6_hdr(pkt)->saddr;
1089 msg->im6_dst = ipv6_hdr(pkt)->daddr;
14fb64e1
YH		 1090
1091 skb->ip_summed = CHECKSUM_UNNECESSARY;
1092 } else
1093#endif
1094 {
7bc570c8
YH		 1095 /*
1096 * Copy the IP header
1097 */
1098
1099 skb_put(skb, sizeof(struct ipv6hdr));
1100 skb_reset_network_header(skb);
1101 skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
1102
1103 /*
1104 * Add our header
1105 */
1106 skb_put(skb, sizeof(*msg));
1107 skb_reset_transport_header(skb);
1108 msg = (struct mrt6msg *)skb_transport_header(skb);
1109
1110 msg->im6_mbz = 0;
1111 msg->im6_msgtype = assert;
6ac7eb08 1112 msg->im6_mif = mifi;
7bc570c8 1113 msg->im6_pad = 0;
4e3fd7a0
AD		 1114 msg->im6_src = ipv6_hdr(pkt)->saddr;
1115 msg->im6_dst = ipv6_hdr(pkt)->daddr;
7bc570c8 1116
adf30907 1117 skb_dst_set(skb, dst_clone(skb_dst(pkt)));
7bc570c8 1118 skb->ip_summed = CHECKSUM_UNNECESSARY;
14fb64e1 1119 }
7bc570c8 1120
b70432f7 1121 mroute6_sk = rcu_dereference(mrt->mroute_sk);
8571ab47 1122 if (!mroute6_sk) {
7bc570c8
YH		 1123 kfree_skb(skb);
1124 return -EINVAL;
1125 }
1126
dd12d15c
JG		 1127 mrt6msg_netlink_event(mrt, skb);
1128
8571ab47
YM		 1129 /* Deliver to user space multicast routing algorithms */
1130 ret = sock_queue_rcv_skb(mroute6_sk, skb);
3493a5b7 1131
bd91b8bf 1132 if (ret < 0) {
e87cc472 1133 net_warn_ratelimited("mroute6: pending queue full, dropping entries\n");
7bc570c8
YH		 1134 kfree_skb(skb);
1135 }
1136
1137 return ret;
1138}
1139
494fff56
YM		 1140/* Queue a packet for resolution. It gets locked cache entry! */
1141static int ip6mr_cache_unresolved(struct mr_table *mrt, mifi_t mifi,
e4a38c0c 1142 struct sk_buff *skb, struct net_device *dev)
7bc570c8 1143{
494fff56 1144 struct mfc6_cache *c;
f30a7784 1145 bool found = false;
7bc570c8 1146 int err;
7bc570c8
YH		 1147
1148 spin_lock_bh(&mfc_unres_lock);
494fff56 1149 list_for_each_entry(c, &mrt->mfc_unres_queue, _c.list) {
c476efbc 1150 if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
f30a7784
PM		 1151 ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr)) {
1152 found = true;
7bc570c8 1153 break;
f30a7784 1154 }
7bc570c8
YH		 1155 }
1156
f30a7784 1157 if (!found) {
7bc570c8
YH		 1158 /*
1159 * Create a new entry if allowable
1160 */
1161
0079ad8e
HL		 1162 c = ip6mr_cache_alloc_unres();
1163 if (!c) {
7bc570c8
YH		 1164 spin_unlock_bh(&mfc_unres_lock);
1165
1166 kfree_skb(skb);
1167 return -ENOBUFS;
1168 }
1169
494fff56
YM		 1170 /* Fill in the new cache entry */
1171 c->_c.mfc_parent = -1;
7bc570c8
YH		 1172 c->mf6c_origin = ipv6_hdr(skb)->saddr;
1173 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
1174
1175 /*
1176 * Reflect first query at pim6sd
1177 */
6bd52143 1178 err = ip6mr_cache_report(mrt, skb, mifi, MRT6MSG_NOCACHE);
8229efda 1179 if (err < 0) {
7bc570c8
YH		 1180 /* If the report failed throw the cache entry
1181 out - Brad Parker
1182 */
1183 spin_unlock_bh(&mfc_unres_lock);
1184
58701ad4 1185 ip6mr_cache_free(c);
7bc570c8
YH		 1186 kfree_skb(skb);
1187 return err;
1188 }
1189
6bd52143 1190 atomic_inc(&mrt->cache_resolve_queue_len);
494fff56 1191 list_add(&c->_c.list, &mrt->mfc_unres_queue);
812e44dd 1192 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
7bc570c8 1193
6bd52143 1194 ipmr_do_expire_process(mrt);
7bc570c8
YH		 1195 }
1196
494fff56
YM		 1197 /* See if we can append the packet */
1198 if (c->_c.mfc_un.unres.unresolved.qlen > 3) {
7bc570c8
YH		 1199 kfree_skb(skb);
1200 err = -ENOBUFS;
1201 } else {
e4a38c0c
PR		 1202 if (dev) {
1203 skb->dev = dev;
1204 skb->skb_iif = dev->ifindex;
1205 }
494fff56 1206 skb_queue_tail(&c->_c.mfc_un.unres.unresolved, skb);
7bc570c8
YH		 1207 err = 0;
1208 }
1209
1210 spin_unlock_bh(&mfc_unres_lock);
1211 return err;
1212}
1213
1214/*
1215 * MFC6 cache manipulation by user space
1216 */
1217
b70432f7 1218static int ip6mr_mfc_delete(struct mr_table *mrt, struct mf6cctl *mfc,
660b26dc 1219 int parent)
7bc570c8 1220{
87c418bf 1221 struct mfc6_cache *c;
7bc570c8 1222
87c418bf
YM		 1223 /* The entries are added/deleted only under RTNL */
1224 rcu_read_lock();
1225 c = ip6mr_cache_find_parent(mrt, &mfc->mf6cc_origin.sin6_addr,
1226 &mfc->mf6cc_mcastgrp.sin6_addr, parent);
1227 rcu_read_unlock();
1228 if (!c)
1229 return -ENOENT;
494fff56
YM		 1230 rhltable_remove(&mrt->mfc_hash, &c->_c.mnode, ip6mr_rht_params);
1231 list_del_rcu(&c->_c.list);
7bc570c8 1232
088aa3ee
YM		 1233 call_ip6mr_mfc_entry_notifiers(read_pnet(&mrt->net),
1234 FIB_EVENT_ENTRY_DEL, c, mrt->id);
87c418bf 1235 mr6_netlink_event(mrt, c, RTM_DELROUTE);
8c13af2a 1236 mr_cache_put(&c->_c);
87c418bf 1237 return 0;
7bc570c8
YH		 1238}
1239
1240static int ip6mr_device_event(struct notifier_block *this,
1241 unsigned long event, void *ptr)
1242{
351638e7 1243 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
8229efda 1244 struct net *net = dev_net(dev);
b70432f7 1245 struct mr_table *mrt;
6853f21f 1246 struct vif_device *v;
7bc570c8
YH		 1247 int ct;
1248
7bc570c8
YH		 1249 if (event != NETDEV_UNREGISTER)
1250 return NOTIFY_DONE;
1251
d1db275d 1252 ip6mr_for_each_table(mrt, net) {
b70432f7 1253 v = &mrt->vif_table[0];
d1db275d 1254 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
ebc31979 1255 if (rcu_access_pointer(v->dev) == dev)
723b929c 1256 mif6_delete(mrt, ct, 1, NULL);
d1db275d 1257 }
7bc570c8 1258 }
c871e664 1259
7bc570c8
YH		 1260 return NOTIFY_DONE;
1261}
1262
088aa3ee
YM		 1263static unsigned int ip6mr_seq_read(struct net *net)
1264{
1265 ASSERT_RTNL();
1266
1267 return net->ipv6.ipmr_seq + ip6mr_rules_seq_read(net);
1268}
1269
b7a59557
JP		 1270static int ip6mr_dump(struct net *net, struct notifier_block *nb,
1271 struct netlink_ext_ack *extack)
088aa3ee
YM		 1272{
1273 return mr_dump(net, nb, RTNL_FAMILY_IP6MR, ip6mr_rules_dump,
194366b2 1274 ip6mr_mr_table_iter, extack);
088aa3ee
YM		 1275}
1276
7bc570c8
YH		 1277static struct notifier_block ip6_mr_notifier = {
1278 .notifier_call = ip6mr_device_event
1279};
1280
088aa3ee
YM		 1281static const struct fib_notifier_ops ip6mr_notifier_ops_template = {
1282 .family = RTNL_FAMILY_IP6MR,
1283 .fib_seq_read = ip6mr_seq_read,
1284 .fib_dump = ip6mr_dump,
1285 .owner = THIS_MODULE,
1286};
1287
1288static int __net_init ip6mr_notifier_init(struct net *net)
1289{
1290 struct fib_notifier_ops *ops;
1291
1292 net->ipv6.ipmr_seq = 0;
7bc570c8 1293
088aa3ee
YM		 1294 ops = fib_notifier_ops_register(&ip6mr_notifier_ops_template, net);
1295 if (IS_ERR(ops))
1296 return PTR_ERR(ops);
1297
1298 net->ipv6.ip6mr_notifier_ops = ops;
1299
1300 return 0;
1301}
1302
1303static void __net_exit ip6mr_notifier_exit(struct net *net)
1304{
1305 fib_notifier_ops_unregister(net->ipv6.ip6mr_notifier_ops);
1306 net->ipv6.ip6mr_notifier_ops = NULL;
1307}
1308
1309/* Setup for IP multicast routing */
4e16880c
BT		 1310static int __net_init ip6mr_net_init(struct net *net)
1311{
d1db275d 1312 int err;
f30a7784 1313
088aa3ee
YM		 1314 err = ip6mr_notifier_init(net);
1315 if (err)
1316 return err;
1317
d1db275d
PM		 1318 err = ip6mr_rules_init(net);
1319 if (err < 0)
088aa3ee 1320 goto ip6mr_rules_fail;
8b90fc7e
BT		 1321
1322#ifdef CONFIG_PROC_FS
1323 err = -ENOMEM;
c3506372
CH		 1324 if (!proc_create_net("ip6_mr_vif", 0, net->proc_net, &ip6mr_vif_seq_ops,
1325 sizeof(struct mr_vif_iter)))
8b90fc7e 1326 goto proc_vif_fail;
c3506372
CH		 1327 if (!proc_create_net("ip6_mr_cache", 0, net->proc_net, &ipmr_mfc_seq_ops,
1328 sizeof(struct mr_mfc_iter)))
8b90fc7e
BT		 1329 goto proc_cache_fail;
1330#endif
6bd52143 1331
4a6258a0
BT		 1332 return 0;
1333
8b90fc7e
BT		 1334#ifdef CONFIG_PROC_FS
1335proc_cache_fail:
ece31ffd 1336 remove_proc_entry("ip6_mr_vif", net->proc_net);
8b90fc7e 1337proc_vif_fail:
e2f736b7 1338 rtnl_lock();
d1db275d 1339 ip6mr_rules_exit(net);
e2f736b7 1340 rtnl_unlock();
8b90fc7e 1341#endif
088aa3ee
YM		 1342ip6mr_rules_fail:
1343 ip6mr_notifier_exit(net);
4e16880c
BT		 1344 return err;
1345}
1346
1347static void __net_exit ip6mr_net_exit(struct net *net)
1348{
8b90fc7e 1349#ifdef CONFIG_PROC_FS
ece31ffd
G		 1350 remove_proc_entry("ip6_mr_cache", net->proc_net);
1351 remove_proc_entry("ip6_mr_vif", net->proc_net);
8b90fc7e 1352#endif
088aa3ee 1353 ip6mr_notifier_exit(net);
4e16880c
BT		 1354}
1355
e2f736b7
ED		 1356static void __net_exit ip6mr_net_exit_batch(struct list_head *net_list)
1357{
1358 struct net *net;
1359
1360 rtnl_lock();
1361 list_for_each_entry(net, net_list, exit_list)
1362 ip6mr_rules_exit(net);
1363 rtnl_unlock();
1364}
1365
4e16880c
BT		 1366static struct pernet_operations ip6mr_net_ops = {
1367 .init = ip6mr_net_init,
1368 .exit = ip6mr_net_exit,
e2f736b7 1369 .exit_batch = ip6mr_net_exit_batch,
4e16880c
BT		 1370};
1371
623d1a1a 1372int __init ip6_mr_init(void)
7bc570c8 1373{
623d1a1a
WC		 1374 int err;
1375
7bc570c8
YH		 1376 mrt_cachep = kmem_cache_create("ip6_mrt_cache",
1377 sizeof(struct mfc6_cache),
1378 0, SLAB_HWCACHE_ALIGN,
1379 NULL);
1380 if (!mrt_cachep)
623d1a1a 1381 return -ENOMEM;
7bc570c8 1382
4e16880c
BT		 1383 err = register_pernet_subsys(&ip6mr_net_ops);
1384 if (err)
1385 goto reg_pernet_fail;
1386
623d1a1a
WC		 1387 err = register_netdevice_notifier(&ip6_mr_notifier);
1388 if (err)
1389 goto reg_notif_fail;
403dbb97
TG		 1390#ifdef CONFIG_IPV6_PIMSM_V2
1391 if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
f3213831 1392 pr_err("%s: can't add PIM protocol\n", __func__);
403dbb97
TG		 1393 err = -EAGAIN;
1394 goto add_proto_fail;
1395 }
1396#endif
a3fde2ad 1397 err = rtnl_register_module(THIS_MODULE, RTNL_FAMILY_IP6MR, RTM_GETROUTE,
d7c31cbd 1398 ip6mr_rtm_getroute, ip6mr_rtm_dumproute, 0);
a3fde2ad
FW		 1399 if (err == 0)
1400 return 0;
1401
403dbb97 1402#ifdef CONFIG_IPV6_PIMSM_V2
a3fde2ad 1403 inet6_del_protocol(&pim6_protocol, IPPROTO_PIM);
403dbb97
TG		 1404add_proto_fail:
1405 unregister_netdevice_notifier(&ip6_mr_notifier);
1406#endif
87b30a65 1407reg_notif_fail:
4e16880c
BT		 1408 unregister_pernet_subsys(&ip6mr_net_ops);
1409reg_pernet_fail:
87b30a65 1410 kmem_cache_destroy(mrt_cachep);
623d1a1a 1411 return err;
7bc570c8
YH		 1412}
1413
623d1a1a
WC		 1414void ip6_mr_cleanup(void)
1415{
ffb1388a
DJ		 1416 rtnl_unregister(RTNL_FAMILY_IP6MR, RTM_GETROUTE);
1417#ifdef CONFIG_IPV6_PIMSM_V2
1418 inet6_del_protocol(&pim6_protocol, IPPROTO_PIM);
1419#endif
623d1a1a 1420 unregister_netdevice_notifier(&ip6_mr_notifier);
4e16880c 1421 unregister_pernet_subsys(&ip6mr_net_ops);
623d1a1a
WC		 1422 kmem_cache_destroy(mrt_cachep);
1423}
7bc570c8 1424
b70432f7 1425static int ip6mr_mfc_add(struct net *net, struct mr_table *mrt,
660b26dc 1426 struct mf6cctl *mfc, int mrtsock, int parent)
7bc570c8 1427{
6ac7eb08 1428 unsigned char ttls[MAXMIFS];
87c418bf 1429 struct mfc6_cache *uc, *c;
494fff56 1430 struct mr_mfc *_uc;
87c418bf
YM		 1431 bool found;
1432 int i, err;
7bc570c8 1433
a50436f2
PM		 1434 if (mfc->mf6cc_parent >= MAXMIFS)
1435 return -ENFILE;
1436
6ac7eb08
RR		 1437 memset(ttls, 255, MAXMIFS);
1438 for (i = 0; i < MAXMIFS; i++) {
7bc570c8
YH		 1439 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1440 ttls[i] = 1;
7bc570c8
YH		 1441 }
1442
87c418bf
YM		 1443 /* The entries are added/deleted only under RTNL */
1444 rcu_read_lock();
1445 c = ip6mr_cache_find_parent(mrt, &mfc->mf6cc_origin.sin6_addr,
1446 &mfc->mf6cc_mcastgrp.sin6_addr, parent);
1447 rcu_read_unlock();
1448 if (c) {
a96f7a6a 1449 spin_lock(&mrt_lock);
494fff56
YM		 1450 c->_c.mfc_parent = mfc->mf6cc_parent;
1451 ip6mr_update_thresholds(mrt, &c->_c, ttls);
7bc570c8 1452 if (!mrtsock)
494fff56 1453 c->_c.mfc_flags |= MFC_STATIC;
a96f7a6a 1454 spin_unlock(&mrt_lock);
088aa3ee
YM		 1455 call_ip6mr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_REPLACE,
1456 c, mrt->id);
812e44dd 1457 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
7bc570c8
YH		 1458 return 0;
1459 }
1460
660b26dc
ND		 1461 if (!ipv6_addr_any(&mfc->mf6cc_mcastgrp.sin6_addr) &&
1462 !ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
7bc570c8
YH		 1463 return -EINVAL;
1464
b5aa30b1 1465 c = ip6mr_cache_alloc();
63159f29 1466 if (!c)
7bc570c8
YH		 1467 return -ENOMEM;
1468
1469 c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1470 c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
494fff56
YM		 1471 c->_c.mfc_parent = mfc->mf6cc_parent;
1472 ip6mr_update_thresholds(mrt, &c->_c, ttls);
7bc570c8 1473 if (!mrtsock)
494fff56 1474 c->_c.mfc_flags |= MFC_STATIC;
7bc570c8 1475
494fff56 1476 err = rhltable_insert_key(&mrt->mfc_hash, &c->cmparg, &c->_c.mnode,
87c418bf
YM		 1477 ip6mr_rht_params);
1478 if (err) {
1479 pr_err("ip6mr: rhtable insert error %d\n", err);
1480 ip6mr_cache_free(c);
1481 return err;
1482 }
494fff56 1483 list_add_tail_rcu(&c->_c.list, &mrt->mfc_cache_list);
7bc570c8 1484
87c418bf
YM		 1485 /* Check to see if we resolved a queued list. If so we
1486 * need to send on the frames and tidy up.
7bc570c8 1487 */
f30a7784 1488 found = false;
7bc570c8 1489 spin_lock_bh(&mfc_unres_lock);
494fff56
YM		 1490 list_for_each_entry(_uc, &mrt->mfc_unres_queue, list) {
1491 uc = (struct mfc6_cache *)_uc;
c476efbc 1492 if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
7bc570c8 1493 ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
494fff56 1494 list_del(&_uc->list);
6bd52143 1495 atomic_dec(&mrt->cache_resolve_queue_len);
f30a7784 1496 found = true;
7bc570c8
YH		 1497 break;
1498 }
1499 }
b70432f7 1500 if (list_empty(&mrt->mfc_unres_queue))
6bd52143 1501 del_timer(&mrt->ipmr_expire_timer);
7bc570c8
YH		 1502 spin_unlock_bh(&mfc_unres_lock);
1503
f30a7784 1504 if (found) {
6bd52143 1505 ip6mr_cache_resolve(net, mrt, uc, c);
58701ad4 1506 ip6mr_cache_free(uc);
7bc570c8 1507 }
088aa3ee
YM		 1508 call_ip6mr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_ADD,
1509 c, mrt->id);
812e44dd 1510 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
7bc570c8
YH		 1511 return 0;
1512}
1513
1514/*
1515 * Close the multicast socket, and clear the vif tables etc
1516 */
1517
ca8d4794 1518static void mroute_clean_tables(struct mr_table *mrt, int flags)
7bc570c8 1519{
494fff56 1520 struct mr_mfc *c, *tmp;
c871e664 1521 LIST_HEAD(list);
87c418bf 1522 int i;
7bc570c8 1523
87c418bf 1524 /* Shut down all active vif entries */
ca8d4794
CS		 1525 if (flags & (MRT6_FLUSH_MIFS | MRT6_FLUSH_MIFS_STATIC)) {
1526 for (i = 0; i < mrt->maxvif; i++) {
1527 if (((mrt->vif_table[i].flags & VIFF_STATIC) &&
1528 !(flags & MRT6_FLUSH_MIFS_STATIC)) ||
1529 (!(mrt->vif_table[i].flags & VIFF_STATIC) && !(flags & MRT6_FLUSH_MIFS)))
1530 continue;
1531 mif6_delete(mrt, i, 0, &list);
1532 }
1533 unregister_netdevice_many(&list);
7bc570c8
YH		 1534 }
1535
87c418bf 1536 /* Wipe the cache */
ca8d4794
CS		 1537 if (flags & (MRT6_FLUSH_MFC | MRT6_FLUSH_MFC_STATIC)) {
1538 list_for_each_entry_safe(c, tmp, &mrt->mfc_cache_list, list) {
1539 if (((c->mfc_flags & MFC_STATIC) && !(flags & MRT6_FLUSH_MFC_STATIC)) ||
1540 (!(c->mfc_flags & MFC_STATIC) && !(flags & MRT6_FLUSH_MFC)))
1541 continue;
1542 rhltable_remove(&mrt->mfc_hash, &c->mnode, ip6mr_rht_params);
1543 list_del_rcu(&c->list);
1544 call_ip6mr_mfc_entry_notifiers(read_pnet(&mrt->net),
1545 FIB_EVENT_ENTRY_DEL,
1546 (struct mfc6_cache *)c, mrt->id);
1547 mr6_netlink_event(mrt, (struct mfc6_cache *)c, RTM_DELROUTE);
1548 mr_cache_put(c);
1549 }
7bc570c8
YH		 1550 }
1551
ca8d4794
CS		 1552 if (flags & MRT6_FLUSH_MFC) {
1553 if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
1554 spin_lock_bh(&mfc_unres_lock);
1555 list_for_each_entry_safe(c, tmp, &mrt->mfc_unres_queue, list) {
1556 list_del(&c->list);
1557 mr6_netlink_event(mrt, (struct mfc6_cache *)c,
1558 RTM_DELROUTE);
1559 ip6mr_destroy_unres(mrt, (struct mfc6_cache *)c);
1560 }
1561 spin_unlock_bh(&mfc_unres_lock);
7bc570c8 1562 }
7bc570c8
YH		 1563 }
1564}
1565
b70432f7 1566static int ip6mr_sk_init(struct mr_table *mrt, struct sock *sk)
7bc570c8
YH		 1567{
1568 int err = 0;
8229efda 1569 struct net *net = sock_net(sk);
7bc570c8
YH		 1570
1571 rtnl_lock();
a96f7a6a 1572 spin_lock(&mrt_lock);
b70432f7 1573 if (rtnl_dereference(mrt->mroute_sk)) {
7bc570c8 1574 err = -EADDRINUSE;
8571ab47 1575 } else {
b70432f7 1576 rcu_assign_pointer(mrt->mroute_sk, sk);
a366e300 1577 sock_set_flag(sk, SOCK_RCU_FREE);
145c7a79 1578 atomic_inc(&net->ipv6.devconf_all->mc_forwarding);
927265bc 1579 }
a96f7a6a 1580 spin_unlock(&mrt_lock);
7bc570c8 1581
927265bc 1582 if (!err)
85b3daad
DA		 1583 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
1584 NETCONFA_MC_FORWARDING,
927265bc
ED		 1585 NETCONFA_IFINDEX_ALL,
1586 net->ipv6.devconf_all);
7bc570c8
YH		 1587 rtnl_unlock();
1588
1589 return err;
1590}
1591
1592int ip6mr_sk_done(struct sock *sk)
1593{
8229efda 1594 struct net *net = sock_net(sk);
7d9b1b57 1595 struct ipv6_devconf *devconf;
b70432f7 1596 struct mr_table *mrt;
7d9b1b57 1597 int err = -EACCES;
7bc570c8 1598
338d182f
FR		 1599 if (sk->sk_type != SOCK_RAW ||
1600 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1601 return err;
1602
7d9b1b57
ED		 1603 devconf = net->ipv6.devconf_all;
1604 if (!devconf || !atomic_read(&devconf->mc_forwarding))
f2f2325e
ED		 1605 return err;
1606
7bc570c8 1607 rtnl_lock();
d1db275d 1608 ip6mr_for_each_table(mrt, net) {
b70432f7 1609 if (sk == rtnl_dereference(mrt->mroute_sk)) {
a96f7a6a 1610 spin_lock(&mrt_lock);
b70432f7 1611 RCU_INIT_POINTER(mrt->mroute_sk, NULL);
a366e300
ED		 1612 /* Note that mroute_sk had SOCK_RCU_FREE set,
1613 * so the RCU grace period before sk freeing
1614 * is guaranteed by sk_destruct()
1615 */
7d9b1b57 1616 atomic_dec(&devconf->mc_forwarding);
a96f7a6a 1617 spin_unlock(&mrt_lock);
85b3daad 1618 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
d67b8c61
ND		 1619 NETCONFA_MC_FORWARDING,
1620 NETCONFA_IFINDEX_ALL,
1621 net->ipv6.devconf_all);
7bc570c8 1622
ca8d4794 1623 mroute_clean_tables(mrt, MRT6_FLUSH_MIFS | MRT6_FLUSH_MFC);
d1db275d
PM		 1624 err = 0;
1625 break;
1626 }
1627 }
7bc570c8
YH		 1628 rtnl_unlock();
1629
1630 return err;
1631}
1632
8571ab47 1633bool mroute6_is_socket(struct net *net, struct sk_buff *skb)
6bd52143 1634{
b70432f7 1635 struct mr_table *mrt;
4c9483b2 1636 struct flowi6 fl6 = {
e374c618 1637 .flowi6_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
4c9483b2
DM		 1638 .flowi6_oif = skb->dev->ifindex,
1639 .flowi6_mark = skb->mark,
d1db275d
PM		 1640 };
1641
4c9483b2 1642 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
d1db275d 1643 return NULL;
6bd52143 1644
b70432f7 1645 return rcu_access_pointer(mrt->mroute_sk);
6bd52143 1646}
8571ab47 1647EXPORT_SYMBOL(mroute6_is_socket);
6bd52143 1648
7bc570c8
YH		 1649/*
1650 * Socket options and virtual interface manipulation. The whole
1651 * virtual interface system is a complete heap, but unfortunately
1652 * that's how BSD mrouted happens to think. Maybe one day with a proper
1653 * MOSPF/PIM router set up we can clean this up.
1654 */
1655
b43c6153
CH		 1656int ip6_mroute_setsockopt(struct sock *sk, int optname, sockptr_t optval,
1657 unsigned int optlen)
7bc570c8 1658{
660b26dc 1659 int ret, parent = 0;
7bc570c8
YH		 1660 struct mif6ctl vif;
1661 struct mf6cctl mfc;
1662 mifi_t mifi;
8229efda 1663 struct net *net = sock_net(sk);
b70432f7 1664 struct mr_table *mrt;
d1db275d 1665
99253eb7
XL		 1666 if (sk->sk_type != SOCK_RAW ||
1667 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1668 return -EOPNOTSUPP;
1669
d1db275d 1670 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
63159f29 1671 if (!mrt)
d1db275d 1672 return -ENOENT;
7bc570c8
YH		 1673
1674 if (optname != MRT6_INIT) {
b70432f7 1675 if (sk != rcu_access_pointer(mrt->mroute_sk) &&
8571ab47 1676 !ns_capable(net->user_ns, CAP_NET_ADMIN))
7bc570c8
YH		 1677 return -EACCES;
1678 }
1679
1680 switch (optname) {
1681 case MRT6_INIT:
7bc570c8
YH		 1682 if (optlen < sizeof(int))
1683 return -EINVAL;
1684
6bd52143 1685 return ip6mr_sk_init(mrt, sk);
7bc570c8
YH		 1686
1687 case MRT6_DONE:
1688 return ip6mr_sk_done(sk);
1689
1690 case MRT6_ADD_MIF:
1691 if (optlen < sizeof(vif))
1692 return -EINVAL;
b43c6153 1693 if (copy_from_sockptr(&vif, optval, sizeof(vif)))
7bc570c8 1694 return -EFAULT;
6ac7eb08 1695 if (vif.mif6c_mifi >= MAXMIFS)
7bc570c8
YH		 1696 return -ENFILE;
1697 rtnl_lock();
8571ab47 1698 ret = mif6_add(net, mrt, &vif,
b70432f7 1699 sk == rtnl_dereference(mrt->mroute_sk));
7bc570c8
YH		 1700 rtnl_unlock();
1701 return ret;
1702
1703 case MRT6_DEL_MIF:
1704 if (optlen < sizeof(mifi_t))
1705 return -EINVAL;
b43c6153 1706 if (copy_from_sockptr(&mifi, optval, sizeof(mifi_t)))
7bc570c8
YH		 1707 return -EFAULT;
1708 rtnl_lock();
723b929c 1709 ret = mif6_delete(mrt, mifi, 0, NULL);
7bc570c8
YH		 1710 rtnl_unlock();
1711 return ret;
1712
1713 /*
1714 * Manipulate the forwarding caches. These live
1715 * in a sort of kernel/user symbiosis.
1716 */
1717 case MRT6_ADD_MFC:
1718 case MRT6_DEL_MFC:
660b26dc 1719 parent = -1;
a8eceea8 1720 fallthrough;
660b26dc
ND		 1721 case MRT6_ADD_MFC_PROXY:
1722 case MRT6_DEL_MFC_PROXY:
7bc570c8
YH		 1723 if (optlen < sizeof(mfc))
1724 return -EINVAL;
b43c6153 1725 if (copy_from_sockptr(&mfc, optval, sizeof(mfc)))
7bc570c8 1726 return -EFAULT;
660b26dc
ND		 1727 if (parent == 0)
1728 parent = mfc.mf6cc_parent;
7bc570c8 1729 rtnl_lock();
660b26dc
ND		 1730 if (optname == MRT6_DEL_MFC || optname == MRT6_DEL_MFC_PROXY)
1731 ret = ip6mr_mfc_delete(mrt, &mfc, parent);
7bc570c8 1732 else
660b26dc 1733 ret = ip6mr_mfc_add(net, mrt, &mfc,
8571ab47 1734 sk ==
b70432f7 1735 rtnl_dereference(mrt->mroute_sk),
8571ab47 1736 parent);
7bc570c8
YH		 1737 rtnl_unlock();
1738 return ret;
1739
ca8d4794
CS		 1740 case MRT6_FLUSH:
1741 {
1742 int flags;
1743
1744 if (optlen != sizeof(flags))
1745 return -EINVAL;
b43c6153 1746 if (copy_from_sockptr(&flags, optval, sizeof(flags)))
ca8d4794
CS		 1747 return -EFAULT;
1748 rtnl_lock();
1749 mroute_clean_tables(mrt, flags);
1750 rtnl_unlock();
1751 return 0;
1752 }
1753
14fb64e1
YH		 1754 /*
1755 * Control PIM assert (to activate pim will activate assert)
1756 */
1757 case MRT6_ASSERT:
1758 {
1759 int v;
03f52a0a
JP		 1760
1761 if (optlen != sizeof(v))
1762 return -EINVAL;
b43c6153 1763 if (copy_from_sockptr(&v, optval, sizeof(v)))
14fb64e1 1764 return -EFAULT;
53d6841d 1765 mrt->mroute_do_assert = v;
14fb64e1
YH		 1766 return 0;
1767 }
1768
1769#ifdef CONFIG_IPV6_PIMSM_V2
1770 case MRT6_PIM:
1771 {
a3ebe92a 1772 bool do_wrmifwhole;
a9f83bf3 1773 int v;
03f52a0a
JP		 1774
1775 if (optlen != sizeof(v))
1776 return -EINVAL;
b43c6153 1777 if (copy_from_sockptr(&v, optval, sizeof(v)))
14fb64e1 1778 return -EFAULT;
4b340a5a
MR		 1779
1780 do_wrmifwhole = (v == MRT6MSG_WRMIFWHOLE);
14fb64e1
YH		 1781 v = !!v;
1782 rtnl_lock();
1783 ret = 0;
6bd52143
PM		 1784 if (v != mrt->mroute_do_pim) {
1785 mrt->mroute_do_pim = v;
1786 mrt->mroute_do_assert = v;
4b340a5a 1787 mrt->mroute_do_wrvifwhole = do_wrmifwhole;
14fb64e1
YH		 1788 }
1789 rtnl_unlock();
1790 return ret;
1791 }
1792
d1db275d
PM		 1793#endif
1794#ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
1795 case MRT6_TABLE:
1796 {
1797 u32 v;
1798
1799 if (optlen != sizeof(u32))
1800 return -EINVAL;
b43c6153 1801 if (copy_from_sockptr(&v, optval, sizeof(v)))
d1db275d 1802 return -EFAULT;
75356a81
DC		 1803 /* "pim6reg%u" should not exceed 16 bytes (IFNAMSIZ) */
1804 if (v != RT_TABLE_DEFAULT && v >= 100000000)
1805 return -EINVAL;
b70432f7 1806 if (sk == rcu_access_pointer(mrt->mroute_sk))
d1db275d
PM		 1807 return -EBUSY;
1808
1809 rtnl_lock();
1810 ret = 0;
e783bb00
SD		 1811 mrt = ip6mr_new_table(net, v);
1812 if (IS_ERR(mrt))
1813 ret = PTR_ERR(mrt);
848235ed
SD		 1814 else
1815 raw6_sk(sk)->ip6mr_table = v;
d1db275d
PM		 1816 rtnl_unlock();
1817 return ret;
1818 }
14fb64e1 1819#endif
7bc570c8 1820 /*
7d120c55 1821 * Spurious command, or MRT6_VERSION which you cannot
7bc570c8
YH		 1822 * set.
1823 */
1824 default:
1825 return -ENOPROTOOPT;
1826 }
1827}
1828
1829/*
1830 * Getsock opt support for the multicast routing system.
1831 */
1832
6dadbe4b
MKL		 1833int ip6_mroute_getsockopt(struct sock *sk, int optname, sockptr_t optval,
1834 sockptr_t optlen)
7bc570c8
YH		 1835{
1836 int olr;
1837 int val;
8229efda 1838 struct net *net = sock_net(sk);
b70432f7 1839 struct mr_table *mrt;
d1db275d 1840
99253eb7
XL		 1841 if (sk->sk_type != SOCK_RAW ||
1842 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1843 return -EOPNOTSUPP;
1844
d1db275d 1845 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
63159f29 1846 if (!mrt)
d1db275d 1847 return -ENOENT;
7bc570c8
YH		 1848
1849 switch (optname) {
1850 case MRT6_VERSION:
1851 val = 0x0305;
1852 break;
14fb64e1
YH		 1853#ifdef CONFIG_IPV6_PIMSM_V2
1854 case MRT6_PIM:
6bd52143 1855 val = mrt->mroute_do_pim;
14fb64e1
YH		 1856 break;
1857#endif
1858 case MRT6_ASSERT:
6bd52143 1859 val = mrt->mroute_do_assert;
14fb64e1 1860 break;
7bc570c8
YH		 1861 default:
1862 return -ENOPROTOOPT;
1863 }
1864
6dadbe4b 1865 if (copy_from_sockptr(&olr, optlen, sizeof(int)))
7bc570c8
YH		 1866 return -EFAULT;
1867
1868 olr = min_t(int, olr, sizeof(int));
1869 if (olr < 0)
1870 return -EINVAL;
1871
6dadbe4b 1872 if (copy_to_sockptr(optlen, &olr, sizeof(int)))
7bc570c8 1873 return -EFAULT;
6dadbe4b 1874 if (copy_to_sockptr(optval, &val, olr))
7bc570c8
YH		 1875 return -EFAULT;
1876 return 0;
1877}
1878
1879/*
1880 * The IP multicast ioctl support routines.
1881 */
1882
1883int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1884{
1885 struct sioc_sg_req6 sr;
1886 struct sioc_mif_req6 vr;
6853f21f 1887 struct vif_device *vif;
7bc570c8 1888 struct mfc6_cache *c;
8229efda 1889 struct net *net = sock_net(sk);
b70432f7 1890 struct mr_table *mrt;
d1db275d
PM		 1891
1892 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
63159f29 1893 if (!mrt)
d1db275d 1894 return -ENOENT;
7bc570c8
YH		 1895
1896 switch (cmd) {
1897 case SIOCGETMIFCNT_IN6:
1898 if (copy_from_user(&vr, arg, sizeof(vr)))
1899 return -EFAULT;
6bd52143 1900 if (vr.mifi >= mrt->maxvif)
7bc570c8 1901 return -EINVAL;
69d2c867 1902 vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
638cf4a2 1903 rcu_read_lock();
b70432f7
YM		 1904 vif = &mrt->vif_table[vr.mifi];
1905 if (VIF_EXISTS(mrt, vr.mifi)) {
638cf4a2
ED		 1906 vr.icount = READ_ONCE(vif->pkt_in);
1907 vr.ocount = READ_ONCE(vif->pkt_out);
1908 vr.ibytes = READ_ONCE(vif->bytes_in);
1909 vr.obytes = READ_ONCE(vif->bytes_out);
1910 rcu_read_unlock();
7bc570c8
YH		 1911
1912 if (copy_to_user(arg, &vr, sizeof(vr)))
1913 return -EFAULT;
1914 return 0;
1915 }
638cf4a2 1916 rcu_read_unlock();
7bc570c8
YH		 1917 return -EADDRNOTAVAIL;
1918 case SIOCGETSGCNT_IN6:
1919 if (copy_from_user(&sr, arg, sizeof(sr)))
1920 return -EFAULT;
1921
87c418bf 1922 rcu_read_lock();
6bd52143 1923 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
7bc570c8 1924 if (c) {
494fff56
YM		 1925 sr.pktcnt = c->_c.mfc_un.res.pkt;
1926 sr.bytecnt = c->_c.mfc_un.res.bytes;
1927 sr.wrong_if = c->_c.mfc_un.res.wrong_if;
87c418bf 1928 rcu_read_unlock();
7bc570c8
YH		 1929
1930 if (copy_to_user(arg, &sr, sizeof(sr)))
1931 return -EFAULT;
1932 return 0;
1933 }
87c418bf 1934 rcu_read_unlock();
7bc570c8
YH		 1935 return -EADDRNOTAVAIL;
1936 default:
1937 return -ENOIOCTLCMD;
1938 }
1939}
1940
e2d57766
DM		 1941#ifdef CONFIG_COMPAT
1942struct compat_sioc_sg_req6 {
1943 struct sockaddr_in6 src;
1944 struct sockaddr_in6 grp;
1945 compat_ulong_t pktcnt;
1946 compat_ulong_t bytecnt;
1947 compat_ulong_t wrong_if;
1948};
1949
1950struct compat_sioc_mif_req6 {
1951 mifi_t mifi;
1952 compat_ulong_t icount;
1953 compat_ulong_t ocount;
1954 compat_ulong_t ibytes;
1955 compat_ulong_t obytes;
1956};
1957
1958int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1959{
1960 struct compat_sioc_sg_req6 sr;
1961 struct compat_sioc_mif_req6 vr;
6853f21f 1962 struct vif_device *vif;
e2d57766
DM		 1963 struct mfc6_cache *c;
1964 struct net *net = sock_net(sk);
b70432f7 1965 struct mr_table *mrt;
e2d57766
DM		 1966
1967 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
63159f29 1968 if (!mrt)
e2d57766
DM		 1969 return -ENOENT;
1970
1971 switch (cmd) {
1972 case SIOCGETMIFCNT_IN6:
1973 if (copy_from_user(&vr, arg, sizeof(vr)))
1974 return -EFAULT;
1975 if (vr.mifi >= mrt->maxvif)
1976 return -EINVAL;
69d2c867 1977 vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
638cf4a2 1978 rcu_read_lock();
b70432f7
YM		 1979 vif = &mrt->vif_table[vr.mifi];
1980 if (VIF_EXISTS(mrt, vr.mifi)) {
638cf4a2
ED		 1981 vr.icount = READ_ONCE(vif->pkt_in);
1982 vr.ocount = READ_ONCE(vif->pkt_out);
1983 vr.ibytes = READ_ONCE(vif->bytes_in);
1984 vr.obytes = READ_ONCE(vif->bytes_out);
1985 rcu_read_unlock();
e2d57766
DM		 1986
1987 if (copy_to_user(arg, &vr, sizeof(vr)))
1988 return -EFAULT;
1989 return 0;
1990 }
638cf4a2 1991 rcu_read_unlock();
e2d57766
DM		 1992 return -EADDRNOTAVAIL;
1993 case SIOCGETSGCNT_IN6:
1994 if (copy_from_user(&sr, arg, sizeof(sr)))
1995 return -EFAULT;
1996
87c418bf 1997 rcu_read_lock();
e2d57766
DM		 1998 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1999 if (c) {
494fff56
YM		 2000 sr.pktcnt = c->_c.mfc_un.res.pkt;
2001 sr.bytecnt = c->_c.mfc_un.res.bytes;
2002 sr.wrong_if = c->_c.mfc_un.res.wrong_if;
87c418bf 2003 rcu_read_unlock();
e2d57766
DM		 2004
2005 if (copy_to_user(arg, &sr, sizeof(sr)))
2006 return -EFAULT;
2007 return 0;
2008 }
87c418bf 2009 rcu_read_unlock();
e2d57766
DM		 2010 return -EADDRNOTAVAIL;
2011 default:
2012 return -ENOIOCTLCMD;
2013 }
2014}
2015#endif
7bc570c8 2016
0c4b51f0 2017static inline int ip6mr_forward2_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
7bc570c8 2018{
87c11f1d
IS		 2019 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
2020 IPSTATS_MIB_OUTFORWDATAGRAMS);
2021 IP6_ADD_STATS(net, ip6_dst_idev(skb_dst(skb)),
2022 IPSTATS_MIB_OUTOCTETS, skb->len);
13206b6b 2023 return dst_output(net, sk, skb);
7bc570c8
YH		 2024}
2025
2026/*
2027 * Processing handlers for ip6mr_forward
2028 */
2029
b70432f7 2030static int ip6mr_forward2(struct net *net, struct mr_table *mrt,
f5c6dfde 2031 struct sk_buff *skb, int vifi)
7bc570c8 2032{
b70432f7 2033 struct vif_device *vif = &mrt->vif_table[vifi];
ebc31979
ED		 2034 struct net_device *vif_dev;
2035 struct ipv6hdr *ipv6h;
7bc570c8 2036 struct dst_entry *dst;
4c9483b2 2037 struct flowi6 fl6;
7bc570c8 2038
ebc31979
ED		 2039 vif_dev = vif_dev_read(vif);
2040 if (!vif_dev)
7bc570c8
YH		 2041 goto out_free;
2042
14fb64e1
YH		 2043#ifdef CONFIG_IPV6_PIMSM_V2
2044 if (vif->flags & MIFF_REGISTER) {
638cf4a2
ED		 2045 WRITE_ONCE(vif->pkt_out, vif->pkt_out + 1);
2046 WRITE_ONCE(vif->bytes_out, vif->bytes_out + skb->len);
2fad1ba3
ED		 2047 DEV_STATS_ADD(vif_dev, tx_bytes, skb->len);
2048 DEV_STATS_INC(vif_dev, tx_packets);
6bd52143 2049 ip6mr_cache_report(mrt, skb, vifi, MRT6MSG_WHOLEPKT);
8da73b73 2050 goto out_free;
14fb64e1
YH		 2051 }
2052#endif
2053
7bc570c8
YH		 2054 ipv6h = ipv6_hdr(skb);
2055
4c9483b2
DM		 2056 fl6 = (struct flowi6) {
2057 .flowi6_oif = vif->link,
2058 .daddr = ipv6h->daddr,
7bc570c8
YH		 2059 };
2060
4c9483b2 2061 dst = ip6_route_output(net, NULL, &fl6);
5095d64d
RL		 2062 if (dst->error) {
2063 dst_release(dst);
7bc570c8 2064 goto out_free;
5095d64d 2065 }
7bc570c8 2066
adf30907
ED		 2067 skb_dst_drop(skb);
2068 skb_dst_set(skb, dst);
7bc570c8
YH		 2069
2070 /*
2071 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
2072 * not only before forwarding, but after forwarding on all output
2073 * interfaces. It is clear, if mrouter runs a multicasting
2074 * program, it should receive packets not depending to what interface
2075 * program is joined.
2076 * If we will not make it, the program will have to join on all
2077 * interfaces. On the other hand, multihoming host (or router, but
2078 * not mrouter) cannot join to more than one interface - it will
2079 * result in receiving multiple packets.
2080 */
ebc31979 2081 skb->dev = vif_dev;
638cf4a2
ED		 2082 WRITE_ONCE(vif->pkt_out, vif->pkt_out + 1);
2083 WRITE_ONCE(vif->bytes_out, vif->bytes_out + skb->len);
7bc570c8
YH		 2084
2085 /* We are about to write */
2086 /* XXX: extension headers? */
ebc31979 2087 if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(vif_dev)))
7bc570c8
YH		 2088 goto out_free;
2089
2090 ipv6h = ipv6_hdr(skb);
2091 ipv6h->hop_limit--;
2092
2093 IP6CB(skb)->flags |= IP6SKB_FORWARDED;
2094
29a26a56 2095 return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD,
ebc31979 2096 net, NULL, skb, skb->dev, vif_dev,
7bc570c8
YH		 2097 ip6mr_forward2_finish);
2098
2099out_free:
2100 kfree_skb(skb);
2101 return 0;
2102}
2103
a96f7a6a 2104/* Called with rcu_read_lock() */
b70432f7 2105static int ip6mr_find_vif(struct mr_table *mrt, struct net_device *dev)
7bc570c8
YH		 2106{
2107 int ct;
6bd52143 2108
db9eb7c8
ED		 2109 /* Pairs with WRITE_ONCE() in mif6_delete()/mif6_add() */
2110 for (ct = READ_ONCE(mrt->maxvif) - 1; ct >= 0; ct--) {
ebc31979 2111 if (rcu_access_pointer(mrt->vif_table[ct].dev) == dev)
7bc570c8
YH		 2112 break;
2113 }
2114 return ct;
2115}
2116
9b1c21d8 2117/* Called under rcu_read_lock() */
b70432f7 2118static void ip6_mr_forward(struct net *net, struct mr_table *mrt,
e4a38c0c
PR		 2119 struct net_device *dev, struct sk_buff *skb,
2120 struct mfc6_cache *c)
7bc570c8
YH		 2121{
2122 int psend = -1;
2123 int vif, ct;
e4a38c0c 2124 int true_vifi = ip6mr_find_vif(mrt, dev);
7bc570c8 2125
494fff56
YM		 2126 vif = c->_c.mfc_parent;
2127 c->_c.mfc_un.res.pkt++;
2128 c->_c.mfc_un.res.bytes += skb->len;
2129 c->_c.mfc_un.res.lastuse = jiffies;
7bc570c8 2130
494fff56 2131 if (ipv6_addr_any(&c->mf6c_origin) && true_vifi >= 0) {
660b26dc
ND		 2132 struct mfc6_cache *cache_proxy;
2133
40dc2ca3 2134 /* For an (*,G) entry, we only check that the incoming
660b26dc
ND		 2135 * interface is part of the static tree.
2136 */
845c9a7a 2137 cache_proxy = mr_mfc_find_any_parent(mrt, vif);
660b26dc 2138 if (cache_proxy &&
a7e555d4 2139 cache_proxy->_c.mfc_un.res.ttls[true_vifi] < 255)
660b26dc
ND		 2140 goto forward;
2141 }
2142
14fb64e1
YH		 2143 /*
2144 * Wrong interface: drop packet and (maybe) send PIM assert.
2145 */
ebc31979 2146 if (rcu_access_pointer(mrt->vif_table[vif].dev) != dev) {
494fff56 2147 c->_c.mfc_un.res.wrong_if++;
14fb64e1 2148
6bd52143 2149 if (true_vifi >= 0 && mrt->mroute_do_assert &&
14fb64e1
YH		 2150 /* pimsm uses asserts, when switching from RPT to SPT,
2151 so that we cannot check that packet arrived on an oif.
2152 It is bad, but otherwise we would need to move pretty
2153 large chunk of pimd to kernel. Ough... --ANK
2154 */
6bd52143 2155 (mrt->mroute_do_pim ||
494fff56 2156 c->_c.mfc_un.res.ttls[true_vifi] < 255) &&
14fb64e1 2157 time_after(jiffies,
494fff56
YM		 2158 c->_c.mfc_un.res.last_assert +
2159 MFC_ASSERT_THRESH)) {
2160 c->_c.mfc_un.res.last_assert = jiffies;
6bd52143 2161 ip6mr_cache_report(mrt, skb, true_vifi, MRT6MSG_WRONGMIF);
4b340a5a
MR		 2162 if (mrt->mroute_do_wrvifwhole)
2163 ip6mr_cache_report(mrt, skb, true_vifi,
2164 MRT6MSG_WRMIFWHOLE);
14fb64e1
YH		 2165 }
2166 goto dont_forward;
2167 }
2168
660b26dc 2169forward:
638cf4a2
ED		 2170 WRITE_ONCE(mrt->vif_table[vif].pkt_in,
2171 mrt->vif_table[vif].pkt_in + 1);
2172 WRITE_ONCE(mrt->vif_table[vif].bytes_in,
2173 mrt->vif_table[vif].bytes_in + skb->len);
7bc570c8
YH		 2174
2175 /*
2176 * Forward the frame
2177 */
494fff56
YM		 2178 if (ipv6_addr_any(&c->mf6c_origin) &&
2179 ipv6_addr_any(&c->mf6c_mcastgrp)) {
660b26dc 2180 if (true_vifi >= 0 &&
494fff56 2181 true_vifi != c->_c.mfc_parent &&
660b26dc 2182 ipv6_hdr(skb)->hop_limit >
494fff56 2183 c->_c.mfc_un.res.ttls[c->_c.mfc_parent]) {
660b26dc
ND		 2184 /* It's an (*,*) entry and the packet is not coming from
2185 * the upstream: forward the packet to the upstream
2186 * only.
2187 */
494fff56 2188 psend = c->_c.mfc_parent;
660b26dc
ND		 2189 goto last_forward;
2190 }
2191 goto dont_forward;
2192 }
494fff56
YM		 2193 for (ct = c->_c.mfc_un.res.maxvif - 1;
2194 ct >= c->_c.mfc_un.res.minvif; ct--) {
660b26dc 2195 /* For (*,G) entry, don't forward to the incoming interface */
494fff56
YM		 2196 if ((!ipv6_addr_any(&c->mf6c_origin) || ct != true_vifi) &&
2197 ipv6_hdr(skb)->hop_limit > c->_c.mfc_un.res.ttls[ct]) {
7bc570c8
YH		 2198 if (psend != -1) {
2199 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2200 if (skb2)
f5c6dfde 2201 ip6mr_forward2(net, mrt, skb2, psend);
7bc570c8
YH		 2202 }
2203 psend = ct;
2204 }
2205 }
660b26dc 2206last_forward:
7bc570c8 2207 if (psend != -1) {
f5c6dfde 2208 ip6mr_forward2(net, mrt, skb, psend);
2b52c3ad 2209 return;
7bc570c8
YH		 2210 }
2211
14fb64e1 2212dont_forward:
7bc570c8 2213 kfree_skb(skb);
7bc570c8
YH		 2214}
2215
2216
2217/*
2218 * Multicast packets for forwarding arrive here
2219 */
2220
2221int ip6_mr_input(struct sk_buff *skb)
2222{
2223 struct mfc6_cache *cache;
8229efda 2224 struct net *net = dev_net(skb->dev);
b70432f7 2225 struct mr_table *mrt;
4c9483b2
DM		 2226 struct flowi6 fl6 = {
2227 .flowi6_iif = skb->dev->ifindex,
2228 .flowi6_mark = skb->mark,
d1db275d
PM		 2229 };
2230 int err;
e4a38c0c
PR		 2231 struct net_device *dev;
2232
2233 /* skb->dev passed in is the master dev for vrfs.
2234 * Get the proper interface that does have a vif associated with it.
2235 */
2236 dev = skb->dev;
2237 if (netif_is_l3_master(skb->dev)) {
2238 dev = dev_get_by_index_rcu(net, IPCB(skb)->iif);
2239 if (!dev) {
2240 kfree_skb(skb);
2241 return -ENODEV;
2242 }
2243 }
d1db275d 2244
4c9483b2 2245 err = ip6mr_fib_lookup(net, &fl6, &mrt);
2015de5f
BG		 2246 if (err < 0) {
2247 kfree_skb(skb);
d1db275d 2248 return err;
2015de5f 2249 }
7bc570c8 2250
6bd52143 2251 cache = ip6mr_cache_find(mrt,
8229efda 2252 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
63159f29 2253 if (!cache) {
e4a38c0c 2254 int vif = ip6mr_find_vif(mrt, dev);
660b26dc
ND		 2255
2256 if (vif >= 0)
2257 cache = ip6mr_cache_find_any(mrt,
2258 &ipv6_hdr(skb)->daddr,
2259 vif);
2260 }
7bc570c8
YH		 2261
2262 /*
2263 * No usable cache entry
2264 */
63159f29 2265 if (!cache) {
7bc570c8
YH		 2266 int vif;
2267
e4a38c0c 2268 vif = ip6mr_find_vif(mrt, dev);
7bc570c8 2269 if (vif >= 0) {
e4a38c0c 2270 int err = ip6mr_cache_unresolved(mrt, vif, skb, dev);
7bc570c8
YH		 2271
2272 return err;
2273 }
7bc570c8
YH		 2274 kfree_skb(skb);
2275 return -ENODEV;
2276 }
2277
e4a38c0c 2278 ip6_mr_forward(net, mrt, dev, skb, cache);
7bc570c8 2279
7bc570c8
YH		 2280 return 0;
2281}
2282
2cf75070 2283int ip6mr_get_route(struct net *net, struct sk_buff *skb, struct rtmsg *rtm,
fd61c6ba 2284 u32 portid)
7bc570c8
YH		 2285{
2286 int err;
b70432f7 2287 struct mr_table *mrt;
7bc570c8 2288 struct mfc6_cache *cache;
adf30907 2289 struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
7bc570c8 2290
d1db275d 2291 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
63159f29 2292 if (!mrt)
d1db275d
PM		 2293 return -ENOENT;
2294
6fa40a29 2295 rcu_read_lock();
6bd52143 2296 cache = ip6mr_cache_find(mrt, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
660b26dc
ND		 2297 if (!cache && skb->dev) {
2298 int vif = ip6mr_find_vif(mrt, skb->dev);
2299
2300 if (vif >= 0)
2301 cache = ip6mr_cache_find_any(mrt, &rt->rt6i_dst.addr,
2302 vif);
2303 }
7bc570c8
YH		 2304
2305 if (!cache) {
2306 struct sk_buff *skb2;
2307 struct ipv6hdr *iph;
2308 struct net_device *dev;
2309 int vif;
2310
7bc570c8 2311 dev = skb->dev;
63159f29 2312 if (!dev || (vif = ip6mr_find_vif(mrt, dev)) < 0) {
6fa40a29 2313 rcu_read_unlock();
7bc570c8
YH		 2314 return -ENODEV;
2315 }
2316
2317 /* really correct? */
2318 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
2319 if (!skb2) {
6fa40a29 2320 rcu_read_unlock();
7bc570c8
YH		 2321 return -ENOMEM;
2322 }
2323
2cf75070 2324 NETLINK_CB(skb2).portid = portid;
7bc570c8
YH		 2325 skb_reset_transport_header(skb2);
2326
2327 skb_put(skb2, sizeof(struct ipv6hdr));
2328 skb_reset_network_header(skb2);
2329
2330 iph = ipv6_hdr(skb2);
2331 iph->version = 0;
2332 iph->priority = 0;
2333 iph->flow_lbl[0] = 0;
2334 iph->flow_lbl[1] = 0;
2335 iph->flow_lbl[2] = 0;
2336 iph->payload_len = 0;
2337 iph->nexthdr = IPPROTO_NONE;
2338 iph->hop_limit = 0;
4e3fd7a0
AD		 2339 iph->saddr = rt->rt6i_src.addr;
2340 iph->daddr = rt->rt6i_dst.addr;
7bc570c8 2341
e4a38c0c 2342 err = ip6mr_cache_unresolved(mrt, vif, skb2, dev);
6fa40a29 2343 rcu_read_unlock();
7bc570c8
YH		 2344
2345 return err;
2346 }
2347
7b0db857 2348 err = mr_fill_mroute(mrt, skb, &cache->_c, rtm);
6fa40a29 2349 rcu_read_unlock();
7bc570c8
YH		 2350 return err;
2351}
2352
b70432f7 2353static int ip6mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
f518338b
ND		 2354 u32 portid, u32 seq, struct mfc6_cache *c, int cmd,
2355 int flags)
5b285cac
PM		 2356{
2357 struct nlmsghdr *nlh;
2358 struct rtmsg *rtm;
1eb99af5 2359 int err;
5b285cac 2360
f518338b 2361 nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
63159f29 2362 if (!nlh)
5b285cac
PM		 2363 return -EMSGSIZE;
2364
2365 rtm = nlmsg_data(nlh);
193c1e47 2366 rtm->rtm_family = RTNL_FAMILY_IP6MR;
5b285cac
PM		 2367 rtm->rtm_dst_len = 128;
2368 rtm->rtm_src_len = 128;
2369 rtm->rtm_tos = 0;
2370 rtm->rtm_table = mrt->id;
c78679e8
DM		 2371 if (nla_put_u32(skb, RTA_TABLE, mrt->id))
2372 goto nla_put_failure;
1eb99af5 2373 rtm->rtm_type = RTN_MULTICAST;
5b285cac 2374 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
494fff56 2375 if (c->_c.mfc_flags & MFC_STATIC)
9a68ac72
ND		 2376 rtm->rtm_protocol = RTPROT_STATIC;
2377 else
2378 rtm->rtm_protocol = RTPROT_MROUTED;
5b285cac
PM		 2379 rtm->rtm_flags = 0;
2380
930345ea
JB		 2381 if (nla_put_in6_addr(skb, RTA_SRC, &c->mf6c_origin) ||
2382 nla_put_in6_addr(skb, RTA_DST, &c->mf6c_mcastgrp))
c78679e8 2383 goto nla_put_failure;
7b0db857 2384 err = mr_fill_mroute(mrt, skb, &c->_c, rtm);
1eb99af5
ND		 2385 /* do not break the dump if cache is unresolved */
2386 if (err < 0 && err != -ENOENT)
5b285cac
PM		 2387 goto nla_put_failure;
2388
053c095a
JB		 2389 nlmsg_end(skb, nlh);
2390 return 0;
5b285cac
PM		 2391
2392nla_put_failure:
2393 nlmsg_cancel(skb, nlh);
2394 return -EMSGSIZE;
2395}
2396
7b0db857
YM		 2397static int _ip6mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
2398 u32 portid, u32 seq, struct mr_mfc *c,
2399 int cmd, int flags)
2400{
2401 return ip6mr_fill_mroute(mrt, skb, portid, seq, (struct mfc6_cache *)c,
2402 cmd, flags);
2403}
2404
812e44dd
ND		 2405static int mr6_msgsize(bool unresolved, int maxvif)
2406{
2407 size_t len =
2408 NLMSG_ALIGN(sizeof(struct rtmsg))
2409 + nla_total_size(4) /* RTA_TABLE */
2410 + nla_total_size(sizeof(struct in6_addr)) /* RTA_SRC */
2411 + nla_total_size(sizeof(struct in6_addr)) /* RTA_DST */
2412 ;
2413
2414 if (!unresolved)
2415 len = len
2416 + nla_total_size(4) /* RTA_IIF */
2417 + nla_total_size(0) /* RTA_MULTIPATH */
2418 + maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
2419 /* RTA_MFC_STATS */
3d6b66c1 2420 + nla_total_size_64bit(sizeof(struct rta_mfc_stats))
812e44dd
ND		 2421 ;
2422
2423 return len;
2424}
2425
b70432f7 2426static void mr6_netlink_event(struct mr_table *mrt, struct mfc6_cache *mfc,
812e44dd
ND		 2427 int cmd)
2428{
2429 struct net *net = read_pnet(&mrt->net);
2430 struct sk_buff *skb;
2431 int err = -ENOBUFS;
2432
494fff56 2433 skb = nlmsg_new(mr6_msgsize(mfc->_c.mfc_parent >= MAXMIFS, mrt->maxvif),
812e44dd 2434 GFP_ATOMIC);
63159f29 2435 if (!skb)
812e44dd
ND		 2436 goto errout;
2437
f518338b 2438 err = ip6mr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
812e44dd
ND		 2439 if (err < 0)
2440 goto errout;
2441
2442 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE, NULL, GFP_ATOMIC);
2443 return;
2444
2445errout:
2446 kfree_skb(skb);
2447 if (err < 0)
2448 rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE, err);
2449}
2450
dd12d15c
JG		 2451static size_t mrt6msg_netlink_msgsize(size_t payloadlen)
2452{
2453 size_t len =
2454 NLMSG_ALIGN(sizeof(struct rtgenmsg))
2455 + nla_total_size(1) /* IP6MRA_CREPORT_MSGTYPE */
2456 + nla_total_size(4) /* IP6MRA_CREPORT_MIF_ID */
2457 /* IP6MRA_CREPORT_SRC_ADDR */
2458 + nla_total_size(sizeof(struct in6_addr))
2459 /* IP6MRA_CREPORT_DST_ADDR */
2460 + nla_total_size(sizeof(struct in6_addr))
2461 /* IP6MRA_CREPORT_PKT */
2462 + nla_total_size(payloadlen)
2463 ;
2464
2465 return len;
2466}
2467
3493a5b7 2468static void mrt6msg_netlink_event(const struct mr_table *mrt, struct sk_buff *pkt)
dd12d15c
JG		 2469{
2470 struct net *net = read_pnet(&mrt->net);
2471 struct nlmsghdr *nlh;
2472 struct rtgenmsg *rtgenm;
2473 struct mrt6msg *msg;
2474 struct sk_buff *skb;
2475 struct nlattr *nla;
2476 int payloadlen;
2477
2478 payloadlen = pkt->len - sizeof(struct mrt6msg);
2479 msg = (struct mrt6msg *)skb_transport_header(pkt);
2480
2481 skb = nlmsg_new(mrt6msg_netlink_msgsize(payloadlen), GFP_ATOMIC);
2482 if (!skb)
2483 goto errout;
2484
2485 nlh = nlmsg_put(skb, 0, 0, RTM_NEWCACHEREPORT,
2486 sizeof(struct rtgenmsg), 0);
2487 if (!nlh)
2488 goto errout;
2489 rtgenm = nlmsg_data(nlh);
2490 rtgenm->rtgen_family = RTNL_FAMILY_IP6MR;
2491 if (nla_put_u8(skb, IP6MRA_CREPORT_MSGTYPE, msg->im6_msgtype) ||
2492 nla_put_u32(skb, IP6MRA_CREPORT_MIF_ID, msg->im6_mif) ||
2493 nla_put_in6_addr(skb, IP6MRA_CREPORT_SRC_ADDR,
2494 &msg->im6_src) ||
2495 nla_put_in6_addr(skb, IP6MRA_CREPORT_DST_ADDR,
2496 &msg->im6_dst))
2497 goto nla_put_failure;
2498
2499 nla = nla_reserve(skb, IP6MRA_CREPORT_PKT, payloadlen);
2500 if (!nla || skb_copy_bits(pkt, sizeof(struct mrt6msg),
2501 nla_data(nla), payloadlen))
2502 goto nla_put_failure;
2503
2504 nlmsg_end(skb, nlh);
2505
2506 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE_R, NULL, GFP_ATOMIC);
2507 return;
2508
2509nla_put_failure:
2510 nlmsg_cancel(skb, nlh);
2511errout:
2512 kfree_skb(skb);
2513 rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE_R, -ENOBUFS);
2514}
2515
d7c31cbd
DL		 2516static const struct nla_policy ip6mr_getroute_policy[RTA_MAX + 1] = {
2517 [RTA_SRC] = NLA_POLICY_EXACT_LEN(sizeof(struct in6_addr)),
2518 [RTA_DST] = NLA_POLICY_EXACT_LEN(sizeof(struct in6_addr)),
2519 [RTA_TABLE] = { .type = NLA_U32 },
2520};
2521
2522static int ip6mr_rtm_valid_getroute_req(struct sk_buff *skb,
2523 const struct nlmsghdr *nlh,
2524 struct nlattr **tb,
2525 struct netlink_ext_ack *extack)
2526{
2527 struct rtmsg *rtm;
2528 int err;
2529
2530 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, ip6mr_getroute_policy,
2531 extack);
2532 if (err)
2533 return err;
2534
2535 rtm = nlmsg_data(nlh);
2536 if ((rtm->rtm_src_len && rtm->rtm_src_len != 128) ||
2537 (rtm->rtm_dst_len && rtm->rtm_dst_len != 128) ||
2538 rtm->rtm_tos || rtm->rtm_table || rtm->rtm_protocol ||
2539 rtm->rtm_scope || rtm->rtm_type || rtm->rtm_flags) {
2540 NL_SET_ERR_MSG_MOD(extack,
2541 "Invalid values in header for multicast route get request");
2542 return -EINVAL;
2543 }
2544
2545 if ((tb[RTA_SRC] && !rtm->rtm_src_len) ||
2546 (tb[RTA_DST] && !rtm->rtm_dst_len)) {
2547 NL_SET_ERR_MSG_MOD(extack, "rtm_src_len and rtm_dst_len must be 128 for IPv6");
2548 return -EINVAL;
2549 }
2550
2551 return 0;
2552}
2553
2554static int ip6mr_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh,
2555 struct netlink_ext_ack *extack)
2556{
2557 struct net *net = sock_net(in_skb->sk);
2558 struct in6_addr src = {}, grp = {};
2559 struct nlattr *tb[RTA_MAX + 1];
2560 struct mfc6_cache *cache;
2561 struct mr_table *mrt;
2562 struct sk_buff *skb;
2563 u32 tableid;
2564 int err;
2565
2566 err = ip6mr_rtm_valid_getroute_req(in_skb, nlh, tb, extack);
2567 if (err < 0)
2568 return err;
2569
2570 if (tb[RTA_SRC])
2571 src = nla_get_in6_addr(tb[RTA_SRC]);
2572 if (tb[RTA_DST])
2573 grp = nla_get_in6_addr(tb[RTA_DST]);
2574 tableid = tb[RTA_TABLE] ? nla_get_u32(tb[RTA_TABLE]) : 0;
2575
2576 mrt = ip6mr_get_table(net, tableid ?: RT_TABLE_DEFAULT);
2577 if (!mrt) {
2578 NL_SET_ERR_MSG_MOD(extack, "MR table does not exist");
2579 return -ENOENT;
2580 }
2581
2582 /* entries are added/deleted only under RTNL */
2583 rcu_read_lock();
2584 cache = ip6mr_cache_find(mrt, &src, &grp);
2585 rcu_read_unlock();
2586 if (!cache) {
2587 NL_SET_ERR_MSG_MOD(extack, "MR cache entry not found");
2588 return -ENOENT;
2589 }
2590
2591 skb = nlmsg_new(mr6_msgsize(false, mrt->maxvif), GFP_KERNEL);
2592 if (!skb)
2593 return -ENOBUFS;
2594
2595 err = ip6mr_fill_mroute(mrt, skb, NETLINK_CB(in_skb).portid,
2596 nlh->nlmsg_seq, cache, RTM_NEWROUTE, 0);
2597 if (err < 0) {
2598 kfree_skb(skb);
2599 return err;
2600 }
2601
2602 return rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2603}
2604
5b285cac
PM		 2605static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2606{
e8ba330a 2607 const struct nlmsghdr *nlh = cb->nlh;
4724676d 2608 struct fib_dump_filter filter = {};
cb167893 2609 int err;
e8ba330a
DA		 2610
2611 if (cb->strict_check) {
4724676d 2612 err = ip_valid_fib_dump_req(sock_net(skb->sk), nlh,
effe6792 2613 &filter, cb);
e8ba330a
DA		 2614 if (err < 0)
2615 return err;
2616 }
2617
cb167893
DA		 2618 if (filter.table_id) {
2619 struct mr_table *mrt;
2620
2621 mrt = ip6mr_get_table(sock_net(skb->sk), filter.table_id);
2622 if (!mrt) {
41b4bd98 2623 if (rtnl_msg_family(cb->nlh) != RTNL_FAMILY_IP6MR)
ae677bbb
DA		 2624 return skb->len;
2625
cb167893
DA		 2626 NL_SET_ERR_MSG_MOD(cb->extack, "MR table does not exist");
2627 return -ENOENT;
2628 }
2629 err = mr_table_dump(mrt, skb, cb, _ip6mr_fill_mroute,
2630 &mfc_unres_lock, &filter);
2631 return skb->len ? : err;
2632 }
2633
7b0db857 2634 return mr_rtm_dumproute(skb, cb, ip6mr_mr_table_iter,
cb167893 2635 _ip6mr_fill_mroute, &mfc_unres_lock, &filter);
5b285cac 2636}
Linux 6.x block layer and io_uring tree(s)