?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
modpost: drop unused command line switches
[linux/fpc-iii.git] / net / ipv6 / route.c
blob2a7423c394560c0bc70d6f0398781a0b35fa9fa0
1 /*
2 * Linux INET6 implementation
3 * FIB front-end.
4 *
5 * Authors:
6 * Pedro Roque <roque@di.fc.ul.pt>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
12 */
13
14 /* Changes:
15 *
16 * YOSHIFUJI Hideaki @USAGI
17 * reworked default router selection.
18 * - respect outgoing interface
19 * - select from (probably) reachable routers (i.e.
20 * routers in REACHABLE, STALE, DELAY or PROBE states).
21 * - always select the same router if it is (probably)
22 * reachable. otherwise, round-robin the list.
23 * Ville Nuorvala
24 * Fixed routing subtrees.
25 */
26
27 #define pr_fmt(fmt) "IPv6: " fmt
28
29 #include <linux/capability.h>
30 #include <linux/errno.h>
31 #include <linux/export.h>
32 #include <linux/types.h>
33 #include <linux/times.h>
34 #include <linux/socket.h>
35 #include <linux/sockios.h>
36 #include <linux/net.h>
37 #include <linux/route.h>
38 #include <linux/netdevice.h>
39 #include <linux/in6.h>
40 #include <linux/mroute6.h>
41 #include <linux/init.h>
42 #include <linux/if_arp.h>
43 #include <linux/proc_fs.h>
44 #include <linux/seq_file.h>
45 #include <linux/nsproxy.h>
46 #include <linux/slab.h>
47 #include <linux/jhash.h>
48 #include <net/net_namespace.h>
49 #include <net/snmp.h>
50 #include <net/ipv6.h>
51 #include <net/ip6_fib.h>
52 #include <net/ip6_route.h>
53 #include <net/ndisc.h>
54 #include <net/addrconf.h>
55 #include <net/tcp.h>
56 #include <linux/rtnetlink.h>
57 #include <net/dst.h>
58 #include <net/dst_metadata.h>
59 #include <net/xfrm.h>
60 #include <net/netevent.h>
61 #include <net/netlink.h>
62 #include <net/nexthop.h>
63 #include <net/lwtunnel.h>
64 #include <net/ip_tunnels.h>
65 #include <net/l3mdev.h>
66 #include <net/ip.h>
67 #include <linux/uaccess.h>
68
69 #ifdef CONFIG_SYSCTL
70 #include <linux/sysctl.h>
71 #endif
72
73 static int ip6_rt_type_to_error(u8 fib6_type);
74
75 #define CREATE_TRACE_POINTS
76 #include <trace/events/fib6.h>
77 EXPORT_TRACEPOINT_SYMBOL_GPL(fib6_table_lookup);
78 #undef CREATE_TRACE_POINTS
79
80 enum rt6_nud_state {
81 RT6_NUD_FAIL_HARD = -3,
82 RT6_NUD_FAIL_PROBE = -2,
83 RT6_NUD_FAIL_DO_RR = -1,
84 RT6_NUD_SUCCEED = 1
85 };
86
87 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
88 static unsigned int ip6_default_advmss(const struct dst_entry *dst);
89 static unsigned int ip6_mtu(const struct dst_entry *dst);
90 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
91 static void ip6_dst_destroy(struct dst_entry *);
92 static void ip6_dst_ifdown(struct dst_entry *,
93 struct net_device *dev, int how);
94 static int ip6_dst_gc(struct dst_ops *ops);
95
96 static int ip6_pkt_discard(struct sk_buff *skb);
97 static int ip6_pkt_discard_out(struct net *net, struct sock *sk, struct sk_buff *skb);
98 static int ip6_pkt_prohibit(struct sk_buff *skb);
99 static int ip6_pkt_prohibit_out(struct net *net, struct sock *sk, struct sk_buff *skb);
100 static void ip6_link_failure(struct sk_buff *skb);
101 static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
102 struct sk_buff *skb, u32 mtu);
103 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk,
104 struct sk_buff *skb);
105 static int rt6_score_route(struct fib6_info *rt, int oif, int strict);
106 static size_t rt6_nlmsg_size(struct fib6_info *rt);
107 static int rt6_fill_node(struct net *net, struct sk_buff *skb,
108 struct fib6_info *rt, struct dst_entry *dst,
109 struct in6_addr *dest, struct in6_addr *src,
110 int iif, int type, u32 portid, u32 seq,
111 unsigned int flags);
112 static struct rt6_info *rt6_find_cached_rt(struct fib6_info *rt,
113 struct in6_addr *daddr,
114 struct in6_addr *saddr);
115
116 #ifdef CONFIG_IPV6_ROUTE_INFO
117 static struct fib6_info *rt6_add_route_info(struct net *net,
118 const struct in6_addr *prefix, int prefixlen,
119 const struct in6_addr *gwaddr,
120 struct net_device *dev,
121 unsigned int pref);
122 static struct fib6_info *rt6_get_route_info(struct net *net,
123 const struct in6_addr *prefix, int prefixlen,
124 const struct in6_addr *gwaddr,
125 struct net_device *dev);
126 #endif
127
128 struct uncached_list {
129 spinlock_t lock;
130 struct list_head head;
131 };
132
133 static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt6_uncached_list);
134
135 void rt6_uncached_list_add(struct rt6_info *rt)
136 {
137 struct uncached_list *ul = raw_cpu_ptr(&rt6_uncached_list);
138
139 rt->rt6i_uncached_list = ul;
140
141 spin_lock_bh(&ul->lock);
142 list_add_tail(&rt->rt6i_uncached, &ul->head);
143 spin_unlock_bh(&ul->lock);
144 }
145
146 void rt6_uncached_list_del(struct rt6_info *rt)
147 {
148 if (!list_empty(&rt->rt6i_uncached)) {
149 struct uncached_list *ul = rt->rt6i_uncached_list;
150 struct net *net = dev_net(rt->dst.dev);
151
152 spin_lock_bh(&ul->lock);
153 list_del(&rt->rt6i_uncached);
154 atomic_dec(&net->ipv6.rt6_stats->fib_rt_uncache);
155 spin_unlock_bh(&ul->lock);
156 }
157 }
158
159 static void rt6_uncached_list_flush_dev(struct net *net, struct net_device *dev)
160 {
161 struct net_device *loopback_dev = net->loopback_dev;
162 int cpu;
163
164 if (dev == loopback_dev)
165 return;
166
167 for_each_possible_cpu(cpu) {
168 struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
169 struct rt6_info *rt;
170
171 spin_lock_bh(&ul->lock);
172 list_for_each_entry(rt, &ul->head, rt6i_uncached) {
173 struct inet6_dev *rt_idev = rt->rt6i_idev;
174 struct net_device *rt_dev = rt->dst.dev;
175
176 if (rt_idev->dev == dev) {
177 rt->rt6i_idev = in6_dev_get(loopback_dev);
178 in6_dev_put(rt_idev);
179 }
180
181 if (rt_dev == dev) {
182 rt->dst.dev = loopback_dev;
183 dev_hold(rt->dst.dev);
184 dev_put(rt_dev);
185 }
186 }
187 spin_unlock_bh(&ul->lock);
188 }
189 }
190
191 static inline const void *choose_neigh_daddr(const struct in6_addr *p,
192 struct sk_buff *skb,
193 const void *daddr)
194 {
195 if (!ipv6_addr_any(p))
196 return (const void *) p;
197 else if (skb)
198 return &ipv6_hdr(skb)->daddr;
199 return daddr;
200 }
201
202 struct neighbour *ip6_neigh_lookup(const struct in6_addr *gw,
203 struct net_device *dev,
204 struct sk_buff *skb,
205 const void *daddr)
206 {
207 struct neighbour *n;
208
209 daddr = choose_neigh_daddr(gw, skb, daddr);
210 n = __ipv6_neigh_lookup(dev, daddr);
211 if (n)
212 return n;
213 return neigh_create(&nd_tbl, daddr, dev);
214 }
215
216 static struct neighbour *ip6_dst_neigh_lookup(const struct dst_entry *dst,
217 struct sk_buff *skb,
218 const void *daddr)
219 {
220 const struct rt6_info *rt = container_of(dst, struct rt6_info, dst);
221
222 return ip6_neigh_lookup(&rt->rt6i_gateway, dst->dev, skb, daddr);
223 }
224
225 static void ip6_confirm_neigh(const struct dst_entry *dst, const void *daddr)
226 {
227 struct net_device *dev = dst->dev;
228 struct rt6_info *rt = (struct rt6_info *)dst;
229
230 daddr = choose_neigh_daddr(&rt->rt6i_gateway, NULL, daddr);
231 if (!daddr)
232 return;
233 if (dev->flags & (IFF_NOARP | IFF_LOOPBACK))
234 return;
235 if (ipv6_addr_is_multicast((const struct in6_addr *)daddr))
236 return;
237 __ipv6_confirm_neigh(dev, daddr);
238 }
239
240 static struct dst_ops ip6_dst_ops_template = {
241 .family = AF_INET6,
242 .gc = ip6_dst_gc,
243 .gc_thresh = 1024,
244 .check = ip6_dst_check,
245 .default_advmss = ip6_default_advmss,
246 .mtu = ip6_mtu,
247 .cow_metrics = dst_cow_metrics_generic,
248 .destroy = ip6_dst_destroy,
249 .ifdown = ip6_dst_ifdown,
250 .negative_advice = ip6_negative_advice,
251 .link_failure = ip6_link_failure,
252 .update_pmtu = ip6_rt_update_pmtu,
253 .redirect = rt6_do_redirect,
254 .local_out = __ip6_local_out,
255 .neigh_lookup = ip6_dst_neigh_lookup,
256 .confirm_neigh = ip6_confirm_neigh,
257 };
258
259 static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)
260 {
261 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
262
263 return mtu ? : dst->dev->mtu;
264 }
265
266 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
267 struct sk_buff *skb, u32 mtu)
268 {
269 }
270
271 static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
272 struct sk_buff *skb)
273 {
274 }
275
276 static struct dst_ops ip6_dst_blackhole_ops = {
277 .family = AF_INET6,
278 .destroy = ip6_dst_destroy,
279 .check = ip6_dst_check,
280 .mtu = ip6_blackhole_mtu,
281 .default_advmss = ip6_default_advmss,
282 .update_pmtu = ip6_rt_blackhole_update_pmtu,
283 .redirect = ip6_rt_blackhole_redirect,
284 .cow_metrics = dst_cow_metrics_generic,
285 .neigh_lookup = ip6_dst_neigh_lookup,
286 };
287
288 static const u32 ip6_template_metrics[RTAX_MAX] = {
289 [RTAX_HOPLIMIT - 1] = 0,
290 };
291
292 static const struct fib6_info fib6_null_entry_template = {
293 .fib6_flags = (RTF_REJECT | RTF_NONEXTHOP),
294 .fib6_protocol = RTPROT_KERNEL,
295 .fib6_metric = ~(u32)0,
296 .fib6_ref = ATOMIC_INIT(1),
297 .fib6_type = RTN_UNREACHABLE,
298 .fib6_metrics = (struct dst_metrics *)&dst_default_metrics,
299 };
300
301 static const struct rt6_info ip6_null_entry_template = {
302 .dst = {
303 .__refcnt = ATOMIC_INIT(1),
304 .__use = 1,
305 .obsolete = DST_OBSOLETE_FORCE_CHK,
306 .error = -ENETUNREACH,
307 .input = ip6_pkt_discard,
308 .output = ip6_pkt_discard_out,
309 },
310 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
311 };
312
313 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
314
315 static const struct rt6_info ip6_prohibit_entry_template = {
316 .dst = {
317 .__refcnt = ATOMIC_INIT(1),
318 .__use = 1,
319 .obsolete = DST_OBSOLETE_FORCE_CHK,
320 .error = -EACCES,
321 .input = ip6_pkt_prohibit,
322 .output = ip6_pkt_prohibit_out,
323 },
324 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
325 };
326
327 static const struct rt6_info ip6_blk_hole_entry_template = {
328 .dst = {
329 .__refcnt = ATOMIC_INIT(1),
330 .__use = 1,
331 .obsolete = DST_OBSOLETE_FORCE_CHK,
332 .error = -EINVAL,
333 .input = dst_discard,
334 .output = dst_discard_out,
335 },
336 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
337 };
338
339 #endif
340
341 static void rt6_info_init(struct rt6_info *rt)
342 {
343 struct dst_entry *dst = &rt->dst;
344
345 memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
346 INIT_LIST_HEAD(&rt->rt6i_uncached);
347 }
348
349 /* allocate dst with ip6_dst_ops */
350 struct rt6_info *ip6_dst_alloc(struct net *net, struct net_device *dev,
351 int flags)
352 {
353 struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
354 1, DST_OBSOLETE_FORCE_CHK, flags);
355
356 if (rt) {
357 rt6_info_init(rt);
358 atomic_inc(&net->ipv6.rt6_stats->fib_rt_alloc);
359 }
360
361 return rt;
362 }
363 EXPORT_SYMBOL(ip6_dst_alloc);
364
365 static void ip6_dst_destroy(struct dst_entry *dst)
366 {
367 struct rt6_info *rt = (struct rt6_info *)dst;
368 struct fib6_info *from;
369 struct inet6_dev *idev;
370
371 ip_dst_metrics_put(dst);
372 rt6_uncached_list_del(rt);
373
374 idev = rt->rt6i_idev;
375 if (idev) {
376 rt->rt6i_idev = NULL;
377 in6_dev_put(idev);
378 }
379
380 rcu_read_lock();
381 from = rcu_dereference(rt->from);
382 rcu_assign_pointer(rt->from, NULL);
383 fib6_info_release(from);
384 rcu_read_unlock();
385 }
386
387 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
388 int how)
389 {
390 struct rt6_info *rt = (struct rt6_info *)dst;
391 struct inet6_dev *idev = rt->rt6i_idev;
392 struct net_device *loopback_dev =
393 dev_net(dev)->loopback_dev;
394
395 if (idev && idev->dev != loopback_dev) {
396 struct inet6_dev *loopback_idev = in6_dev_get(loopback_dev);
397 if (loopback_idev) {
398 rt->rt6i_idev = loopback_idev;
399 in6_dev_put(idev);
400 }
401 }
402 }
403
404 static bool __rt6_check_expired(const struct rt6_info *rt)
405 {
406 if (rt->rt6i_flags & RTF_EXPIRES)
407 return time_after(jiffies, rt->dst.expires);
408 else
409 return false;
410 }
411
412 static bool rt6_check_expired(const struct rt6_info *rt)
413 {
414 struct fib6_info *from;
415
416 from = rcu_dereference(rt->from);
417
418 if (rt->rt6i_flags & RTF_EXPIRES) {
419 if (time_after(jiffies, rt->dst.expires))
420 return true;
421 } else if (from) {
422 return rt->dst.obsolete != DST_OBSOLETE_FORCE_CHK ||
423 fib6_check_expired(from);
424 }
425 return false;
426 }
427
428 struct fib6_info *fib6_multipath_select(const struct net *net,
429 struct fib6_info *match,
430 struct flowi6 *fl6, int oif,
431 const struct sk_buff *skb,
432 int strict)
433 {
434 struct fib6_info *sibling, *next_sibling;
435
436 /* We might have already computed the hash for ICMPv6 errors. In such
437 * case it will always be non-zero. Otherwise now is the time to do it.
438 */
439 if (!fl6->mp_hash)
440 fl6->mp_hash = rt6_multipath_hash(net, fl6, skb, NULL);
441
442 if (fl6->mp_hash <= atomic_read(&match->fib6_nh.nh_upper_bound))
443 return match;
444
445 list_for_each_entry_safe(sibling, next_sibling, &match->fib6_siblings,
446 fib6_siblings) {
447 int nh_upper_bound;
448
449 nh_upper_bound = atomic_read(&sibling->fib6_nh.nh_upper_bound);
450 if (fl6->mp_hash > nh_upper_bound)
451 continue;
452 if (rt6_score_route(sibling, oif, strict) < 0)
453 break;
454 match = sibling;
455 break;
456 }
457
458 return match;
459 }
460
461 /*
462 * Route lookup. rcu_read_lock() should be held.
463 */
464
465 static inline struct fib6_info *rt6_device_match(struct net *net,
466 struct fib6_info *rt,
467 const struct in6_addr *saddr,
468 int oif,
469 int flags)
470 {
471 struct fib6_info *sprt;
472
473 if (!oif && ipv6_addr_any(saddr) &&
474 !(rt->fib6_nh.nh_flags & RTNH_F_DEAD))
475 return rt;
476
477 for (sprt = rt; sprt; sprt = rcu_dereference(sprt->fib6_next)) {
478 const struct net_device *dev = sprt->fib6_nh.nh_dev;
479
480 if (sprt->fib6_nh.nh_flags & RTNH_F_DEAD)
481 continue;
482
483 if (oif) {
484 if (dev->ifindex == oif)
485 return sprt;
486 } else {
487 if (ipv6_chk_addr(net, saddr, dev,
488 flags & RT6_LOOKUP_F_IFACE))
489 return sprt;
490 }
491 }
492
493 if (oif && flags & RT6_LOOKUP_F_IFACE)
494 return net->ipv6.fib6_null_entry;
495
496 return rt->fib6_nh.nh_flags & RTNH_F_DEAD ? net->ipv6.fib6_null_entry : rt;
497 }
498
499 #ifdef CONFIG_IPV6_ROUTER_PREF
500 struct __rt6_probe_work {
501 struct work_struct work;
502 struct in6_addr target;
503 struct net_device *dev;
504 };
505
506 static void rt6_probe_deferred(struct work_struct *w)
507 {
508 struct in6_addr mcaddr;
509 struct __rt6_probe_work *work =
510 container_of(w, struct __rt6_probe_work, work);
511
512 addrconf_addr_solict_mult(&work->target, &mcaddr);
513 ndisc_send_ns(work->dev, &work->target, &mcaddr, NULL, 0);
514 dev_put(work->dev);
515 kfree(work);
516 }
517
518 static void rt6_probe(struct fib6_info *rt)
519 {
520 struct __rt6_probe_work *work = NULL;
521 const struct in6_addr *nh_gw;
522 struct neighbour *neigh;
523 struct net_device *dev;
524 struct inet6_dev *idev;
525
526 /*
527 * Okay, this does not seem to be appropriate
528 * for now, however, we need to check if it
529 * is really so; aka Router Reachability Probing.
530 *
531 * Router Reachability Probe MUST be rate-limited
532 * to no more than one per minute.
533 */
534 if (!rt || !(rt->fib6_flags & RTF_GATEWAY))
535 return;
536
537 nh_gw = &rt->fib6_nh.nh_gw;
538 dev = rt->fib6_nh.nh_dev;
539 rcu_read_lock_bh();
540 idev = __in6_dev_get(dev);
541 neigh = __ipv6_neigh_lookup_noref(dev, nh_gw);
542 if (neigh) {
543 if (neigh->nud_state & NUD_VALID)
544 goto out;
545
546 write_lock(&neigh->lock);
547 if (!(neigh->nud_state & NUD_VALID) &&
548 time_after(jiffies,
549 neigh->updated + idev->cnf.rtr_probe_interval)) {
550 work = kmalloc(sizeof(*work), GFP_ATOMIC);
551 if (work)
552 __neigh_set_probe_once(neigh);
553 }
554 write_unlock(&neigh->lock);
555 } else if (time_after(jiffies, rt->last_probe +
556 idev->cnf.rtr_probe_interval)) {
557 work = kmalloc(sizeof(*work), GFP_ATOMIC);
558 }
559
560 if (work) {
561 rt->last_probe = jiffies;
562 INIT_WORK(&work->work, rt6_probe_deferred);
563 work->target = *nh_gw;
564 dev_hold(dev);
565 work->dev = dev;
566 schedule_work(&work->work);
567 }
568
569 out:
570 rcu_read_unlock_bh();
571 }
572 #else
573 static inline void rt6_probe(struct fib6_info *rt)
574 {
575 }
576 #endif
577
578 /*
579 * Default Router Selection (RFC 2461 6.3.6)
580 */
581 static inline int rt6_check_dev(struct fib6_info *rt, int oif)
582 {
583 const struct net_device *dev = rt->fib6_nh.nh_dev;
584
585 if (!oif || dev->ifindex == oif)
586 return 2;
587 return 0;
588 }
589
590 static inline enum rt6_nud_state rt6_check_neigh(struct fib6_info *rt)
591 {
592 enum rt6_nud_state ret = RT6_NUD_FAIL_HARD;
593 struct neighbour *neigh;
594
595 if (rt->fib6_flags & RTF_NONEXTHOP ||
596 !(rt->fib6_flags & RTF_GATEWAY))
597 return RT6_NUD_SUCCEED;
598
599 rcu_read_lock_bh();
600 neigh = __ipv6_neigh_lookup_noref(rt->fib6_nh.nh_dev,
601 &rt->fib6_nh.nh_gw);
602 if (neigh) {
603 read_lock(&neigh->lock);
604 if (neigh->nud_state & NUD_VALID)
605 ret = RT6_NUD_SUCCEED;
606 #ifdef CONFIG_IPV6_ROUTER_PREF
607 else if (!(neigh->nud_state & NUD_FAILED))
608 ret = RT6_NUD_SUCCEED;
609 else
610 ret = RT6_NUD_FAIL_PROBE;
611 #endif
612 read_unlock(&neigh->lock);
613 } else {
614 ret = IS_ENABLED(CONFIG_IPV6_ROUTER_PREF) ?
615 RT6_NUD_SUCCEED : RT6_NUD_FAIL_DO_RR;
616 }
617 rcu_read_unlock_bh();
618
619 return ret;
620 }
621
622 static int rt6_score_route(struct fib6_info *rt, int oif, int strict)
623 {
624 int m;
625
626 m = rt6_check_dev(rt, oif);
627 if (!m && (strict & RT6_LOOKUP_F_IFACE))
628 return RT6_NUD_FAIL_HARD;
629 #ifdef CONFIG_IPV6_ROUTER_PREF
630 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->fib6_flags)) << 2;
631 #endif
632 if (strict & RT6_LOOKUP_F_REACHABLE) {
633 int n = rt6_check_neigh(rt);
634 if (n < 0)
635 return n;
636 }
637 return m;
638 }
639
640 /* called with rc_read_lock held */
641 static inline bool fib6_ignore_linkdown(const struct fib6_info *f6i)
642 {
643 const struct net_device *dev = fib6_info_nh_dev(f6i);
644 bool rc = false;
645
646 if (dev) {
647 const struct inet6_dev *idev = __in6_dev_get(dev);
648
649 rc = !!idev->cnf.ignore_routes_with_linkdown;
650 }
651
652 return rc;
653 }
654
655 static struct fib6_info *find_match(struct fib6_info *rt, int oif, int strict,
656 int *mpri, struct fib6_info *match,
657 bool *do_rr)
658 {
659 int m;
660 bool match_do_rr = false;
661
662 if (rt->fib6_nh.nh_flags & RTNH_F_DEAD)
663 goto out;
664
665 if (fib6_ignore_linkdown(rt) &&
666 rt->fib6_nh.nh_flags & RTNH_F_LINKDOWN &&
667 !(strict & RT6_LOOKUP_F_IGNORE_LINKSTATE))
668 goto out;
669
670 if (fib6_check_expired(rt))
671 goto out;
672
673 m = rt6_score_route(rt, oif, strict);
674 if (m == RT6_NUD_FAIL_DO_RR) {
675 match_do_rr = true;
676 m = 0; /* lowest valid score */
677 } else if (m == RT6_NUD_FAIL_HARD) {
678 goto out;
679 }
680
681 if (strict & RT6_LOOKUP_F_REACHABLE)
682 rt6_probe(rt);
683
684 /* note that m can be RT6_NUD_FAIL_PROBE at this point */
685 if (m > *mpri) {
686 *do_rr = match_do_rr;
687 *mpri = m;
688 match = rt;
689 }
690 out:
691 return match;
692 }
693
694 static struct fib6_info *find_rr_leaf(struct fib6_node *fn,
695 struct fib6_info *leaf,
696 struct fib6_info *rr_head,
697 u32 metric, int oif, int strict,
698 bool *do_rr)
699 {
700 struct fib6_info *rt, *match, *cont;
701 int mpri = -1;
702
703 match = NULL;
704 cont = NULL;
705 for (rt = rr_head; rt; rt = rcu_dereference(rt->fib6_next)) {
706 if (rt->fib6_metric != metric) {
707 cont = rt;
708 break;
709 }
710
711 match = find_match(rt, oif, strict, &mpri, match, do_rr);
712 }
713
714 for (rt = leaf; rt && rt != rr_head;
715 rt = rcu_dereference(rt->fib6_next)) {
716 if (rt->fib6_metric != metric) {
717 cont = rt;
718 break;
719 }
720
721 match = find_match(rt, oif, strict, &mpri, match, do_rr);
722 }
723
724 if (match || !cont)
725 return match;
726
727 for (rt = cont; rt; rt = rcu_dereference(rt->fib6_next))
728 match = find_match(rt, oif, strict, &mpri, match, do_rr);
729
730 return match;
731 }
732
733 static struct fib6_info *rt6_select(struct net *net, struct fib6_node *fn,
734 int oif, int strict)
735 {
736 struct fib6_info *leaf = rcu_dereference(fn->leaf);
737 struct fib6_info *match, *rt0;
738 bool do_rr = false;
739 int key_plen;
740
741 if (!leaf || leaf == net->ipv6.fib6_null_entry)
742 return net->ipv6.fib6_null_entry;
743
744 rt0 = rcu_dereference(fn->rr_ptr);
745 if (!rt0)
746 rt0 = leaf;
747
748 /* Double check to make sure fn is not an intermediate node
749 * and fn->leaf does not points to its child's leaf
750 * (This might happen if all routes under fn are deleted from
751 * the tree and fib6_repair_tree() is called on the node.)
752 */
753 key_plen = rt0->fib6_dst.plen;
754 #ifdef CONFIG_IPV6_SUBTREES
755 if (rt0->fib6_src.plen)
756 key_plen = rt0->fib6_src.plen;
757 #endif
758 if (fn->fn_bit != key_plen)
759 return net->ipv6.fib6_null_entry;
760
761 match = find_rr_leaf(fn, leaf, rt0, rt0->fib6_metric, oif, strict,
762 &do_rr);
763
764 if (do_rr) {
765 struct fib6_info *next = rcu_dereference(rt0->fib6_next);
766
767 /* no entries matched; do round-robin */
768 if (!next || next->fib6_metric != rt0->fib6_metric)
769 next = leaf;
770
771 if (next != rt0) {
772 spin_lock_bh(&leaf->fib6_table->tb6_lock);
773 /* make sure next is not being deleted from the tree */
774 if (next->fib6_node)
775 rcu_assign_pointer(fn->rr_ptr, next);
776 spin_unlock_bh(&leaf->fib6_table->tb6_lock);
777 }
778 }
779
780 return match ? match : net->ipv6.fib6_null_entry;
781 }
782
783 static bool rt6_is_gw_or_nonexthop(const struct fib6_info *rt)
784 {
785 return (rt->fib6_flags & (RTF_NONEXTHOP | RTF_GATEWAY));
786 }
787
788 #ifdef CONFIG_IPV6_ROUTE_INFO
789 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
790 const struct in6_addr *gwaddr)
791 {
792 struct net *net = dev_net(dev);
793 struct route_info *rinfo = (struct route_info *) opt;
794 struct in6_addr prefix_buf, *prefix;
795 unsigned int pref;
796 unsigned long lifetime;
797 struct fib6_info *rt;
798
799 if (len < sizeof(struct route_info)) {
800 return -EINVAL;
801 }
802
803 /* Sanity check for prefix_len and length */
804 if (rinfo->length > 3) {
805 return -EINVAL;
806 } else if (rinfo->prefix_len > 128) {
807 return -EINVAL;
808 } else if (rinfo->prefix_len > 64) {
809 if (rinfo->length < 2) {
810 return -EINVAL;
811 }
812 } else if (rinfo->prefix_len > 0) {
813 if (rinfo->length < 1) {
814 return -EINVAL;
815 }
816 }
817
818 pref = rinfo->route_pref;
819 if (pref == ICMPV6_ROUTER_PREF_INVALID)
820 return -EINVAL;
821
822 lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
823
824 if (rinfo->length == 3)
825 prefix = (struct in6_addr *)rinfo->prefix;
826 else {
827 /* this function is safe */
828 ipv6_addr_prefix(&prefix_buf,
829 (struct in6_addr *)rinfo->prefix,
830 rinfo->prefix_len);
831 prefix = &prefix_buf;
832 }
833
834 if (rinfo->prefix_len == 0)
835 rt = rt6_get_dflt_router(net, gwaddr, dev);
836 else
837 rt = rt6_get_route_info(net, prefix, rinfo->prefix_len,
838 gwaddr, dev);
839
840 if (rt && !lifetime) {
841 ip6_del_rt(net, rt);
842 rt = NULL;
843 }
844
845 if (!rt && lifetime)
846 rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr,
847 dev, pref);
848 else if (rt)
849 rt->fib6_flags = RTF_ROUTEINFO |
850 (rt->fib6_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
851
852 if (rt) {
853 if (!addrconf_finite_timeout(lifetime))
854 fib6_clean_expires(rt);
855 else
856 fib6_set_expires(rt, jiffies + HZ * lifetime);
857
858 fib6_info_release(rt);
859 }
860 return 0;
861 }
862 #endif
863
864 /*
865 * Misc support functions
866 */
867
868 /* called with rcu_lock held */
869 static struct net_device *ip6_rt_get_dev_rcu(struct fib6_info *rt)
870 {
871 struct net_device *dev = rt->fib6_nh.nh_dev;
872
873 if (rt->fib6_flags & (RTF_LOCAL | RTF_ANYCAST)) {
874 /* for copies of local routes, dst->dev needs to be the
875 * device if it is a master device, the master device if
876 * device is enslaved, and the loopback as the default
877 */
878 if (netif_is_l3_slave(dev) &&
879 !rt6_need_strict(&rt->fib6_dst.addr))
880 dev = l3mdev_master_dev_rcu(dev);
881 else if (!netif_is_l3_master(dev))
882 dev = dev_net(dev)->loopback_dev;
883 /* last case is netif_is_l3_master(dev) is true in which
884 * case we want dev returned to be dev
885 */
886 }
887
888 return dev;
889 }
890
891 static const int fib6_prop[RTN_MAX + 1] = {
892 [RTN_UNSPEC] = 0,
893 [RTN_UNICAST] = 0,
894 [RTN_LOCAL] = 0,
895 [RTN_BROADCAST] = 0,
896 [RTN_ANYCAST] = 0,
897 [RTN_MULTICAST] = 0,
898 [RTN_BLACKHOLE] = -EINVAL,
899 [RTN_UNREACHABLE] = -EHOSTUNREACH,
900 [RTN_PROHIBIT] = -EACCES,
901 [RTN_THROW] = -EAGAIN,
902 [RTN_NAT] = -EINVAL,
903 [RTN_XRESOLVE] = -EINVAL,
904 };
905
906 static int ip6_rt_type_to_error(u8 fib6_type)
907 {
908 return fib6_prop[fib6_type];
909 }
910
911 static unsigned short fib6_info_dst_flags(struct fib6_info *rt)
912 {
913 unsigned short flags = 0;
914
915 if (rt->dst_nocount)
916 flags |= DST_NOCOUNT;
917 if (rt->dst_nopolicy)
918 flags |= DST_NOPOLICY;
919 if (rt->dst_host)
920 flags |= DST_HOST;
921
922 return flags;
923 }
924
925 static void ip6_rt_init_dst_reject(struct rt6_info *rt, struct fib6_info *ort)
926 {
927 rt->dst.error = ip6_rt_type_to_error(ort->fib6_type);
928
929 switch (ort->fib6_type) {
930 case RTN_BLACKHOLE:
931 rt->dst.output = dst_discard_out;
932 rt->dst.input = dst_discard;
933 break;
934 case RTN_PROHIBIT:
935 rt->dst.output = ip6_pkt_prohibit_out;
936 rt->dst.input = ip6_pkt_prohibit;
937 break;
938 case RTN_THROW:
939 case RTN_UNREACHABLE:
940 default:
941 rt->dst.output = ip6_pkt_discard_out;
942 rt->dst.input = ip6_pkt_discard;
943 break;
944 }
945 }
946
947 static void ip6_rt_init_dst(struct rt6_info *rt, struct fib6_info *ort)
948 {
949 if (ort->fib6_flags & RTF_REJECT) {
950 ip6_rt_init_dst_reject(rt, ort);
951 return;
952 }
953
954 rt->dst.error = 0;
955 rt->dst.output = ip6_output;
956
957 if (ort->fib6_type == RTN_LOCAL || ort->fib6_type == RTN_ANYCAST) {
958 rt->dst.input = ip6_input;
959 } else if (ipv6_addr_type(&ort->fib6_dst.addr) & IPV6_ADDR_MULTICAST) {
960 rt->dst.input = ip6_mc_input;
961 } else {
962 rt->dst.input = ip6_forward;
963 }
964
965 if (ort->fib6_nh.nh_lwtstate) {
966 rt->dst.lwtstate = lwtstate_get(ort->fib6_nh.nh_lwtstate);
967 lwtunnel_set_redirect(&rt->dst);
968 }
969
970 rt->dst.lastuse = jiffies;
971 }
972
973 /* Caller must already hold reference to @from */
974 static void rt6_set_from(struct rt6_info *rt, struct fib6_info *from)
975 {
976 rt->rt6i_flags &= ~RTF_EXPIRES;
977 rcu_assign_pointer(rt->from, from);
978 ip_dst_init_metrics(&rt->dst, from->fib6_metrics);
979 }
980
981 /* Caller must already hold reference to @ort */
982 static void ip6_rt_copy_init(struct rt6_info *rt, struct fib6_info *ort)
983 {
984 struct net_device *dev = fib6_info_nh_dev(ort);
985
986 ip6_rt_init_dst(rt, ort);
987
988 rt->rt6i_dst = ort->fib6_dst;
989 rt->rt6i_idev = dev ? in6_dev_get(dev) : NULL;
990 rt->rt6i_gateway = ort->fib6_nh.nh_gw;
991 rt->rt6i_flags = ort->fib6_flags;
992 rt6_set_from(rt, ort);
993 #ifdef CONFIG_IPV6_SUBTREES
994 rt->rt6i_src = ort->fib6_src;
995 #endif
996 }
997
998 static struct fib6_node* fib6_backtrack(struct fib6_node *fn,
999 struct in6_addr *saddr)
1000 {
1001 struct fib6_node *pn, *sn;
1002 while (1) {
1003 if (fn->fn_flags & RTN_TL_ROOT)
1004 return NULL;
1005 pn = rcu_dereference(fn->parent);
1006 sn = FIB6_SUBTREE(pn);
1007 if (sn && sn != fn)
1008 fn = fib6_node_lookup(sn, NULL, saddr);
1009 else
1010 fn = pn;
1011 if (fn->fn_flags & RTN_RTINFO)
1012 return fn;
1013 }
1014 }
1015
1016 static bool ip6_hold_safe(struct net *net, struct rt6_info **prt,
1017 bool null_fallback)
1018 {
1019 struct rt6_info *rt = *prt;
1020
1021 if (dst_hold_safe(&rt->dst))
1022 return true;
1023 if (null_fallback) {
1024 rt = net->ipv6.ip6_null_entry;
1025 dst_hold(&rt->dst);
1026 } else {
1027 rt = NULL;
1028 }
1029 *prt = rt;
1030 return false;
1031 }
1032
1033 /* called with rcu_lock held */
1034 static struct rt6_info *ip6_create_rt_rcu(struct fib6_info *rt)
1035 {
1036 unsigned short flags = fib6_info_dst_flags(rt);
1037 struct net_device *dev = rt->fib6_nh.nh_dev;
1038 struct rt6_info *nrt;
1039
1040 if (!fib6_info_hold_safe(rt))
1041 return NULL;
1042
1043 nrt = ip6_dst_alloc(dev_net(dev), dev, flags);
1044 if (nrt)
1045 ip6_rt_copy_init(nrt, rt);
1046 else
1047 fib6_info_release(rt);
1048
1049 return nrt;
1050 }
1051
1052 static struct rt6_info *ip6_pol_route_lookup(struct net *net,
1053 struct fib6_table *table,
1054 struct flowi6 *fl6,
1055 const struct sk_buff *skb,
1056 int flags)
1057 {
1058 struct fib6_info *f6i;
1059 struct fib6_node *fn;
1060 struct rt6_info *rt;
1061
1062 if (fl6->flowi6_flags & FLOWI_FLAG_SKIP_NH_OIF)
1063 flags &= ~RT6_LOOKUP_F_IFACE;
1064
1065 rcu_read_lock();
1066 fn = fib6_node_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1067 restart:
1068 f6i = rcu_dereference(fn->leaf);
1069 if (!f6i) {
1070 f6i = net->ipv6.fib6_null_entry;
1071 } else {
1072 f6i = rt6_device_match(net, f6i, &fl6->saddr,
1073 fl6->flowi6_oif, flags);
1074 if (f6i->fib6_nsiblings && fl6->flowi6_oif == 0)
1075 f6i = fib6_multipath_select(net, f6i, fl6,
1076 fl6->flowi6_oif, skb,
1077 flags);
1078 }
1079 if (f6i == net->ipv6.fib6_null_entry) {
1080 fn = fib6_backtrack(fn, &fl6->saddr);
1081 if (fn)
1082 goto restart;
1083 }
1084
1085 trace_fib6_table_lookup(net, f6i, table, fl6);
1086
1087 /* Search through exception table */
1088 rt = rt6_find_cached_rt(f6i, &fl6->daddr, &fl6->saddr);
1089 if (rt) {
1090 if (ip6_hold_safe(net, &rt, true))
1091 dst_use_noref(&rt->dst, jiffies);
1092 } else if (f6i == net->ipv6.fib6_null_entry) {
1093 rt = net->ipv6.ip6_null_entry;
1094 dst_hold(&rt->dst);
1095 } else {
1096 rt = ip6_create_rt_rcu(f6i);
1097 if (!rt) {
1098 rt = net->ipv6.ip6_null_entry;
1099 dst_hold(&rt->dst);
1100 }
1101 }
1102
1103 rcu_read_unlock();
1104
1105 return rt;
1106 }
1107
1108 struct dst_entry *ip6_route_lookup(struct net *net, struct flowi6 *fl6,
1109 const struct sk_buff *skb, int flags)
1110 {
1111 return fib6_rule_lookup(net, fl6, skb, flags, ip6_pol_route_lookup);
1112 }
1113 EXPORT_SYMBOL_GPL(ip6_route_lookup);
1114
1115 struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
1116 const struct in6_addr *saddr, int oif,
1117 const struct sk_buff *skb, int strict)
1118 {
1119 struct flowi6 fl6 = {
1120 .flowi6_oif = oif,
1121 .daddr = *daddr,
1122 };
1123 struct dst_entry *dst;
1124 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
1125
1126 if (saddr) {
1127 memcpy(&fl6.saddr, saddr, sizeof(*saddr));
1128 flags |= RT6_LOOKUP_F_HAS_SADDR;
1129 }
1130
1131 dst = fib6_rule_lookup(net, &fl6, skb, flags, ip6_pol_route_lookup);
1132 if (dst->error == 0)
1133 return (struct rt6_info *) dst;
1134
1135 dst_release(dst);
1136
1137 return NULL;
1138 }
1139 EXPORT_SYMBOL(rt6_lookup);
1140
1141 /* ip6_ins_rt is called with FREE table->tb6_lock.
1142 * It takes new route entry, the addition fails by any reason the
1143 * route is released.
1144 * Caller must hold dst before calling it.
1145 */
1146
1147 static int __ip6_ins_rt(struct fib6_info *rt, struct nl_info *info,
1148 struct netlink_ext_ack *extack)
1149 {
1150 int err;
1151 struct fib6_table *table;
1152
1153 table = rt->fib6_table;
1154 spin_lock_bh(&table->tb6_lock);
1155 err = fib6_add(&table->tb6_root, rt, info, extack);
1156 spin_unlock_bh(&table->tb6_lock);
1157
1158 return err;
1159 }
1160
1161 int ip6_ins_rt(struct net *net, struct fib6_info *rt)
1162 {
1163 struct nl_info info = { .nl_net = net, };
1164
1165 return __ip6_ins_rt(rt, &info, NULL);
1166 }
1167
1168 static struct rt6_info *ip6_rt_cache_alloc(struct fib6_info *ort,
1169 const struct in6_addr *daddr,
1170 const struct in6_addr *saddr)
1171 {
1172 struct net_device *dev;
1173 struct rt6_info *rt;
1174
1175 /*
1176 * Clone the route.
1177 */
1178
1179 if (!fib6_info_hold_safe(ort))
1180 return NULL;
1181
1182 dev = ip6_rt_get_dev_rcu(ort);
1183 rt = ip6_dst_alloc(dev_net(dev), dev, 0);
1184 if (!rt) {
1185 fib6_info_release(ort);
1186 return NULL;
1187 }
1188
1189 ip6_rt_copy_init(rt, ort);
1190 rt->rt6i_flags |= RTF_CACHE;
1191 rt->dst.flags |= DST_HOST;
1192 rt->rt6i_dst.addr = *daddr;
1193 rt->rt6i_dst.plen = 128;
1194
1195 if (!rt6_is_gw_or_nonexthop(ort)) {
1196 if (ort->fib6_dst.plen != 128 &&
1197 ipv6_addr_equal(&ort->fib6_dst.addr, daddr))
1198 rt->rt6i_flags |= RTF_ANYCAST;
1199 #ifdef CONFIG_IPV6_SUBTREES
1200 if (rt->rt6i_src.plen && saddr) {
1201 rt->rt6i_src.addr = *saddr;
1202 rt->rt6i_src.plen = 128;
1203 }
1204 #endif
1205 }
1206
1207 return rt;
1208 }
1209
1210 static struct rt6_info *ip6_rt_pcpu_alloc(struct fib6_info *rt)
1211 {
1212 unsigned short flags = fib6_info_dst_flags(rt);
1213 struct net_device *dev;
1214 struct rt6_info *pcpu_rt;
1215
1216 if (!fib6_info_hold_safe(rt))
1217 return NULL;
1218
1219 rcu_read_lock();
1220 dev = ip6_rt_get_dev_rcu(rt);
1221 pcpu_rt = ip6_dst_alloc(dev_net(dev), dev, flags);
1222 rcu_read_unlock();
1223 if (!pcpu_rt) {
1224 fib6_info_release(rt);
1225 return NULL;
1226 }
1227 ip6_rt_copy_init(pcpu_rt, rt);
1228 pcpu_rt->rt6i_flags |= RTF_PCPU;
1229 return pcpu_rt;
1230 }
1231
1232 /* It should be called with rcu_read_lock() acquired */
1233 static struct rt6_info *rt6_get_pcpu_route(struct fib6_info *rt)
1234 {
1235 struct rt6_info *pcpu_rt, **p;
1236
1237 p = this_cpu_ptr(rt->rt6i_pcpu);
1238 pcpu_rt = *p;
1239
1240 if (pcpu_rt)
1241 ip6_hold_safe(NULL, &pcpu_rt, false);
1242
1243 return pcpu_rt;
1244 }
1245
1246 static struct rt6_info *rt6_make_pcpu_route(struct net *net,
1247 struct fib6_info *rt)
1248 {
1249 struct rt6_info *pcpu_rt, *prev, **p;
1250
1251 pcpu_rt = ip6_rt_pcpu_alloc(rt);
1252 if (!pcpu_rt) {
1253 dst_hold(&net->ipv6.ip6_null_entry->dst);
1254 return net->ipv6.ip6_null_entry;
1255 }
1256
1257 dst_hold(&pcpu_rt->dst);
1258 p = this_cpu_ptr(rt->rt6i_pcpu);
1259 prev = cmpxchg(p, NULL, pcpu_rt);
1260 BUG_ON(prev);
1261
1262 return pcpu_rt;
1263 }
1264
1265 /* exception hash table implementation
1266 */
1267 static DEFINE_SPINLOCK(rt6_exception_lock);
1268
1269 /* Remove rt6_ex from hash table and free the memory
1270 * Caller must hold rt6_exception_lock
1271 */
1272 static void rt6_remove_exception(struct rt6_exception_bucket *bucket,
1273 struct rt6_exception *rt6_ex)
1274 {
1275 struct net *net;
1276
1277 if (!bucket || !rt6_ex)
1278 return;
1279
1280 net = dev_net(rt6_ex->rt6i->dst.dev);
1281 hlist_del_rcu(&rt6_ex->hlist);
1282 dst_release(&rt6_ex->rt6i->dst);
1283 kfree_rcu(rt6_ex, rcu);
1284 WARN_ON_ONCE(!bucket->depth);
1285 bucket->depth--;
1286 net->ipv6.rt6_stats->fib_rt_cache--;
1287 }
1288
1289 /* Remove oldest rt6_ex in bucket and free the memory
1290 * Caller must hold rt6_exception_lock
1291 */
1292 static void rt6_exception_remove_oldest(struct rt6_exception_bucket *bucket)
1293 {
1294 struct rt6_exception *rt6_ex, *oldest = NULL;
1295
1296 if (!bucket)
1297 return;
1298
1299 hlist_for_each_entry(rt6_ex, &bucket->chain, hlist) {
1300 if (!oldest || time_before(rt6_ex->stamp, oldest->stamp))
1301 oldest = rt6_ex;
1302 }
1303 rt6_remove_exception(bucket, oldest);
1304 }
1305
1306 static u32 rt6_exception_hash(const struct in6_addr *dst,
1307 const struct in6_addr *src)
1308 {
1309 static u32 seed __read_mostly;
1310 u32 val;
1311
1312 net_get_random_once(&seed, sizeof(seed));
1313 val = jhash(dst, sizeof(*dst), seed);
1314
1315 #ifdef CONFIG_IPV6_SUBTREES
1316 if (src)
1317 val = jhash(src, sizeof(*src), val);
1318 #endif
1319 return hash_32(val, FIB6_EXCEPTION_BUCKET_SIZE_SHIFT);
1320 }
1321
1322 /* Helper function to find the cached rt in the hash table
1323 * and update bucket pointer to point to the bucket for this
1324 * (daddr, saddr) pair
1325 * Caller must hold rt6_exception_lock
1326 */
1327 static struct rt6_exception *
1328 __rt6_find_exception_spinlock(struct rt6_exception_bucket **bucket,
1329 const struct in6_addr *daddr,
1330 const struct in6_addr *saddr)
1331 {
1332 struct rt6_exception *rt6_ex;
1333 u32 hval;
1334
1335 if (!(*bucket) || !daddr)
1336 return NULL;
1337
1338 hval = rt6_exception_hash(daddr, saddr);
1339 *bucket += hval;
1340
1341 hlist_for_each_entry(rt6_ex, &(*bucket)->chain, hlist) {
1342 struct rt6_info *rt6 = rt6_ex->rt6i;
1343 bool matched = ipv6_addr_equal(daddr, &rt6->rt6i_dst.addr);
1344
1345 #ifdef CONFIG_IPV6_SUBTREES
1346 if (matched && saddr)
1347 matched = ipv6_addr_equal(saddr, &rt6->rt6i_src.addr);
1348 #endif
1349 if (matched)
1350 return rt6_ex;
1351 }
1352 return NULL;
1353 }
1354
1355 /* Helper function to find the cached rt in the hash table
1356 * and update bucket pointer to point to the bucket for this
1357 * (daddr, saddr) pair
1358 * Caller must hold rcu_read_lock()
1359 */
1360 static struct rt6_exception *
1361 __rt6_find_exception_rcu(struct rt6_exception_bucket **bucket,
1362 const struct in6_addr *daddr,
1363 const struct in6_addr *saddr)
1364 {
1365 struct rt6_exception *rt6_ex;
1366 u32 hval;
1367
1368 WARN_ON_ONCE(!rcu_read_lock_held());
1369
1370 if (!(*bucket) || !daddr)
1371 return NULL;
1372
1373 hval = rt6_exception_hash(daddr, saddr);
1374 *bucket += hval;
1375
1376 hlist_for_each_entry_rcu(rt6_ex, &(*bucket)->chain, hlist) {
1377 struct rt6_info *rt6 = rt6_ex->rt6i;
1378 bool matched = ipv6_addr_equal(daddr, &rt6->rt6i_dst.addr);
1379
1380 #ifdef CONFIG_IPV6_SUBTREES
1381 if (matched && saddr)
1382 matched = ipv6_addr_equal(saddr, &rt6->rt6i_src.addr);
1383 #endif
1384 if (matched)
1385 return rt6_ex;
1386 }
1387 return NULL;
1388 }
1389
1390 static unsigned int fib6_mtu(const struct fib6_info *rt)
1391 {
1392 unsigned int mtu;
1393
1394 if (rt->fib6_pmtu) {
1395 mtu = rt->fib6_pmtu;
1396 } else {
1397 struct net_device *dev = fib6_info_nh_dev(rt);
1398 struct inet6_dev *idev;
1399
1400 rcu_read_lock();
1401 idev = __in6_dev_get(dev);
1402 mtu = idev->cnf.mtu6;
1403 rcu_read_unlock();
1404 }
1405
1406 mtu = min_t(unsigned int, mtu, IP6_MAX_MTU);
1407
1408 return mtu - lwtunnel_headroom(rt->fib6_nh.nh_lwtstate, mtu);
1409 }
1410
1411 static int rt6_insert_exception(struct rt6_info *nrt,
1412 struct fib6_info *ort)
1413 {
1414 struct net *net = dev_net(nrt->dst.dev);
1415 struct rt6_exception_bucket *bucket;
1416 struct in6_addr *src_key = NULL;
1417 struct rt6_exception *rt6_ex;
1418 int err = 0;
1419
1420 spin_lock_bh(&rt6_exception_lock);
1421
1422 if (ort->exception_bucket_flushed) {
1423 err = -EINVAL;
1424 goto out;
1425 }
1426
1427 bucket = rcu_dereference_protected(ort->rt6i_exception_bucket,
1428 lockdep_is_held(&rt6_exception_lock));
1429 if (!bucket) {
1430 bucket = kcalloc(FIB6_EXCEPTION_BUCKET_SIZE, sizeof(*bucket),
1431 GFP_ATOMIC);
1432 if (!bucket) {
1433 err = -ENOMEM;
1434 goto out;
1435 }
1436 rcu_assign_pointer(ort->rt6i_exception_bucket, bucket);
1437 }
1438
1439 #ifdef CONFIG_IPV6_SUBTREES
1440 /* rt6i_src.plen != 0 indicates ort is in subtree
1441 * and exception table is indexed by a hash of
1442 * both rt6i_dst and rt6i_src.
1443 * Otherwise, the exception table is indexed by
1444 * a hash of only rt6i_dst.
1445 */
1446 if (ort->fib6_src.plen)
1447 src_key = &nrt->rt6i_src.addr;
1448 #endif
1449 /* rt6_mtu_change() might lower mtu on ort.
1450 * Only insert this exception route if its mtu
1451 * is less than ort's mtu value.
1452 */
1453 if (dst_metric_raw(&nrt->dst, RTAX_MTU) >= fib6_mtu(ort)) {
1454 err = -EINVAL;
1455 goto out;
1456 }
1457
1458 rt6_ex = __rt6_find_exception_spinlock(&bucket, &nrt->rt6i_dst.addr,
1459 src_key);
1460 if (rt6_ex)
1461 rt6_remove_exception(bucket, rt6_ex);
1462
1463 rt6_ex = kzalloc(sizeof(*rt6_ex), GFP_ATOMIC);
1464 if (!rt6_ex) {
1465 err = -ENOMEM;
1466 goto out;
1467 }
1468 rt6_ex->rt6i = nrt;
1469 rt6_ex->stamp = jiffies;
1470 hlist_add_head_rcu(&rt6_ex->hlist, &bucket->chain);
1471 bucket->depth++;
1472 net->ipv6.rt6_stats->fib_rt_cache++;
1473
1474 if (bucket->depth > FIB6_MAX_DEPTH)
1475 rt6_exception_remove_oldest(bucket);
1476
1477 out:
1478 spin_unlock_bh(&rt6_exception_lock);
1479
1480 /* Update fn->fn_sernum to invalidate all cached dst */
1481 if (!err) {
1482 spin_lock_bh(&ort->fib6_table->tb6_lock);
1483 fib6_update_sernum(net, ort);
1484 spin_unlock_bh(&ort->fib6_table->tb6_lock);
1485 fib6_force_start_gc(net);
1486 }
1487
1488 return err;
1489 }
1490
1491 void rt6_flush_exceptions(struct fib6_info *rt)
1492 {
1493 struct rt6_exception_bucket *bucket;
1494 struct rt6_exception *rt6_ex;
1495 struct hlist_node *tmp;
1496 int i;
1497
1498 spin_lock_bh(&rt6_exception_lock);
1499 /* Prevent rt6_insert_exception() to recreate the bucket list */
1500 rt->exception_bucket_flushed = 1;
1501
1502 bucket = rcu_dereference_protected(rt->rt6i_exception_bucket,
1503 lockdep_is_held(&rt6_exception_lock));
1504 if (!bucket)
1505 goto out;
1506
1507 for (i = 0; i < FIB6_EXCEPTION_BUCKET_SIZE; i++) {
1508 hlist_for_each_entry_safe(rt6_ex, tmp, &bucket->chain, hlist)
1509 rt6_remove_exception(bucket, rt6_ex);
1510 WARN_ON_ONCE(bucket->depth);
1511 bucket++;
1512 }
1513
1514 out:
1515 spin_unlock_bh(&rt6_exception_lock);
1516 }
1517
1518 /* Find cached rt in the hash table inside passed in rt
1519 * Caller has to hold rcu_read_lock()
1520 */
1521 static struct rt6_info *rt6_find_cached_rt(struct fib6_info *rt,
1522 struct in6_addr *daddr,
1523 struct in6_addr *saddr)
1524 {
1525 struct rt6_exception_bucket *bucket;
1526 struct in6_addr *src_key = NULL;
1527 struct rt6_exception *rt6_ex;
1528 struct rt6_info *res = NULL;
1529
1530 bucket = rcu_dereference(rt->rt6i_exception_bucket);
1531
1532 #ifdef CONFIG_IPV6_SUBTREES
1533 /* rt6i_src.plen != 0 indicates rt is in subtree
1534 * and exception table is indexed by a hash of
1535 * both rt6i_dst and rt6i_src.
1536 * Otherwise, the exception table is indexed by
1537 * a hash of only rt6i_dst.
1538 */
1539 if (rt->fib6_src.plen)
1540 src_key = saddr;
1541 #endif
1542 rt6_ex = __rt6_find_exception_rcu(&bucket, daddr, src_key);
1543
1544 if (rt6_ex && !rt6_check_expired(rt6_ex->rt6i))
1545 res = rt6_ex->rt6i;
1546
1547 return res;
1548 }
1549
1550 /* Remove the passed in cached rt from the hash table that contains it */
1551 static int rt6_remove_exception_rt(struct rt6_info *rt)
1552 {
1553 struct rt6_exception_bucket *bucket;
1554 struct in6_addr *src_key = NULL;
1555 struct rt6_exception *rt6_ex;
1556 struct fib6_info *from;
1557 int err;
1558
1559 from = rcu_dereference(rt->from);
1560 if (!from ||
1561 !(rt->rt6i_flags & RTF_CACHE))
1562 return -EINVAL;
1563
1564 if (!rcu_access_pointer(from->rt6i_exception_bucket))
1565 return -ENOENT;
1566
1567 spin_lock_bh(&rt6_exception_lock);
1568 bucket = rcu_dereference_protected(from->rt6i_exception_bucket,
1569 lockdep_is_held(&rt6_exception_lock));
1570 #ifdef CONFIG_IPV6_SUBTREES
1571 /* rt6i_src.plen != 0 indicates 'from' is in subtree
1572 * and exception table is indexed by a hash of
1573 * both rt6i_dst and rt6i_src.
1574 * Otherwise, the exception table is indexed by
1575 * a hash of only rt6i_dst.
1576 */
1577 if (from->fib6_src.plen)
1578 src_key = &rt->rt6i_src.addr;
1579 #endif
1580 rt6_ex = __rt6_find_exception_spinlock(&bucket,
1581 &rt->rt6i_dst.addr,
1582 src_key);
1583 if (rt6_ex) {
1584 rt6_remove_exception(bucket, rt6_ex);
1585 err = 0;
1586 } else {
1587 err = -ENOENT;
1588 }
1589
1590 spin_unlock_bh(&rt6_exception_lock);
1591 return err;
1592 }
1593
1594 /* Find rt6_ex which contains the passed in rt cache and
1595 * refresh its stamp
1596 */
1597 static void rt6_update_exception_stamp_rt(struct rt6_info *rt)
1598 {
1599 struct rt6_exception_bucket *bucket;
1600 struct fib6_info *from = rt->from;
1601 struct in6_addr *src_key = NULL;
1602 struct rt6_exception *rt6_ex;
1603
1604 if (!from ||
1605 !(rt->rt6i_flags & RTF_CACHE))
1606 return;
1607
1608 rcu_read_lock();
1609 bucket = rcu_dereference(from->rt6i_exception_bucket);
1610
1611 #ifdef CONFIG_IPV6_SUBTREES
1612 /* rt6i_src.plen != 0 indicates 'from' is in subtree
1613 * and exception table is indexed by a hash of
1614 * both rt6i_dst and rt6i_src.
1615 * Otherwise, the exception table is indexed by
1616 * a hash of only rt6i_dst.
1617 */
1618 if (from->fib6_src.plen)
1619 src_key = &rt->rt6i_src.addr;
1620 #endif
1621 rt6_ex = __rt6_find_exception_rcu(&bucket,
1622 &rt->rt6i_dst.addr,
1623 src_key);
1624 if (rt6_ex)
1625 rt6_ex->stamp = jiffies;
1626
1627 rcu_read_unlock();
1628 }
1629
1630 static bool rt6_mtu_change_route_allowed(struct inet6_dev *idev,
1631 struct rt6_info *rt, int mtu)
1632 {
1633 /* If the new MTU is lower than the route PMTU, this new MTU will be the
1634 * lowest MTU in the path: always allow updating the route PMTU to
1635 * reflect PMTU decreases.
1636 *
1637 * If the new MTU is higher, and the route PMTU is equal to the local
1638 * MTU, this means the old MTU is the lowest in the path, so allow
1639 * updating it: if other nodes now have lower MTUs, PMTU discovery will
1640 * handle this.
1641 */
1642
1643 if (dst_mtu(&rt->dst) >= mtu)
1644 return true;
1645
1646 if (dst_mtu(&rt->dst) == idev->cnf.mtu6)
1647 return true;
1648
1649 return false;
1650 }
1651
1652 static void rt6_exceptions_update_pmtu(struct inet6_dev *idev,
1653 struct fib6_info *rt, int mtu)
1654 {
1655 struct rt6_exception_bucket *bucket;
1656 struct rt6_exception *rt6_ex;
1657 int i;
1658
1659 bucket = rcu_dereference_protected(rt->rt6i_exception_bucket,
1660 lockdep_is_held(&rt6_exception_lock));
1661
1662 if (!bucket)
1663 return;
1664
1665 for (i = 0; i < FIB6_EXCEPTION_BUCKET_SIZE; i++) {
1666 hlist_for_each_entry(rt6_ex, &bucket->chain, hlist) {
1667 struct rt6_info *entry = rt6_ex->rt6i;
1668
1669 /* For RTF_CACHE with rt6i_pmtu == 0 (i.e. a redirected
1670 * route), the metrics of its rt->from have already
1671 * been updated.
1672 */
1673 if (dst_metric_raw(&entry->dst, RTAX_MTU) &&
1674 rt6_mtu_change_route_allowed(idev, entry, mtu))
1675 dst_metric_set(&entry->dst, RTAX_MTU, mtu);
1676 }
1677 bucket++;
1678 }
1679 }
1680
1681 #define RTF_CACHE_GATEWAY (RTF_GATEWAY | RTF_CACHE)
1682
1683 static void rt6_exceptions_clean_tohost(struct fib6_info *rt,
1684 struct in6_addr *gateway)
1685 {
1686 struct rt6_exception_bucket *bucket;
1687 struct rt6_exception *rt6_ex;
1688 struct hlist_node *tmp;
1689 int i;
1690
1691 if (!rcu_access_pointer(rt->rt6i_exception_bucket))
1692 return;
1693
1694 spin_lock_bh(&rt6_exception_lock);
1695 bucket = rcu_dereference_protected(rt->rt6i_exception_bucket,
1696 lockdep_is_held(&rt6_exception_lock));
1697
1698 if (bucket) {
1699 for (i = 0; i < FIB6_EXCEPTION_BUCKET_SIZE; i++) {
1700 hlist_for_each_entry_safe(rt6_ex, tmp,
1701 &bucket->chain, hlist) {
1702 struct rt6_info *entry = rt6_ex->rt6i;
1703
1704 if ((entry->rt6i_flags & RTF_CACHE_GATEWAY) ==
1705 RTF_CACHE_GATEWAY &&
1706 ipv6_addr_equal(gateway,
1707 &entry->rt6i_gateway)) {
1708 rt6_remove_exception(bucket, rt6_ex);
1709 }
1710 }
1711 bucket++;
1712 }
1713 }
1714
1715 spin_unlock_bh(&rt6_exception_lock);
1716 }
1717
1718 static void rt6_age_examine_exception(struct rt6_exception_bucket *bucket,
1719 struct rt6_exception *rt6_ex,
1720 struct fib6_gc_args *gc_args,
1721 unsigned long now)
1722 {
1723 struct rt6_info *rt = rt6_ex->rt6i;
1724
1725 /* we are pruning and obsoleting aged-out and non gateway exceptions
1726 * even if others have still references to them, so that on next
1727 * dst_check() such references can be dropped.
1728 * EXPIRES exceptions - e.g. pmtu-generated ones are pruned when
1729 * expired, independently from their aging, as per RFC 8201 section 4
1730 */
1731 if (!(rt->rt6i_flags & RTF_EXPIRES)) {
1732 if (time_after_eq(now, rt->dst.lastuse + gc_args->timeout)) {
1733 RT6_TRACE("aging clone %p\n", rt);
1734 rt6_remove_exception(bucket, rt6_ex);
1735 return;
1736 }
1737 } else if (time_after(jiffies, rt->dst.expires)) {
1738 RT6_TRACE("purging expired route %p\n", rt);
1739 rt6_remove_exception(bucket, rt6_ex);
1740 return;
1741 }
1742
1743 if (rt->rt6i_flags & RTF_GATEWAY) {
1744 struct neighbour *neigh;
1745 __u8 neigh_flags = 0;
1746
1747 neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
1748 if (neigh)
1749 neigh_flags = neigh->flags;
1750
1751 if (!(neigh_flags & NTF_ROUTER)) {
1752 RT6_TRACE("purging route %p via non-router but gateway\n",
1753 rt);
1754 rt6_remove_exception(bucket, rt6_ex);
1755 return;
1756 }
1757 }
1758
1759 gc_args->more++;
1760 }
1761
1762 void rt6_age_exceptions(struct fib6_info *rt,
1763 struct fib6_gc_args *gc_args,
1764 unsigned long now)
1765 {
1766 struct rt6_exception_bucket *bucket;
1767 struct rt6_exception *rt6_ex;
1768 struct hlist_node *tmp;
1769 int i;
1770
1771 if (!rcu_access_pointer(rt->rt6i_exception_bucket))
1772 return;
1773
1774 rcu_read_lock_bh();
1775 spin_lock(&rt6_exception_lock);
1776 bucket = rcu_dereference_protected(rt->rt6i_exception_bucket,
1777 lockdep_is_held(&rt6_exception_lock));
1778
1779 if (bucket) {
1780 for (i = 0; i < FIB6_EXCEPTION_BUCKET_SIZE; i++) {
1781 hlist_for_each_entry_safe(rt6_ex, tmp,
1782 &bucket->chain, hlist) {
1783 rt6_age_examine_exception(bucket, rt6_ex,
1784 gc_args, now);
1785 }
1786 bucket++;
1787 }
1788 }
1789 spin_unlock(&rt6_exception_lock);
1790 rcu_read_unlock_bh();
1791 }
1792
1793 /* must be called with rcu lock held */
1794 struct fib6_info *fib6_table_lookup(struct net *net, struct fib6_table *table,
1795 int oif, struct flowi6 *fl6, int strict)
1796 {
1797 struct fib6_node *fn, *saved_fn;
1798 struct fib6_info *f6i;
1799
1800 fn = fib6_node_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1801 saved_fn = fn;
1802
1803 if (fl6->flowi6_flags & FLOWI_FLAG_SKIP_NH_OIF)
1804 oif = 0;
1805
1806 redo_rt6_select:
1807 f6i = rt6_select(net, fn, oif, strict);
1808 if (f6i == net->ipv6.fib6_null_entry) {
1809 fn = fib6_backtrack(fn, &fl6->saddr);
1810 if (fn)
1811 goto redo_rt6_select;
1812 else if (strict & RT6_LOOKUP_F_REACHABLE) {
1813 /* also consider unreachable route */
1814 strict &= ~RT6_LOOKUP_F_REACHABLE;
1815 fn = saved_fn;
1816 goto redo_rt6_select;
1817 }
1818 }
1819
1820 trace_fib6_table_lookup(net, f6i, table, fl6);
1821
1822 return f6i;
1823 }
1824
1825 struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table,
1826 int oif, struct flowi6 *fl6,
1827 const struct sk_buff *skb, int flags)
1828 {
1829 struct fib6_info *f6i;
1830 struct rt6_info *rt;
1831 int strict = 0;
1832
1833 strict |= flags & RT6_LOOKUP_F_IFACE;
1834 strict |= flags & RT6_LOOKUP_F_IGNORE_LINKSTATE;
1835 if (net->ipv6.devconf_all->forwarding == 0)
1836 strict |= RT6_LOOKUP_F_REACHABLE;
1837
1838 rcu_read_lock();
1839
1840 f6i = fib6_table_lookup(net, table, oif, fl6, strict);
1841 if (f6i->fib6_nsiblings)
1842 f6i = fib6_multipath_select(net, f6i, fl6, oif, skb, strict);
1843
1844 if (f6i == net->ipv6.fib6_null_entry) {
1845 rt = net->ipv6.ip6_null_entry;
1846 rcu_read_unlock();
1847 dst_hold(&rt->dst);
1848 return rt;
1849 }
1850
1851 /*Search through exception table */
1852 rt = rt6_find_cached_rt(f6i, &fl6->daddr, &fl6->saddr);
1853 if (rt) {
1854 if (ip6_hold_safe(net, &rt, true))
1855 dst_use_noref(&rt->dst, jiffies);
1856
1857 rcu_read_unlock();
1858 return rt;
1859 } else if (unlikely((fl6->flowi6_flags & FLOWI_FLAG_KNOWN_NH) &&
1860 !(f6i->fib6_flags & RTF_GATEWAY))) {
1861 /* Create a RTF_CACHE clone which will not be
1862 * owned by the fib6 tree. It is for the special case where
1863 * the daddr in the skb during the neighbor look-up is different
1864 * from the fl6->daddr used to look-up route here.
1865 */
1866 struct rt6_info *uncached_rt;
1867
1868 uncached_rt = ip6_rt_cache_alloc(f6i, &fl6->daddr, NULL);
1869
1870 rcu_read_unlock();
1871
1872 if (uncached_rt) {
1873 /* Uncached_rt's refcnt is taken during ip6_rt_cache_alloc()
1874 * No need for another dst_hold()
1875 */
1876 rt6_uncached_list_add(uncached_rt);
1877 atomic_inc(&net->ipv6.rt6_stats->fib_rt_uncache);
1878 } else {
1879 uncached_rt = net->ipv6.ip6_null_entry;
1880 dst_hold(&uncached_rt->dst);
1881 }
1882
1883 return uncached_rt;
1884 } else {
1885 /* Get a percpu copy */
1886
1887 struct rt6_info *pcpu_rt;
1888
1889 local_bh_disable();
1890 pcpu_rt = rt6_get_pcpu_route(f6i);
1891
1892 if (!pcpu_rt)
1893 pcpu_rt = rt6_make_pcpu_route(net, f6i);
1894
1895 local_bh_enable();
1896 rcu_read_unlock();
1897
1898 return pcpu_rt;
1899 }
1900 }
1901 EXPORT_SYMBOL_GPL(ip6_pol_route);
1902
1903 static struct rt6_info *ip6_pol_route_input(struct net *net,
1904 struct fib6_table *table,
1905 struct flowi6 *fl6,
1906 const struct sk_buff *skb,
1907 int flags)
1908 {
1909 return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, skb, flags);
1910 }
1911
1912 struct dst_entry *ip6_route_input_lookup(struct net *net,
1913 struct net_device *dev,
1914 struct flowi6 *fl6,
1915 const struct sk_buff *skb,
1916 int flags)
1917 {
1918 if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
1919 flags |= RT6_LOOKUP_F_IFACE;
1920
1921 return fib6_rule_lookup(net, fl6, skb, flags, ip6_pol_route_input);
1922 }
1923 EXPORT_SYMBOL_GPL(ip6_route_input_lookup);
1924
1925 static void ip6_multipath_l3_keys(const struct sk_buff *skb,
1926 struct flow_keys *keys,
1927 struct flow_keys *flkeys)
1928 {
1929 const struct ipv6hdr *outer_iph = ipv6_hdr(skb);
1930 const struct ipv6hdr *key_iph = outer_iph;
1931 struct flow_keys *_flkeys = flkeys;
1932 const struct ipv6hdr *inner_iph;
1933 const struct icmp6hdr *icmph;
1934 struct ipv6hdr _inner_iph;
1935 struct icmp6hdr _icmph;
1936
1937 if (likely(outer_iph->nexthdr != IPPROTO_ICMPV6))
1938 goto out;
1939
1940 icmph = skb_header_pointer(skb, skb_transport_offset(skb),
1941 sizeof(_icmph), &_icmph);
1942 if (!icmph)
1943 goto out;
1944
1945 if (icmph->icmp6_type != ICMPV6_DEST_UNREACH &&
1946 icmph->icmp6_type != ICMPV6_PKT_TOOBIG &&
1947 icmph->icmp6_type != ICMPV6_TIME_EXCEED &&
1948 icmph->icmp6_type != ICMPV6_PARAMPROB)
1949 goto out;
1950
1951 inner_iph = skb_header_pointer(skb,
1952 skb_transport_offset(skb) + sizeof(*icmph),
1953 sizeof(_inner_iph), &_inner_iph);
1954 if (!inner_iph)
1955 goto out;
1956
1957 key_iph = inner_iph;
1958 _flkeys = NULL;
1959 out:
1960 if (_flkeys) {
1961 keys->addrs.v6addrs.src = _flkeys->addrs.v6addrs.src;
1962 keys->addrs.v6addrs.dst = _flkeys->addrs.v6addrs.dst;
1963 keys->tags.flow_label = _flkeys->tags.flow_label;
1964 keys->basic.ip_proto = _flkeys->basic.ip_proto;
1965 } else {
1966 keys->addrs.v6addrs.src = key_iph->saddr;
1967 keys->addrs.v6addrs.dst = key_iph->daddr;
1968 keys->tags.flow_label = ip6_flowlabel(key_iph);
1969 keys->basic.ip_proto = key_iph->nexthdr;
1970 }
1971 }
1972
1973 /* if skb is set it will be used and fl6 can be NULL */
1974 u32 rt6_multipath_hash(const struct net *net, const struct flowi6 *fl6,
1975 const struct sk_buff *skb, struct flow_keys *flkeys)
1976 {
1977 struct flow_keys hash_keys;
1978 u32 mhash;
1979
1980 switch (ip6_multipath_hash_policy(net)) {
1981 case 0:
1982 memset(&hash_keys, 0, sizeof(hash_keys));
1983 hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS;
1984 if (skb) {
1985 ip6_multipath_l3_keys(skb, &hash_keys, flkeys);
1986 } else {
1987 hash_keys.addrs.v6addrs.src = fl6->saddr;
1988 hash_keys.addrs.v6addrs.dst = fl6->daddr;
1989 hash_keys.tags.flow_label = (__force u32)flowi6_get_flowlabel(fl6);
1990 hash_keys.basic.ip_proto = fl6->flowi6_proto;
1991 }
1992 break;
1993 case 1:
1994 if (skb) {
1995 unsigned int flag = FLOW_DISSECTOR_F_STOP_AT_ENCAP;
1996 struct flow_keys keys;
1997
1998 /* short-circuit if we already have L4 hash present */
1999 if (skb->l4_hash)
2000 return skb_get_hash_raw(skb) >> 1;
2001
2002 memset(&hash_keys, 0, sizeof(hash_keys));
2003
2004 if (!flkeys) {
2005 skb_flow_dissect_flow_keys(skb, &keys, flag);
2006 flkeys = &keys;
2007 }
2008 hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS;
2009 hash_keys.addrs.v6addrs.src = flkeys->addrs.v6addrs.src;
2010 hash_keys.addrs.v6addrs.dst = flkeys->addrs.v6addrs.dst;
2011 hash_keys.ports.src = flkeys->ports.src;
2012 hash_keys.ports.dst = flkeys->ports.dst;
2013 hash_keys.basic.ip_proto = flkeys->basic.ip_proto;
2014 } else {
2015 memset(&hash_keys, 0, sizeof(hash_keys));
2016 hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS;
2017 hash_keys.addrs.v6addrs.src = fl6->saddr;
2018 hash_keys.addrs.v6addrs.dst = fl6->daddr;
2019 hash_keys.ports.src = fl6->fl6_sport;
2020 hash_keys.ports.dst = fl6->fl6_dport;
2021 hash_keys.basic.ip_proto = fl6->flowi6_proto;
2022 }
2023 break;
2024 }
2025 mhash = flow_hash_from_keys(&hash_keys);
2026
2027 return mhash >> 1;
2028 }
2029
2030 void ip6_route_input(struct sk_buff *skb)
2031 {
2032 const struct ipv6hdr *iph = ipv6_hdr(skb);
2033 struct net *net = dev_net(skb->dev);
2034 int flags = RT6_LOOKUP_F_HAS_SADDR;
2035 struct ip_tunnel_info *tun_info;
2036 struct flowi6 fl6 = {
2037 .flowi6_iif = skb->dev->ifindex,
2038 .daddr = iph->daddr,
2039 .saddr = iph->saddr,
2040 .flowlabel = ip6_flowinfo(iph),
2041 .flowi6_mark = skb->mark,
2042 .flowi6_proto = iph->nexthdr,
2043 };
2044 struct flow_keys *flkeys = NULL, _flkeys;
2045
2046 tun_info = skb_tunnel_info(skb);
2047 if (tun_info && !(tun_info->mode & IP_TUNNEL_INFO_TX))
2048 fl6.flowi6_tun_key.tun_id = tun_info->key.tun_id;
2049
2050 if (fib6_rules_early_flow_dissect(net, skb, &fl6, &_flkeys))
2051 flkeys = &_flkeys;
2052
2053 if (unlikely(fl6.flowi6_proto == IPPROTO_ICMPV6))
2054 fl6.mp_hash = rt6_multipath_hash(net, &fl6, skb, flkeys);
2055 skb_dst_drop(skb);
2056 skb_dst_set(skb,
2057 ip6_route_input_lookup(net, skb->dev, &fl6, skb, flags));
2058 }
2059
2060 static struct rt6_info *ip6_pol_route_output(struct net *net,
2061 struct fib6_table *table,
2062 struct flowi6 *fl6,
2063 const struct sk_buff *skb,
2064 int flags)
2065 {
2066 return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, skb, flags);
2067 }
2068
2069 struct dst_entry *ip6_route_output_flags(struct net *net, const struct sock *sk,
2070 struct flowi6 *fl6, int flags)
2071 {
2072 bool any_src;
2073
2074 if (ipv6_addr_type(&fl6->daddr) &
2075 (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL)) {
2076 struct dst_entry *dst;
2077
2078 dst = l3mdev_link_scope_lookup(net, fl6);
2079 if (dst)
2080 return dst;
2081 }
2082
2083 fl6->flowi6_iif = LOOPBACK_IFINDEX;
2084
2085 any_src = ipv6_addr_any(&fl6->saddr);
2086 if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr) ||
2087 (fl6->flowi6_oif && any_src))
2088 flags |= RT6_LOOKUP_F_IFACE;
2089
2090 if (!any_src)
2091 flags |= RT6_LOOKUP_F_HAS_SADDR;
2092 else if (sk)
2093 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
2094
2095 return fib6_rule_lookup(net, fl6, NULL, flags, ip6_pol_route_output);
2096 }
2097 EXPORT_SYMBOL_GPL(ip6_route_output_flags);
2098
2099 struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)
2100 {
2101 struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;
2102 struct net_device *loopback_dev = net->loopback_dev;
2103 struct dst_entry *new = NULL;
2104
2105 rt = dst_alloc(&ip6_dst_blackhole_ops, loopback_dev, 1,
2106 DST_OBSOLETE_DEAD, 0);
2107 if (rt) {
2108 rt6_info_init(rt);
2109 atomic_inc(&net->ipv6.rt6_stats->fib_rt_alloc);
2110
2111 new = &rt->dst;
2112 new->__use = 1;
2113 new->input = dst_discard;
2114 new->output = dst_discard_out;
2115
2116 dst_copy_metrics(new, &ort->dst);
2117
2118 rt->rt6i_idev = in6_dev_get(loopback_dev);
2119 rt->rt6i_gateway = ort->rt6i_gateway;
2120 rt->rt6i_flags = ort->rt6i_flags & ~RTF_PCPU;
2121
2122 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
2123 #ifdef CONFIG_IPV6_SUBTREES
2124 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
2125 #endif
2126 }
2127
2128 dst_release(dst_orig);
2129 return new ? new : ERR_PTR(-ENOMEM);
2130 }
2131
2132 /*
2133 * Destination cache support functions
2134 */
2135
2136 static bool fib6_check(struct fib6_info *f6i, u32 cookie)
2137 {
2138 u32 rt_cookie = 0;
2139
2140 if (!fib6_get_cookie_safe(f6i, &rt_cookie) || rt_cookie != cookie)
2141 return false;
2142
2143 if (fib6_check_expired(f6i))
2144 return false;
2145
2146 return true;
2147 }
2148
2149 static struct dst_entry *rt6_check(struct rt6_info *rt,
2150 struct fib6_info *from,
2151 u32 cookie)
2152 {
2153 u32 rt_cookie = 0;
2154
2155 if ((from && !fib6_get_cookie_safe(from, &rt_cookie)) ||
2156 rt_cookie != cookie)
2157 return NULL;
2158
2159 if (rt6_check_expired(rt))
2160 return NULL;
2161
2162 return &rt->dst;
2163 }
2164
2165 static struct dst_entry *rt6_dst_from_check(struct rt6_info *rt,
2166 struct fib6_info *from,
2167 u32 cookie)
2168 {
2169 if (!__rt6_check_expired(rt) &&
2170 rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
2171 fib6_check(from, cookie))
2172 return &rt->dst;
2173 else
2174 return NULL;
2175 }
2176
2177 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
2178 {
2179 struct dst_entry *dst_ret;
2180 struct fib6_info *from;
2181 struct rt6_info *rt;
2182
2183 rt = container_of(dst, struct rt6_info, dst);
2184
2185 rcu_read_lock();
2186
2187 /* All IPV6 dsts are created with ->obsolete set to the value
2188 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
2189 * into this function always.
2190 */
2191
2192 from = rcu_dereference(rt->from);
2193
2194 if (from && (rt->rt6i_flags & RTF_PCPU ||
2195 unlikely(!list_empty(&rt->rt6i_uncached))))
2196 dst_ret = rt6_dst_from_check(rt, from, cookie);
2197 else
2198 dst_ret = rt6_check(rt, from, cookie);
2199
2200 rcu_read_unlock();
2201
2202 return dst_ret;
2203 }
2204
2205 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
2206 {
2207 struct rt6_info *rt = (struct rt6_info *) dst;
2208
2209 if (rt) {
2210 if (rt->rt6i_flags & RTF_CACHE) {
2211 rcu_read_lock();
2212 if (rt6_check_expired(rt)) {
2213 rt6_remove_exception_rt(rt);
2214 dst = NULL;
2215 }
2216 rcu_read_unlock();
2217 } else {
2218 dst_release(dst);
2219 dst = NULL;
2220 }
2221 }
2222 return dst;
2223 }
2224
2225 static void ip6_link_failure(struct sk_buff *skb)
2226 {
2227 struct rt6_info *rt;
2228
2229 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
2230
2231 rt = (struct rt6_info *) skb_dst(skb);
2232 if (rt) {
2233 rcu_read_lock();
2234 if (rt->rt6i_flags & RTF_CACHE) {
2235 if (dst_hold_safe(&rt->dst))
2236 rt6_remove_exception_rt(rt);
2237 } else {
2238 struct fib6_info *from;
2239 struct fib6_node *fn;
2240
2241 from = rcu_dereference(rt->from);
2242 if (from) {
2243 fn = rcu_dereference(from->fib6_node);
2244 if (fn && (rt->rt6i_flags & RTF_DEFAULT))
2245 fn->fn_sernum = -1;
2246 }
2247 }
2248 rcu_read_unlock();
2249 }
2250 }
2251
2252 static void rt6_update_expires(struct rt6_info *rt0, int timeout)
2253 {
2254 if (!(rt0->rt6i_flags & RTF_EXPIRES)) {
2255 struct fib6_info *from;
2256
2257 rcu_read_lock();
2258 from = rcu_dereference(rt0->from);
2259 if (from)
2260 rt0->dst.expires = from->expires;
2261 rcu_read_unlock();
2262 }
2263
2264 dst_set_expires(&rt0->dst, timeout);
2265 rt0->rt6i_flags |= RTF_EXPIRES;
2266 }
2267
2268 static void rt6_do_update_pmtu(struct rt6_info *rt, u32 mtu)
2269 {
2270 struct net *net = dev_net(rt->dst.dev);
2271
2272 dst_metric_set(&rt->dst, RTAX_MTU, mtu);
2273 rt->rt6i_flags |= RTF_MODIFIED;
2274 rt6_update_expires(rt, net->ipv6.sysctl.ip6_rt_mtu_expires);
2275 }
2276
2277 static bool rt6_cache_allowed_for_pmtu(const struct rt6_info *rt)
2278 {
2279 bool from_set;
2280
2281 rcu_read_lock();
2282 from_set = !!rcu_dereference(rt->from);
2283 rcu_read_unlock();
2284
2285 return !(rt->rt6i_flags & RTF_CACHE) &&
2286 (rt->rt6i_flags & RTF_PCPU || from_set);
2287 }
2288
2289 static void __ip6_rt_update_pmtu(struct dst_entry *dst, const struct sock *sk,
2290 const struct ipv6hdr *iph, u32 mtu)
2291 {
2292 const struct in6_addr *daddr, *saddr;
2293 struct rt6_info *rt6 = (struct rt6_info *)dst;
2294
2295 if (dst_metric_locked(dst, RTAX_MTU))
2296 return;
2297
2298 if (iph) {
2299 daddr = &iph->daddr;
2300 saddr = &iph->saddr;
2301 } else if (sk) {
2302 daddr = &sk->sk_v6_daddr;
2303 saddr = &inet6_sk(sk)->saddr;
2304 } else {
2305 daddr = NULL;
2306 saddr = NULL;
2307 }
2308 dst_confirm_neigh(dst, daddr);
2309 mtu = max_t(u32, mtu, IPV6_MIN_MTU);
2310 if (mtu >= dst_mtu(dst))
2311 return;
2312
2313 if (!rt6_cache_allowed_for_pmtu(rt6)) {
2314 rt6_do_update_pmtu(rt6, mtu);
2315 /* update rt6_ex->stamp for cache */
2316 if (rt6->rt6i_flags & RTF_CACHE)
2317 rt6_update_exception_stamp_rt(rt6);
2318 } else if (daddr) {
2319 struct fib6_info *from;
2320 struct rt6_info *nrt6;
2321
2322 rcu_read_lock();
2323 from = rcu_dereference(rt6->from);
2324 nrt6 = ip6_rt_cache_alloc(from, daddr, saddr);
2325 if (nrt6) {
2326 rt6_do_update_pmtu(nrt6, mtu);
2327 if (rt6_insert_exception(nrt6, from))
2328 dst_release_immediate(&nrt6->dst);
2329 }
2330 rcu_read_unlock();
2331 }
2332 }
2333
2334 static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
2335 struct sk_buff *skb, u32 mtu)
2336 {
2337 __ip6_rt_update_pmtu(dst, sk, skb ? ipv6_hdr(skb) : NULL, mtu);
2338 }
2339
2340 void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
2341 int oif, u32 mark, kuid_t uid)
2342 {
2343 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
2344 struct dst_entry *dst;
2345 struct flowi6 fl6 = {
2346 .flowi6_oif = oif,
2347 .flowi6_mark = mark ? mark : IP6_REPLY_MARK(net, skb->mark),
2348 .daddr = iph->daddr,
2349 .saddr = iph->saddr,
2350 .flowlabel = ip6_flowinfo(iph),
2351 .flowi6_uid = uid,
2352 };
2353
2354 dst = ip6_route_output(net, NULL, &fl6);
2355 if (!dst->error)
2356 __ip6_rt_update_pmtu(dst, NULL, iph, ntohl(mtu));
2357 dst_release(dst);
2358 }
2359 EXPORT_SYMBOL_GPL(ip6_update_pmtu);
2360
2361 void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
2362 {
2363 struct dst_entry *dst;
2364
2365 ip6_update_pmtu(skb, sock_net(sk), mtu,
2366 sk->sk_bound_dev_if, sk->sk_mark, sk->sk_uid);
2367
2368 dst = __sk_dst_get(sk);
2369 if (!dst || !dst->obsolete ||
2370 dst->ops->check(dst, inet6_sk(sk)->dst_cookie))
2371 return;
2372
2373 bh_lock_sock(sk);
2374 if (!sock_owned_by_user(sk) && !ipv6_addr_v4mapped(&sk->sk_v6_daddr))
2375 ip6_datagram_dst_update(sk, false);
2376 bh_unlock_sock(sk);
2377 }
2378 EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
2379
2380 void ip6_sk_dst_store_flow(struct sock *sk, struct dst_entry *dst,
2381 const struct flowi6 *fl6)
2382 {
2383 #ifdef CONFIG_IPV6_SUBTREES
2384 struct ipv6_pinfo *np = inet6_sk(sk);
2385 #endif
2386
2387 ip6_dst_store(sk, dst,
2388 ipv6_addr_equal(&fl6->daddr, &sk->sk_v6_daddr) ?
2389 &sk->sk_v6_daddr : NULL,
2390 #ifdef CONFIG_IPV6_SUBTREES
2391 ipv6_addr_equal(&fl6->saddr, &np->saddr) ?
2392 &np->saddr :
2393 #endif
2394 NULL);
2395 }
2396
2397 /* Handle redirects */
2398 struct ip6rd_flowi {
2399 struct flowi6 fl6;
2400 struct in6_addr gateway;
2401 };
2402
2403 static struct rt6_info *__ip6_route_redirect(struct net *net,
2404 struct fib6_table *table,
2405 struct flowi6 *fl6,
2406 const struct sk_buff *skb,
2407 int flags)
2408 {
2409 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl6;
2410 struct rt6_info *ret = NULL, *rt_cache;
2411 struct fib6_info *rt;
2412 struct fib6_node *fn;
2413
2414 /* Get the "current" route for this destination and
2415 * check if the redirect has come from appropriate router.
2416 *
2417 * RFC 4861 specifies that redirects should only be
2418 * accepted if they come from the nexthop to the target.
2419 * Due to the way the routes are chosen, this notion
2420 * is a bit fuzzy and one might need to check all possible
2421 * routes.
2422 */
2423
2424 rcu_read_lock();
2425 fn = fib6_node_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
2426 restart:
2427 for_each_fib6_node_rt_rcu(fn) {
2428 if (rt->fib6_nh.nh_flags & RTNH_F_DEAD)
2429 continue;
2430 if (fib6_check_expired(rt))
2431 continue;
2432 if (rt->fib6_flags & RTF_REJECT)
2433 break;
2434 if (!(rt->fib6_flags & RTF_GATEWAY))
2435 continue;
2436 if (fl6->flowi6_oif != rt->fib6_nh.nh_dev->ifindex)
2437 continue;
2438 /* rt_cache's gateway might be different from its 'parent'
2439 * in the case of an ip redirect.
2440 * So we keep searching in the exception table if the gateway
2441 * is different.
2442 */
2443 if (!ipv6_addr_equal(&rdfl->gateway, &rt->fib6_nh.nh_gw)) {
2444 rt_cache = rt6_find_cached_rt(rt,
2445 &fl6->daddr,
2446 &fl6->saddr);
2447 if (rt_cache &&
2448 ipv6_addr_equal(&rdfl->gateway,
2449 &rt_cache->rt6i_gateway)) {
2450 ret = rt_cache;
2451 break;
2452 }
2453 continue;
2454 }
2455 break;
2456 }
2457
2458 if (!rt)
2459 rt = net->ipv6.fib6_null_entry;
2460 else if (rt->fib6_flags & RTF_REJECT) {
2461 ret = net->ipv6.ip6_null_entry;
2462 goto out;
2463 }
2464
2465 if (rt == net->ipv6.fib6_null_entry) {
2466 fn = fib6_backtrack(fn, &fl6->saddr);
2467 if (fn)
2468 goto restart;
2469 }
2470
2471 out:
2472 if (ret)
2473 ip6_hold_safe(net, &ret, true);
2474 else
2475 ret = ip6_create_rt_rcu(rt);
2476
2477 rcu_read_unlock();
2478
2479 trace_fib6_table_lookup(net, rt, table, fl6);
2480 return ret;
2481 };
2482
2483 static struct dst_entry *ip6_route_redirect(struct net *net,
2484 const struct flowi6 *fl6,
2485 const struct sk_buff *skb,
2486 const struct in6_addr *gateway)
2487 {
2488 int flags = RT6_LOOKUP_F_HAS_SADDR;
2489 struct ip6rd_flowi rdfl;
2490
2491 rdfl.fl6 = *fl6;
2492 rdfl.gateway = *gateway;
2493
2494 return fib6_rule_lookup(net, &rdfl.fl6, skb,
2495 flags, __ip6_route_redirect);
2496 }
2497
2498 void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark,
2499 kuid_t uid)
2500 {
2501 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
2502 struct dst_entry *dst;
2503 struct flowi6 fl6 = {
2504 .flowi6_iif = LOOPBACK_IFINDEX,
2505 .flowi6_oif = oif,
2506 .flowi6_mark = mark,
2507 .daddr = iph->daddr,
2508 .saddr = iph->saddr,
2509 .flowlabel = ip6_flowinfo(iph),
2510 .flowi6_uid = uid,
2511 };
2512
2513 dst = ip6_route_redirect(net, &fl6, skb, &ipv6_hdr(skb)->saddr);
2514 rt6_do_redirect(dst, NULL, skb);
2515 dst_release(dst);
2516 }
2517 EXPORT_SYMBOL_GPL(ip6_redirect);
2518
2519 void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif)
2520 {
2521 const struct ipv6hdr *iph = ipv6_hdr(skb);
2522 const struct rd_msg *msg = (struct rd_msg *)icmp6_hdr(skb);
2523 struct dst_entry *dst;
2524 struct flowi6 fl6 = {
2525 .flowi6_iif = LOOPBACK_IFINDEX,
2526 .flowi6_oif = oif,
2527 .daddr = msg->dest,
2528 .saddr = iph->daddr,
2529 .flowi6_uid = sock_net_uid(net, NULL),
2530 };
2531
2532 dst = ip6_route_redirect(net, &fl6, skb, &iph->saddr);
2533 rt6_do_redirect(dst, NULL, skb);
2534 dst_release(dst);
2535 }
2536
2537 void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
2538 {
2539 ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark,
2540 sk->sk_uid);
2541 }
2542 EXPORT_SYMBOL_GPL(ip6_sk_redirect);
2543
2544 static unsigned int ip6_default_advmss(const struct dst_entry *dst)
2545 {
2546 struct net_device *dev = dst->dev;
2547 unsigned int mtu = dst_mtu(dst);
2548 struct net *net = dev_net(dev);
2549
2550 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
2551
2552 if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
2553 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
2554
2555 /*
2556 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
2557 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
2558 * IPV6_MAXPLEN is also valid and means: "any MSS,
2559 * rely only on pmtu discovery"
2560 */
2561 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
2562 mtu = IPV6_MAXPLEN;
2563 return mtu;
2564 }
2565
2566 static unsigned int ip6_mtu(const struct dst_entry *dst)
2567 {
2568 struct inet6_dev *idev;
2569 unsigned int mtu;
2570
2571 mtu = dst_metric_raw(dst, RTAX_MTU);
2572 if (mtu)
2573 goto out;
2574
2575 mtu = IPV6_MIN_MTU;
2576
2577 rcu_read_lock();
2578 idev = __in6_dev_get(dst->dev);
2579 if (idev)
2580 mtu = idev->cnf.mtu6;
2581 rcu_read_unlock();
2582
2583 out:
2584 mtu = min_t(unsigned int, mtu, IP6_MAX_MTU);
2585
2586 return mtu - lwtunnel_headroom(dst->lwtstate, mtu);
2587 }
2588
2589 /* MTU selection:
2590 * 1. mtu on route is locked - use it
2591 * 2. mtu from nexthop exception
2592 * 3. mtu from egress device
2593 *
2594 * based on ip6_dst_mtu_forward and exception logic of
2595 * rt6_find_cached_rt; called with rcu_read_lock
2596 */
2597 u32 ip6_mtu_from_fib6(struct fib6_info *f6i, struct in6_addr *daddr,
2598 struct in6_addr *saddr)
2599 {
2600 struct rt6_exception_bucket *bucket;
2601 struct rt6_exception *rt6_ex;
2602 struct in6_addr *src_key;
2603 struct inet6_dev *idev;
2604 u32 mtu = 0;
2605
2606 if (unlikely(fib6_metric_locked(f6i, RTAX_MTU))) {
2607 mtu = f6i->fib6_pmtu;
2608 if (mtu)
2609 goto out;
2610 }
2611
2612 src_key = NULL;
2613 #ifdef CONFIG_IPV6_SUBTREES
2614 if (f6i->fib6_src.plen)
2615 src_key = saddr;
2616 #endif
2617
2618 bucket = rcu_dereference(f6i->rt6i_exception_bucket);
2619 rt6_ex = __rt6_find_exception_rcu(&bucket, daddr, src_key);
2620 if (rt6_ex && !rt6_check_expired(rt6_ex->rt6i))
2621 mtu = dst_metric_raw(&rt6_ex->rt6i->dst, RTAX_MTU);
2622
2623 if (likely(!mtu)) {
2624 struct net_device *dev = fib6_info_nh_dev(f6i);
2625
2626 mtu = IPV6_MIN_MTU;
2627 idev = __in6_dev_get(dev);
2628 if (idev && idev->cnf.mtu6 > mtu)
2629 mtu = idev->cnf.mtu6;
2630 }
2631
2632 mtu = min_t(unsigned int, mtu, IP6_MAX_MTU);
2633 out:
2634 return mtu - lwtunnel_headroom(fib6_info_nh_lwt(f6i), mtu);
2635 }
2636
2637 struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
2638 struct flowi6 *fl6)
2639 {
2640 struct dst_entry *dst;
2641 struct rt6_info *rt;
2642 struct inet6_dev *idev = in6_dev_get(dev);
2643 struct net *net = dev_net(dev);
2644
2645 if (unlikely(!idev))
2646 return ERR_PTR(-ENODEV);
2647
2648 rt = ip6_dst_alloc(net, dev, 0);
2649 if (unlikely(!rt)) {
2650 in6_dev_put(idev);
2651 dst = ERR_PTR(-ENOMEM);
2652 goto out;
2653 }
2654
2655 rt->dst.flags |= DST_HOST;
2656 rt->dst.input = ip6_input;
2657 rt->dst.output = ip6_output;
2658 rt->rt6i_gateway = fl6->daddr;
2659 rt->rt6i_dst.addr = fl6->daddr;
2660 rt->rt6i_dst.plen = 128;
2661 rt->rt6i_idev = idev;
2662 dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
2663
2664 /* Add this dst into uncached_list so that rt6_disable_ip() can
2665 * do proper release of the net_device
2666 */
2667 rt6_uncached_list_add(rt);
2668 atomic_inc(&net->ipv6.rt6_stats->fib_rt_uncache);
2669
2670 dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
2671
2672 out:
2673 return dst;
2674 }
2675
2676 static int ip6_dst_gc(struct dst_ops *ops)
2677 {
2678 struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
2679 int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
2680 int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
2681 int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
2682 int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
2683 unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
2684 int entries;
2685
2686 entries = dst_entries_get_fast(ops);
2687 if (time_after(rt_last_gc + rt_min_interval, jiffies) &&
2688 entries <= rt_max_size)
2689 goto out;
2690
2691 net->ipv6.ip6_rt_gc_expire++;
2692 fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, true);
2693 entries = dst_entries_get_slow(ops);
2694 if (entries < ops->gc_thresh)
2695 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
2696 out:
2697 net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
2698 return entries > rt_max_size;
2699 }
2700
2701 static struct rt6_info *ip6_nh_lookup_table(struct net *net,
2702 struct fib6_config *cfg,
2703 const struct in6_addr *gw_addr,
2704 u32 tbid, int flags)
2705 {
2706 struct flowi6 fl6 = {
2707 .flowi6_oif = cfg->fc_ifindex,
2708 .daddr = *gw_addr,
2709 .saddr = cfg->fc_prefsrc,
2710 };
2711 struct fib6_table *table;
2712 struct rt6_info *rt;
2713
2714 table = fib6_get_table(net, tbid);
2715 if (!table)
2716 return NULL;
2717
2718 if (!ipv6_addr_any(&cfg->fc_prefsrc))
2719 flags |= RT6_LOOKUP_F_HAS_SADDR;
2720
2721 flags |= RT6_LOOKUP_F_IGNORE_LINKSTATE;
2722 rt = ip6_pol_route(net, table, cfg->fc_ifindex, &fl6, NULL, flags);
2723
2724 /* if table lookup failed, fall back to full lookup */
2725 if (rt == net->ipv6.ip6_null_entry) {
2726 ip6_rt_put(rt);
2727 rt = NULL;
2728 }
2729
2730 return rt;
2731 }
2732
2733 static int ip6_route_check_nh_onlink(struct net *net,
2734 struct fib6_config *cfg,
2735 const struct net_device *dev,
2736 struct netlink_ext_ack *extack)
2737 {
2738 u32 tbid = l3mdev_fib_table(dev) ? : RT_TABLE_MAIN;
2739 const struct in6_addr *gw_addr = &cfg->fc_gateway;
2740 u32 flags = RTF_LOCAL | RTF_ANYCAST | RTF_REJECT;
2741 struct rt6_info *grt;
2742 int err;
2743
2744 err = 0;
2745 grt = ip6_nh_lookup_table(net, cfg, gw_addr, tbid, 0);
2746 if (grt) {
2747 if (!grt->dst.error &&
2748 /* ignore match if it is the default route */
2749 grt->from && !ipv6_addr_any(&grt->from->fib6_dst.addr) &&
2750 (grt->rt6i_flags & flags || dev != grt->dst.dev)) {
2751 NL_SET_ERR_MSG(extack,
2752 "Nexthop has invalid gateway or device mismatch");
2753 err = -EINVAL;
2754 }
2755
2756 ip6_rt_put(grt);
2757 }
2758
2759 return err;
2760 }
2761
2762 static int ip6_route_check_nh(struct net *net,
2763 struct fib6_config *cfg,
2764 struct net_device **_dev,
2765 struct inet6_dev **idev)
2766 {
2767 const struct in6_addr *gw_addr = &cfg->fc_gateway;
2768 struct net_device *dev = _dev ? *_dev : NULL;
2769 struct rt6_info *grt = NULL;
2770 int err = -EHOSTUNREACH;
2771
2772 if (cfg->fc_table) {
2773 int flags = RT6_LOOKUP_F_IFACE;
2774
2775 grt = ip6_nh_lookup_table(net, cfg, gw_addr,
2776 cfg->fc_table, flags);
2777 if (grt) {
2778 if (grt->rt6i_flags & RTF_GATEWAY ||
2779 (dev && dev != grt->dst.dev)) {
2780 ip6_rt_put(grt);
2781 grt = NULL;
2782 }
2783 }
2784 }
2785
2786 if (!grt)
2787 grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, NULL, 1);
2788
2789 if (!grt)
2790 goto out;
2791
2792 if (dev) {
2793 if (dev != grt->dst.dev) {
2794 ip6_rt_put(grt);
2795 goto out;
2796 }
2797 } else {
2798 *_dev = dev = grt->dst.dev;
2799 *idev = grt->rt6i_idev;
2800 dev_hold(dev);
2801 in6_dev_hold(grt->rt6i_idev);
2802 }
2803
2804 if (!(grt->rt6i_flags & RTF_GATEWAY))
2805 err = 0;
2806
2807 ip6_rt_put(grt);
2808
2809 out:
2810 return err;
2811 }
2812
2813 static int ip6_validate_gw(struct net *net, struct fib6_config *cfg,
2814 struct net_device **_dev, struct inet6_dev **idev,
2815 struct netlink_ext_ack *extack)
2816 {
2817 const struct in6_addr *gw_addr = &cfg->fc_gateway;
2818 int gwa_type = ipv6_addr_type(gw_addr);
2819 bool skip_dev = gwa_type & IPV6_ADDR_LINKLOCAL ? false : true;
2820 const struct net_device *dev = *_dev;
2821 bool need_addr_check = !dev;
2822 int err = -EINVAL;
2823
2824 /* if gw_addr is local we will fail to detect this in case
2825 * address is still TENTATIVE (DAD in progress). rt6_lookup()
2826 * will return already-added prefix route via interface that
2827 * prefix route was assigned to, which might be non-loopback.
2828 */
2829 if (dev &&
2830 ipv6_chk_addr_and_flags(net, gw_addr, dev, skip_dev, 0, 0)) {
2831 NL_SET_ERR_MSG(extack, "Gateway can not be a local address");
2832 goto out;
2833 }
2834
2835 if (gwa_type != (IPV6_ADDR_LINKLOCAL | IPV6_ADDR_UNICAST)) {
2836 /* IPv6 strictly inhibits using not link-local
2837 * addresses as nexthop address.
2838 * Otherwise, router will not able to send redirects.
2839 * It is very good, but in some (rare!) circumstances
2840 * (SIT, PtP, NBMA NOARP links) it is handy to allow
2841 * some exceptions. --ANK
2842 * We allow IPv4-mapped nexthops to support RFC4798-type
2843 * addressing
2844 */
2845 if (!(gwa_type & (IPV6_ADDR_UNICAST | IPV6_ADDR_MAPPED))) {
2846 NL_SET_ERR_MSG(extack, "Invalid gateway address");
2847 goto out;
2848 }
2849
2850 if (cfg->fc_flags & RTNH_F_ONLINK)
2851 err = ip6_route_check_nh_onlink(net, cfg, dev, extack);
2852 else
2853 err = ip6_route_check_nh(net, cfg, _dev, idev);
2854
2855 if (err)
2856 goto out;
2857 }
2858
2859 /* reload in case device was changed */
2860 dev = *_dev;
2861
2862 err = -EINVAL;
2863 if (!dev) {
2864 NL_SET_ERR_MSG(extack, "Egress device not specified");
2865 goto out;
2866 } else if (dev->flags & IFF_LOOPBACK) {
2867 NL_SET_ERR_MSG(extack,
2868 "Egress device can not be loopback device for this route");
2869 goto out;
2870 }
2871
2872 /* if we did not check gw_addr above, do so now that the
2873 * egress device has been resolved.
2874 */
2875 if (need_addr_check &&
2876 ipv6_chk_addr_and_flags(net, gw_addr, dev, skip_dev, 0, 0)) {
2877 NL_SET_ERR_MSG(extack, "Gateway can not be a local address");
2878 goto out;
2879 }
2880
2881 err = 0;
2882 out:
2883 return err;
2884 }
2885
2886 static struct fib6_info *ip6_route_info_create(struct fib6_config *cfg,
2887 gfp_t gfp_flags,
2888 struct netlink_ext_ack *extack)
2889 {
2890 struct net *net = cfg->fc_nlinfo.nl_net;
2891 struct fib6_info *rt = NULL;
2892 struct net_device *dev = NULL;
2893 struct inet6_dev *idev = NULL;
2894 struct fib6_table *table;
2895 int addr_type;
2896 int err = -EINVAL;
2897
2898 /* RTF_PCPU is an internal flag; can not be set by userspace */
2899 if (cfg->fc_flags & RTF_PCPU) {
2900 NL_SET_ERR_MSG(extack, "Userspace can not set RTF_PCPU");
2901 goto out;
2902 }
2903
2904 /* RTF_CACHE is an internal flag; can not be set by userspace */
2905 if (cfg->fc_flags & RTF_CACHE) {
2906 NL_SET_ERR_MSG(extack, "Userspace can not set RTF_CACHE");
2907 goto out;
2908 }
2909
2910 if (cfg->fc_type > RTN_MAX) {
2911 NL_SET_ERR_MSG(extack, "Invalid route type");
2912 goto out;
2913 }
2914
2915 if (cfg->fc_dst_len > 128) {
2916 NL_SET_ERR_MSG(extack, "Invalid prefix length");
2917 goto out;
2918 }
2919 if (cfg->fc_src_len > 128) {
2920 NL_SET_ERR_MSG(extack, "Invalid source address length");
2921 goto out;
2922 }
2923 #ifndef CONFIG_IPV6_SUBTREES
2924 if (cfg->fc_src_len) {
2925 NL_SET_ERR_MSG(extack,
2926 "Specifying source address requires IPV6_SUBTREES to be enabled");
2927 goto out;
2928 }
2929 #endif
2930 if (cfg->fc_ifindex) {
2931 err = -ENODEV;
2932 dev = dev_get_by_index(net, cfg->fc_ifindex);
2933 if (!dev)
2934 goto out;
2935 idev = in6_dev_get(dev);
2936 if (!idev)
2937 goto out;
2938 }
2939
2940 if (cfg->fc_metric == 0)
2941 cfg->fc_metric = IP6_RT_PRIO_USER;
2942
2943 if (cfg->fc_flags & RTNH_F_ONLINK) {
2944 if (!dev) {
2945 NL_SET_ERR_MSG(extack,
2946 "Nexthop device required for onlink");
2947 err = -ENODEV;
2948 goto out;
2949 }
2950
2951 if (!(dev->flags & IFF_UP)) {
2952 NL_SET_ERR_MSG(extack, "Nexthop device is not up");
2953 err = -ENETDOWN;
2954 goto out;
2955 }
2956 }
2957
2958 err = -ENOBUFS;
2959 if (cfg->fc_nlinfo.nlh &&
2960 !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
2961 table = fib6_get_table(net, cfg->fc_table);
2962 if (!table) {
2963 pr_warn("NLM_F_CREATE should be specified when creating new route\n");
2964 table = fib6_new_table(net, cfg->fc_table);
2965 }
2966 } else {
2967 table = fib6_new_table(net, cfg->fc_table);
2968 }
2969
2970 if (!table)
2971 goto out;
2972
2973 err = -ENOMEM;
2974 rt = fib6_info_alloc(gfp_flags);
2975 if (!rt)
2976 goto out;
2977
2978 rt->fib6_metrics = ip_fib_metrics_init(net, cfg->fc_mx, cfg->fc_mx_len);
2979 if (IS_ERR(rt->fib6_metrics)) {
2980 err = PTR_ERR(rt->fib6_metrics);
2981 /* Do not leave garbage there. */
2982 rt->fib6_metrics = (struct dst_metrics *)&dst_default_metrics;
2983 goto out;
2984 }
2985
2986 if (cfg->fc_flags & RTF_ADDRCONF)
2987 rt->dst_nocount = true;
2988
2989 if (cfg->fc_flags & RTF_EXPIRES)
2990 fib6_set_expires(rt, jiffies +
2991 clock_t_to_jiffies(cfg->fc_expires));
2992 else
2993 fib6_clean_expires(rt);
2994
2995 if (cfg->fc_protocol == RTPROT_UNSPEC)
2996 cfg->fc_protocol = RTPROT_BOOT;
2997 rt->fib6_protocol = cfg->fc_protocol;
2998
2999 addr_type = ipv6_addr_type(&cfg->fc_dst);
3000
3001 if (cfg->fc_encap) {
3002 struct lwtunnel_state *lwtstate;
3003
3004 err = lwtunnel_build_state(cfg->fc_encap_type,
3005 cfg->fc_encap, AF_INET6, cfg,
3006 &lwtstate, extack);
3007 if (err)
3008 goto out;
3009 rt->fib6_nh.nh_lwtstate = lwtstate_get(lwtstate);
3010 }
3011
3012 ipv6_addr_prefix(&rt->fib6_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
3013 rt->fib6_dst.plen = cfg->fc_dst_len;
3014 if (rt->fib6_dst.plen == 128)
3015 rt->dst_host = true;
3016
3017 #ifdef CONFIG_IPV6_SUBTREES
3018 ipv6_addr_prefix(&rt->fib6_src.addr, &cfg->fc_src, cfg->fc_src_len);
3019 rt->fib6_src.plen = cfg->fc_src_len;
3020 #endif
3021
3022 rt->fib6_metric = cfg->fc_metric;
3023 rt->fib6_nh.nh_weight = 1;
3024
3025 rt->fib6_type = cfg->fc_type;
3026
3027 /* We cannot add true routes via loopback here,
3028 they would result in kernel looping; promote them to reject routes
3029 */
3030 if ((cfg->fc_flags & RTF_REJECT) ||
3031 (dev && (dev->flags & IFF_LOOPBACK) &&
3032 !(addr_type & IPV6_ADDR_LOOPBACK) &&
3033 !(cfg->fc_flags & RTF_LOCAL))) {
3034 /* hold loopback dev/idev if we haven't done so. */
3035 if (dev != net->loopback_dev) {
3036 if (dev) {
3037 dev_put(dev);
3038 in6_dev_put(idev);
3039 }
3040 dev = net->loopback_dev;
3041 dev_hold(dev);
3042 idev = in6_dev_get(dev);
3043 if (!idev) {
3044 err = -ENODEV;
3045 goto out;
3046 }
3047 }
3048 rt->fib6_flags = RTF_REJECT|RTF_NONEXTHOP;
3049 goto install_route;
3050 }
3051
3052 if (cfg->fc_flags & RTF_GATEWAY) {
3053 err = ip6_validate_gw(net, cfg, &dev, &idev, extack);
3054 if (err)
3055 goto out;
3056
3057 rt->fib6_nh.nh_gw = cfg->fc_gateway;
3058 }
3059
3060 err = -ENODEV;
3061 if (!dev)
3062 goto out;
3063
3064 if (idev->cnf.disable_ipv6) {
3065 NL_SET_ERR_MSG(extack, "IPv6 is disabled on nexthop device");
3066 err = -EACCES;
3067 goto out;
3068 }
3069
3070 if (!(dev->flags & IFF_UP)) {
3071 NL_SET_ERR_MSG(extack, "Nexthop device is not up");
3072 err = -ENETDOWN;
3073 goto out;
3074 }
3075
3076 if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
3077 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
3078 NL_SET_ERR_MSG(extack, "Invalid source address");
3079 err = -EINVAL;
3080 goto out;
3081 }
3082 rt->fib6_prefsrc.addr = cfg->fc_prefsrc;
3083 rt->fib6_prefsrc.plen = 128;
3084 } else
3085 rt->fib6_prefsrc.plen = 0;
3086
3087 rt->fib6_flags = cfg->fc_flags;
3088
3089 install_route:
3090 if (!(rt->fib6_flags & (RTF_LOCAL | RTF_ANYCAST)) &&
3091 !netif_carrier_ok(dev))
3092 rt->fib6_nh.nh_flags |= RTNH_F_LINKDOWN;
3093 rt->fib6_nh.nh_flags |= (cfg->fc_flags & RTNH_F_ONLINK);
3094 rt->fib6_nh.nh_dev = dev;
3095 rt->fib6_table = table;
3096
3097 if (idev)
3098 in6_dev_put(idev);
3099
3100 return rt;
3101 out:
3102 if (dev)
3103 dev_put(dev);
3104 if (idev)
3105 in6_dev_put(idev);
3106
3107 fib6_info_release(rt);
3108 return ERR_PTR(err);
3109 }
3110
3111 int ip6_route_add(struct fib6_config *cfg, gfp_t gfp_flags,
3112 struct netlink_ext_ack *extack)
3113 {
3114 struct fib6_info *rt;
3115 int err;
3116
3117 rt = ip6_route_info_create(cfg, gfp_flags, extack);
3118 if (IS_ERR(rt))
3119 return PTR_ERR(rt);
3120
3121 err = __ip6_ins_rt(rt, &cfg->fc_nlinfo, extack);
3122 fib6_info_release(rt);
3123
3124 return err;
3125 }
3126
3127 static int __ip6_del_rt(struct fib6_info *rt, struct nl_info *info)
3128 {
3129 struct net *net = info->nl_net;
3130 struct fib6_table *table;
3131 int err;
3132
3133 if (rt == net->ipv6.fib6_null_entry) {
3134 err = -ENOENT;
3135 goto out;
3136 }
3137
3138 table = rt->fib6_table;
3139 spin_lock_bh(&table->tb6_lock);
3140 err = fib6_del(rt, info);
3141 spin_unlock_bh(&table->tb6_lock);
3142
3143 out:
3144 fib6_info_release(rt);
3145 return err;
3146 }
3147
3148 int ip6_del_rt(struct net *net, struct fib6_info *rt)
3149 {
3150 struct nl_info info = { .nl_net = net };
3151
3152 return __ip6_del_rt(rt, &info);
3153 }
3154
3155 static int __ip6_del_rt_siblings(struct fib6_info *rt, struct fib6_config *cfg)
3156 {
3157 struct nl_info *info = &cfg->fc_nlinfo;
3158 struct net *net = info->nl_net;
3159 struct sk_buff *skb = NULL;
3160 struct fib6_table *table;
3161 int err = -ENOENT;
3162
3163 if (rt == net->ipv6.fib6_null_entry)
3164 goto out_put;
3165 table = rt->fib6_table;
3166 spin_lock_bh(&table->tb6_lock);
3167
3168 if (rt->fib6_nsiblings && cfg->fc_delete_all_nh) {
3169 struct fib6_info *sibling, *next_sibling;
3170
3171 /* prefer to send a single notification with all hops */
3172 skb = nlmsg_new(rt6_nlmsg_size(rt), gfp_any());
3173 if (skb) {
3174 u32 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
3175
3176 if (rt6_fill_node(net, skb, rt, NULL,
3177 NULL, NULL, 0, RTM_DELROUTE,
3178 info->portid, seq, 0) < 0) {
3179 kfree_skb(skb);
3180 skb = NULL;
3181 } else
3182 info->skip_notify = 1;
3183 }
3184
3185 list_for_each_entry_safe(sibling, next_sibling,
3186 &rt->fib6_siblings,
3187 fib6_siblings) {
3188 err = fib6_del(sibling, info);
3189 if (err)
3190 goto out_unlock;
3191 }
3192 }
3193
3194 err = fib6_del(rt, info);
3195 out_unlock:
3196 spin_unlock_bh(&table->tb6_lock);
3197 out_put:
3198 fib6_info_release(rt);
3199
3200 if (skb) {
3201 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
3202 info->nlh, gfp_any());
3203 }
3204 return err;
3205 }
3206
3207 static int ip6_del_cached_rt(struct rt6_info *rt, struct fib6_config *cfg)
3208 {
3209 int rc = -ESRCH;
3210
3211 if (cfg->fc_ifindex && rt->dst.dev->ifindex != cfg->fc_ifindex)
3212 goto out;
3213
3214 if (cfg->fc_flags & RTF_GATEWAY &&
3215 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
3216 goto out;
3217 if (dst_hold_safe(&rt->dst))
3218 rc = rt6_remove_exception_rt(rt);
3219 out:
3220 return rc;
3221 }
3222
3223 static int ip6_route_del(struct fib6_config *cfg,
3224 struct netlink_ext_ack *extack)
3225 {
3226 struct rt6_info *rt_cache;
3227 struct fib6_table *table;
3228 struct fib6_info *rt;
3229 struct fib6_node *fn;
3230 int err = -ESRCH;
3231
3232 table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
3233 if (!table) {
3234 NL_SET_ERR_MSG(extack, "FIB table does not exist");
3235 return err;
3236 }
3237
3238 rcu_read_lock();
3239
3240 fn = fib6_locate(&table->tb6_root,
3241 &cfg->fc_dst, cfg->fc_dst_len,
3242 &cfg->fc_src, cfg->fc_src_len,
3243 !(cfg->fc_flags & RTF_CACHE));
3244
3245 if (fn) {
3246 for_each_fib6_node_rt_rcu(fn) {
3247 if (cfg->fc_flags & RTF_CACHE) {
3248 int rc;
3249
3250 rt_cache = rt6_find_cached_rt(rt, &cfg->fc_dst,
3251 &cfg->fc_src);
3252 if (rt_cache) {
3253 rc = ip6_del_cached_rt(rt_cache, cfg);
3254 if (rc != -ESRCH) {
3255 rcu_read_unlock();
3256 return rc;
3257 }
3258 }
3259 continue;
3260 }
3261 if (cfg->fc_ifindex &&
3262 (!rt->fib6_nh.nh_dev ||
3263 rt->fib6_nh.nh_dev->ifindex != cfg->fc_ifindex))
3264 continue;
3265 if (cfg->fc_flags & RTF_GATEWAY &&
3266 !ipv6_addr_equal(&cfg->fc_gateway, &rt->fib6_nh.nh_gw))
3267 continue;
3268 if (cfg->fc_metric && cfg->fc_metric != rt->fib6_metric)
3269 continue;
3270 if (cfg->fc_protocol && cfg->fc_protocol != rt->fib6_protocol)
3271 continue;
3272 if (!fib6_info_hold_safe(rt))
3273 continue;
3274 rcu_read_unlock();
3275
3276 /* if gateway was specified only delete the one hop */
3277 if (cfg->fc_flags & RTF_GATEWAY)
3278 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
3279
3280 return __ip6_del_rt_siblings(rt, cfg);
3281 }
3282 }
3283 rcu_read_unlock();
3284
3285 return err;
3286 }
3287
3288 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
3289 {
3290 struct netevent_redirect netevent;
3291 struct rt6_info *rt, *nrt = NULL;
3292 struct ndisc_options ndopts;
3293 struct inet6_dev *in6_dev;
3294 struct neighbour *neigh;
3295 struct fib6_info *from;
3296 struct rd_msg *msg;
3297 int optlen, on_link;
3298 u8 *lladdr;
3299
3300 optlen = skb_tail_pointer(skb) - skb_transport_header(skb);
3301 optlen -= sizeof(*msg);
3302
3303 if (optlen < 0) {
3304 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
3305 return;
3306 }
3307
3308 msg = (struct rd_msg *)icmp6_hdr(skb);
3309
3310 if (ipv6_addr_is_multicast(&msg->dest)) {
3311 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
3312 return;
3313 }
3314
3315 on_link = 0;
3316 if (ipv6_addr_equal(&msg->dest, &msg->target)) {
3317 on_link = 1;
3318 } else if (ipv6_addr_type(&msg->target) !=
3319 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
3320 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
3321 return;
3322 }
3323
3324 in6_dev = __in6_dev_get(skb->dev);
3325 if (!in6_dev)
3326 return;
3327 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
3328 return;
3329
3330 /* RFC2461 8.1:
3331 * The IP source address of the Redirect MUST be the same as the current
3332 * first-hop router for the specified ICMP Destination Address.
3333 */
3334
3335 if (!ndisc_parse_options(skb->dev, msg->opt, optlen, &ndopts)) {
3336 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
3337 return;
3338 }
3339
3340 lladdr = NULL;
3341 if (ndopts.nd_opts_tgt_lladdr) {
3342 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
3343 skb->dev);
3344 if (!lladdr) {
3345 net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
3346 return;
3347 }
3348 }
3349
3350 rt = (struct rt6_info *) dst;
3351 if (rt->rt6i_flags & RTF_REJECT) {
3352 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
3353 return;
3354 }
3355
3356 /* Redirect received -> path was valid.
3357 * Look, redirects are sent only in response to data packets,
3358 * so that this nexthop apparently is reachable. --ANK
3359 */
3360 dst_confirm_neigh(&rt->dst, &ipv6_hdr(skb)->saddr);
3361
3362 neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
3363 if (!neigh)
3364 return;
3365
3366 /*
3367 * We have finally decided to accept it.
3368 */
3369
3370 ndisc_update(skb->dev, neigh, lladdr, NUD_STALE,
3371 NEIGH_UPDATE_F_WEAK_OVERRIDE|
3372 NEIGH_UPDATE_F_OVERRIDE|
3373 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
3374 NEIGH_UPDATE_F_ISROUTER)),
3375 NDISC_REDIRECT, &ndopts);
3376
3377 rcu_read_lock();
3378 from = rcu_dereference(rt->from);
3379 /* This fib6_info_hold() is safe here because we hold reference to rt
3380 * and rt already holds reference to fib6_info.
3381 */
3382 fib6_info_hold(from);
3383 rcu_read_unlock();
3384
3385 nrt = ip6_rt_cache_alloc(from, &msg->dest, NULL);
3386 if (!nrt)
3387 goto out;
3388
3389 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
3390 if (on_link)
3391 nrt->rt6i_flags &= ~RTF_GATEWAY;
3392
3393 nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
3394
3395 /* No need to remove rt from the exception table if rt is
3396 * a cached route because rt6_insert_exception() will
3397 * takes care of it
3398 */
3399 if (rt6_insert_exception(nrt, from)) {
3400 dst_release_immediate(&nrt->dst);
3401 goto out;
3402 }
3403
3404 netevent.old = &rt->dst;
3405 netevent.new = &nrt->dst;
3406 netevent.daddr = &msg->dest;
3407 netevent.neigh = neigh;
3408 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
3409
3410 out:
3411 fib6_info_release(from);
3412 neigh_release(neigh);
3413 }
3414
3415 #ifdef CONFIG_IPV6_ROUTE_INFO
3416 static struct fib6_info *rt6_get_route_info(struct net *net,
3417 const struct in6_addr *prefix, int prefixlen,
3418 const struct in6_addr *gwaddr,
3419 struct net_device *dev)
3420 {
3421 u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_INFO;
3422 int ifindex = dev->ifindex;
3423 struct fib6_node *fn;
3424 struct fib6_info *rt = NULL;
3425 struct fib6_table *table;
3426
3427 table = fib6_get_table(net, tb_id);
3428 if (!table)
3429 return NULL;
3430
3431 rcu_read_lock();
3432 fn = fib6_locate(&table->tb6_root, prefix, prefixlen, NULL, 0, true);
3433 if (!fn)
3434 goto out;
3435
3436 for_each_fib6_node_rt_rcu(fn) {
3437 if (rt->fib6_nh.nh_dev->ifindex != ifindex)
3438 continue;
3439 if ((rt->fib6_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
3440 continue;
3441 if (!ipv6_addr_equal(&rt->fib6_nh.nh_gw, gwaddr))
3442 continue;
3443 if (!fib6_info_hold_safe(rt))
3444 continue;
3445 break;
3446 }
3447 out:
3448 rcu_read_unlock();
3449 return rt;
3450 }
3451
3452 static struct fib6_info *rt6_add_route_info(struct net *net,
3453 const struct in6_addr *prefix, int prefixlen,
3454 const struct in6_addr *gwaddr,
3455 struct net_device *dev,
3456 unsigned int pref)
3457 {
3458 struct fib6_config cfg = {
3459 .fc_metric = IP6_RT_PRIO_USER,
3460 .fc_ifindex = dev->ifindex,
3461 .fc_dst_len = prefixlen,
3462 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
3463 RTF_UP | RTF_PREF(pref),
3464 .fc_protocol = RTPROT_RA,
3465 .fc_type = RTN_UNICAST,
3466 .fc_nlinfo.portid = 0,
3467 .fc_nlinfo.nlh = NULL,
3468 .fc_nlinfo.nl_net = net,
3469 };
3470
3471 cfg.fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_INFO,
3472 cfg.fc_dst = *prefix;
3473 cfg.fc_gateway = *gwaddr;
3474
3475 /* We should treat it as a default route if prefix length is 0. */
3476 if (!prefixlen)
3477 cfg.fc_flags |= RTF_DEFAULT;
3478
3479 ip6_route_add(&cfg, GFP_ATOMIC, NULL);
3480
3481 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, dev);
3482 }
3483 #endif
3484
3485 struct fib6_info *rt6_get_dflt_router(struct net *net,
3486 const struct in6_addr *addr,
3487 struct net_device *dev)
3488 {
3489 u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_DFLT;
3490 struct fib6_info *rt;
3491 struct fib6_table *table;
3492
3493 table = fib6_get_table(net, tb_id);
3494 if (!table)
3495 return NULL;
3496
3497 rcu_read_lock();
3498 for_each_fib6_node_rt_rcu(&table->tb6_root) {
3499 if (dev == rt->fib6_nh.nh_dev &&
3500 ((rt->fib6_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
3501 ipv6_addr_equal(&rt->fib6_nh.nh_gw, addr))
3502 break;
3503 }
3504 if (rt && !fib6_info_hold_safe(rt))
3505 rt = NULL;
3506 rcu_read_unlock();
3507 return rt;
3508 }
3509
3510 struct fib6_info *rt6_add_dflt_router(struct net *net,
3511 const struct in6_addr *gwaddr,
3512 struct net_device *dev,
3513 unsigned int pref)
3514 {
3515 struct fib6_config cfg = {
3516 .fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_DFLT,
3517 .fc_metric = IP6_RT_PRIO_USER,
3518 .fc_ifindex = dev->ifindex,
3519 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
3520 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
3521 .fc_protocol = RTPROT_RA,
3522 .fc_type = RTN_UNICAST,
3523 .fc_nlinfo.portid = 0,
3524 .fc_nlinfo.nlh = NULL,
3525 .fc_nlinfo.nl_net = net,
3526 };
3527
3528 cfg.fc_gateway = *gwaddr;
3529
3530 if (!ip6_route_add(&cfg, GFP_ATOMIC, NULL)) {
3531 struct fib6_table *table;
3532
3533 table = fib6_get_table(dev_net(dev), cfg.fc_table);
3534 if (table)
3535 table->flags |= RT6_TABLE_HAS_DFLT_ROUTER;
3536 }
3537
3538 return rt6_get_dflt_router(net, gwaddr, dev);
3539 }
3540
3541 static void __rt6_purge_dflt_routers(struct net *net,
3542 struct fib6_table *table)
3543 {
3544 struct fib6_info *rt;
3545
3546 restart:
3547 rcu_read_lock();
3548 for_each_fib6_node_rt_rcu(&table->tb6_root) {
3549 struct net_device *dev = fib6_info_nh_dev(rt);
3550 struct inet6_dev *idev = dev ? __in6_dev_get(dev) : NULL;
3551
3552 if (rt->fib6_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
3553 (!idev || idev->cnf.accept_ra != 2) &&
3554 fib6_info_hold_safe(rt)) {
3555 rcu_read_unlock();
3556 ip6_del_rt(net, rt);
3557 goto restart;
3558 }
3559 }
3560 rcu_read_unlock();
3561
3562 table->flags &= ~RT6_TABLE_HAS_DFLT_ROUTER;
3563 }
3564
3565 void rt6_purge_dflt_routers(struct net *net)
3566 {
3567 struct fib6_table *table;
3568 struct hlist_head *head;
3569 unsigned int h;
3570
3571 rcu_read_lock();
3572
3573 for (h = 0; h < FIB6_TABLE_HASHSZ; h++) {
3574 head = &net->ipv6.fib_table_hash[h];
3575 hlist_for_each_entry_rcu(table, head, tb6_hlist) {
3576 if (table->flags & RT6_TABLE_HAS_DFLT_ROUTER)
3577 __rt6_purge_dflt_routers(net, table);
3578 }
3579 }
3580
3581 rcu_read_unlock();
3582 }
3583
3584 static void rtmsg_to_fib6_config(struct net *net,
3585 struct in6_rtmsg *rtmsg,
3586 struct fib6_config *cfg)
3587 {
3588 *cfg = (struct fib6_config){
3589 .fc_table = l3mdev_fib_table_by_index(net, rtmsg->rtmsg_ifindex) ?
3590 : RT6_TABLE_MAIN,
3591 .fc_ifindex = rtmsg->rtmsg_ifindex,
3592 .fc_metric = rtmsg->rtmsg_metric,
3593 .fc_expires = rtmsg->rtmsg_info,
3594 .fc_dst_len = rtmsg->rtmsg_dst_len,
3595 .fc_src_len = rtmsg->rtmsg_src_len,
3596 .fc_flags = rtmsg->rtmsg_flags,
3597 .fc_type = rtmsg->rtmsg_type,
3598
3599 .fc_nlinfo.nl_net = net,
3600
3601 .fc_dst = rtmsg->rtmsg_dst,
3602 .fc_src = rtmsg->rtmsg_src,
3603 .fc_gateway = rtmsg->rtmsg_gateway,
3604 };
3605 }
3606
3607 int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
3608 {
3609 struct fib6_config cfg;
3610 struct in6_rtmsg rtmsg;
3611 int err;
3612
3613 switch (cmd) {
3614 case SIOCADDRT: /* Add a route */
3615 case SIOCDELRT: /* Delete a route */
3616 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
3617 return -EPERM;
3618 err = copy_from_user(&rtmsg, arg,
3619 sizeof(struct in6_rtmsg));
3620 if (err)
3621 return -EFAULT;
3622
3623 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
3624
3625 rtnl_lock();
3626 switch (cmd) {
3627 case SIOCADDRT:
3628 err = ip6_route_add(&cfg, GFP_KERNEL, NULL);
3629 break;
3630 case SIOCDELRT:
3631 err = ip6_route_del(&cfg, NULL);
3632 break;
3633 default:
3634 err = -EINVAL;
3635 }
3636 rtnl_unlock();
3637
3638 return err;
3639 }
3640
3641 return -EINVAL;
3642 }
3643
3644 /*
3645 * Drop the packet on the floor
3646 */
3647
3648 static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
3649 {
3650 int type;
3651 struct dst_entry *dst = skb_dst(skb);
3652 switch (ipstats_mib_noroutes) {
3653 case IPSTATS_MIB_INNOROUTES:
3654 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
3655 if (type == IPV6_ADDR_ANY) {
3656 IP6_INC_STATS(dev_net(dst->dev),
3657 __in6_dev_get_safely(skb->dev),
3658 IPSTATS_MIB_INADDRERRORS);
3659 break;
3660 }
3661 /* FALLTHROUGH */
3662 case IPSTATS_MIB_OUTNOROUTES:
3663 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
3664 ipstats_mib_noroutes);
3665 break;
3666 }
3667 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
3668 kfree_skb(skb);
3669 return 0;
3670 }
3671
3672 static int ip6_pkt_discard(struct sk_buff *skb)
3673 {
3674 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
3675 }
3676
3677 static int ip6_pkt_discard_out(struct net *net, struct sock *sk, struct sk_buff *skb)
3678 {
3679 skb->dev = skb_dst(skb)->dev;
3680 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
3681 }
3682
3683 static int ip6_pkt_prohibit(struct sk_buff *skb)
3684 {
3685 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
3686 }
3687
3688 static int ip6_pkt_prohibit_out(struct net *net, struct sock *sk, struct sk_buff *skb)
3689 {
3690 skb->dev = skb_dst(skb)->dev;
3691 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
3692 }
3693
3694 /*
3695 * Allocate a dst for local (unicast / anycast) address.
3696 */
3697
3698 struct fib6_info *addrconf_f6i_alloc(struct net *net,
3699 struct inet6_dev *idev,
3700 const struct in6_addr *addr,
3701 bool anycast, gfp_t gfp_flags)
3702 {
3703 u32 tb_id;
3704 struct net_device *dev = idev->dev;
3705 struct fib6_info *f6i;
3706
3707 f6i = fib6_info_alloc(gfp_flags);
3708 if (!f6i)
3709 return ERR_PTR(-ENOMEM);
3710
3711 f6i->fib6_metrics = ip_fib_metrics_init(net, NULL, 0);
3712 f6i->dst_nocount = true;
3713 f6i->dst_host = true;
3714 f6i->fib6_protocol = RTPROT_KERNEL;
3715 f6i->fib6_flags = RTF_UP | RTF_NONEXTHOP;
3716 if (anycast) {
3717 f6i->fib6_type = RTN_ANYCAST;
3718 f6i->fib6_flags |= RTF_ANYCAST;
3719 } else {
3720 f6i->fib6_type = RTN_LOCAL;
3721 f6i->fib6_flags |= RTF_LOCAL;
3722 }
3723
3724 f6i->fib6_nh.nh_gw = *addr;
3725 dev_hold(dev);
3726 f6i->fib6_nh.nh_dev = dev;
3727 f6i->fib6_dst.addr = *addr;
3728 f6i->fib6_dst.plen = 128;
3729 tb_id = l3mdev_fib_table(idev->dev) ? : RT6_TABLE_LOCAL;
3730 f6i->fib6_table = fib6_get_table(net, tb_id);
3731
3732 return f6i;
3733 }
3734
3735 /* remove deleted ip from prefsrc entries */
3736 struct arg_dev_net_ip {
3737 struct net_device *dev;
3738 struct net *net;
3739 struct in6_addr *addr;
3740 };
3741
3742 static int fib6_remove_prefsrc(struct fib6_info *rt, void *arg)
3743 {
3744 struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
3745 struct net *net = ((struct arg_dev_net_ip *)arg)->net;
3746 struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
3747
3748 if (((void *)rt->fib6_nh.nh_dev == dev || !dev) &&
3749 rt != net->ipv6.fib6_null_entry &&
3750 ipv6_addr_equal(addr, &rt->fib6_prefsrc.addr)) {
3751 spin_lock_bh(&rt6_exception_lock);
3752 /* remove prefsrc entry */
3753 rt->fib6_prefsrc.plen = 0;
3754 spin_unlock_bh(&rt6_exception_lock);
3755 }
3756 return 0;
3757 }
3758
3759 void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
3760 {
3761 struct net *net = dev_net(ifp->idev->dev);
3762 struct arg_dev_net_ip adni = {
3763 .dev = ifp->idev->dev,
3764 .net = net,
3765 .addr = &ifp->addr,
3766 };
3767 fib6_clean_all(net, fib6_remove_prefsrc, &adni);
3768 }
3769
3770 #define RTF_RA_ROUTER (RTF_ADDRCONF | RTF_DEFAULT | RTF_GATEWAY)
3771
3772 /* Remove routers and update dst entries when gateway turn into host. */
3773 static int fib6_clean_tohost(struct fib6_info *rt, void *arg)
3774 {
3775 struct in6_addr *gateway = (struct in6_addr *)arg;
3776
3777 if (((rt->fib6_flags & RTF_RA_ROUTER) == RTF_RA_ROUTER) &&
3778 ipv6_addr_equal(gateway, &rt->fib6_nh.nh_gw)) {
3779 return -1;
3780 }
3781
3782 /* Further clean up cached routes in exception table.
3783 * This is needed because cached route may have a different
3784 * gateway than its 'parent' in the case of an ip redirect.
3785 */
3786 rt6_exceptions_clean_tohost(rt, gateway);
3787
3788 return 0;
3789 }
3790
3791 void rt6_clean_tohost(struct net *net, struct in6_addr *gateway)
3792 {
3793 fib6_clean_all(net, fib6_clean_tohost, gateway);
3794 }
3795
3796 struct arg_netdev_event {
3797 const struct net_device *dev;
3798 union {
3799 unsigned int nh_flags;
3800 unsigned long event;
3801 };
3802 };
3803
3804 static struct fib6_info *rt6_multipath_first_sibling(const struct fib6_info *rt)
3805 {
3806 struct fib6_info *iter;
3807 struct fib6_node *fn;
3808
3809 fn = rcu_dereference_protected(rt->fib6_node,
3810 lockdep_is_held(&rt->fib6_table->tb6_lock));
3811 iter = rcu_dereference_protected(fn->leaf,
3812 lockdep_is_held(&rt->fib6_table->tb6_lock));
3813 while (iter) {
3814 if (iter->fib6_metric == rt->fib6_metric &&
3815 rt6_qualify_for_ecmp(iter))
3816 return iter;
3817 iter = rcu_dereference_protected(iter->fib6_next,
3818 lockdep_is_held(&rt->fib6_table->tb6_lock));
3819 }
3820
3821 return NULL;
3822 }
3823
3824 static bool rt6_is_dead(const struct fib6_info *rt)
3825 {
3826 if (rt->fib6_nh.nh_flags & RTNH_F_DEAD ||
3827 (rt->fib6_nh.nh_flags & RTNH_F_LINKDOWN &&
3828 fib6_ignore_linkdown(rt)))
3829 return true;
3830
3831 return false;
3832 }
3833
3834 static int rt6_multipath_total_weight(const struct fib6_info *rt)
3835 {
3836 struct fib6_info *iter;
3837 int total = 0;
3838
3839 if (!rt6_is_dead(rt))
3840 total += rt->fib6_nh.nh_weight;
3841
3842 list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings) {
3843 if (!rt6_is_dead(iter))
3844 total += iter->fib6_nh.nh_weight;
3845 }
3846
3847 return total;
3848 }
3849
3850 static void rt6_upper_bound_set(struct fib6_info *rt, int *weight, int total)
3851 {
3852 int upper_bound = -1;
3853
3854 if (!rt6_is_dead(rt)) {
3855 *weight += rt->fib6_nh.nh_weight;
3856 upper_bound = DIV_ROUND_CLOSEST_ULL((u64) (*weight) << 31,
3857 total) - 1;
3858 }
3859 atomic_set(&rt->fib6_nh.nh_upper_bound, upper_bound);
3860 }
3861
3862 static void rt6_multipath_upper_bound_set(struct fib6_info *rt, int total)
3863 {
3864 struct fib6_info *iter;
3865 int weight = 0;
3866
3867 rt6_upper_bound_set(rt, &weight, total);
3868
3869 list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings)
3870 rt6_upper_bound_set(iter, &weight, total);
3871 }
3872
3873 void rt6_multipath_rebalance(struct fib6_info *rt)
3874 {
3875 struct fib6_info *first;
3876 int total;
3877
3878 /* In case the entire multipath route was marked for flushing,
3879 * then there is no need to rebalance upon the removal of every
3880 * sibling route.
3881 */
3882 if (!rt->fib6_nsiblings || rt->should_flush)
3883 return;
3884
3885 /* During lookup routes are evaluated in order, so we need to
3886 * make sure upper bounds are assigned from the first sibling
3887 * onwards.
3888 */
3889 first = rt6_multipath_first_sibling(rt);
3890 if (WARN_ON_ONCE(!first))
3891 return;
3892
3893 total = rt6_multipath_total_weight(first);
3894 rt6_multipath_upper_bound_set(first, total);
3895 }
3896
3897 static int fib6_ifup(struct fib6_info *rt, void *p_arg)
3898 {
3899 const struct arg_netdev_event *arg = p_arg;
3900 struct net *net = dev_net(arg->dev);
3901
3902 if (rt != net->ipv6.fib6_null_entry && rt->fib6_nh.nh_dev == arg->dev) {
3903 rt->fib6_nh.nh_flags &= ~arg->nh_flags;
3904 fib6_update_sernum_upto_root(net, rt);
3905 rt6_multipath_rebalance(rt);
3906 }
3907
3908 return 0;
3909 }
3910
3911 void rt6_sync_up(struct net_device *dev, unsigned int nh_flags)
3912 {
3913 struct arg_netdev_event arg = {
3914 .dev = dev,
3915 {
3916 .nh_flags = nh_flags,
3917 },
3918 };
3919
3920 if (nh_flags & RTNH_F_DEAD && netif_carrier_ok(dev))
3921 arg.nh_flags |= RTNH_F_LINKDOWN;
3922
3923 fib6_clean_all(dev_net(dev), fib6_ifup, &arg);
3924 }
3925
3926 static bool rt6_multipath_uses_dev(const struct fib6_info *rt,
3927 const struct net_device *dev)
3928 {
3929 struct fib6_info *iter;
3930
3931 if (rt->fib6_nh.nh_dev == dev)
3932 return true;
3933 list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings)
3934 if (iter->fib6_nh.nh_dev == dev)
3935 return true;
3936
3937 return false;
3938 }
3939
3940 static void rt6_multipath_flush(struct fib6_info *rt)
3941 {
3942 struct fib6_info *iter;
3943
3944 rt->should_flush = 1;
3945 list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings)
3946 iter->should_flush = 1;
3947 }
3948
3949 static unsigned int rt6_multipath_dead_count(const struct fib6_info *rt,
3950 const struct net_device *down_dev)
3951 {
3952 struct fib6_info *iter;
3953 unsigned int dead = 0;
3954
3955 if (rt->fib6_nh.nh_dev == down_dev ||
3956 rt->fib6_nh.nh_flags & RTNH_F_DEAD)
3957 dead++;
3958 list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings)
3959 if (iter->fib6_nh.nh_dev == down_dev ||
3960 iter->fib6_nh.nh_flags & RTNH_F_DEAD)
3961 dead++;
3962
3963 return dead;
3964 }
3965
3966 static void rt6_multipath_nh_flags_set(struct fib6_info *rt,
3967 const struct net_device *dev,
3968 unsigned int nh_flags)
3969 {
3970 struct fib6_info *iter;
3971
3972 if (rt->fib6_nh.nh_dev == dev)
3973 rt->fib6_nh.nh_flags |= nh_flags;
3974 list_for_each_entry(iter, &rt->fib6_siblings, fib6_siblings)
3975 if (iter->fib6_nh.nh_dev == dev)
3976 iter->fib6_nh.nh_flags |= nh_flags;
3977 }
3978
3979 /* called with write lock held for table with rt */
3980 static int fib6_ifdown(struct fib6_info *rt, void *p_arg)
3981 {
3982 const struct arg_netdev_event *arg = p_arg;
3983 const struct net_device *dev = arg->dev;
3984 struct net *net = dev_net(dev);
3985
3986 if (rt == net->ipv6.fib6_null_entry)
3987 return 0;
3988
3989 switch (arg->event) {
3990 case NETDEV_UNREGISTER:
3991 return rt->fib6_nh.nh_dev == dev ? -1 : 0;
3992 case NETDEV_DOWN:
3993 if (rt->should_flush)
3994 return -1;
3995 if (!rt->fib6_nsiblings)
3996 return rt->fib6_nh.nh_dev == dev ? -1 : 0;
3997 if (rt6_multipath_uses_dev(rt, dev)) {
3998 unsigned int count;
3999
4000 count = rt6_multipath_dead_count(rt, dev);
4001 if (rt->fib6_nsiblings + 1 == count) {
4002 rt6_multipath_flush(rt);
4003 return -1;
4004 }
4005 rt6_multipath_nh_flags_set(rt, dev, RTNH_F_DEAD |
4006 RTNH_F_LINKDOWN);
4007 fib6_update_sernum(net, rt);
4008 rt6_multipath_rebalance(rt);
4009 }
4010 return -2;
4011 case NETDEV_CHANGE:
4012 if (rt->fib6_nh.nh_dev != dev ||
4013 rt->fib6_flags & (RTF_LOCAL | RTF_ANYCAST))
4014 break;
4015 rt->fib6_nh.nh_flags |= RTNH_F_LINKDOWN;
4016 rt6_multipath_rebalance(rt);
4017 break;
4018 }
4019
4020 return 0;
4021 }
4022
4023 void rt6_sync_down_dev(struct net_device *dev, unsigned long event)
4024 {
4025 struct arg_netdev_event arg = {
4026 .dev = dev,
4027 {
4028 .event = event,
4029 },
4030 };
4031 struct net *net = dev_net(dev);
4032
4033 if (net->ipv6.sysctl.skip_notify_on_dev_down)
4034 fib6_clean_all_skip_notify(net, fib6_ifdown, &arg);
4035 else
4036 fib6_clean_all(net, fib6_ifdown, &arg);
4037 }
4038
4039 void rt6_disable_ip(struct net_device *dev, unsigned long event)
4040 {
4041 rt6_sync_down_dev(dev, event);
4042 rt6_uncached_list_flush_dev(dev_net(dev), dev);
4043 neigh_ifdown(&nd_tbl, dev);
4044 }
4045
4046 struct rt6_mtu_change_arg {
4047 struct net_device *dev;
4048 unsigned int mtu;
4049 };
4050
4051 static int rt6_mtu_change_route(struct fib6_info *rt, void *p_arg)
4052 {
4053 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
4054 struct inet6_dev *idev;
4055
4056 /* In IPv6 pmtu discovery is not optional,
4057 so that RTAX_MTU lock cannot disable it.
4058 We still use this lock to block changes
4059 caused by addrconf/ndisc.
4060 */
4061
4062 idev = __in6_dev_get(arg->dev);
4063 if (!idev)
4064 return 0;
4065
4066 /* For administrative MTU increase, there is no way to discover
4067 IPv6 PMTU increase, so PMTU increase should be updated here.
4068 Since RFC 1981 doesn't include administrative MTU increase
4069 update PMTU increase is a MUST. (i.e. jumbo frame)
4070 */
4071 if (rt->fib6_nh.nh_dev == arg->dev &&
4072 !fib6_metric_locked(rt, RTAX_MTU)) {
4073 u32 mtu = rt->fib6_pmtu;
4074
4075 if (mtu >= arg->mtu ||
4076 (mtu < arg->mtu && mtu == idev->cnf.mtu6))
4077 fib6_metric_set(rt, RTAX_MTU, arg->mtu);
4078
4079 spin_lock_bh(&rt6_exception_lock);
4080 rt6_exceptions_update_pmtu(idev, rt, arg->mtu);
4081 spin_unlock_bh(&rt6_exception_lock);
4082 }
4083 return 0;
4084 }
4085
4086 void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
4087 {
4088 struct rt6_mtu_change_arg arg = {
4089 .dev = dev,
4090 .mtu = mtu,
4091 };
4092
4093 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);
4094 }
4095
4096 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
4097 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
4098 [RTA_PREFSRC] = { .len = sizeof(struct in6_addr) },
4099 [RTA_OIF] = { .type = NLA_U32 },
4100 [RTA_IIF] = { .type = NLA_U32 },
4101 [RTA_PRIORITY] = { .type = NLA_U32 },
4102 [RTA_METRICS] = { .type = NLA_NESTED },
4103 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
4104 [RTA_PREF] = { .type = NLA_U8 },
4105 [RTA_ENCAP_TYPE] = { .type = NLA_U16 },
4106 [RTA_ENCAP] = { .type = NLA_NESTED },
4107 [RTA_EXPIRES] = { .type = NLA_U32 },
4108 [RTA_UID] = { .type = NLA_U32 },
4109 [RTA_MARK] = { .type = NLA_U32 },
4110 [RTA_TABLE] = { .type = NLA_U32 },
4111 [RTA_IP_PROTO] = { .type = NLA_U8 },
4112 [RTA_SPORT] = { .type = NLA_U16 },
4113 [RTA_DPORT] = { .type = NLA_U16 },
4114 };
4115
4116 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
4117 struct fib6_config *cfg,
4118 struct netlink_ext_ack *extack)
4119 {
4120 struct rtmsg *rtm;
4121 struct nlattr *tb[RTA_MAX+1];
4122 unsigned int pref;
4123 int err;
4124
4125 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy,
4126 extack);
4127 if (err < 0)
4128 goto errout;
4129
4130 err = -EINVAL;
4131 rtm = nlmsg_data(nlh);
4132
4133 *cfg = (struct fib6_config){
4134 .fc_table = rtm->rtm_table,
4135 .fc_dst_len = rtm->rtm_dst_len,
4136 .fc_src_len = rtm->rtm_src_len,
4137 .fc_flags = RTF_UP,
4138 .fc_protocol = rtm->rtm_protocol,
4139 .fc_type = rtm->rtm_type,
4140
4141 .fc_nlinfo.portid = NETLINK_CB(skb).portid,
4142 .fc_nlinfo.nlh = nlh,
4143 .fc_nlinfo.nl_net = sock_net(skb->sk),
4144 };
4145
4146 if (rtm->rtm_type == RTN_UNREACHABLE ||
4147 rtm->rtm_type == RTN_BLACKHOLE ||
4148 rtm->rtm_type == RTN_PROHIBIT ||
4149 rtm->rtm_type == RTN_THROW)
4150 cfg->fc_flags |= RTF_REJECT;
4151
4152 if (rtm->rtm_type == RTN_LOCAL)
4153 cfg->fc_flags |= RTF_LOCAL;
4154
4155 if (rtm->rtm_flags & RTM_F_CLONED)
4156 cfg->fc_flags |= RTF_CACHE;
4157
4158 cfg->fc_flags |= (rtm->rtm_flags & RTNH_F_ONLINK);
4159
4160 if (tb[RTA_GATEWAY]) {
4161 cfg->fc_gateway = nla_get_in6_addr(tb[RTA_GATEWAY]);
4162 cfg->fc_flags |= RTF_GATEWAY;
4163 }
4164
4165 if (tb[RTA_DST]) {
4166 int plen = (rtm->rtm_dst_len + 7) >> 3;
4167
4168 if (nla_len(tb[RTA_DST]) < plen)
4169 goto errout;
4170
4171 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
4172 }
4173
4174 if (tb[RTA_SRC]) {
4175 int plen = (rtm->rtm_src_len + 7) >> 3;
4176
4177 if (nla_len(tb[RTA_SRC]) < plen)
4178 goto errout;
4179
4180 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
4181 }
4182
4183 if (tb[RTA_PREFSRC])
4184 cfg->fc_prefsrc = nla_get_in6_addr(tb[RTA_PREFSRC]);
4185
4186 if (tb[RTA_OIF])
4187 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
4188
4189 if (tb[RTA_PRIORITY])
4190 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
4191
4192 if (tb[RTA_METRICS]) {
4193 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
4194 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
4195 }
4196
4197 if (tb[RTA_TABLE])
4198 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
4199
4200 if (tb[RTA_MULTIPATH]) {
4201 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
4202 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
4203
4204 err = lwtunnel_valid_encap_type_attr(cfg->fc_mp,
4205 cfg->fc_mp_len, extack);
4206 if (err < 0)
4207 goto errout;
4208 }
4209
4210 if (tb[RTA_PREF]) {
4211 pref = nla_get_u8(tb[RTA_PREF]);
4212 if (pref != ICMPV6_ROUTER_PREF_LOW &&
4213 pref != ICMPV6_ROUTER_PREF_HIGH)
4214 pref = ICMPV6_ROUTER_PREF_MEDIUM;
4215 cfg->fc_flags |= RTF_PREF(pref);
4216 }
4217
4218 if (tb[RTA_ENCAP])
4219 cfg->fc_encap = tb[RTA_ENCAP];
4220
4221 if (tb[RTA_ENCAP_TYPE]) {
4222 cfg->fc_encap_type = nla_get_u16(tb[RTA_ENCAP_TYPE]);
4223
4224 err = lwtunnel_valid_encap_type(cfg->fc_encap_type, extack);
4225 if (err < 0)
4226 goto errout;
4227 }
4228
4229 if (tb[RTA_EXPIRES]) {
4230 unsigned long timeout = addrconf_timeout_fixup(nla_get_u32(tb[RTA_EXPIRES]), HZ);
4231
4232 if (addrconf_finite_timeout(timeout)) {
4233 cfg->fc_expires = jiffies_to_clock_t(timeout * HZ);
4234 cfg->fc_flags |= RTF_EXPIRES;
4235 }
4236 }
4237
4238 err = 0;
4239 errout:
4240 return err;
4241 }
4242
4243 struct rt6_nh {
4244 struct fib6_info *fib6_info;
4245 struct fib6_config r_cfg;
4246 struct list_head next;
4247 };
4248
4249 static void ip6_print_replace_route_err(struct list_head *rt6_nh_list)
4250 {
4251 struct rt6_nh *nh;
4252
4253 list_for_each_entry(nh, rt6_nh_list, next) {
4254 pr_warn("IPV6: multipath route replace failed (check consistency of installed routes): %pI6c nexthop %pI6c ifi %d\n",
4255 &nh->r_cfg.fc_dst, &nh->r_cfg.fc_gateway,
4256 nh->r_cfg.fc_ifindex);
4257 }
4258 }
4259
4260 static int ip6_route_info_append(struct net *net,
4261 struct list_head *rt6_nh_list,
4262 struct fib6_info *rt,
4263 struct fib6_config *r_cfg)
4264 {
4265 struct rt6_nh *nh;
4266 int err = -EEXIST;
4267
4268 list_for_each_entry(nh, rt6_nh_list, next) {
4269 /* check if fib6_info already exists */
4270 if (rt6_duplicate_nexthop(nh->fib6_info, rt))
4271 return err;
4272 }
4273
4274 nh = kzalloc(sizeof(*nh), GFP_KERNEL);
4275 if (!nh)
4276 return -ENOMEM;
4277 nh->fib6_info = rt;
4278 memcpy(&nh->r_cfg, r_cfg, sizeof(*r_cfg));
4279 list_add_tail(&nh->next, rt6_nh_list);
4280
4281 return 0;
4282 }
4283
4284 static void ip6_route_mpath_notify(struct fib6_info *rt,
4285 struct fib6_info *rt_last,
4286 struct nl_info *info,
4287 __u16 nlflags)
4288 {
4289 /* if this is an APPEND route, then rt points to the first route
4290 * inserted and rt_last points to last route inserted. Userspace
4291 * wants a consistent dump of the route which starts at the first
4292 * nexthop. Since sibling routes are always added at the end of
4293 * the list, find the first sibling of the last route appended
4294 */
4295 if ((nlflags & NLM_F_APPEND) && rt_last && rt_last->fib6_nsiblings) {
4296 rt = list_first_entry(&rt_last->fib6_siblings,
4297 struct fib6_info,
4298 fib6_siblings);
4299 }
4300
4301 if (rt)
4302 inet6_rt_notify(RTM_NEWROUTE, rt, info, nlflags);
4303 }
4304
4305 static int ip6_route_multipath_add(struct fib6_config *cfg,
4306 struct netlink_ext_ack *extack)
4307 {
4308 struct fib6_info *rt_notif = NULL, *rt_last = NULL;
4309 struct nl_info *info = &cfg->fc_nlinfo;
4310 struct fib6_config r_cfg;
4311 struct rtnexthop *rtnh;
4312 struct fib6_info *rt;
4313 struct rt6_nh *err_nh;
4314 struct rt6_nh *nh, *nh_safe;
4315 __u16 nlflags;
4316 int remaining;
4317 int attrlen;
4318 int err = 1;
4319 int nhn = 0;
4320 int replace = (cfg->fc_nlinfo.nlh &&
4321 (cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_REPLACE));
4322 LIST_HEAD(rt6_nh_list);
4323
4324 nlflags = replace ? NLM_F_REPLACE : NLM_F_CREATE;
4325 if (info->nlh && info->nlh->nlmsg_flags & NLM_F_APPEND)
4326 nlflags |= NLM_F_APPEND;
4327
4328 remaining = cfg->fc_mp_len;
4329 rtnh = (struct rtnexthop *)cfg->fc_mp;
4330
4331 /* Parse a Multipath Entry and build a list (rt6_nh_list) of
4332 * fib6_info structs per nexthop
4333 */
4334 while (rtnh_ok(rtnh, remaining)) {
4335 memcpy(&r_cfg, cfg, sizeof(*cfg));
4336 if (rtnh->rtnh_ifindex)
4337 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
4338
4339 attrlen = rtnh_attrlen(rtnh);
4340 if (attrlen > 0) {
4341 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
4342
4343 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
4344 if (nla) {
4345 r_cfg.fc_gateway = nla_get_in6_addr(nla);
4346 r_cfg.fc_flags |= RTF_GATEWAY;
4347 }
4348 r_cfg.fc_encap = nla_find(attrs, attrlen, RTA_ENCAP);
4349 nla = nla_find(attrs, attrlen, RTA_ENCAP_TYPE);
4350 if (nla)
4351 r_cfg.fc_encap_type = nla_get_u16(nla);
4352 }
4353
4354 r_cfg.fc_flags |= (rtnh->rtnh_flags & RTNH_F_ONLINK);
4355 rt = ip6_route_info_create(&r_cfg, GFP_KERNEL, extack);
4356 if (IS_ERR(rt)) {
4357 err = PTR_ERR(rt);
4358 rt = NULL;
4359 goto cleanup;
4360 }
4361 if (!rt6_qualify_for_ecmp(rt)) {
4362 err = -EINVAL;
4363 NL_SET_ERR_MSG(extack,
4364 "Device only routes can not be added for IPv6 using the multipath API.");
4365 fib6_info_release(rt);
4366 goto cleanup;
4367 }
4368
4369 rt->fib6_nh.nh_weight = rtnh->rtnh_hops + 1;
4370
4371 err = ip6_route_info_append(info->nl_net, &rt6_nh_list,
4372 rt, &r_cfg);
4373 if (err) {
4374 fib6_info_release(rt);
4375 goto cleanup;
4376 }
4377
4378 rtnh = rtnh_next(rtnh, &remaining);
4379 }
4380
4381 /* for add and replace send one notification with all nexthops.
4382 * Skip the notification in fib6_add_rt2node and send one with
4383 * the full route when done
4384 */
4385 info->skip_notify = 1;
4386
4387 err_nh = NULL;
4388 list_for_each_entry(nh, &rt6_nh_list, next) {
4389 err = __ip6_ins_rt(nh->fib6_info, info, extack);
4390 fib6_info_release(nh->fib6_info);
4391
4392 if (!err) {
4393 /* save reference to last route successfully inserted */
4394 rt_last = nh->fib6_info;
4395
4396 /* save reference to first route for notification */
4397 if (!rt_notif)
4398 rt_notif = nh->fib6_info;
4399 }
4400
4401 /* nh->fib6_info is used or freed at this point, reset to NULL*/
4402 nh->fib6_info = NULL;
4403 if (err) {
4404 if (replace && nhn)
4405 ip6_print_replace_route_err(&rt6_nh_list);
4406 err_nh = nh;
4407 goto add_errout;
4408 }
4409
4410 /* Because each route is added like a single route we remove
4411 * these flags after the first nexthop: if there is a collision,
4412 * we have already failed to add the first nexthop:
4413 * fib6_add_rt2node() has rejected it; when replacing, old
4414 * nexthops have been replaced by first new, the rest should
4415 * be added to it.
4416 */
4417 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~(NLM_F_EXCL |
4418 NLM_F_REPLACE);
4419 nhn++;
4420 }
4421
4422 /* success ... tell user about new route */
4423 ip6_route_mpath_notify(rt_notif, rt_last, info, nlflags);
4424 goto cleanup;
4425
4426 add_errout:
4427 /* send notification for routes that were added so that
4428 * the delete notifications sent by ip6_route_del are
4429 * coherent
4430 */
4431 if (rt_notif)
4432 ip6_route_mpath_notify(rt_notif, rt_last, info, nlflags);
4433
4434 /* Delete routes that were already added */
4435 list_for_each_entry(nh, &rt6_nh_list, next) {
4436 if (err_nh == nh)
4437 break;
4438 ip6_route_del(&nh->r_cfg, extack);
4439 }
4440
4441 cleanup:
4442 list_for_each_entry_safe(nh, nh_safe, &rt6_nh_list, next) {
4443 if (nh->fib6_info)
4444 fib6_info_release(nh->fib6_info);
4445 list_del(&nh->next);
4446 kfree(nh);
4447 }
4448
4449 return err;
4450 }
4451
4452 static int ip6_route_multipath_del(struct fib6_config *cfg,
4453 struct netlink_ext_ack *extack)
4454 {
4455 struct fib6_config r_cfg;
4456 struct rtnexthop *rtnh;
4457 int remaining;
4458 int attrlen;
4459 int err = 1, last_err = 0;
4460
4461 remaining = cfg->fc_mp_len;
4462 rtnh = (struct rtnexthop *)cfg->fc_mp;
4463
4464 /* Parse a Multipath Entry */
4465 while (rtnh_ok(rtnh, remaining)) {
4466 memcpy(&r_cfg, cfg, sizeof(*cfg));
4467 if (rtnh->rtnh_ifindex)
4468 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
4469
4470 attrlen = rtnh_attrlen(rtnh);
4471 if (attrlen > 0) {
4472 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
4473
4474 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
4475 if (nla) {
4476 nla_memcpy(&r_cfg.fc_gateway, nla, 16);
4477 r_cfg.fc_flags |= RTF_GATEWAY;
4478 }
4479 }
4480 err = ip6_route_del(&r_cfg, extack);
4481 if (err)
4482 last_err = err;
4483
4484 rtnh = rtnh_next(rtnh, &remaining);
4485 }
4486
4487 return last_err;
4488 }
4489
4490 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh,
4491 struct netlink_ext_ack *extack)
4492 {
4493 struct fib6_config cfg;
4494 int err;
4495
4496 err = rtm_to_fib6_config(skb, nlh, &cfg, extack);
4497 if (err < 0)
4498 return err;
4499
4500 if (cfg.fc_mp)
4501 return ip6_route_multipath_del(&cfg, extack);
4502 else {
4503 cfg.fc_delete_all_nh = 1;
4504 return ip6_route_del(&cfg, extack);
4505 }
4506 }
4507
4508 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh,
4509 struct netlink_ext_ack *extack)
4510 {
4511 struct fib6_config cfg;
4512 int err;
4513
4514 err = rtm_to_fib6_config(skb, nlh, &cfg, extack);
4515 if (err < 0)
4516 return err;
4517
4518 if (cfg.fc_mp)
4519 return ip6_route_multipath_add(&cfg, extack);
4520 else
4521 return ip6_route_add(&cfg, GFP_KERNEL, extack);
4522 }
4523
4524 static size_t rt6_nlmsg_size(struct fib6_info *rt)
4525 {
4526 int nexthop_len = 0;
4527
4528 if (rt->fib6_nsiblings) {
4529 nexthop_len = nla_total_size(0) /* RTA_MULTIPATH */
4530 + NLA_ALIGN(sizeof(struct rtnexthop))
4531 + nla_total_size(16) /* RTA_GATEWAY */
4532 + lwtunnel_get_encap_size(rt->fib6_nh.nh_lwtstate);
4533
4534 nexthop_len *= rt->fib6_nsiblings;
4535 }
4536
4537 return NLMSG_ALIGN(sizeof(struct rtmsg))
4538 + nla_total_size(16) /* RTA_SRC */
4539 + nla_total_size(16) /* RTA_DST */
4540 + nla_total_size(16) /* RTA_GATEWAY */
4541 + nla_total_size(16) /* RTA_PREFSRC */
4542 + nla_total_size(4) /* RTA_TABLE */
4543 + nla_total_size(4) /* RTA_IIF */
4544 + nla_total_size(4) /* RTA_OIF */
4545 + nla_total_size(4) /* RTA_PRIORITY */
4546 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
4547 + nla_total_size(sizeof(struct rta_cacheinfo))
4548 + nla_total_size(TCP_CA_NAME_MAX) /* RTAX_CC_ALGO */
4549 + nla_total_size(1) /* RTA_PREF */
4550 + lwtunnel_get_encap_size(rt->fib6_nh.nh_lwtstate)
4551 + nexthop_len;
4552 }
4553
4554 static int rt6_nexthop_info(struct sk_buff *skb, struct fib6_info *rt,
4555 unsigned int *flags, bool skip_oif)
4556 {
4557 if (rt->fib6_nh.nh_flags & RTNH_F_DEAD)
4558 *flags |= RTNH_F_DEAD;
4559
4560 if (rt->fib6_nh.nh_flags & RTNH_F_LINKDOWN) {
4561 *flags |= RTNH_F_LINKDOWN;
4562
4563 rcu_read_lock();
4564 if (fib6_ignore_linkdown(rt))
4565 *flags |= RTNH_F_DEAD;
4566 rcu_read_unlock();
4567 }
4568
4569 if (rt->fib6_flags & RTF_GATEWAY) {
4570 if (nla_put_in6_addr(skb, RTA_GATEWAY, &rt->fib6_nh.nh_gw) < 0)
4571 goto nla_put_failure;
4572 }
4573
4574 *flags |= (rt->fib6_nh.nh_flags & RTNH_F_ONLINK);
4575 if (rt->fib6_nh.nh_flags & RTNH_F_OFFLOAD)
4576 *flags |= RTNH_F_OFFLOAD;
4577
4578 /* not needed for multipath encoding b/c it has a rtnexthop struct */
4579 if (!skip_oif && rt->fib6_nh.nh_dev &&
4580 nla_put_u32(skb, RTA_OIF, rt->fib6_nh.nh_dev->ifindex))
4581 goto nla_put_failure;
4582
4583 if (rt->fib6_nh.nh_lwtstate &&
4584 lwtunnel_fill_encap(skb, rt->fib6_nh.nh_lwtstate) < 0)
4585 goto nla_put_failure;
4586
4587 return 0;
4588
4589 nla_put_failure:
4590 return -EMSGSIZE;
4591 }
4592
4593 /* add multipath next hop */
4594 static int rt6_add_nexthop(struct sk_buff *skb, struct fib6_info *rt)
4595 {
4596 const struct net_device *dev = rt->fib6_nh.nh_dev;
4597 struct rtnexthop *rtnh;
4598 unsigned int flags = 0;
4599
4600 rtnh = nla_reserve_nohdr(skb, sizeof(*rtnh));
4601 if (!rtnh)
4602 goto nla_put_failure;
4603
4604 rtnh->rtnh_hops = rt->fib6_nh.nh_weight - 1;
4605 rtnh->rtnh_ifindex = dev ? dev->ifindex : 0;
4606
4607 if (rt6_nexthop_info(skb, rt, &flags, true) < 0)
4608 goto nla_put_failure;
4609
4610 rtnh->rtnh_flags = flags;
4611
4612 /* length of rtnetlink header + attributes */
4613 rtnh->rtnh_len = nlmsg_get_pos(skb) - (void *)rtnh;
4614
4615 return 0;
4616
4617 nla_put_failure:
4618 return -EMSGSIZE;
4619 }
4620
4621 static int rt6_fill_node(struct net *net, struct sk_buff *skb,
4622 struct fib6_info *rt, struct dst_entry *dst,
4623 struct in6_addr *dest, struct in6_addr *src,
4624 int iif, int type, u32 portid, u32 seq,
4625 unsigned int flags)
4626 {
4627 struct rt6_info *rt6 = (struct rt6_info *)dst;
4628 struct rt6key *rt6_dst, *rt6_src;
4629 u32 *pmetrics, table, rt6_flags;
4630 struct nlmsghdr *nlh;
4631 struct rtmsg *rtm;
4632 long expires = 0;
4633
4634 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
4635 if (!nlh)
4636 return -EMSGSIZE;
4637
4638 if (rt6) {
4639 rt6_dst = &rt6->rt6i_dst;
4640 rt6_src = &rt6->rt6i_src;
4641 rt6_flags = rt6->rt6i_flags;
4642 } else {
4643 rt6_dst = &rt->fib6_dst;
4644 rt6_src = &rt->fib6_src;
4645 rt6_flags = rt->fib6_flags;
4646 }
4647
4648 rtm = nlmsg_data(nlh);
4649 rtm->rtm_family = AF_INET6;
4650 rtm->rtm_dst_len = rt6_dst->plen;
4651 rtm->rtm_src_len = rt6_src->plen;
4652 rtm->rtm_tos = 0;
4653 if (rt->fib6_table)
4654 table = rt->fib6_table->tb6_id;
4655 else
4656 table = RT6_TABLE_UNSPEC;
4657 rtm->rtm_table = table;
4658 if (nla_put_u32(skb, RTA_TABLE, table))
4659 goto nla_put_failure;
4660
4661 rtm->rtm_type = rt->fib6_type;
4662 rtm->rtm_flags = 0;
4663 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
4664 rtm->rtm_protocol = rt->fib6_protocol;
4665
4666 if (rt6_flags & RTF_CACHE)
4667 rtm->rtm_flags |= RTM_F_CLONED;
4668
4669 if (dest) {
4670 if (nla_put_in6_addr(skb, RTA_DST, dest))
4671 goto nla_put_failure;
4672 rtm->rtm_dst_len = 128;
4673 } else if (rtm->rtm_dst_len)
4674 if (nla_put_in6_addr(skb, RTA_DST, &rt6_dst->addr))
4675 goto nla_put_failure;
4676 #ifdef CONFIG_IPV6_SUBTREES
4677 if (src) {
4678 if (nla_put_in6_addr(skb, RTA_SRC, src))
4679 goto nla_put_failure;
4680 rtm->rtm_src_len = 128;
4681 } else if (rtm->rtm_src_len &&
4682 nla_put_in6_addr(skb, RTA_SRC, &rt6_src->addr))
4683 goto nla_put_failure;
4684 #endif
4685 if (iif) {
4686 #ifdef CONFIG_IPV6_MROUTE
4687 if (ipv6_addr_is_multicast(&rt6_dst->addr)) {
4688 int err = ip6mr_get_route(net, skb, rtm, portid);
4689
4690 if (err == 0)
4691 return 0;
4692 if (err < 0)
4693 goto nla_put_failure;
4694 } else
4695 #endif
4696 if (nla_put_u32(skb, RTA_IIF, iif))
4697 goto nla_put_failure;
4698 } else if (dest) {
4699 struct in6_addr saddr_buf;
4700 if (ip6_route_get_saddr(net, rt, dest, 0, &saddr_buf) == 0 &&
4701 nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
4702 goto nla_put_failure;
4703 }
4704
4705 if (rt->fib6_prefsrc.plen) {
4706 struct in6_addr saddr_buf;
4707 saddr_buf = rt->fib6_prefsrc.addr;
4708 if (nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
4709 goto nla_put_failure;
4710 }
4711
4712 pmetrics = dst ? dst_metrics_ptr(dst) : rt->fib6_metrics->metrics;
4713 if (rtnetlink_put_metrics(skb, pmetrics) < 0)
4714 goto nla_put_failure;
4715
4716 if (nla_put_u32(skb, RTA_PRIORITY, rt->fib6_metric))
4717 goto nla_put_failure;
4718
4719 /* For multipath routes, walk the siblings list and add
4720 * each as a nexthop within RTA_MULTIPATH.
4721 */
4722 if (rt6) {
4723 if (rt6_flags & RTF_GATEWAY &&
4724 nla_put_in6_addr(skb, RTA_GATEWAY, &rt6->rt6i_gateway))
4725 goto nla_put_failure;
4726
4727 if (dst->dev && nla_put_u32(skb, RTA_OIF, dst->dev->ifindex))
4728 goto nla_put_failure;
4729 } else if (rt->fib6_nsiblings) {
4730 struct fib6_info *sibling, *next_sibling;
4731 struct nlattr *mp;
4732
4733 mp = nla_nest_start(skb, RTA_MULTIPATH);
4734 if (!mp)
4735 goto nla_put_failure;
4736
4737 if (rt6_add_nexthop(skb, rt) < 0)
4738 goto nla_put_failure;
4739
4740 list_for_each_entry_safe(sibling, next_sibling,
4741 &rt->fib6_siblings, fib6_siblings) {
4742 if (rt6_add_nexthop(skb, sibling) < 0)
4743 goto nla_put_failure;
4744 }
4745
4746 nla_nest_end(skb, mp);
4747 } else {
4748 if (rt6_nexthop_info(skb, rt, &rtm->rtm_flags, false) < 0)
4749 goto nla_put_failure;
4750 }
4751
4752 if (rt6_flags & RTF_EXPIRES) {
4753 expires = dst ? dst->expires : rt->expires;
4754 expires -= jiffies;
4755 }
4756
4757 if (rtnl_put_cacheinfo(skb, dst, 0, expires, dst ? dst->error : 0) < 0)
4758 goto nla_put_failure;
4759
4760 if (nla_put_u8(skb, RTA_PREF, IPV6_EXTRACT_PREF(rt6_flags)))
4761 goto nla_put_failure;
4762
4763
4764 nlmsg_end(skb, nlh);
4765 return 0;
4766
4767 nla_put_failure:
4768 nlmsg_cancel(skb, nlh);
4769 return -EMSGSIZE;
4770 }
4771
4772 static bool fib6_info_uses_dev(const struct fib6_info *f6i,
4773 const struct net_device *dev)
4774 {
4775 if (f6i->fib6_nh.nh_dev == dev)
4776 return true;
4777
4778 if (f6i->fib6_nsiblings) {
4779 struct fib6_info *sibling, *next_sibling;
4780
4781 list_for_each_entry_safe(sibling, next_sibling,
4782 &f6i->fib6_siblings, fib6_siblings) {
4783 if (sibling->fib6_nh.nh_dev == dev)
4784 return true;
4785 }
4786 }
4787
4788 return false;
4789 }
4790
4791 int rt6_dump_route(struct fib6_info *rt, void *p_arg)
4792 {
4793 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
4794 struct fib_dump_filter *filter = &arg->filter;
4795 unsigned int flags = NLM_F_MULTI;
4796 struct net *net = arg->net;
4797
4798 if (rt == net->ipv6.fib6_null_entry)
4799 return 0;
4800
4801 if ((filter->flags & RTM_F_PREFIX) &&
4802 !(rt->fib6_flags & RTF_PREFIX_RT)) {
4803 /* success since this is not a prefix route */
4804 return 1;
4805 }
4806 if (filter->filter_set) {
4807 if ((filter->rt_type && rt->fib6_type != filter->rt_type) ||
4808 (filter->dev && !fib6_info_uses_dev(rt, filter->dev)) ||
4809 (filter->protocol && rt->fib6_protocol != filter->protocol)) {
4810 return 1;
4811 }
4812 flags |= NLM_F_DUMP_FILTERED;
4813 }
4814
4815 return rt6_fill_node(net, arg->skb, rt, NULL, NULL, NULL, 0,
4816 RTM_NEWROUTE, NETLINK_CB(arg->cb->skb).portid,
4817 arg->cb->nlh->nlmsg_seq, flags);
4818 }
4819
4820 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh,
4821 struct netlink_ext_ack *extack)
4822 {
4823 struct net *net = sock_net(in_skb->sk);
4824 struct nlattr *tb[RTA_MAX+1];
4825 int err, iif = 0, oif = 0;
4826 struct fib6_info *from;
4827 struct dst_entry *dst;
4828 struct rt6_info *rt;
4829 struct sk_buff *skb;
4830 struct rtmsg *rtm;
4831 struct flowi6 fl6 = {};
4832 bool fibmatch;
4833
4834 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy,
4835 extack);
4836 if (err < 0)
4837 goto errout;
4838
4839 err = -EINVAL;
4840 rtm = nlmsg_data(nlh);
4841 fl6.flowlabel = ip6_make_flowinfo(rtm->rtm_tos, 0);
4842 fibmatch = !!(rtm->rtm_flags & RTM_F_FIB_MATCH);
4843
4844 if (tb[RTA_SRC]) {
4845 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
4846 goto errout;
4847
4848 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
4849 }
4850
4851 if (tb[RTA_DST]) {
4852 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
4853 goto errout;
4854
4855 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
4856 }
4857
4858 if (tb[RTA_IIF])
4859 iif = nla_get_u32(tb[RTA_IIF]);
4860
4861 if (tb[RTA_OIF])
4862 oif = nla_get_u32(tb[RTA_OIF]);
4863
4864 if (tb[RTA_MARK])
4865 fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);
4866
4867 if (tb[RTA_UID])
4868 fl6.flowi6_uid = make_kuid(current_user_ns(),
4869 nla_get_u32(tb[RTA_UID]));
4870 else
4871 fl6.flowi6_uid = iif ? INVALID_UID : current_uid();
4872
4873 if (tb[RTA_SPORT])
4874 fl6.fl6_sport = nla_get_be16(tb[RTA_SPORT]);
4875
4876 if (tb[RTA_DPORT])
4877 fl6.fl6_dport = nla_get_be16(tb[RTA_DPORT]);
4878
4879 if (tb[RTA_IP_PROTO]) {
4880 err = rtm_getroute_parse_ip_proto(tb[RTA_IP_PROTO],
4881 &fl6.flowi6_proto, extack);
4882 if (err)
4883 goto errout;
4884 }
4885
4886 if (iif) {
4887 struct net_device *dev;
4888 int flags = 0;
4889
4890 rcu_read_lock();
4891
4892 dev = dev_get_by_index_rcu(net, iif);
4893 if (!dev) {
4894 rcu_read_unlock();
4895 err = -ENODEV;
4896 goto errout;
4897 }
4898
4899 fl6.flowi6_iif = iif;
4900
4901 if (!ipv6_addr_any(&fl6.saddr))
4902 flags |= RT6_LOOKUP_F_HAS_SADDR;
4903
4904 dst = ip6_route_input_lookup(net, dev, &fl6, NULL, flags);
4905
4906 rcu_read_unlock();
4907 } else {
4908 fl6.flowi6_oif = oif;
4909
4910 dst = ip6_route_output(net, NULL, &fl6);
4911 }
4912
4913
4914 rt = container_of(dst, struct rt6_info, dst);
4915 if (rt->dst.error) {
4916 err = rt->dst.error;
4917 ip6_rt_put(rt);
4918 goto errout;
4919 }
4920
4921 if (rt == net->ipv6.ip6_null_entry) {
4922 err = rt->dst.error;
4923 ip6_rt_put(rt);
4924 goto errout;
4925 }
4926
4927 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
4928 if (!skb) {
4929 ip6_rt_put(rt);
4930 err = -ENOBUFS;
4931 goto errout;
4932 }
4933
4934 skb_dst_set(skb, &rt->dst);
4935
4936 rcu_read_lock();
4937 from = rcu_dereference(rt->from);
4938
4939 if (fibmatch)
4940 err = rt6_fill_node(net, skb, from, NULL, NULL, NULL, iif,
4941 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
4942 nlh->nlmsg_seq, 0);
4943 else
4944 err = rt6_fill_node(net, skb, from, dst, &fl6.daddr,
4945 &fl6.saddr, iif, RTM_NEWROUTE,
4946 NETLINK_CB(in_skb).portid, nlh->nlmsg_seq,
4947 0);
4948 rcu_read_unlock();
4949
4950 if (err < 0) {
4951 kfree_skb(skb);
4952 goto errout;
4953 }
4954
4955 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
4956 errout:
4957 return err;
4958 }
4959
4960 void inet6_rt_notify(int event, struct fib6_info *rt, struct nl_info *info,
4961 unsigned int nlm_flags)
4962 {
4963 struct sk_buff *skb;
4964 struct net *net = info->nl_net;
4965 u32 seq;
4966 int err;
4967
4968 err = -ENOBUFS;
4969 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
4970
4971 skb = nlmsg_new(rt6_nlmsg_size(rt), gfp_any());
4972 if (!skb)
4973 goto errout;
4974
4975 err = rt6_fill_node(net, skb, rt, NULL, NULL, NULL, 0,
4976 event, info->portid, seq, nlm_flags);
4977 if (err < 0) {
4978 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
4979 WARN_ON(err == -EMSGSIZE);
4980 kfree_skb(skb);
4981 goto errout;
4982 }
4983 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
4984 info->nlh, gfp_any());
4985 return;
4986 errout:
4987 if (err < 0)
4988 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
4989 }
4990
4991 static int ip6_route_dev_notify(struct notifier_block *this,
4992 unsigned long event, void *ptr)
4993 {
4994 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
4995 struct net *net = dev_net(dev);
4996
4997 if (!(dev->flags & IFF_LOOPBACK))
4998 return NOTIFY_OK;
4999
5000 if (event == NETDEV_REGISTER) {
5001 net->ipv6.fib6_null_entry->fib6_nh.nh_dev = dev;
5002 net->ipv6.ip6_null_entry->dst.dev = dev;
5003 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
5004 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
5005 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
5006 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
5007 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
5008 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
5009 #endif
5010 } else if (event == NETDEV_UNREGISTER &&
5011 dev->reg_state != NETREG_UNREGISTERED) {
5012 /* NETDEV_UNREGISTER could be fired for multiple times by
5013 * netdev_wait_allrefs(). Make sure we only call this once.
5014 */
5015 in6_dev_put_clear(&net->ipv6.ip6_null_entry->rt6i_idev);
5016 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
5017 in6_dev_put_clear(&net->ipv6.ip6_prohibit_entry->rt6i_idev);
5018 in6_dev_put_clear(&net->ipv6.ip6_blk_hole_entry->rt6i_idev);
5019 #endif
5020 }
5021
5022 return NOTIFY_OK;
5023 }
5024
5025 /*
5026 * /proc
5027 */
5028
5029 #ifdef CONFIG_PROC_FS
5030 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
5031 {
5032 struct net *net = (struct net *)seq->private;
5033 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
5034 net->ipv6.rt6_stats->fib_nodes,
5035 net->ipv6.rt6_stats->fib_route_nodes,
5036 atomic_read(&net->ipv6.rt6_stats->fib_rt_alloc),
5037 net->ipv6.rt6_stats->fib_rt_entries,
5038 net->ipv6.rt6_stats->fib_rt_cache,
5039 dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
5040 net->ipv6.rt6_stats->fib_discarded_routes);
5041
5042 return 0;
5043 }
5044 #endif /* CONFIG_PROC_FS */
5045
5046 #ifdef CONFIG_SYSCTL
5047
5048 static
5049 int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,
5050 void __user *buffer, size_t *lenp, loff_t *ppos)
5051 {
5052 struct net *net;
5053 int delay;
5054 if (!write)
5055 return -EINVAL;
5056
5057 net = (struct net *)ctl->extra1;
5058 delay = net->ipv6.sysctl.flush_delay;
5059 proc_dointvec(ctl, write, buffer, lenp, ppos);
5060 fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
5061 return 0;
5062 }
5063
5064 static int zero;
5065 static int one = 1;
5066
5067 static struct ctl_table ipv6_route_table_template[] = {
5068 {
5069 .procname = "flush",
5070 .data = &init_net.ipv6.sysctl.flush_delay,
5071 .maxlen = sizeof(int),
5072 .mode = 0200,
5073 .proc_handler = ipv6_sysctl_rtcache_flush
5074 },
5075 {
5076 .procname = "gc_thresh",
5077 .data = &ip6_dst_ops_template.gc_thresh,
5078 .maxlen = sizeof(int),
5079 .mode = 0644,
5080 .proc_handler = proc_dointvec,
5081 },
5082 {
5083 .procname = "max_size",
5084 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
5085 .maxlen = sizeof(int),
5086 .mode = 0644,
5087 .proc_handler = proc_dointvec,
5088 },
5089 {
5090 .procname = "gc_min_interval",
5091 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
5092 .maxlen = sizeof(int),
5093 .mode = 0644,
5094 .proc_handler = proc_dointvec_jiffies,
5095 },
5096 {
5097 .procname = "gc_timeout",
5098 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
5099 .maxlen = sizeof(int),
5100 .mode = 0644,
5101 .proc_handler = proc_dointvec_jiffies,
5102 },
5103 {
5104 .procname = "gc_interval",
5105 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
5106 .maxlen = sizeof(int),
5107 .mode = 0644,
5108 .proc_handler = proc_dointvec_jiffies,
5109 },
5110 {
5111 .procname = "gc_elasticity",
5112 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
5113 .maxlen = sizeof(int),
5114 .mode = 0644,
5115 .proc_handler = proc_dointvec,
5116 },
5117 {
5118 .procname = "mtu_expires",
5119 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
5120 .maxlen = sizeof(int),
5121 .mode = 0644,
5122 .proc_handler = proc_dointvec_jiffies,
5123 },
5124 {
5125 .procname = "min_adv_mss",
5126 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
5127 .maxlen = sizeof(int),
5128 .mode = 0644,
5129 .proc_handler = proc_dointvec,
5130 },
5131 {
5132 .procname = "gc_min_interval_ms",
5133 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
5134 .maxlen = sizeof(int),
5135 .mode = 0644,
5136 .proc_handler = proc_dointvec_ms_jiffies,
5137 },
5138 {
5139 .procname = "skip_notify_on_dev_down",
5140 .data = &init_net.ipv6.sysctl.skip_notify_on_dev_down,
5141 .maxlen = sizeof(int),
5142 .mode = 0644,
5143 .proc_handler = proc_dointvec,
5144 .extra1 = &zero,
5145 .extra2 = &one,
5146 },
5147 { }
5148 };
5149
5150 struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
5151 {
5152 struct ctl_table *table;
5153
5154 table = kmemdup(ipv6_route_table_template,
5155 sizeof(ipv6_route_table_template),
5156 GFP_KERNEL);
5157
5158 if (table) {
5159 table[0].data = &net->ipv6.sysctl.flush_delay;
5160 table[0].extra1 = net;
5161 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
5162 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
5163 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
5164 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
5165 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
5166 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
5167 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
5168 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
5169 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
5170 table[10].data = &net->ipv6.sysctl.skip_notify_on_dev_down;
5171
5172 /* Don't export sysctls to unprivileged users */
5173 if (net->user_ns != &init_user_ns)
5174 table[0].procname = NULL;
5175 }
5176
5177 return table;
5178 }
5179 #endif
5180
5181 static int __net_init ip6_route_net_init(struct net *net)
5182 {
5183 int ret = -ENOMEM;
5184
5185 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
5186 sizeof(net->ipv6.ip6_dst_ops));
5187
5188 if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
5189 goto out_ip6_dst_ops;
5190
5191 net->ipv6.fib6_null_entry = kmemdup(&fib6_null_entry_template,
5192 sizeof(*net->ipv6.fib6_null_entry),
5193 GFP_KERNEL);
5194 if (!net->ipv6.fib6_null_entry)
5195 goto out_ip6_dst_entries;
5196
5197 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
5198 sizeof(*net->ipv6.ip6_null_entry),
5199 GFP_KERNEL);
5200 if (!net->ipv6.ip6_null_entry)
5201 goto out_fib6_null_entry;
5202 net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
5203 dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
5204 ip6_template_metrics, true);
5205
5206 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
5207 net->ipv6.fib6_has_custom_rules = false;
5208 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
5209 sizeof(*net->ipv6.ip6_prohibit_entry),
5210 GFP_KERNEL);
5211 if (!net->ipv6.ip6_prohibit_entry)
5212 goto out_ip6_null_entry;
5213 net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
5214 dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
5215 ip6_template_metrics, true);
5216
5217 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
5218 sizeof(*net->ipv6.ip6_blk_hole_entry),
5219 GFP_KERNEL);
5220 if (!net->ipv6.ip6_blk_hole_entry)
5221 goto out_ip6_prohibit_entry;
5222 net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
5223 dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
5224 ip6_template_metrics, true);
5225 #endif
5226
5227 net->ipv6.sysctl.flush_delay = 0;
5228 net->ipv6.sysctl.ip6_rt_max_size = 4096;
5229 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
5230 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
5231 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
5232 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
5233 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
5234 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
5235 net->ipv6.sysctl.skip_notify_on_dev_down = 0;
5236
5237 net->ipv6.ip6_rt_gc_expire = 30*HZ;
5238
5239 ret = 0;
5240 out:
5241 return ret;
5242
5243 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
5244 out_ip6_prohibit_entry:
5245 kfree(net->ipv6.ip6_prohibit_entry);
5246 out_ip6_null_entry:
5247 kfree(net->ipv6.ip6_null_entry);
5248 #endif
5249 out_fib6_null_entry:
5250 kfree(net->ipv6.fib6_null_entry);
5251 out_ip6_dst_entries:
5252 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
5253 out_ip6_dst_ops:
5254 goto out;
5255 }
5256
5257 static void __net_exit ip6_route_net_exit(struct net *net)
5258 {
5259 kfree(net->ipv6.fib6_null_entry);
5260 kfree(net->ipv6.ip6_null_entry);
5261 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
5262 kfree(net->ipv6.ip6_prohibit_entry);
5263 kfree(net->ipv6.ip6_blk_hole_entry);
5264 #endif
5265 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
5266 }
5267
5268 static int __net_init ip6_route_net_init_late(struct net *net)
5269 {
5270 #ifdef CONFIG_PROC_FS
5271 proc_create_net("ipv6_route", 0, net->proc_net, &ipv6_route_seq_ops,
5272 sizeof(struct ipv6_route_iter));
5273 proc_create_net_single("rt6_stats", 0444, net->proc_net,
5274 rt6_stats_seq_show, NULL);
5275 #endif
5276 return 0;
5277 }
5278
5279 static void __net_exit ip6_route_net_exit_late(struct net *net)
5280 {
5281 #ifdef CONFIG_PROC_FS
5282 remove_proc_entry("ipv6_route", net->proc_net);
5283 remove_proc_entry("rt6_stats", net->proc_net);
5284 #endif
5285 }
5286
5287 static struct pernet_operations ip6_route_net_ops = {
5288 .init = ip6_route_net_init,
5289 .exit = ip6_route_net_exit,
5290 };
5291
5292 static int __net_init ipv6_inetpeer_init(struct net *net)
5293 {
5294 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
5295
5296 if (!bp)
5297 return -ENOMEM;
5298 inet_peer_base_init(bp);
5299 net->ipv6.peers = bp;
5300 return 0;
5301 }
5302
5303 static void __net_exit ipv6_inetpeer_exit(struct net *net)
5304 {
5305 struct inet_peer_base *bp = net->ipv6.peers;
5306
5307 net->ipv6.peers = NULL;
5308 inetpeer_invalidate_tree(bp);
5309 kfree(bp);
5310 }
5311
5312 static struct pernet_operations ipv6_inetpeer_ops = {
5313 .init = ipv6_inetpeer_init,
5314 .exit = ipv6_inetpeer_exit,
5315 };
5316
5317 static struct pernet_operations ip6_route_net_late_ops = {
5318 .init = ip6_route_net_init_late,
5319 .exit = ip6_route_net_exit_late,
5320 };
5321
5322 static struct notifier_block ip6_route_dev_notifier = {
5323 .notifier_call = ip6_route_dev_notify,
5324 .priority = ADDRCONF_NOTIFY_PRIORITY - 10,
5325 };
5326
5327 void __init ip6_route_init_special_entries(void)
5328 {
5329 /* Registering of the loopback is done before this portion of code,
5330 * the loopback reference in rt6_info will not be taken, do it
5331 * manually for init_net */
5332 init_net.ipv6.fib6_null_entry->fib6_nh.nh_dev = init_net.loopback_dev;
5333 init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
5334 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
5335 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
5336 init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
5337 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
5338 init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
5339 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
5340 #endif
5341 }
5342
5343 int __init ip6_route_init(void)
5344 {
5345 int ret;
5346 int cpu;
5347
5348 ret = -ENOMEM;
5349 ip6_dst_ops_template.kmem_cachep =
5350 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
5351 SLAB_HWCACHE_ALIGN, NULL);
5352 if (!ip6_dst_ops_template.kmem_cachep)
5353 goto out;
5354
5355 ret = dst_entries_init(&ip6_dst_blackhole_ops);
5356 if (ret)
5357 goto out_kmem_cache;
5358
5359 ret = register_pernet_subsys(&ipv6_inetpeer_ops);
5360 if (ret)
5361 goto out_dst_entries;
5362
5363 ret = register_pernet_subsys(&ip6_route_net_ops);
5364 if (ret)
5365 goto out_register_inetpeer;
5366
5367 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
5368
5369 ret = fib6_init();
5370 if (ret)
5371 goto out_register_subsys;
5372
5373 ret = xfrm6_init();
5374 if (ret)
5375 goto out_fib6_init;
5376
5377 ret = fib6_rules_init();
5378 if (ret)
5379 goto xfrm6_init;
5380
5381 ret = register_pernet_subsys(&ip6_route_net_late_ops);
5382 if (ret)
5383 goto fib6_rules_init;
5384
5385 ret = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_NEWROUTE,
5386 inet6_rtm_newroute, NULL, 0);
5387 if (ret < 0)
5388 goto out_register_late_subsys;
5389
5390 ret = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_DELROUTE,
5391 inet6_rtm_delroute, NULL, 0);
5392 if (ret < 0)
5393 goto out_register_late_subsys;
5394
5395 ret = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETROUTE,
5396 inet6_rtm_getroute, NULL,
5397 RTNL_FLAG_DOIT_UNLOCKED);
5398 if (ret < 0)
5399 goto out_register_late_subsys;
5400
5401 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
5402 if (ret)
5403 goto out_register_late_subsys;
5404
5405 for_each_possible_cpu(cpu) {
5406 struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
5407
5408 INIT_LIST_HEAD(&ul->head);
5409 spin_lock_init(&ul->lock);
5410 }
5411
5412 out:
5413 return ret;
5414
5415 out_register_late_subsys:
5416 rtnl_unregister_all(PF_INET6);
5417 unregister_pernet_subsys(&ip6_route_net_late_ops);
5418 fib6_rules_init:
5419 fib6_rules_cleanup();
5420 xfrm6_init:
5421 xfrm6_fini();
5422 out_fib6_init:
5423 fib6_gc_cleanup();
5424 out_register_subsys:
5425 unregister_pernet_subsys(&ip6_route_net_ops);
5426 out_register_inetpeer:
5427 unregister_pernet_subsys(&ipv6_inetpeer_ops);
5428 out_dst_entries:
5429 dst_entries_destroy(&ip6_dst_blackhole_ops);
5430 out_kmem_cache:
5431 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
5432 goto out;
5433 }
5434
5435 void ip6_route_cleanup(void)
5436 {
5437 unregister_netdevice_notifier(&ip6_route_dev_notifier);
5438 unregister_pernet_subsys(&ip6_route_net_late_ops);
5439 fib6_rules_cleanup();
5440 xfrm6_fini();
5441 fib6_gc_cleanup();
5442 unregister_pernet_subsys(&ipv6_inetpeer_ops);
5443 unregister_pernet_subsys(&ip6_route_net_ops);
5444 dst_entries_destroy(&ip6_dst_blackhole_ops);
5445 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
5446 }
Linux with added FPC-III support