?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
staging: unisys: visorbus: vbuschannel.h remove unused pound defines
[linux-2.6/btrfs-unstable.git] / net / ipv6 / route.c
blob947ed1ded026388ed626122df3df11bc0922f6e7
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 <net/net_namespace.h>
48 #include <net/snmp.h>
49 #include <net/ipv6.h>
50 #include <net/ip6_fib.h>
51 #include <net/ip6_route.h>
52 #include <net/ndisc.h>
53 #include <net/addrconf.h>
54 #include <net/tcp.h>
55 #include <linux/rtnetlink.h>
56 #include <net/dst.h>
57 #include <net/dst_metadata.h>
58 #include <net/xfrm.h>
59 #include <net/netevent.h>
60 #include <net/netlink.h>
61 #include <net/nexthop.h>
62 #include <net/lwtunnel.h>
63 #include <net/ip_tunnels.h>
64 #include <net/l3mdev.h>
65 #include <trace/events/fib6.h>
66
67 #include <asm/uaccess.h>
68
69 #ifdef CONFIG_SYSCTL
70 #include <linux/sysctl.h>
71 #endif
72
73 enum rt6_nud_state {
74 RT6_NUD_FAIL_HARD = -3,
75 RT6_NUD_FAIL_PROBE = -2,
76 RT6_NUD_FAIL_DO_RR = -1,
77 RT6_NUD_SUCCEED = 1
78 };
79
80 static void ip6_rt_copy_init(struct rt6_info *rt, struct rt6_info *ort);
81 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
82 static unsigned int ip6_default_advmss(const struct dst_entry *dst);
83 static unsigned int ip6_mtu(const struct dst_entry *dst);
84 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
85 static void ip6_dst_destroy(struct dst_entry *);
86 static void ip6_dst_ifdown(struct dst_entry *,
87 struct net_device *dev, int how);
88 static int ip6_dst_gc(struct dst_ops *ops);
89
90 static int ip6_pkt_discard(struct sk_buff *skb);
91 static int ip6_pkt_discard_out(struct net *net, struct sock *sk, struct sk_buff *skb);
92 static int ip6_pkt_prohibit(struct sk_buff *skb);
93 static int ip6_pkt_prohibit_out(struct net *net, struct sock *sk, struct sk_buff *skb);
94 static void ip6_link_failure(struct sk_buff *skb);
95 static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
96 struct sk_buff *skb, u32 mtu);
97 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk,
98 struct sk_buff *skb);
99 static void rt6_dst_from_metrics_check(struct rt6_info *rt);
100 static int rt6_score_route(struct rt6_info *rt, int oif, int strict);
101
102 #ifdef CONFIG_IPV6_ROUTE_INFO
103 static struct rt6_info *rt6_add_route_info(struct net *net,
104 const struct in6_addr *prefix, int prefixlen,
105 const struct in6_addr *gwaddr,
106 struct net_device *dev,
107 unsigned int pref);
108 static struct rt6_info *rt6_get_route_info(struct net *net,
109 const struct in6_addr *prefix, int prefixlen,
110 const struct in6_addr *gwaddr,
111 struct net_device *dev);
112 #endif
113
114 struct uncached_list {
115 spinlock_t lock;
116 struct list_head head;
117 };
118
119 static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt6_uncached_list);
120
121 static void rt6_uncached_list_add(struct rt6_info *rt)
122 {
123 struct uncached_list *ul = raw_cpu_ptr(&rt6_uncached_list);
124
125 rt->dst.flags |= DST_NOCACHE;
126 rt->rt6i_uncached_list = ul;
127
128 spin_lock_bh(&ul->lock);
129 list_add_tail(&rt->rt6i_uncached, &ul->head);
130 spin_unlock_bh(&ul->lock);
131 }
132
133 static void rt6_uncached_list_del(struct rt6_info *rt)
134 {
135 if (!list_empty(&rt->rt6i_uncached)) {
136 struct uncached_list *ul = rt->rt6i_uncached_list;
137
138 spin_lock_bh(&ul->lock);
139 list_del(&rt->rt6i_uncached);
140 spin_unlock_bh(&ul->lock);
141 }
142 }
143
144 static void rt6_uncached_list_flush_dev(struct net *net, struct net_device *dev)
145 {
146 struct net_device *loopback_dev = net->loopback_dev;
147 int cpu;
148
149 if (dev == loopback_dev)
150 return;
151
152 for_each_possible_cpu(cpu) {
153 struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
154 struct rt6_info *rt;
155
156 spin_lock_bh(&ul->lock);
157 list_for_each_entry(rt, &ul->head, rt6i_uncached) {
158 struct inet6_dev *rt_idev = rt->rt6i_idev;
159 struct net_device *rt_dev = rt->dst.dev;
160
161 if (rt_idev->dev == dev) {
162 rt->rt6i_idev = in6_dev_get(loopback_dev);
163 in6_dev_put(rt_idev);
164 }
165
166 if (rt_dev == dev) {
167 rt->dst.dev = loopback_dev;
168 dev_hold(rt->dst.dev);
169 dev_put(rt_dev);
170 }
171 }
172 spin_unlock_bh(&ul->lock);
173 }
174 }
175
176 static u32 *rt6_pcpu_cow_metrics(struct rt6_info *rt)
177 {
178 return dst_metrics_write_ptr(rt->dst.from);
179 }
180
181 static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)
182 {
183 struct rt6_info *rt = (struct rt6_info *)dst;
184
185 if (rt->rt6i_flags & RTF_PCPU)
186 return rt6_pcpu_cow_metrics(rt);
187 else if (rt->rt6i_flags & RTF_CACHE)
188 return NULL;
189 else
190 return dst_cow_metrics_generic(dst, old);
191 }
192
193 static inline const void *choose_neigh_daddr(struct rt6_info *rt,
194 struct sk_buff *skb,
195 const void *daddr)
196 {
197 struct in6_addr *p = &rt->rt6i_gateway;
198
199 if (!ipv6_addr_any(p))
200 return (const void *) p;
201 else if (skb)
202 return &ipv6_hdr(skb)->daddr;
203 return daddr;
204 }
205
206 static struct neighbour *ip6_neigh_lookup(const struct dst_entry *dst,
207 struct sk_buff *skb,
208 const void *daddr)
209 {
210 struct rt6_info *rt = (struct rt6_info *) dst;
211 struct neighbour *n;
212
213 daddr = choose_neigh_daddr(rt, skb, daddr);
214 n = __ipv6_neigh_lookup(dst->dev, daddr);
215 if (n)
216 return n;
217 return neigh_create(&nd_tbl, daddr, dst->dev);
218 }
219
220 static struct dst_ops ip6_dst_ops_template = {
221 .family = AF_INET6,
222 .gc = ip6_dst_gc,
223 .gc_thresh = 1024,
224 .check = ip6_dst_check,
225 .default_advmss = ip6_default_advmss,
226 .mtu = ip6_mtu,
227 .cow_metrics = ipv6_cow_metrics,
228 .destroy = ip6_dst_destroy,
229 .ifdown = ip6_dst_ifdown,
230 .negative_advice = ip6_negative_advice,
231 .link_failure = ip6_link_failure,
232 .update_pmtu = ip6_rt_update_pmtu,
233 .redirect = rt6_do_redirect,
234 .local_out = __ip6_local_out,
235 .neigh_lookup = ip6_neigh_lookup,
236 };
237
238 static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)
239 {
240 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
241
242 return mtu ? : dst->dev->mtu;
243 }
244
245 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
246 struct sk_buff *skb, u32 mtu)
247 {
248 }
249
250 static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
251 struct sk_buff *skb)
252 {
253 }
254
255 static struct dst_ops ip6_dst_blackhole_ops = {
256 .family = AF_INET6,
257 .destroy = ip6_dst_destroy,
258 .check = ip6_dst_check,
259 .mtu = ip6_blackhole_mtu,
260 .default_advmss = ip6_default_advmss,
261 .update_pmtu = ip6_rt_blackhole_update_pmtu,
262 .redirect = ip6_rt_blackhole_redirect,
263 .cow_metrics = dst_cow_metrics_generic,
264 .neigh_lookup = ip6_neigh_lookup,
265 };
266
267 static const u32 ip6_template_metrics[RTAX_MAX] = {
268 [RTAX_HOPLIMIT - 1] = 0,
269 };
270
271 static const struct rt6_info ip6_null_entry_template = {
272 .dst = {
273 .__refcnt = ATOMIC_INIT(1),
274 .__use = 1,
275 .obsolete = DST_OBSOLETE_FORCE_CHK,
276 .error = -ENETUNREACH,
277 .input = ip6_pkt_discard,
278 .output = ip6_pkt_discard_out,
279 },
280 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
281 .rt6i_protocol = RTPROT_KERNEL,
282 .rt6i_metric = ~(u32) 0,
283 .rt6i_ref = ATOMIC_INIT(1),
284 };
285
286 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
287
288 static const struct rt6_info ip6_prohibit_entry_template = {
289 .dst = {
290 .__refcnt = ATOMIC_INIT(1),
291 .__use = 1,
292 .obsolete = DST_OBSOLETE_FORCE_CHK,
293 .error = -EACCES,
294 .input = ip6_pkt_prohibit,
295 .output = ip6_pkt_prohibit_out,
296 },
297 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
298 .rt6i_protocol = RTPROT_KERNEL,
299 .rt6i_metric = ~(u32) 0,
300 .rt6i_ref = ATOMIC_INIT(1),
301 };
302
303 static const struct rt6_info ip6_blk_hole_entry_template = {
304 .dst = {
305 .__refcnt = ATOMIC_INIT(1),
306 .__use = 1,
307 .obsolete = DST_OBSOLETE_FORCE_CHK,
308 .error = -EINVAL,
309 .input = dst_discard,
310 .output = dst_discard_out,
311 },
312 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
313 .rt6i_protocol = RTPROT_KERNEL,
314 .rt6i_metric = ~(u32) 0,
315 .rt6i_ref = ATOMIC_INIT(1),
316 };
317
318 #endif
319
320 static void rt6_info_init(struct rt6_info *rt)
321 {
322 struct dst_entry *dst = &rt->dst;
323
324 memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
325 INIT_LIST_HEAD(&rt->rt6i_siblings);
326 INIT_LIST_HEAD(&rt->rt6i_uncached);
327 }
328
329 /* allocate dst with ip6_dst_ops */
330 static struct rt6_info *__ip6_dst_alloc(struct net *net,
331 struct net_device *dev,
332 int flags)
333 {
334 struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
335 0, DST_OBSOLETE_FORCE_CHK, flags);
336
337 if (rt)
338 rt6_info_init(rt);
339
340 return rt;
341 }
342
343 struct rt6_info *ip6_dst_alloc(struct net *net,
344 struct net_device *dev,
345 int flags)
346 {
347 struct rt6_info *rt = __ip6_dst_alloc(net, dev, flags);
348
349 if (rt) {
350 rt->rt6i_pcpu = alloc_percpu_gfp(struct rt6_info *, GFP_ATOMIC);
351 if (rt->rt6i_pcpu) {
352 int cpu;
353
354 for_each_possible_cpu(cpu) {
355 struct rt6_info **p;
356
357 p = per_cpu_ptr(rt->rt6i_pcpu, cpu);
358 /* no one shares rt */
359 *p = NULL;
360 }
361 } else {
362 dst_destroy((struct dst_entry *)rt);
363 return NULL;
364 }
365 }
366
367 return rt;
368 }
369 EXPORT_SYMBOL(ip6_dst_alloc);
370
371 static void ip6_dst_destroy(struct dst_entry *dst)
372 {
373 struct rt6_info *rt = (struct rt6_info *)dst;
374 struct dst_entry *from = dst->from;
375 struct inet6_dev *idev;
376
377 dst_destroy_metrics_generic(dst);
378 free_percpu(rt->rt6i_pcpu);
379 rt6_uncached_list_del(rt);
380
381 idev = rt->rt6i_idev;
382 if (idev) {
383 rt->rt6i_idev = NULL;
384 in6_dev_put(idev);
385 }
386
387 dst->from = NULL;
388 dst_release(from);
389 }
390
391 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
392 int how)
393 {
394 struct rt6_info *rt = (struct rt6_info *)dst;
395 struct inet6_dev *idev = rt->rt6i_idev;
396 struct net_device *loopback_dev =
397 dev_net(dev)->loopback_dev;
398
399 if (dev != loopback_dev) {
400 if (idev && idev->dev == dev) {
401 struct inet6_dev *loopback_idev =
402 in6_dev_get(loopback_dev);
403 if (loopback_idev) {
404 rt->rt6i_idev = loopback_idev;
405 in6_dev_put(idev);
406 }
407 }
408 }
409 }
410
411 static bool __rt6_check_expired(const struct rt6_info *rt)
412 {
413 if (rt->rt6i_flags & RTF_EXPIRES)
414 return time_after(jiffies, rt->dst.expires);
415 else
416 return false;
417 }
418
419 static bool rt6_check_expired(const struct rt6_info *rt)
420 {
421 if (rt->rt6i_flags & RTF_EXPIRES) {
422 if (time_after(jiffies, rt->dst.expires))
423 return true;
424 } else if (rt->dst.from) {
425 return rt6_check_expired((struct rt6_info *) rt->dst.from);
426 }
427 return false;
428 }
429
430 /* Multipath route selection:
431 * Hash based function using packet header and flowlabel.
432 * Adapted from fib_info_hashfn()
433 */
434 static int rt6_info_hash_nhsfn(unsigned int candidate_count,
435 const struct flowi6 *fl6)
436 {
437 return get_hash_from_flowi6(fl6) % candidate_count;
438 }
439
440 static struct rt6_info *rt6_multipath_select(struct rt6_info *match,
441 struct flowi6 *fl6, int oif,
442 int strict)
443 {
444 struct rt6_info *sibling, *next_sibling;
445 int route_choosen;
446
447 route_choosen = rt6_info_hash_nhsfn(match->rt6i_nsiblings + 1, fl6);
448 /* Don't change the route, if route_choosen == 0
449 * (siblings does not include ourself)
450 */
451 if (route_choosen)
452 list_for_each_entry_safe(sibling, next_sibling,
453 &match->rt6i_siblings, rt6i_siblings) {
454 route_choosen--;
455 if (route_choosen == 0) {
456 if (rt6_score_route(sibling, oif, strict) < 0)
457 break;
458 match = sibling;
459 break;
460 }
461 }
462 return match;
463 }
464
465 /*
466 * Route lookup. Any table->tb6_lock is implied.
467 */
468
469 static inline struct rt6_info *rt6_device_match(struct net *net,
470 struct rt6_info *rt,
471 const struct in6_addr *saddr,
472 int oif,
473 int flags)
474 {
475 struct rt6_info *local = NULL;
476 struct rt6_info *sprt;
477
478 if (!oif && ipv6_addr_any(saddr))
479 goto out;
480
481 for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
482 struct net_device *dev = sprt->dst.dev;
483
484 if (oif) {
485 if (dev->ifindex == oif)
486 return sprt;
487 if (dev->flags & IFF_LOOPBACK) {
488 if (!sprt->rt6i_idev ||
489 sprt->rt6i_idev->dev->ifindex != oif) {
490 if (flags & RT6_LOOKUP_F_IFACE)
491 continue;
492 if (local &&
493 local->rt6i_idev->dev->ifindex == oif)
494 continue;
495 }
496 local = sprt;
497 }
498 } else {
499 if (ipv6_chk_addr(net, saddr, dev,
500 flags & RT6_LOOKUP_F_IFACE))
501 return sprt;
502 }
503 }
504
505 if (oif) {
506 if (local)
507 return local;
508
509 if (flags & RT6_LOOKUP_F_IFACE)
510 return net->ipv6.ip6_null_entry;
511 }
512 out:
513 return rt;
514 }
515
516 #ifdef CONFIG_IPV6_ROUTER_PREF
517 struct __rt6_probe_work {
518 struct work_struct work;
519 struct in6_addr target;
520 struct net_device *dev;
521 };
522
523 static void rt6_probe_deferred(struct work_struct *w)
524 {
525 struct in6_addr mcaddr;
526 struct __rt6_probe_work *work =
527 container_of(w, struct __rt6_probe_work, work);
528
529 addrconf_addr_solict_mult(&work->target, &mcaddr);
530 ndisc_send_ns(work->dev, &work->target, &mcaddr, NULL);
531 dev_put(work->dev);
532 kfree(work);
533 }
534
535 static void rt6_probe(struct rt6_info *rt)
536 {
537 struct __rt6_probe_work *work;
538 struct neighbour *neigh;
539 /*
540 * Okay, this does not seem to be appropriate
541 * for now, however, we need to check if it
542 * is really so; aka Router Reachability Probing.
543 *
544 * Router Reachability Probe MUST be rate-limited
545 * to no more than one per minute.
546 */
547 if (!rt || !(rt->rt6i_flags & RTF_GATEWAY))
548 return;
549 rcu_read_lock_bh();
550 neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
551 if (neigh) {
552 if (neigh->nud_state & NUD_VALID)
553 goto out;
554
555 work = NULL;
556 write_lock(&neigh->lock);
557 if (!(neigh->nud_state & NUD_VALID) &&
558 time_after(jiffies,
559 neigh->updated +
560 rt->rt6i_idev->cnf.rtr_probe_interval)) {
561 work = kmalloc(sizeof(*work), GFP_ATOMIC);
562 if (work)
563 __neigh_set_probe_once(neigh);
564 }
565 write_unlock(&neigh->lock);
566 } else {
567 work = kmalloc(sizeof(*work), GFP_ATOMIC);
568 }
569
570 if (work) {
571 INIT_WORK(&work->work, rt6_probe_deferred);
572 work->target = rt->rt6i_gateway;
573 dev_hold(rt->dst.dev);
574 work->dev = rt->dst.dev;
575 schedule_work(&work->work);
576 }
577
578 out:
579 rcu_read_unlock_bh();
580 }
581 #else
582 static inline void rt6_probe(struct rt6_info *rt)
583 {
584 }
585 #endif
586
587 /*
588 * Default Router Selection (RFC 2461 6.3.6)
589 */
590 static inline int rt6_check_dev(struct rt6_info *rt, int oif)
591 {
592 struct net_device *dev = rt->dst.dev;
593 if (!oif || dev->ifindex == oif)
594 return 2;
595 if ((dev->flags & IFF_LOOPBACK) &&
596 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
597 return 1;
598 return 0;
599 }
600
601 static inline enum rt6_nud_state rt6_check_neigh(struct rt6_info *rt)
602 {
603 struct neighbour *neigh;
604 enum rt6_nud_state ret = RT6_NUD_FAIL_HARD;
605
606 if (rt->rt6i_flags & RTF_NONEXTHOP ||
607 !(rt->rt6i_flags & RTF_GATEWAY))
608 return RT6_NUD_SUCCEED;
609
610 rcu_read_lock_bh();
611 neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
612 if (neigh) {
613 read_lock(&neigh->lock);
614 if (neigh->nud_state & NUD_VALID)
615 ret = RT6_NUD_SUCCEED;
616 #ifdef CONFIG_IPV6_ROUTER_PREF
617 else if (!(neigh->nud_state & NUD_FAILED))
618 ret = RT6_NUD_SUCCEED;
619 else
620 ret = RT6_NUD_FAIL_PROBE;
621 #endif
622 read_unlock(&neigh->lock);
623 } else {
624 ret = IS_ENABLED(CONFIG_IPV6_ROUTER_PREF) ?
625 RT6_NUD_SUCCEED : RT6_NUD_FAIL_DO_RR;
626 }
627 rcu_read_unlock_bh();
628
629 return ret;
630 }
631
632 static int rt6_score_route(struct rt6_info *rt, int oif,
633 int strict)
634 {
635 int m;
636
637 m = rt6_check_dev(rt, oif);
638 if (!m && (strict & RT6_LOOKUP_F_IFACE))
639 return RT6_NUD_FAIL_HARD;
640 #ifdef CONFIG_IPV6_ROUTER_PREF
641 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
642 #endif
643 if (strict & RT6_LOOKUP_F_REACHABLE) {
644 int n = rt6_check_neigh(rt);
645 if (n < 0)
646 return n;
647 }
648 return m;
649 }
650
651 static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
652 int *mpri, struct rt6_info *match,
653 bool *do_rr)
654 {
655 int m;
656 bool match_do_rr = false;
657 struct inet6_dev *idev = rt->rt6i_idev;
658 struct net_device *dev = rt->dst.dev;
659
660 if (dev && !netif_carrier_ok(dev) &&
661 idev->cnf.ignore_routes_with_linkdown &&
662 !(strict & RT6_LOOKUP_F_IGNORE_LINKSTATE))
663 goto out;
664
665 if (rt6_check_expired(rt))
666 goto out;
667
668 m = rt6_score_route(rt, oif, strict);
669 if (m == RT6_NUD_FAIL_DO_RR) {
670 match_do_rr = true;
671 m = 0; /* lowest valid score */
672 } else if (m == RT6_NUD_FAIL_HARD) {
673 goto out;
674 }
675
676 if (strict & RT6_LOOKUP_F_REACHABLE)
677 rt6_probe(rt);
678
679 /* note that m can be RT6_NUD_FAIL_PROBE at this point */
680 if (m > *mpri) {
681 *do_rr = match_do_rr;
682 *mpri = m;
683 match = rt;
684 }
685 out:
686 return match;
687 }
688
689 static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
690 struct rt6_info *rr_head,
691 u32 metric, int oif, int strict,
692 bool *do_rr)
693 {
694 struct rt6_info *rt, *match, *cont;
695 int mpri = -1;
696
697 match = NULL;
698 cont = NULL;
699 for (rt = rr_head; rt; rt = rt->dst.rt6_next) {
700 if (rt->rt6i_metric != metric) {
701 cont = rt;
702 break;
703 }
704
705 match = find_match(rt, oif, strict, &mpri, match, do_rr);
706 }
707
708 for (rt = fn->leaf; rt && rt != rr_head; rt = rt->dst.rt6_next) {
709 if (rt->rt6i_metric != metric) {
710 cont = rt;
711 break;
712 }
713
714 match = find_match(rt, oif, strict, &mpri, match, do_rr);
715 }
716
717 if (match || !cont)
718 return match;
719
720 for (rt = cont; rt; rt = rt->dst.rt6_next)
721 match = find_match(rt, oif, strict, &mpri, match, do_rr);
722
723 return match;
724 }
725
726 static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
727 {
728 struct rt6_info *match, *rt0;
729 struct net *net;
730 bool do_rr = false;
731
732 rt0 = fn->rr_ptr;
733 if (!rt0)
734 fn->rr_ptr = rt0 = fn->leaf;
735
736 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict,
737 &do_rr);
738
739 if (do_rr) {
740 struct rt6_info *next = rt0->dst.rt6_next;
741
742 /* no entries matched; do round-robin */
743 if (!next || next->rt6i_metric != rt0->rt6i_metric)
744 next = fn->leaf;
745
746 if (next != rt0)
747 fn->rr_ptr = next;
748 }
749
750 net = dev_net(rt0->dst.dev);
751 return match ? match : net->ipv6.ip6_null_entry;
752 }
753
754 static bool rt6_is_gw_or_nonexthop(const struct rt6_info *rt)
755 {
756 return (rt->rt6i_flags & (RTF_NONEXTHOP | RTF_GATEWAY));
757 }
758
759 #ifdef CONFIG_IPV6_ROUTE_INFO
760 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
761 const struct in6_addr *gwaddr)
762 {
763 struct net *net = dev_net(dev);
764 struct route_info *rinfo = (struct route_info *) opt;
765 struct in6_addr prefix_buf, *prefix;
766 unsigned int pref;
767 unsigned long lifetime;
768 struct rt6_info *rt;
769
770 if (len < sizeof(struct route_info)) {
771 return -EINVAL;
772 }
773
774 /* Sanity check for prefix_len and length */
775 if (rinfo->length > 3) {
776 return -EINVAL;
777 } else if (rinfo->prefix_len > 128) {
778 return -EINVAL;
779 } else if (rinfo->prefix_len > 64) {
780 if (rinfo->length < 2) {
781 return -EINVAL;
782 }
783 } else if (rinfo->prefix_len > 0) {
784 if (rinfo->length < 1) {
785 return -EINVAL;
786 }
787 }
788
789 pref = rinfo->route_pref;
790 if (pref == ICMPV6_ROUTER_PREF_INVALID)
791 return -EINVAL;
792
793 lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
794
795 if (rinfo->length == 3)
796 prefix = (struct in6_addr *)rinfo->prefix;
797 else {
798 /* this function is safe */
799 ipv6_addr_prefix(&prefix_buf,
800 (struct in6_addr *)rinfo->prefix,
801 rinfo->prefix_len);
802 prefix = &prefix_buf;
803 }
804
805 if (rinfo->prefix_len == 0)
806 rt = rt6_get_dflt_router(gwaddr, dev);
807 else
808 rt = rt6_get_route_info(net, prefix, rinfo->prefix_len,
809 gwaddr, dev);
810
811 if (rt && !lifetime) {
812 ip6_del_rt(rt);
813 rt = NULL;
814 }
815
816 if (!rt && lifetime)
817 rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr,
818 dev, pref);
819 else if (rt)
820 rt->rt6i_flags = RTF_ROUTEINFO |
821 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
822
823 if (rt) {
824 if (!addrconf_finite_timeout(lifetime))
825 rt6_clean_expires(rt);
826 else
827 rt6_set_expires(rt, jiffies + HZ * lifetime);
828
829 ip6_rt_put(rt);
830 }
831 return 0;
832 }
833 #endif
834
835 static struct fib6_node* fib6_backtrack(struct fib6_node *fn,
836 struct in6_addr *saddr)
837 {
838 struct fib6_node *pn;
839 while (1) {
840 if (fn->fn_flags & RTN_TL_ROOT)
841 return NULL;
842 pn = fn->parent;
843 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn)
844 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr);
845 else
846 fn = pn;
847 if (fn->fn_flags & RTN_RTINFO)
848 return fn;
849 }
850 }
851
852 static struct rt6_info *ip6_pol_route_lookup(struct net *net,
853 struct fib6_table *table,
854 struct flowi6 *fl6, int flags)
855 {
856 struct fib6_node *fn;
857 struct rt6_info *rt;
858
859 read_lock_bh(&table->tb6_lock);
860 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
861 restart:
862 rt = fn->leaf;
863 rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);
864 if (rt->rt6i_nsiblings && fl6->flowi6_oif == 0)
865 rt = rt6_multipath_select(rt, fl6, fl6->flowi6_oif, flags);
866 if (rt == net->ipv6.ip6_null_entry) {
867 fn = fib6_backtrack(fn, &fl6->saddr);
868 if (fn)
869 goto restart;
870 }
871 dst_use(&rt->dst, jiffies);
872 read_unlock_bh(&table->tb6_lock);
873
874 trace_fib6_table_lookup(net, rt, table->tb6_id, fl6);
875
876 return rt;
877
878 }
879
880 struct dst_entry *ip6_route_lookup(struct net *net, struct flowi6 *fl6,
881 int flags)
882 {
883 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_lookup);
884 }
885 EXPORT_SYMBOL_GPL(ip6_route_lookup);
886
887 struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
888 const struct in6_addr *saddr, int oif, int strict)
889 {
890 struct flowi6 fl6 = {
891 .flowi6_oif = oif,
892 .daddr = *daddr,
893 };
894 struct dst_entry *dst;
895 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
896
897 if (saddr) {
898 memcpy(&fl6.saddr, saddr, sizeof(*saddr));
899 flags |= RT6_LOOKUP_F_HAS_SADDR;
900 }
901
902 dst = fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_lookup);
903 if (dst->error == 0)
904 return (struct rt6_info *) dst;
905
906 dst_release(dst);
907
908 return NULL;
909 }
910 EXPORT_SYMBOL(rt6_lookup);
911
912 /* ip6_ins_rt is called with FREE table->tb6_lock.
913 It takes new route entry, the addition fails by any reason the
914 route is freed. In any case, if caller does not hold it, it may
915 be destroyed.
916 */
917
918 static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info,
919 struct mx6_config *mxc)
920 {
921 int err;
922 struct fib6_table *table;
923
924 table = rt->rt6i_table;
925 write_lock_bh(&table->tb6_lock);
926 err = fib6_add(&table->tb6_root, rt, info, mxc);
927 write_unlock_bh(&table->tb6_lock);
928
929 return err;
930 }
931
932 int ip6_ins_rt(struct rt6_info *rt)
933 {
934 struct nl_info info = { .nl_net = dev_net(rt->dst.dev), };
935 struct mx6_config mxc = { .mx = NULL, };
936
937 return __ip6_ins_rt(rt, &info, &mxc);
938 }
939
940 static struct rt6_info *ip6_rt_cache_alloc(struct rt6_info *ort,
941 const struct in6_addr *daddr,
942 const struct in6_addr *saddr)
943 {
944 struct rt6_info *rt;
945
946 /*
947 * Clone the route.
948 */
949
950 if (ort->rt6i_flags & (RTF_CACHE | RTF_PCPU))
951 ort = (struct rt6_info *)ort->dst.from;
952
953 rt = __ip6_dst_alloc(dev_net(ort->dst.dev), ort->dst.dev, 0);
954
955 if (!rt)
956 return NULL;
957
958 ip6_rt_copy_init(rt, ort);
959 rt->rt6i_flags |= RTF_CACHE;
960 rt->rt6i_metric = 0;
961 rt->dst.flags |= DST_HOST;
962 rt->rt6i_dst.addr = *daddr;
963 rt->rt6i_dst.plen = 128;
964
965 if (!rt6_is_gw_or_nonexthop(ort)) {
966 if (ort->rt6i_dst.plen != 128 &&
967 ipv6_addr_equal(&ort->rt6i_dst.addr, daddr))
968 rt->rt6i_flags |= RTF_ANYCAST;
969 #ifdef CONFIG_IPV6_SUBTREES
970 if (rt->rt6i_src.plen && saddr) {
971 rt->rt6i_src.addr = *saddr;
972 rt->rt6i_src.plen = 128;
973 }
974 #endif
975 }
976
977 return rt;
978 }
979
980 static struct rt6_info *ip6_rt_pcpu_alloc(struct rt6_info *rt)
981 {
982 struct rt6_info *pcpu_rt;
983
984 pcpu_rt = __ip6_dst_alloc(dev_net(rt->dst.dev),
985 rt->dst.dev, rt->dst.flags);
986
987 if (!pcpu_rt)
988 return NULL;
989 ip6_rt_copy_init(pcpu_rt, rt);
990 pcpu_rt->rt6i_protocol = rt->rt6i_protocol;
991 pcpu_rt->rt6i_flags |= RTF_PCPU;
992 return pcpu_rt;
993 }
994
995 /* It should be called with read_lock_bh(&tb6_lock) acquired */
996 static struct rt6_info *rt6_get_pcpu_route(struct rt6_info *rt)
997 {
998 struct rt6_info *pcpu_rt, **p;
999
1000 p = this_cpu_ptr(rt->rt6i_pcpu);
1001 pcpu_rt = *p;
1002
1003 if (pcpu_rt) {
1004 dst_hold(&pcpu_rt->dst);
1005 rt6_dst_from_metrics_check(pcpu_rt);
1006 }
1007 return pcpu_rt;
1008 }
1009
1010 static struct rt6_info *rt6_make_pcpu_route(struct rt6_info *rt)
1011 {
1012 struct fib6_table *table = rt->rt6i_table;
1013 struct rt6_info *pcpu_rt, *prev, **p;
1014
1015 pcpu_rt = ip6_rt_pcpu_alloc(rt);
1016 if (!pcpu_rt) {
1017 struct net *net = dev_net(rt->dst.dev);
1018
1019 dst_hold(&net->ipv6.ip6_null_entry->dst);
1020 return net->ipv6.ip6_null_entry;
1021 }
1022
1023 read_lock_bh(&table->tb6_lock);
1024 if (rt->rt6i_pcpu) {
1025 p = this_cpu_ptr(rt->rt6i_pcpu);
1026 prev = cmpxchg(p, NULL, pcpu_rt);
1027 if (prev) {
1028 /* If someone did it before us, return prev instead */
1029 dst_destroy(&pcpu_rt->dst);
1030 pcpu_rt = prev;
1031 }
1032 } else {
1033 /* rt has been removed from the fib6 tree
1034 * before we have a chance to acquire the read_lock.
1035 * In this case, don't brother to create a pcpu rt
1036 * since rt is going away anyway. The next
1037 * dst_check() will trigger a re-lookup.
1038 */
1039 dst_destroy(&pcpu_rt->dst);
1040 pcpu_rt = rt;
1041 }
1042 dst_hold(&pcpu_rt->dst);
1043 rt6_dst_from_metrics_check(pcpu_rt);
1044 read_unlock_bh(&table->tb6_lock);
1045 return pcpu_rt;
1046 }
1047
1048 struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table,
1049 int oif, struct flowi6 *fl6, int flags)
1050 {
1051 struct fib6_node *fn, *saved_fn;
1052 struct rt6_info *rt;
1053 int strict = 0;
1054
1055 strict |= flags & RT6_LOOKUP_F_IFACE;
1056 strict |= flags & RT6_LOOKUP_F_IGNORE_LINKSTATE;
1057 if (net->ipv6.devconf_all->forwarding == 0)
1058 strict |= RT6_LOOKUP_F_REACHABLE;
1059
1060 read_lock_bh(&table->tb6_lock);
1061
1062 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1063 saved_fn = fn;
1064
1065 if (fl6->flowi6_flags & FLOWI_FLAG_SKIP_NH_OIF)
1066 oif = 0;
1067
1068 redo_rt6_select:
1069 rt = rt6_select(fn, oif, strict);
1070 if (rt->rt6i_nsiblings)
1071 rt = rt6_multipath_select(rt, fl6, oif, strict);
1072 if (rt == net->ipv6.ip6_null_entry) {
1073 fn = fib6_backtrack(fn, &fl6->saddr);
1074 if (fn)
1075 goto redo_rt6_select;
1076 else if (strict & RT6_LOOKUP_F_REACHABLE) {
1077 /* also consider unreachable route */
1078 strict &= ~RT6_LOOKUP_F_REACHABLE;
1079 fn = saved_fn;
1080 goto redo_rt6_select;
1081 }
1082 }
1083
1084
1085 if (rt == net->ipv6.ip6_null_entry || (rt->rt6i_flags & RTF_CACHE)) {
1086 dst_use(&rt->dst, jiffies);
1087 read_unlock_bh(&table->tb6_lock);
1088
1089 rt6_dst_from_metrics_check(rt);
1090
1091 trace_fib6_table_lookup(net, rt, table->tb6_id, fl6);
1092 return rt;
1093 } else if (unlikely((fl6->flowi6_flags & FLOWI_FLAG_KNOWN_NH) &&
1094 !(rt->rt6i_flags & RTF_GATEWAY))) {
1095 /* Create a RTF_CACHE clone which will not be
1096 * owned by the fib6 tree. It is for the special case where
1097 * the daddr in the skb during the neighbor look-up is different
1098 * from the fl6->daddr used to look-up route here.
1099 */
1100
1101 struct rt6_info *uncached_rt;
1102
1103 dst_use(&rt->dst, jiffies);
1104 read_unlock_bh(&table->tb6_lock);
1105
1106 uncached_rt = ip6_rt_cache_alloc(rt, &fl6->daddr, NULL);
1107 dst_release(&rt->dst);
1108
1109 if (uncached_rt)
1110 rt6_uncached_list_add(uncached_rt);
1111 else
1112 uncached_rt = net->ipv6.ip6_null_entry;
1113
1114 dst_hold(&uncached_rt->dst);
1115
1116 trace_fib6_table_lookup(net, uncached_rt, table->tb6_id, fl6);
1117 return uncached_rt;
1118
1119 } else {
1120 /* Get a percpu copy */
1121
1122 struct rt6_info *pcpu_rt;
1123
1124 rt->dst.lastuse = jiffies;
1125 rt->dst.__use++;
1126 pcpu_rt = rt6_get_pcpu_route(rt);
1127
1128 if (pcpu_rt) {
1129 read_unlock_bh(&table->tb6_lock);
1130 } else {
1131 /* We have to do the read_unlock first
1132 * because rt6_make_pcpu_route() may trigger
1133 * ip6_dst_gc() which will take the write_lock.
1134 */
1135 dst_hold(&rt->dst);
1136 read_unlock_bh(&table->tb6_lock);
1137 pcpu_rt = rt6_make_pcpu_route(rt);
1138 dst_release(&rt->dst);
1139 }
1140
1141 trace_fib6_table_lookup(net, pcpu_rt, table->tb6_id, fl6);
1142 return pcpu_rt;
1143
1144 }
1145 }
1146 EXPORT_SYMBOL_GPL(ip6_pol_route);
1147
1148 static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
1149 struct flowi6 *fl6, int flags)
1150 {
1151 return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);
1152 }
1153
1154 struct dst_entry *ip6_route_input_lookup(struct net *net,
1155 struct net_device *dev,
1156 struct flowi6 *fl6, int flags)
1157 {
1158 if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
1159 flags |= RT6_LOOKUP_F_IFACE;
1160
1161 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);
1162 }
1163 EXPORT_SYMBOL_GPL(ip6_route_input_lookup);
1164
1165 void ip6_route_input(struct sk_buff *skb)
1166 {
1167 const struct ipv6hdr *iph = ipv6_hdr(skb);
1168 struct net *net = dev_net(skb->dev);
1169 int flags = RT6_LOOKUP_F_HAS_SADDR;
1170 struct ip_tunnel_info *tun_info;
1171 struct flowi6 fl6 = {
1172 .flowi6_iif = skb->dev->ifindex,
1173 .daddr = iph->daddr,
1174 .saddr = iph->saddr,
1175 .flowlabel = ip6_flowinfo(iph),
1176 .flowi6_mark = skb->mark,
1177 .flowi6_proto = iph->nexthdr,
1178 };
1179
1180 tun_info = skb_tunnel_info(skb);
1181 if (tun_info && !(tun_info->mode & IP_TUNNEL_INFO_TX))
1182 fl6.flowi6_tun_key.tun_id = tun_info->key.tun_id;
1183 skb_dst_drop(skb);
1184 skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));
1185 }
1186
1187 static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
1188 struct flowi6 *fl6, int flags)
1189 {
1190 return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);
1191 }
1192
1193 struct dst_entry *ip6_route_output_flags(struct net *net, const struct sock *sk,
1194 struct flowi6 *fl6, int flags)
1195 {
1196 bool any_src;
1197
1198 if (rt6_need_strict(&fl6->daddr)) {
1199 struct dst_entry *dst;
1200
1201 dst = l3mdev_link_scope_lookup(net, fl6);
1202 if (dst)
1203 return dst;
1204 }
1205
1206 fl6->flowi6_iif = LOOPBACK_IFINDEX;
1207
1208 any_src = ipv6_addr_any(&fl6->saddr);
1209 if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr) ||
1210 (fl6->flowi6_oif && any_src))
1211 flags |= RT6_LOOKUP_F_IFACE;
1212
1213 if (!any_src)
1214 flags |= RT6_LOOKUP_F_HAS_SADDR;
1215 else if (sk)
1216 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
1217
1218 return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);
1219 }
1220 EXPORT_SYMBOL_GPL(ip6_route_output_flags);
1221
1222 struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)
1223 {
1224 struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;
1225 struct dst_entry *new = NULL;
1226
1227 rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, DST_OBSOLETE_NONE, 0);
1228 if (rt) {
1229 rt6_info_init(rt);
1230
1231 new = &rt->dst;
1232 new->__use = 1;
1233 new->input = dst_discard;
1234 new->output = dst_discard_out;
1235
1236 dst_copy_metrics(new, &ort->dst);
1237 rt->rt6i_idev = ort->rt6i_idev;
1238 if (rt->rt6i_idev)
1239 in6_dev_hold(rt->rt6i_idev);
1240
1241 rt->rt6i_gateway = ort->rt6i_gateway;
1242 rt->rt6i_flags = ort->rt6i_flags & ~RTF_PCPU;
1243 rt->rt6i_metric = 0;
1244
1245 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1246 #ifdef CONFIG_IPV6_SUBTREES
1247 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1248 #endif
1249
1250 dst_free(new);
1251 }
1252
1253 dst_release(dst_orig);
1254 return new ? new : ERR_PTR(-ENOMEM);
1255 }
1256
1257 /*
1258 * Destination cache support functions
1259 */
1260
1261 static void rt6_dst_from_metrics_check(struct rt6_info *rt)
1262 {
1263 if (rt->dst.from &&
1264 dst_metrics_ptr(&rt->dst) != dst_metrics_ptr(rt->dst.from))
1265 dst_init_metrics(&rt->dst, dst_metrics_ptr(rt->dst.from), true);
1266 }
1267
1268 static struct dst_entry *rt6_check(struct rt6_info *rt, u32 cookie)
1269 {
1270 if (!rt->rt6i_node || (rt->rt6i_node->fn_sernum != cookie))
1271 return NULL;
1272
1273 if (rt6_check_expired(rt))
1274 return NULL;
1275
1276 return &rt->dst;
1277 }
1278
1279 static struct dst_entry *rt6_dst_from_check(struct rt6_info *rt, u32 cookie)
1280 {
1281 if (!__rt6_check_expired(rt) &&
1282 rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
1283 rt6_check((struct rt6_info *)(rt->dst.from), cookie))
1284 return &rt->dst;
1285 else
1286 return NULL;
1287 }
1288
1289 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
1290 {
1291 struct rt6_info *rt;
1292
1293 rt = (struct rt6_info *) dst;
1294
1295 /* All IPV6 dsts are created with ->obsolete set to the value
1296 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1297 * into this function always.
1298 */
1299
1300 rt6_dst_from_metrics_check(rt);
1301
1302 if (rt->rt6i_flags & RTF_PCPU ||
1303 (unlikely(dst->flags & DST_NOCACHE) && rt->dst.from))
1304 return rt6_dst_from_check(rt, cookie);
1305 else
1306 return rt6_check(rt, cookie);
1307 }
1308
1309 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
1310 {
1311 struct rt6_info *rt = (struct rt6_info *) dst;
1312
1313 if (rt) {
1314 if (rt->rt6i_flags & RTF_CACHE) {
1315 if (rt6_check_expired(rt)) {
1316 ip6_del_rt(rt);
1317 dst = NULL;
1318 }
1319 } else {
1320 dst_release(dst);
1321 dst = NULL;
1322 }
1323 }
1324 return dst;
1325 }
1326
1327 static void ip6_link_failure(struct sk_buff *skb)
1328 {
1329 struct rt6_info *rt;
1330
1331 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
1332
1333 rt = (struct rt6_info *) skb_dst(skb);
1334 if (rt) {
1335 if (rt->rt6i_flags & RTF_CACHE) {
1336 dst_hold(&rt->dst);
1337 ip6_del_rt(rt);
1338 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT)) {
1339 rt->rt6i_node->fn_sernum = -1;
1340 }
1341 }
1342 }
1343
1344 static void rt6_do_update_pmtu(struct rt6_info *rt, u32 mtu)
1345 {
1346 struct net *net = dev_net(rt->dst.dev);
1347
1348 rt->rt6i_flags |= RTF_MODIFIED;
1349 rt->rt6i_pmtu = mtu;
1350 rt6_update_expires(rt, net->ipv6.sysctl.ip6_rt_mtu_expires);
1351 }
1352
1353 static bool rt6_cache_allowed_for_pmtu(const struct rt6_info *rt)
1354 {
1355 return !(rt->rt6i_flags & RTF_CACHE) &&
1356 (rt->rt6i_flags & RTF_PCPU || rt->rt6i_node);
1357 }
1358
1359 static void __ip6_rt_update_pmtu(struct dst_entry *dst, const struct sock *sk,
1360 const struct ipv6hdr *iph, u32 mtu)
1361 {
1362 struct rt6_info *rt6 = (struct rt6_info *)dst;
1363
1364 if (rt6->rt6i_flags & RTF_LOCAL)
1365 return;
1366
1367 dst_confirm(dst);
1368 mtu = max_t(u32, mtu, IPV6_MIN_MTU);
1369 if (mtu >= dst_mtu(dst))
1370 return;
1371
1372 if (!rt6_cache_allowed_for_pmtu(rt6)) {
1373 rt6_do_update_pmtu(rt6, mtu);
1374 } else {
1375 const struct in6_addr *daddr, *saddr;
1376 struct rt6_info *nrt6;
1377
1378 if (iph) {
1379 daddr = &iph->daddr;
1380 saddr = &iph->saddr;
1381 } else if (sk) {
1382 daddr = &sk->sk_v6_daddr;
1383 saddr = &inet6_sk(sk)->saddr;
1384 } else {
1385 return;
1386 }
1387 nrt6 = ip6_rt_cache_alloc(rt6, daddr, saddr);
1388 if (nrt6) {
1389 rt6_do_update_pmtu(nrt6, mtu);
1390
1391 /* ip6_ins_rt(nrt6) will bump the
1392 * rt6->rt6i_node->fn_sernum
1393 * which will fail the next rt6_check() and
1394 * invalidate the sk->sk_dst_cache.
1395 */
1396 ip6_ins_rt(nrt6);
1397 }
1398 }
1399 }
1400
1401 static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
1402 struct sk_buff *skb, u32 mtu)
1403 {
1404 __ip6_rt_update_pmtu(dst, sk, skb ? ipv6_hdr(skb) : NULL, mtu);
1405 }
1406
1407 void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
1408 int oif, u32 mark)
1409 {
1410 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1411 struct dst_entry *dst;
1412 struct flowi6 fl6;
1413
1414 memset(&fl6, 0, sizeof(fl6));
1415 fl6.flowi6_oif = oif;
1416 fl6.flowi6_mark = mark ? mark : IP6_REPLY_MARK(net, skb->mark);
1417 fl6.daddr = iph->daddr;
1418 fl6.saddr = iph->saddr;
1419 fl6.flowlabel = ip6_flowinfo(iph);
1420
1421 dst = ip6_route_output(net, NULL, &fl6);
1422 if (!dst->error)
1423 __ip6_rt_update_pmtu(dst, NULL, iph, ntohl(mtu));
1424 dst_release(dst);
1425 }
1426 EXPORT_SYMBOL_GPL(ip6_update_pmtu);
1427
1428 void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
1429 {
1430 struct dst_entry *dst;
1431
1432 ip6_update_pmtu(skb, sock_net(sk), mtu,
1433 sk->sk_bound_dev_if, sk->sk_mark);
1434
1435 dst = __sk_dst_get(sk);
1436 if (!dst || !dst->obsolete ||
1437 dst->ops->check(dst, inet6_sk(sk)->dst_cookie))
1438 return;
1439
1440 bh_lock_sock(sk);
1441 if (!sock_owned_by_user(sk) && !ipv6_addr_v4mapped(&sk->sk_v6_daddr))
1442 ip6_datagram_dst_update(sk, false);
1443 bh_unlock_sock(sk);
1444 }
1445 EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
1446
1447 /* Handle redirects */
1448 struct ip6rd_flowi {
1449 struct flowi6 fl6;
1450 struct in6_addr gateway;
1451 };
1452
1453 static struct rt6_info *__ip6_route_redirect(struct net *net,
1454 struct fib6_table *table,
1455 struct flowi6 *fl6,
1456 int flags)
1457 {
1458 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl6;
1459 struct rt6_info *rt;
1460 struct fib6_node *fn;
1461
1462 /* Get the "current" route for this destination and
1463 * check if the redirect has come from approriate router.
1464 *
1465 * RFC 4861 specifies that redirects should only be
1466 * accepted if they come from the nexthop to the target.
1467 * Due to the way the routes are chosen, this notion
1468 * is a bit fuzzy and one might need to check all possible
1469 * routes.
1470 */
1471
1472 read_lock_bh(&table->tb6_lock);
1473 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1474 restart:
1475 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1476 if (rt6_check_expired(rt))
1477 continue;
1478 if (rt->dst.error)
1479 break;
1480 if (!(rt->rt6i_flags & RTF_GATEWAY))
1481 continue;
1482 if (fl6->flowi6_oif != rt->dst.dev->ifindex)
1483 continue;
1484 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1485 continue;
1486 break;
1487 }
1488
1489 if (!rt)
1490 rt = net->ipv6.ip6_null_entry;
1491 else if (rt->dst.error) {
1492 rt = net->ipv6.ip6_null_entry;
1493 goto out;
1494 }
1495
1496 if (rt == net->ipv6.ip6_null_entry) {
1497 fn = fib6_backtrack(fn, &fl6->saddr);
1498 if (fn)
1499 goto restart;
1500 }
1501
1502 out:
1503 dst_hold(&rt->dst);
1504
1505 read_unlock_bh(&table->tb6_lock);
1506
1507 trace_fib6_table_lookup(net, rt, table->tb6_id, fl6);
1508 return rt;
1509 };
1510
1511 static struct dst_entry *ip6_route_redirect(struct net *net,
1512 const struct flowi6 *fl6,
1513 const struct in6_addr *gateway)
1514 {
1515 int flags = RT6_LOOKUP_F_HAS_SADDR;
1516 struct ip6rd_flowi rdfl;
1517
1518 rdfl.fl6 = *fl6;
1519 rdfl.gateway = *gateway;
1520
1521 return fib6_rule_lookup(net, &rdfl.fl6,
1522 flags, __ip6_route_redirect);
1523 }
1524
1525 void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark)
1526 {
1527 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1528 struct dst_entry *dst;
1529 struct flowi6 fl6;
1530
1531 memset(&fl6, 0, sizeof(fl6));
1532 fl6.flowi6_iif = LOOPBACK_IFINDEX;
1533 fl6.flowi6_oif = oif;
1534 fl6.flowi6_mark = mark;
1535 fl6.daddr = iph->daddr;
1536 fl6.saddr = iph->saddr;
1537 fl6.flowlabel = ip6_flowinfo(iph);
1538
1539 dst = ip6_route_redirect(net, &fl6, &ipv6_hdr(skb)->saddr);
1540 rt6_do_redirect(dst, NULL, skb);
1541 dst_release(dst);
1542 }
1543 EXPORT_SYMBOL_GPL(ip6_redirect);
1544
1545 void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif,
1546 u32 mark)
1547 {
1548 const struct ipv6hdr *iph = ipv6_hdr(skb);
1549 const struct rd_msg *msg = (struct rd_msg *)icmp6_hdr(skb);
1550 struct dst_entry *dst;
1551 struct flowi6 fl6;
1552
1553 memset(&fl6, 0, sizeof(fl6));
1554 fl6.flowi6_iif = LOOPBACK_IFINDEX;
1555 fl6.flowi6_oif = oif;
1556 fl6.flowi6_mark = mark;
1557 fl6.daddr = msg->dest;
1558 fl6.saddr = iph->daddr;
1559
1560 dst = ip6_route_redirect(net, &fl6, &iph->saddr);
1561 rt6_do_redirect(dst, NULL, skb);
1562 dst_release(dst);
1563 }
1564
1565 void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
1566 {
1567 ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);
1568 }
1569 EXPORT_SYMBOL_GPL(ip6_sk_redirect);
1570
1571 static unsigned int ip6_default_advmss(const struct dst_entry *dst)
1572 {
1573 struct net_device *dev = dst->dev;
1574 unsigned int mtu = dst_mtu(dst);
1575 struct net *net = dev_net(dev);
1576
1577 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
1578
1579 if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
1580 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
1581
1582 /*
1583 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1584 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1585 * IPV6_MAXPLEN is also valid and means: "any MSS,
1586 * rely only on pmtu discovery"
1587 */
1588 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
1589 mtu = IPV6_MAXPLEN;
1590 return mtu;
1591 }
1592
1593 static unsigned int ip6_mtu(const struct dst_entry *dst)
1594 {
1595 const struct rt6_info *rt = (const struct rt6_info *)dst;
1596 unsigned int mtu = rt->rt6i_pmtu;
1597 struct inet6_dev *idev;
1598
1599 if (mtu)
1600 goto out;
1601
1602 mtu = dst_metric_raw(dst, RTAX_MTU);
1603 if (mtu)
1604 goto out;
1605
1606 mtu = IPV6_MIN_MTU;
1607
1608 rcu_read_lock();
1609 idev = __in6_dev_get(dst->dev);
1610 if (idev)
1611 mtu = idev->cnf.mtu6;
1612 rcu_read_unlock();
1613
1614 out:
1615 mtu = min_t(unsigned int, mtu, IP6_MAX_MTU);
1616
1617 return mtu - lwtunnel_headroom(dst->lwtstate, mtu);
1618 }
1619
1620 static struct dst_entry *icmp6_dst_gc_list;
1621 static DEFINE_SPINLOCK(icmp6_dst_lock);
1622
1623 struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
1624 struct flowi6 *fl6)
1625 {
1626 struct dst_entry *dst;
1627 struct rt6_info *rt;
1628 struct inet6_dev *idev = in6_dev_get(dev);
1629 struct net *net = dev_net(dev);
1630
1631 if (unlikely(!idev))
1632 return ERR_PTR(-ENODEV);
1633
1634 rt = ip6_dst_alloc(net, dev, 0);
1635 if (unlikely(!rt)) {
1636 in6_dev_put(idev);
1637 dst = ERR_PTR(-ENOMEM);
1638 goto out;
1639 }
1640
1641 rt->dst.flags |= DST_HOST;
1642 rt->dst.output = ip6_output;
1643 atomic_set(&rt->dst.__refcnt, 1);
1644 rt->rt6i_gateway = fl6->daddr;
1645 rt->rt6i_dst.addr = fl6->daddr;
1646 rt->rt6i_dst.plen = 128;
1647 rt->rt6i_idev = idev;
1648 dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
1649
1650 spin_lock_bh(&icmp6_dst_lock);
1651 rt->dst.next = icmp6_dst_gc_list;
1652 icmp6_dst_gc_list = &rt->dst;
1653 spin_unlock_bh(&icmp6_dst_lock);
1654
1655 fib6_force_start_gc(net);
1656
1657 dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
1658
1659 out:
1660 return dst;
1661 }
1662
1663 int icmp6_dst_gc(void)
1664 {
1665 struct dst_entry *dst, **pprev;
1666 int more = 0;
1667
1668 spin_lock_bh(&icmp6_dst_lock);
1669 pprev = &icmp6_dst_gc_list;
1670
1671 while ((dst = *pprev) != NULL) {
1672 if (!atomic_read(&dst->__refcnt)) {
1673 *pprev = dst->next;
1674 dst_free(dst);
1675 } else {
1676 pprev = &dst->next;
1677 ++more;
1678 }
1679 }
1680
1681 spin_unlock_bh(&icmp6_dst_lock);
1682
1683 return more;
1684 }
1685
1686 static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1687 void *arg)
1688 {
1689 struct dst_entry *dst, **pprev;
1690
1691 spin_lock_bh(&icmp6_dst_lock);
1692 pprev = &icmp6_dst_gc_list;
1693 while ((dst = *pprev) != NULL) {
1694 struct rt6_info *rt = (struct rt6_info *) dst;
1695 if (func(rt, arg)) {
1696 *pprev = dst->next;
1697 dst_free(dst);
1698 } else {
1699 pprev = &dst->next;
1700 }
1701 }
1702 spin_unlock_bh(&icmp6_dst_lock);
1703 }
1704
1705 static int ip6_dst_gc(struct dst_ops *ops)
1706 {
1707 struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
1708 int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1709 int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1710 int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1711 int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1712 unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
1713 int entries;
1714
1715 entries = dst_entries_get_fast(ops);
1716 if (time_after(rt_last_gc + rt_min_interval, jiffies) &&
1717 entries <= rt_max_size)
1718 goto out;
1719
1720 net->ipv6.ip6_rt_gc_expire++;
1721 fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, true);
1722 entries = dst_entries_get_slow(ops);
1723 if (entries < ops->gc_thresh)
1724 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1725 out:
1726 net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
1727 return entries > rt_max_size;
1728 }
1729
1730 static int ip6_convert_metrics(struct mx6_config *mxc,
1731 const struct fib6_config *cfg)
1732 {
1733 bool ecn_ca = false;
1734 struct nlattr *nla;
1735 int remaining;
1736 u32 *mp;
1737
1738 if (!cfg->fc_mx)
1739 return 0;
1740
1741 mp = kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);
1742 if (unlikely(!mp))
1743 return -ENOMEM;
1744
1745 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1746 int type = nla_type(nla);
1747 u32 val;
1748
1749 if (!type)
1750 continue;
1751 if (unlikely(type > RTAX_MAX))
1752 goto err;
1753
1754 if (type == RTAX_CC_ALGO) {
1755 char tmp[TCP_CA_NAME_MAX];
1756
1757 nla_strlcpy(tmp, nla, sizeof(tmp));
1758 val = tcp_ca_get_key_by_name(tmp, &ecn_ca);
1759 if (val == TCP_CA_UNSPEC)
1760 goto err;
1761 } else {
1762 val = nla_get_u32(nla);
1763 }
1764 if (type == RTAX_HOPLIMIT && val > 255)
1765 val = 255;
1766 if (type == RTAX_FEATURES && (val & ~RTAX_FEATURE_MASK))
1767 goto err;
1768
1769 mp[type - 1] = val;
1770 __set_bit(type - 1, mxc->mx_valid);
1771 }
1772
1773 if (ecn_ca) {
1774 __set_bit(RTAX_FEATURES - 1, mxc->mx_valid);
1775 mp[RTAX_FEATURES - 1] |= DST_FEATURE_ECN_CA;
1776 }
1777
1778 mxc->mx = mp;
1779 return 0;
1780 err:
1781 kfree(mp);
1782 return -EINVAL;
1783 }
1784
1785 static struct rt6_info *ip6_nh_lookup_table(struct net *net,
1786 struct fib6_config *cfg,
1787 const struct in6_addr *gw_addr)
1788 {
1789 struct flowi6 fl6 = {
1790 .flowi6_oif = cfg->fc_ifindex,
1791 .daddr = *gw_addr,
1792 .saddr = cfg->fc_prefsrc,
1793 };
1794 struct fib6_table *table;
1795 struct rt6_info *rt;
1796 int flags = RT6_LOOKUP_F_IFACE | RT6_LOOKUP_F_IGNORE_LINKSTATE;
1797
1798 table = fib6_get_table(net, cfg->fc_table);
1799 if (!table)
1800 return NULL;
1801
1802 if (!ipv6_addr_any(&cfg->fc_prefsrc))
1803 flags |= RT6_LOOKUP_F_HAS_SADDR;
1804
1805 rt = ip6_pol_route(net, table, cfg->fc_ifindex, &fl6, flags);
1806
1807 /* if table lookup failed, fall back to full lookup */
1808 if (rt == net->ipv6.ip6_null_entry) {
1809 ip6_rt_put(rt);
1810 rt = NULL;
1811 }
1812
1813 return rt;
1814 }
1815
1816 static struct rt6_info *ip6_route_info_create(struct fib6_config *cfg)
1817 {
1818 struct net *net = cfg->fc_nlinfo.nl_net;
1819 struct rt6_info *rt = NULL;
1820 struct net_device *dev = NULL;
1821 struct inet6_dev *idev = NULL;
1822 struct fib6_table *table;
1823 int addr_type;
1824 int err = -EINVAL;
1825
1826 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1827 goto out;
1828 #ifndef CONFIG_IPV6_SUBTREES
1829 if (cfg->fc_src_len)
1830 goto out;
1831 #endif
1832 if (cfg->fc_ifindex) {
1833 err = -ENODEV;
1834 dev = dev_get_by_index(net, cfg->fc_ifindex);
1835 if (!dev)
1836 goto out;
1837 idev = in6_dev_get(dev);
1838 if (!idev)
1839 goto out;
1840 }
1841
1842 if (cfg->fc_metric == 0)
1843 cfg->fc_metric = IP6_RT_PRIO_USER;
1844
1845 err = -ENOBUFS;
1846 if (cfg->fc_nlinfo.nlh &&
1847 !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
1848 table = fib6_get_table(net, cfg->fc_table);
1849 if (!table) {
1850 pr_warn("NLM_F_CREATE should be specified when creating new route\n");
1851 table = fib6_new_table(net, cfg->fc_table);
1852 }
1853 } else {
1854 table = fib6_new_table(net, cfg->fc_table);
1855 }
1856
1857 if (!table)
1858 goto out;
1859
1860 rt = ip6_dst_alloc(net, NULL,
1861 (cfg->fc_flags & RTF_ADDRCONF) ? 0 : DST_NOCOUNT);
1862
1863 if (!rt) {
1864 err = -ENOMEM;
1865 goto out;
1866 }
1867
1868 if (cfg->fc_flags & RTF_EXPIRES)
1869 rt6_set_expires(rt, jiffies +
1870 clock_t_to_jiffies(cfg->fc_expires));
1871 else
1872 rt6_clean_expires(rt);
1873
1874 if (cfg->fc_protocol == RTPROT_UNSPEC)
1875 cfg->fc_protocol = RTPROT_BOOT;
1876 rt->rt6i_protocol = cfg->fc_protocol;
1877
1878 addr_type = ipv6_addr_type(&cfg->fc_dst);
1879
1880 if (addr_type & IPV6_ADDR_MULTICAST)
1881 rt->dst.input = ip6_mc_input;
1882 else if (cfg->fc_flags & RTF_LOCAL)
1883 rt->dst.input = ip6_input;
1884 else
1885 rt->dst.input = ip6_forward;
1886
1887 rt->dst.output = ip6_output;
1888
1889 if (cfg->fc_encap) {
1890 struct lwtunnel_state *lwtstate;
1891
1892 err = lwtunnel_build_state(dev, cfg->fc_encap_type,
1893 cfg->fc_encap, AF_INET6, cfg,
1894 &lwtstate);
1895 if (err)
1896 goto out;
1897 rt->dst.lwtstate = lwtstate_get(lwtstate);
1898 if (lwtunnel_output_redirect(rt->dst.lwtstate)) {
1899 rt->dst.lwtstate->orig_output = rt->dst.output;
1900 rt->dst.output = lwtunnel_output;
1901 }
1902 if (lwtunnel_input_redirect(rt->dst.lwtstate)) {
1903 rt->dst.lwtstate->orig_input = rt->dst.input;
1904 rt->dst.input = lwtunnel_input;
1905 }
1906 }
1907
1908 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1909 rt->rt6i_dst.plen = cfg->fc_dst_len;
1910 if (rt->rt6i_dst.plen == 128)
1911 rt->dst.flags |= DST_HOST;
1912
1913 #ifdef CONFIG_IPV6_SUBTREES
1914 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1915 rt->rt6i_src.plen = cfg->fc_src_len;
1916 #endif
1917
1918 rt->rt6i_metric = cfg->fc_metric;
1919
1920 /* We cannot add true routes via loopback here,
1921 they would result in kernel looping; promote them to reject routes
1922 */
1923 if ((cfg->fc_flags & RTF_REJECT) ||
1924 (dev && (dev->flags & IFF_LOOPBACK) &&
1925 !(addr_type & IPV6_ADDR_LOOPBACK) &&
1926 !(cfg->fc_flags & RTF_LOCAL))) {
1927 /* hold loopback dev/idev if we haven't done so. */
1928 if (dev != net->loopback_dev) {
1929 if (dev) {
1930 dev_put(dev);
1931 in6_dev_put(idev);
1932 }
1933 dev = net->loopback_dev;
1934 dev_hold(dev);
1935 idev = in6_dev_get(dev);
1936 if (!idev) {
1937 err = -ENODEV;
1938 goto out;
1939 }
1940 }
1941 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1942 switch (cfg->fc_type) {
1943 case RTN_BLACKHOLE:
1944 rt->dst.error = -EINVAL;
1945 rt->dst.output = dst_discard_out;
1946 rt->dst.input = dst_discard;
1947 break;
1948 case RTN_PROHIBIT:
1949 rt->dst.error = -EACCES;
1950 rt->dst.output = ip6_pkt_prohibit_out;
1951 rt->dst.input = ip6_pkt_prohibit;
1952 break;
1953 case RTN_THROW:
1954 case RTN_UNREACHABLE:
1955 default:
1956 rt->dst.error = (cfg->fc_type == RTN_THROW) ? -EAGAIN
1957 : (cfg->fc_type == RTN_UNREACHABLE)
1958 ? -EHOSTUNREACH : -ENETUNREACH;
1959 rt->dst.output = ip6_pkt_discard_out;
1960 rt->dst.input = ip6_pkt_discard;
1961 break;
1962 }
1963 goto install_route;
1964 }
1965
1966 if (cfg->fc_flags & RTF_GATEWAY) {
1967 const struct in6_addr *gw_addr;
1968 int gwa_type;
1969
1970 gw_addr = &cfg->fc_gateway;
1971 gwa_type = ipv6_addr_type(gw_addr);
1972
1973 /* if gw_addr is local we will fail to detect this in case
1974 * address is still TENTATIVE (DAD in progress). rt6_lookup()
1975 * will return already-added prefix route via interface that
1976 * prefix route was assigned to, which might be non-loopback.
1977 */
1978 err = -EINVAL;
1979 if (ipv6_chk_addr_and_flags(net, gw_addr,
1980 gwa_type & IPV6_ADDR_LINKLOCAL ?
1981 dev : NULL, 0, 0))
1982 goto out;
1983
1984 rt->rt6i_gateway = *gw_addr;
1985
1986 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1987 struct rt6_info *grt = NULL;
1988
1989 /* IPv6 strictly inhibits using not link-local
1990 addresses as nexthop address.
1991 Otherwise, router will not able to send redirects.
1992 It is very good, but in some (rare!) circumstances
1993 (SIT, PtP, NBMA NOARP links) it is handy to allow
1994 some exceptions. --ANK
1995 */
1996 if (!(gwa_type & IPV6_ADDR_UNICAST))
1997 goto out;
1998
1999 if (cfg->fc_table) {
2000 grt = ip6_nh_lookup_table(net, cfg, gw_addr);
2001
2002 if (grt) {
2003 if (grt->rt6i_flags & RTF_GATEWAY ||
2004 (dev && dev != grt->dst.dev)) {
2005 ip6_rt_put(grt);
2006 grt = NULL;
2007 }
2008 }
2009 }
2010
2011 if (!grt)
2012 grt = rt6_lookup(net, gw_addr, NULL,
2013 cfg->fc_ifindex, 1);
2014
2015 err = -EHOSTUNREACH;
2016 if (!grt)
2017 goto out;
2018 if (dev) {
2019 if (dev != grt->dst.dev) {
2020 ip6_rt_put(grt);
2021 goto out;
2022 }
2023 } else {
2024 dev = grt->dst.dev;
2025 idev = grt->rt6i_idev;
2026 dev_hold(dev);
2027 in6_dev_hold(grt->rt6i_idev);
2028 }
2029 if (!(grt->rt6i_flags & RTF_GATEWAY))
2030 err = 0;
2031 ip6_rt_put(grt);
2032
2033 if (err)
2034 goto out;
2035 }
2036 err = -EINVAL;
2037 if (!dev || (dev->flags & IFF_LOOPBACK))
2038 goto out;
2039 }
2040
2041 err = -ENODEV;
2042 if (!dev)
2043 goto out;
2044
2045 if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
2046 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
2047 err = -EINVAL;
2048 goto out;
2049 }
2050 rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
2051 rt->rt6i_prefsrc.plen = 128;
2052 } else
2053 rt->rt6i_prefsrc.plen = 0;
2054
2055 rt->rt6i_flags = cfg->fc_flags;
2056
2057 install_route:
2058 rt->dst.dev = dev;
2059 rt->rt6i_idev = idev;
2060 rt->rt6i_table = table;
2061
2062 cfg->fc_nlinfo.nl_net = dev_net(dev);
2063
2064 return rt;
2065 out:
2066 if (dev)
2067 dev_put(dev);
2068 if (idev)
2069 in6_dev_put(idev);
2070 if (rt)
2071 dst_free(&rt->dst);
2072
2073 return ERR_PTR(err);
2074 }
2075
2076 int ip6_route_add(struct fib6_config *cfg)
2077 {
2078 struct mx6_config mxc = { .mx = NULL, };
2079 struct rt6_info *rt;
2080 int err;
2081
2082 rt = ip6_route_info_create(cfg);
2083 if (IS_ERR(rt)) {
2084 err = PTR_ERR(rt);
2085 rt = NULL;
2086 goto out;
2087 }
2088
2089 err = ip6_convert_metrics(&mxc, cfg);
2090 if (err)
2091 goto out;
2092
2093 err = __ip6_ins_rt(rt, &cfg->fc_nlinfo, &mxc);
2094
2095 kfree(mxc.mx);
2096
2097 return err;
2098 out:
2099 if (rt)
2100 dst_free(&rt->dst);
2101
2102 return err;
2103 }
2104
2105 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
2106 {
2107 int err;
2108 struct fib6_table *table;
2109 struct net *net = dev_net(rt->dst.dev);
2110
2111 if (rt == net->ipv6.ip6_null_entry ||
2112 rt->dst.flags & DST_NOCACHE) {
2113 err = -ENOENT;
2114 goto out;
2115 }
2116
2117 table = rt->rt6i_table;
2118 write_lock_bh(&table->tb6_lock);
2119 err = fib6_del(rt, info);
2120 write_unlock_bh(&table->tb6_lock);
2121
2122 out:
2123 ip6_rt_put(rt);
2124 return err;
2125 }
2126
2127 int ip6_del_rt(struct rt6_info *rt)
2128 {
2129 struct nl_info info = {
2130 .nl_net = dev_net(rt->dst.dev),
2131 };
2132 return __ip6_del_rt(rt, &info);
2133 }
2134
2135 static int ip6_route_del(struct fib6_config *cfg)
2136 {
2137 struct fib6_table *table;
2138 struct fib6_node *fn;
2139 struct rt6_info *rt;
2140 int err = -ESRCH;
2141
2142 table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
2143 if (!table)
2144 return err;
2145
2146 read_lock_bh(&table->tb6_lock);
2147
2148 fn = fib6_locate(&table->tb6_root,
2149 &cfg->fc_dst, cfg->fc_dst_len,
2150 &cfg->fc_src, cfg->fc_src_len);
2151
2152 if (fn) {
2153 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
2154 if ((rt->rt6i_flags & RTF_CACHE) &&
2155 !(cfg->fc_flags & RTF_CACHE))
2156 continue;
2157 if (cfg->fc_ifindex &&
2158 (!rt->dst.dev ||
2159 rt->dst.dev->ifindex != cfg->fc_ifindex))
2160 continue;
2161 if (cfg->fc_flags & RTF_GATEWAY &&
2162 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
2163 continue;
2164 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
2165 continue;
2166 dst_hold(&rt->dst);
2167 read_unlock_bh(&table->tb6_lock);
2168
2169 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
2170 }
2171 }
2172 read_unlock_bh(&table->tb6_lock);
2173
2174 return err;
2175 }
2176
2177 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
2178 {
2179 struct netevent_redirect netevent;
2180 struct rt6_info *rt, *nrt = NULL;
2181 struct ndisc_options ndopts;
2182 struct inet6_dev *in6_dev;
2183 struct neighbour *neigh;
2184 struct rd_msg *msg;
2185 int optlen, on_link;
2186 u8 *lladdr;
2187
2188 optlen = skb_tail_pointer(skb) - skb_transport_header(skb);
2189 optlen -= sizeof(*msg);
2190
2191 if (optlen < 0) {
2192 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
2193 return;
2194 }
2195
2196 msg = (struct rd_msg *)icmp6_hdr(skb);
2197
2198 if (ipv6_addr_is_multicast(&msg->dest)) {
2199 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
2200 return;
2201 }
2202
2203 on_link = 0;
2204 if (ipv6_addr_equal(&msg->dest, &msg->target)) {
2205 on_link = 1;
2206 } else if (ipv6_addr_type(&msg->target) !=
2207 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
2208 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
2209 return;
2210 }
2211
2212 in6_dev = __in6_dev_get(skb->dev);
2213 if (!in6_dev)
2214 return;
2215 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
2216 return;
2217
2218 /* RFC2461 8.1:
2219 * The IP source address of the Redirect MUST be the same as the current
2220 * first-hop router for the specified ICMP Destination Address.
2221 */
2222
2223 if (!ndisc_parse_options(skb->dev, msg->opt, optlen, &ndopts)) {
2224 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
2225 return;
2226 }
2227
2228 lladdr = NULL;
2229 if (ndopts.nd_opts_tgt_lladdr) {
2230 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
2231 skb->dev);
2232 if (!lladdr) {
2233 net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
2234 return;
2235 }
2236 }
2237
2238 rt = (struct rt6_info *) dst;
2239 if (rt->rt6i_flags & RTF_REJECT) {
2240 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
2241 return;
2242 }
2243
2244 /* Redirect received -> path was valid.
2245 * Look, redirects are sent only in response to data packets,
2246 * so that this nexthop apparently is reachable. --ANK
2247 */
2248 dst_confirm(&rt->dst);
2249
2250 neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
2251 if (!neigh)
2252 return;
2253
2254 /*
2255 * We have finally decided to accept it.
2256 */
2257
2258 ndisc_update(skb->dev, neigh, lladdr, NUD_STALE,
2259 NEIGH_UPDATE_F_WEAK_OVERRIDE|
2260 NEIGH_UPDATE_F_OVERRIDE|
2261 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
2262 NEIGH_UPDATE_F_ISROUTER)),
2263 NDISC_REDIRECT, &ndopts);
2264
2265 nrt = ip6_rt_cache_alloc(rt, &msg->dest, NULL);
2266 if (!nrt)
2267 goto out;
2268
2269 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
2270 if (on_link)
2271 nrt->rt6i_flags &= ~RTF_GATEWAY;
2272
2273 nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
2274
2275 if (ip6_ins_rt(nrt))
2276 goto out;
2277
2278 netevent.old = &rt->dst;
2279 netevent.new = &nrt->dst;
2280 netevent.daddr = &msg->dest;
2281 netevent.neigh = neigh;
2282 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
2283
2284 if (rt->rt6i_flags & RTF_CACHE) {
2285 rt = (struct rt6_info *) dst_clone(&rt->dst);
2286 ip6_del_rt(rt);
2287 }
2288
2289 out:
2290 neigh_release(neigh);
2291 }
2292
2293 /*
2294 * Misc support functions
2295 */
2296
2297 static void rt6_set_from(struct rt6_info *rt, struct rt6_info *from)
2298 {
2299 BUG_ON(from->dst.from);
2300
2301 rt->rt6i_flags &= ~RTF_EXPIRES;
2302 dst_hold(&from->dst);
2303 rt->dst.from = &from->dst;
2304 dst_init_metrics(&rt->dst, dst_metrics_ptr(&from->dst), true);
2305 }
2306
2307 static void ip6_rt_copy_init(struct rt6_info *rt, struct rt6_info *ort)
2308 {
2309 rt->dst.input = ort->dst.input;
2310 rt->dst.output = ort->dst.output;
2311 rt->rt6i_dst = ort->rt6i_dst;
2312 rt->dst.error = ort->dst.error;
2313 rt->rt6i_idev = ort->rt6i_idev;
2314 if (rt->rt6i_idev)
2315 in6_dev_hold(rt->rt6i_idev);
2316 rt->dst.lastuse = jiffies;
2317 rt->rt6i_gateway = ort->rt6i_gateway;
2318 rt->rt6i_flags = ort->rt6i_flags;
2319 rt6_set_from(rt, ort);
2320 rt->rt6i_metric = ort->rt6i_metric;
2321 #ifdef CONFIG_IPV6_SUBTREES
2322 rt->rt6i_src = ort->rt6i_src;
2323 #endif
2324 rt->rt6i_prefsrc = ort->rt6i_prefsrc;
2325 rt->rt6i_table = ort->rt6i_table;
2326 rt->dst.lwtstate = lwtstate_get(ort->dst.lwtstate);
2327 }
2328
2329 #ifdef CONFIG_IPV6_ROUTE_INFO
2330 static struct rt6_info *rt6_get_route_info(struct net *net,
2331 const struct in6_addr *prefix, int prefixlen,
2332 const struct in6_addr *gwaddr,
2333 struct net_device *dev)
2334 {
2335 u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_INFO;
2336 int ifindex = dev->ifindex;
2337 struct fib6_node *fn;
2338 struct rt6_info *rt = NULL;
2339 struct fib6_table *table;
2340
2341 table = fib6_get_table(net, tb_id);
2342 if (!table)
2343 return NULL;
2344
2345 read_lock_bh(&table->tb6_lock);
2346 fn = fib6_locate(&table->tb6_root, prefix, prefixlen, NULL, 0);
2347 if (!fn)
2348 goto out;
2349
2350 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
2351 if (rt->dst.dev->ifindex != ifindex)
2352 continue;
2353 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
2354 continue;
2355 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
2356 continue;
2357 dst_hold(&rt->dst);
2358 break;
2359 }
2360 out:
2361 read_unlock_bh(&table->tb6_lock);
2362 return rt;
2363 }
2364
2365 static struct rt6_info *rt6_add_route_info(struct net *net,
2366 const struct in6_addr *prefix, int prefixlen,
2367 const struct in6_addr *gwaddr,
2368 struct net_device *dev,
2369 unsigned int pref)
2370 {
2371 struct fib6_config cfg = {
2372 .fc_metric = IP6_RT_PRIO_USER,
2373 .fc_ifindex = dev->ifindex,
2374 .fc_dst_len = prefixlen,
2375 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
2376 RTF_UP | RTF_PREF(pref),
2377 .fc_nlinfo.portid = 0,
2378 .fc_nlinfo.nlh = NULL,
2379 .fc_nlinfo.nl_net = net,
2380 };
2381
2382 cfg.fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_INFO,
2383 cfg.fc_dst = *prefix;
2384 cfg.fc_gateway = *gwaddr;
2385
2386 /* We should treat it as a default route if prefix length is 0. */
2387 if (!prefixlen)
2388 cfg.fc_flags |= RTF_DEFAULT;
2389
2390 ip6_route_add(&cfg);
2391
2392 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, dev);
2393 }
2394 #endif
2395
2396 struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
2397 {
2398 u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_DFLT;
2399 struct rt6_info *rt;
2400 struct fib6_table *table;
2401
2402 table = fib6_get_table(dev_net(dev), tb_id);
2403 if (!table)
2404 return NULL;
2405
2406 read_lock_bh(&table->tb6_lock);
2407 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
2408 if (dev == rt->dst.dev &&
2409 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
2410 ipv6_addr_equal(&rt->rt6i_gateway, addr))
2411 break;
2412 }
2413 if (rt)
2414 dst_hold(&rt->dst);
2415 read_unlock_bh(&table->tb6_lock);
2416 return rt;
2417 }
2418
2419 struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
2420 struct net_device *dev,
2421 unsigned int pref)
2422 {
2423 struct fib6_config cfg = {
2424 .fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_DFLT,
2425 .fc_metric = IP6_RT_PRIO_USER,
2426 .fc_ifindex = dev->ifindex,
2427 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
2428 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
2429 .fc_nlinfo.portid = 0,
2430 .fc_nlinfo.nlh = NULL,
2431 .fc_nlinfo.nl_net = dev_net(dev),
2432 };
2433
2434 cfg.fc_gateway = *gwaddr;
2435
2436 if (!ip6_route_add(&cfg)) {
2437 struct fib6_table *table;
2438
2439 table = fib6_get_table(dev_net(dev), cfg.fc_table);
2440 if (table)
2441 table->flags |= RT6_TABLE_HAS_DFLT_ROUTER;
2442 }
2443
2444 return rt6_get_dflt_router(gwaddr, dev);
2445 }
2446
2447 static void __rt6_purge_dflt_routers(struct fib6_table *table)
2448 {
2449 struct rt6_info *rt;
2450
2451 restart:
2452 read_lock_bh(&table->tb6_lock);
2453 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
2454 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
2455 (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) {
2456 dst_hold(&rt->dst);
2457 read_unlock_bh(&table->tb6_lock);
2458 ip6_del_rt(rt);
2459 goto restart;
2460 }
2461 }
2462 read_unlock_bh(&table->tb6_lock);
2463
2464 table->flags &= ~RT6_TABLE_HAS_DFLT_ROUTER;
2465 }
2466
2467 void rt6_purge_dflt_routers(struct net *net)
2468 {
2469 struct fib6_table *table;
2470 struct hlist_head *head;
2471 unsigned int h;
2472
2473 rcu_read_lock();
2474
2475 for (h = 0; h < FIB6_TABLE_HASHSZ; h++) {
2476 head = &net->ipv6.fib_table_hash[h];
2477 hlist_for_each_entry_rcu(table, head, tb6_hlist) {
2478 if (table->flags & RT6_TABLE_HAS_DFLT_ROUTER)
2479 __rt6_purge_dflt_routers(table);
2480 }
2481 }
2482
2483 rcu_read_unlock();
2484 }
2485
2486 static void rtmsg_to_fib6_config(struct net *net,
2487 struct in6_rtmsg *rtmsg,
2488 struct fib6_config *cfg)
2489 {
2490 memset(cfg, 0, sizeof(*cfg));
2491
2492 cfg->fc_table = l3mdev_fib_table_by_index(net, rtmsg->rtmsg_ifindex) ?
2493 : RT6_TABLE_MAIN;
2494 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
2495 cfg->fc_metric = rtmsg->rtmsg_metric;
2496 cfg->fc_expires = rtmsg->rtmsg_info;
2497 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
2498 cfg->fc_src_len = rtmsg->rtmsg_src_len;
2499 cfg->fc_flags = rtmsg->rtmsg_flags;
2500
2501 cfg->fc_nlinfo.nl_net = net;
2502
2503 cfg->fc_dst = rtmsg->rtmsg_dst;
2504 cfg->fc_src = rtmsg->rtmsg_src;
2505 cfg->fc_gateway = rtmsg->rtmsg_gateway;
2506 }
2507
2508 int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
2509 {
2510 struct fib6_config cfg;
2511 struct in6_rtmsg rtmsg;
2512 int err;
2513
2514 switch (cmd) {
2515 case SIOCADDRT: /* Add a route */
2516 case SIOCDELRT: /* Delete a route */
2517 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
2518 return -EPERM;
2519 err = copy_from_user(&rtmsg, arg,
2520 sizeof(struct in6_rtmsg));
2521 if (err)
2522 return -EFAULT;
2523
2524 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
2525
2526 rtnl_lock();
2527 switch (cmd) {
2528 case SIOCADDRT:
2529 err = ip6_route_add(&cfg);
2530 break;
2531 case SIOCDELRT:
2532 err = ip6_route_del(&cfg);
2533 break;
2534 default:
2535 err = -EINVAL;
2536 }
2537 rtnl_unlock();
2538
2539 return err;
2540 }
2541
2542 return -EINVAL;
2543 }
2544
2545 /*
2546 * Drop the packet on the floor
2547 */
2548
2549 static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
2550 {
2551 int type;
2552 struct dst_entry *dst = skb_dst(skb);
2553 switch (ipstats_mib_noroutes) {
2554 case IPSTATS_MIB_INNOROUTES:
2555 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
2556 if (type == IPV6_ADDR_ANY) {
2557 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2558 IPSTATS_MIB_INADDRERRORS);
2559 break;
2560 }
2561 /* FALLTHROUGH */
2562 case IPSTATS_MIB_OUTNOROUTES:
2563 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2564 ipstats_mib_noroutes);
2565 break;
2566 }
2567 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
2568 kfree_skb(skb);
2569 return 0;
2570 }
2571
2572 static int ip6_pkt_discard(struct sk_buff *skb)
2573 {
2574 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
2575 }
2576
2577 static int ip6_pkt_discard_out(struct net *net, struct sock *sk, struct sk_buff *skb)
2578 {
2579 skb->dev = skb_dst(skb)->dev;
2580 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
2581 }
2582
2583 static int ip6_pkt_prohibit(struct sk_buff *skb)
2584 {
2585 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
2586 }
2587
2588 static int ip6_pkt_prohibit_out(struct net *net, struct sock *sk, struct sk_buff *skb)
2589 {
2590 skb->dev = skb_dst(skb)->dev;
2591 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
2592 }
2593
2594 /*
2595 * Allocate a dst for local (unicast / anycast) address.
2596 */
2597
2598 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2599 const struct in6_addr *addr,
2600 bool anycast)
2601 {
2602 u32 tb_id;
2603 struct net *net = dev_net(idev->dev);
2604 struct net_device *dev = net->loopback_dev;
2605 struct rt6_info *rt;
2606
2607 /* use L3 Master device as loopback for host routes if device
2608 * is enslaved and address is not link local or multicast
2609 */
2610 if (!rt6_need_strict(addr))
2611 dev = l3mdev_master_dev_rcu(idev->dev) ? : dev;
2612
2613 rt = ip6_dst_alloc(net, dev, DST_NOCOUNT);
2614 if (!rt)
2615 return ERR_PTR(-ENOMEM);
2616
2617 in6_dev_hold(idev);
2618
2619 rt->dst.flags |= DST_HOST;
2620 rt->dst.input = ip6_input;
2621 rt->dst.output = ip6_output;
2622 rt->rt6i_idev = idev;
2623
2624 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
2625 if (anycast)
2626 rt->rt6i_flags |= RTF_ANYCAST;
2627 else
2628 rt->rt6i_flags |= RTF_LOCAL;
2629
2630 rt->rt6i_gateway = *addr;
2631 rt->rt6i_dst.addr = *addr;
2632 rt->rt6i_dst.plen = 128;
2633 tb_id = l3mdev_fib_table(idev->dev) ? : RT6_TABLE_LOCAL;
2634 rt->rt6i_table = fib6_get_table(net, tb_id);
2635 rt->dst.flags |= DST_NOCACHE;
2636
2637 atomic_set(&rt->dst.__refcnt, 1);
2638
2639 return rt;
2640 }
2641
2642 /* remove deleted ip from prefsrc entries */
2643 struct arg_dev_net_ip {
2644 struct net_device *dev;
2645 struct net *net;
2646 struct in6_addr *addr;
2647 };
2648
2649 static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2650 {
2651 struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2652 struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2653 struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2654
2655 if (((void *)rt->dst.dev == dev || !dev) &&
2656 rt != net->ipv6.ip6_null_entry &&
2657 ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2658 /* remove prefsrc entry */
2659 rt->rt6i_prefsrc.plen = 0;
2660 }
2661 return 0;
2662 }
2663
2664 void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2665 {
2666 struct net *net = dev_net(ifp->idev->dev);
2667 struct arg_dev_net_ip adni = {
2668 .dev = ifp->idev->dev,
2669 .net = net,
2670 .addr = &ifp->addr,
2671 };
2672 fib6_clean_all(net, fib6_remove_prefsrc, &adni);
2673 }
2674
2675 #define RTF_RA_ROUTER (RTF_ADDRCONF | RTF_DEFAULT | RTF_GATEWAY)
2676 #define RTF_CACHE_GATEWAY (RTF_GATEWAY | RTF_CACHE)
2677
2678 /* Remove routers and update dst entries when gateway turn into host. */
2679 static int fib6_clean_tohost(struct rt6_info *rt, void *arg)
2680 {
2681 struct in6_addr *gateway = (struct in6_addr *)arg;
2682
2683 if ((((rt->rt6i_flags & RTF_RA_ROUTER) == RTF_RA_ROUTER) ||
2684 ((rt->rt6i_flags & RTF_CACHE_GATEWAY) == RTF_CACHE_GATEWAY)) &&
2685 ipv6_addr_equal(gateway, &rt->rt6i_gateway)) {
2686 return -1;
2687 }
2688 return 0;
2689 }
2690
2691 void rt6_clean_tohost(struct net *net, struct in6_addr *gateway)
2692 {
2693 fib6_clean_all(net, fib6_clean_tohost, gateway);
2694 }
2695
2696 struct arg_dev_net {
2697 struct net_device *dev;
2698 struct net *net;
2699 };
2700
2701 static int fib6_ifdown(struct rt6_info *rt, void *arg)
2702 {
2703 const struct arg_dev_net *adn = arg;
2704 const struct net_device *dev = adn->dev;
2705
2706 if ((rt->dst.dev == dev || !dev) &&
2707 rt != adn->net->ipv6.ip6_null_entry)
2708 return -1;
2709
2710 return 0;
2711 }
2712
2713 void rt6_ifdown(struct net *net, struct net_device *dev)
2714 {
2715 struct arg_dev_net adn = {
2716 .dev = dev,
2717 .net = net,
2718 };
2719
2720 fib6_clean_all(net, fib6_ifdown, &adn);
2721 icmp6_clean_all(fib6_ifdown, &adn);
2722 if (dev)
2723 rt6_uncached_list_flush_dev(net, dev);
2724 }
2725
2726 struct rt6_mtu_change_arg {
2727 struct net_device *dev;
2728 unsigned int mtu;
2729 };
2730
2731 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2732 {
2733 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2734 struct inet6_dev *idev;
2735
2736 /* In IPv6 pmtu discovery is not optional,
2737 so that RTAX_MTU lock cannot disable it.
2738 We still use this lock to block changes
2739 caused by addrconf/ndisc.
2740 */
2741
2742 idev = __in6_dev_get(arg->dev);
2743 if (!idev)
2744 return 0;
2745
2746 /* For administrative MTU increase, there is no way to discover
2747 IPv6 PMTU increase, so PMTU increase should be updated here.
2748 Since RFC 1981 doesn't include administrative MTU increase
2749 update PMTU increase is a MUST. (i.e. jumbo frame)
2750 */
2751 /*
2752 If new MTU is less than route PMTU, this new MTU will be the
2753 lowest MTU in the path, update the route PMTU to reflect PMTU
2754 decreases; if new MTU is greater than route PMTU, and the
2755 old MTU is the lowest MTU in the path, update the route PMTU
2756 to reflect the increase. In this case if the other nodes' MTU
2757 also have the lowest MTU, TOO BIG MESSAGE will be lead to
2758 PMTU discouvery.
2759 */
2760 if (rt->dst.dev == arg->dev &&
2761 !dst_metric_locked(&rt->dst, RTAX_MTU)) {
2762 if (rt->rt6i_flags & RTF_CACHE) {
2763 /* For RTF_CACHE with rt6i_pmtu == 0
2764 * (i.e. a redirected route),
2765 * the metrics of its rt->dst.from has already
2766 * been updated.
2767 */
2768 if (rt->rt6i_pmtu && rt->rt6i_pmtu > arg->mtu)
2769 rt->rt6i_pmtu = arg->mtu;
2770 } else if (dst_mtu(&rt->dst) >= arg->mtu ||
2771 (dst_mtu(&rt->dst) < arg->mtu &&
2772 dst_mtu(&rt->dst) == idev->cnf.mtu6)) {
2773 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
2774 }
2775 }
2776 return 0;
2777 }
2778
2779 void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
2780 {
2781 struct rt6_mtu_change_arg arg = {
2782 .dev = dev,
2783 .mtu = mtu,
2784 };
2785
2786 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);
2787 }
2788
2789 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
2790 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
2791 [RTA_OIF] = { .type = NLA_U32 },
2792 [RTA_IIF] = { .type = NLA_U32 },
2793 [RTA_PRIORITY] = { .type = NLA_U32 },
2794 [RTA_METRICS] = { .type = NLA_NESTED },
2795 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
2796 [RTA_PREF] = { .type = NLA_U8 },
2797 [RTA_ENCAP_TYPE] = { .type = NLA_U16 },
2798 [RTA_ENCAP] = { .type = NLA_NESTED },
2799 [RTA_EXPIRES] = { .type = NLA_U32 },
2800 };
2801
2802 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2803 struct fib6_config *cfg)
2804 {
2805 struct rtmsg *rtm;
2806 struct nlattr *tb[RTA_MAX+1];
2807 unsigned int pref;
2808 int err;
2809
2810 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2811 if (err < 0)
2812 goto errout;
2813
2814 err = -EINVAL;
2815 rtm = nlmsg_data(nlh);
2816 memset(cfg, 0, sizeof(*cfg));
2817
2818 cfg->fc_table = rtm->rtm_table;
2819 cfg->fc_dst_len = rtm->rtm_dst_len;
2820 cfg->fc_src_len = rtm->rtm_src_len;
2821 cfg->fc_flags = RTF_UP;
2822 cfg->fc_protocol = rtm->rtm_protocol;
2823 cfg->fc_type = rtm->rtm_type;
2824
2825 if (rtm->rtm_type == RTN_UNREACHABLE ||
2826 rtm->rtm_type == RTN_BLACKHOLE ||
2827 rtm->rtm_type == RTN_PROHIBIT ||
2828 rtm->rtm_type == RTN_THROW)
2829 cfg->fc_flags |= RTF_REJECT;
2830
2831 if (rtm->rtm_type == RTN_LOCAL)
2832 cfg->fc_flags |= RTF_LOCAL;
2833
2834 if (rtm->rtm_flags & RTM_F_CLONED)
2835 cfg->fc_flags |= RTF_CACHE;
2836
2837 cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
2838 cfg->fc_nlinfo.nlh = nlh;
2839 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
2840
2841 if (tb[RTA_GATEWAY]) {
2842 cfg->fc_gateway = nla_get_in6_addr(tb[RTA_GATEWAY]);
2843 cfg->fc_flags |= RTF_GATEWAY;
2844 }
2845
2846 if (tb[RTA_DST]) {
2847 int plen = (rtm->rtm_dst_len + 7) >> 3;
2848
2849 if (nla_len(tb[RTA_DST]) < plen)
2850 goto errout;
2851
2852 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
2853 }
2854
2855 if (tb[RTA_SRC]) {
2856 int plen = (rtm->rtm_src_len + 7) >> 3;
2857
2858 if (nla_len(tb[RTA_SRC]) < plen)
2859 goto errout;
2860
2861 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
2862 }
2863
2864 if (tb[RTA_PREFSRC])
2865 cfg->fc_prefsrc = nla_get_in6_addr(tb[RTA_PREFSRC]);
2866
2867 if (tb[RTA_OIF])
2868 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2869
2870 if (tb[RTA_PRIORITY])
2871 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2872
2873 if (tb[RTA_METRICS]) {
2874 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2875 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
2876 }
2877
2878 if (tb[RTA_TABLE])
2879 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2880
2881 if (tb[RTA_MULTIPATH]) {
2882 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
2883 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
2884 }
2885
2886 if (tb[RTA_PREF]) {
2887 pref = nla_get_u8(tb[RTA_PREF]);
2888 if (pref != ICMPV6_ROUTER_PREF_LOW &&
2889 pref != ICMPV6_ROUTER_PREF_HIGH)
2890 pref = ICMPV6_ROUTER_PREF_MEDIUM;
2891 cfg->fc_flags |= RTF_PREF(pref);
2892 }
2893
2894 if (tb[RTA_ENCAP])
2895 cfg->fc_encap = tb[RTA_ENCAP];
2896
2897 if (tb[RTA_ENCAP_TYPE])
2898 cfg->fc_encap_type = nla_get_u16(tb[RTA_ENCAP_TYPE]);
2899
2900 if (tb[RTA_EXPIRES]) {
2901 unsigned long timeout = addrconf_timeout_fixup(nla_get_u32(tb[RTA_EXPIRES]), HZ);
2902
2903 if (addrconf_finite_timeout(timeout)) {
2904 cfg->fc_expires = jiffies_to_clock_t(timeout * HZ);
2905 cfg->fc_flags |= RTF_EXPIRES;
2906 }
2907 }
2908
2909 err = 0;
2910 errout:
2911 return err;
2912 }
2913
2914 struct rt6_nh {
2915 struct rt6_info *rt6_info;
2916 struct fib6_config r_cfg;
2917 struct mx6_config mxc;
2918 struct list_head next;
2919 };
2920
2921 static void ip6_print_replace_route_err(struct list_head *rt6_nh_list)
2922 {
2923 struct rt6_nh *nh;
2924
2925 list_for_each_entry(nh, rt6_nh_list, next) {
2926 pr_warn("IPV6: multipath route replace failed (check consistency of installed routes): %pI6 nexthop %pI6 ifi %d\n",
2927 &nh->r_cfg.fc_dst, &nh->r_cfg.fc_gateway,
2928 nh->r_cfg.fc_ifindex);
2929 }
2930 }
2931
2932 static int ip6_route_info_append(struct list_head *rt6_nh_list,
2933 struct rt6_info *rt, struct fib6_config *r_cfg)
2934 {
2935 struct rt6_nh *nh;
2936 struct rt6_info *rtnh;
2937 int err = -EEXIST;
2938
2939 list_for_each_entry(nh, rt6_nh_list, next) {
2940 /* check if rt6_info already exists */
2941 rtnh = nh->rt6_info;
2942
2943 if (rtnh->dst.dev == rt->dst.dev &&
2944 rtnh->rt6i_idev == rt->rt6i_idev &&
2945 ipv6_addr_equal(&rtnh->rt6i_gateway,
2946 &rt->rt6i_gateway))
2947 return err;
2948 }
2949
2950 nh = kzalloc(sizeof(*nh), GFP_KERNEL);
2951 if (!nh)
2952 return -ENOMEM;
2953 nh->rt6_info = rt;
2954 err = ip6_convert_metrics(&nh->mxc, r_cfg);
2955 if (err) {
2956 kfree(nh);
2957 return err;
2958 }
2959 memcpy(&nh->r_cfg, r_cfg, sizeof(*r_cfg));
2960 list_add_tail(&nh->next, rt6_nh_list);
2961
2962 return 0;
2963 }
2964
2965 static int ip6_route_multipath_add(struct fib6_config *cfg)
2966 {
2967 struct fib6_config r_cfg;
2968 struct rtnexthop *rtnh;
2969 struct rt6_info *rt;
2970 struct rt6_nh *err_nh;
2971 struct rt6_nh *nh, *nh_safe;
2972 int remaining;
2973 int attrlen;
2974 int err = 1;
2975 int nhn = 0;
2976 int replace = (cfg->fc_nlinfo.nlh &&
2977 (cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_REPLACE));
2978 LIST_HEAD(rt6_nh_list);
2979
2980 remaining = cfg->fc_mp_len;
2981 rtnh = (struct rtnexthop *)cfg->fc_mp;
2982
2983 /* Parse a Multipath Entry and build a list (rt6_nh_list) of
2984 * rt6_info structs per nexthop
2985 */
2986 while (rtnh_ok(rtnh, remaining)) {
2987 memcpy(&r_cfg, cfg, sizeof(*cfg));
2988 if (rtnh->rtnh_ifindex)
2989 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
2990
2991 attrlen = rtnh_attrlen(rtnh);
2992 if (attrlen > 0) {
2993 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
2994
2995 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
2996 if (nla) {
2997 r_cfg.fc_gateway = nla_get_in6_addr(nla);
2998 r_cfg.fc_flags |= RTF_GATEWAY;
2999 }
3000 r_cfg.fc_encap = nla_find(attrs, attrlen, RTA_ENCAP);
3001 nla = nla_find(attrs, attrlen, RTA_ENCAP_TYPE);
3002 if (nla)
3003 r_cfg.fc_encap_type = nla_get_u16(nla);
3004 }
3005
3006 rt = ip6_route_info_create(&r_cfg);
3007 if (IS_ERR(rt)) {
3008 err = PTR_ERR(rt);
3009 rt = NULL;
3010 goto cleanup;
3011 }
3012
3013 err = ip6_route_info_append(&rt6_nh_list, rt, &r_cfg);
3014 if (err) {
3015 dst_free(&rt->dst);
3016 goto cleanup;
3017 }
3018
3019 rtnh = rtnh_next(rtnh, &remaining);
3020 }
3021
3022 err_nh = NULL;
3023 list_for_each_entry(nh, &rt6_nh_list, next) {
3024 err = __ip6_ins_rt(nh->rt6_info, &cfg->fc_nlinfo, &nh->mxc);
3025 /* nh->rt6_info is used or freed at this point, reset to NULL*/
3026 nh->rt6_info = NULL;
3027 if (err) {
3028 if (replace && nhn)
3029 ip6_print_replace_route_err(&rt6_nh_list);
3030 err_nh = nh;
3031 goto add_errout;
3032 }
3033
3034 /* Because each route is added like a single route we remove
3035 * these flags after the first nexthop: if there is a collision,
3036 * we have already failed to add the first nexthop:
3037 * fib6_add_rt2node() has rejected it; when replacing, old
3038 * nexthops have been replaced by first new, the rest should
3039 * be added to it.
3040 */
3041 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~(NLM_F_EXCL |
3042 NLM_F_REPLACE);
3043 nhn++;
3044 }
3045
3046 goto cleanup;
3047
3048 add_errout:
3049 /* Delete routes that were already added */
3050 list_for_each_entry(nh, &rt6_nh_list, next) {
3051 if (err_nh == nh)
3052 break;
3053 ip6_route_del(&nh->r_cfg);
3054 }
3055
3056 cleanup:
3057 list_for_each_entry_safe(nh, nh_safe, &rt6_nh_list, next) {
3058 if (nh->rt6_info)
3059 dst_free(&nh->rt6_info->dst);
3060 kfree(nh->mxc.mx);
3061 list_del(&nh->next);
3062 kfree(nh);
3063 }
3064
3065 return err;
3066 }
3067
3068 static int ip6_route_multipath_del(struct fib6_config *cfg)
3069 {
3070 struct fib6_config r_cfg;
3071 struct rtnexthop *rtnh;
3072 int remaining;
3073 int attrlen;
3074 int err = 1, last_err = 0;
3075
3076 remaining = cfg->fc_mp_len;
3077 rtnh = (struct rtnexthop *)cfg->fc_mp;
3078
3079 /* Parse a Multipath Entry */
3080 while (rtnh_ok(rtnh, remaining)) {
3081 memcpy(&r_cfg, cfg, sizeof(*cfg));
3082 if (rtnh->rtnh_ifindex)
3083 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
3084
3085 attrlen = rtnh_attrlen(rtnh);
3086 if (attrlen > 0) {
3087 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
3088
3089 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
3090 if (nla) {
3091 nla_memcpy(&r_cfg.fc_gateway, nla, 16);
3092 r_cfg.fc_flags |= RTF_GATEWAY;
3093 }
3094 }
3095 err = ip6_route_del(&r_cfg);
3096 if (err)
3097 last_err = err;
3098
3099 rtnh = rtnh_next(rtnh, &remaining);
3100 }
3101
3102 return last_err;
3103 }
3104
3105 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh)
3106 {
3107 struct fib6_config cfg;
3108 int err;
3109
3110 err = rtm_to_fib6_config(skb, nlh, &cfg);
3111 if (err < 0)
3112 return err;
3113
3114 if (cfg.fc_mp)
3115 return ip6_route_multipath_del(&cfg);
3116 else
3117 return ip6_route_del(&cfg);
3118 }
3119
3120 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh)
3121 {
3122 struct fib6_config cfg;
3123 int err;
3124
3125 err = rtm_to_fib6_config(skb, nlh, &cfg);
3126 if (err < 0)
3127 return err;
3128
3129 if (cfg.fc_mp)
3130 return ip6_route_multipath_add(&cfg);
3131 else
3132 return ip6_route_add(&cfg);
3133 }
3134
3135 static inline size_t rt6_nlmsg_size(struct rt6_info *rt)
3136 {
3137 return NLMSG_ALIGN(sizeof(struct rtmsg))
3138 + nla_total_size(16) /* RTA_SRC */
3139 + nla_total_size(16) /* RTA_DST */
3140 + nla_total_size(16) /* RTA_GATEWAY */
3141 + nla_total_size(16) /* RTA_PREFSRC */
3142 + nla_total_size(4) /* RTA_TABLE */
3143 + nla_total_size(4) /* RTA_IIF */
3144 + nla_total_size(4) /* RTA_OIF */
3145 + nla_total_size(4) /* RTA_PRIORITY */
3146 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
3147 + nla_total_size(sizeof(struct rta_cacheinfo))
3148 + nla_total_size(TCP_CA_NAME_MAX) /* RTAX_CC_ALGO */
3149 + nla_total_size(1) /* RTA_PREF */
3150 + lwtunnel_get_encap_size(rt->dst.lwtstate);
3151 }
3152
3153 static int rt6_fill_node(struct net *net,
3154 struct sk_buff *skb, struct rt6_info *rt,
3155 struct in6_addr *dst, struct in6_addr *src,
3156 int iif, int type, u32 portid, u32 seq,
3157 int prefix, int nowait, unsigned int flags)
3158 {
3159 u32 metrics[RTAX_MAX];
3160 struct rtmsg *rtm;
3161 struct nlmsghdr *nlh;
3162 long expires;
3163 u32 table;
3164
3165 if (prefix) { /* user wants prefix routes only */
3166 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
3167 /* success since this is not a prefix route */
3168 return 1;
3169 }
3170 }
3171
3172 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
3173 if (!nlh)
3174 return -EMSGSIZE;
3175
3176 rtm = nlmsg_data(nlh);
3177 rtm->rtm_family = AF_INET6;
3178 rtm->rtm_dst_len = rt->rt6i_dst.plen;
3179 rtm->rtm_src_len = rt->rt6i_src.plen;
3180 rtm->rtm_tos = 0;
3181 if (rt->rt6i_table)
3182 table = rt->rt6i_table->tb6_id;
3183 else
3184 table = RT6_TABLE_UNSPEC;
3185 rtm->rtm_table = table;
3186 if (nla_put_u32(skb, RTA_TABLE, table))
3187 goto nla_put_failure;
3188 if (rt->rt6i_flags & RTF_REJECT) {
3189 switch (rt->dst.error) {
3190 case -EINVAL:
3191 rtm->rtm_type = RTN_BLACKHOLE;
3192 break;
3193 case -EACCES:
3194 rtm->rtm_type = RTN_PROHIBIT;
3195 break;
3196 case -EAGAIN:
3197 rtm->rtm_type = RTN_THROW;
3198 break;
3199 default:
3200 rtm->rtm_type = RTN_UNREACHABLE;
3201 break;
3202 }
3203 }
3204 else if (rt->rt6i_flags & RTF_LOCAL)
3205 rtm->rtm_type = RTN_LOCAL;
3206 else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
3207 rtm->rtm_type = RTN_LOCAL;
3208 else
3209 rtm->rtm_type = RTN_UNICAST;
3210 rtm->rtm_flags = 0;
3211 if (!netif_carrier_ok(rt->dst.dev)) {
3212 rtm->rtm_flags |= RTNH_F_LINKDOWN;
3213 if (rt->rt6i_idev->cnf.ignore_routes_with_linkdown)
3214 rtm->rtm_flags |= RTNH_F_DEAD;
3215 }
3216 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
3217 rtm->rtm_protocol = rt->rt6i_protocol;
3218 if (rt->rt6i_flags & RTF_DYNAMIC)
3219 rtm->rtm_protocol = RTPROT_REDIRECT;
3220 else if (rt->rt6i_flags & RTF_ADDRCONF) {
3221 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
3222 rtm->rtm_protocol = RTPROT_RA;
3223 else
3224 rtm->rtm_protocol = RTPROT_KERNEL;
3225 }
3226
3227 if (rt->rt6i_flags & RTF_CACHE)
3228 rtm->rtm_flags |= RTM_F_CLONED;
3229
3230 if (dst) {
3231 if (nla_put_in6_addr(skb, RTA_DST, dst))
3232 goto nla_put_failure;
3233 rtm->rtm_dst_len = 128;
3234 } else if (rtm->rtm_dst_len)
3235 if (nla_put_in6_addr(skb, RTA_DST, &rt->rt6i_dst.addr))
3236 goto nla_put_failure;
3237 #ifdef CONFIG_IPV6_SUBTREES
3238 if (src) {
3239 if (nla_put_in6_addr(skb, RTA_SRC, src))
3240 goto nla_put_failure;
3241 rtm->rtm_src_len = 128;
3242 } else if (rtm->rtm_src_len &&
3243 nla_put_in6_addr(skb, RTA_SRC, &rt->rt6i_src.addr))
3244 goto nla_put_failure;
3245 #endif
3246 if (iif) {
3247 #ifdef CONFIG_IPV6_MROUTE
3248 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
3249 int err = ip6mr_get_route(net, skb, rtm, nowait,
3250 portid);
3251
3252 if (err <= 0) {
3253 if (!nowait) {
3254 if (err == 0)
3255 return 0;
3256 goto nla_put_failure;
3257 } else {
3258 if (err == -EMSGSIZE)
3259 goto nla_put_failure;
3260 }
3261 }
3262 } else
3263 #endif
3264 if (nla_put_u32(skb, RTA_IIF, iif))
3265 goto nla_put_failure;
3266 } else if (dst) {
3267 struct in6_addr saddr_buf;
3268 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
3269 nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
3270 goto nla_put_failure;
3271 }
3272
3273 if (rt->rt6i_prefsrc.plen) {
3274 struct in6_addr saddr_buf;
3275 saddr_buf = rt->rt6i_prefsrc.addr;
3276 if (nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
3277 goto nla_put_failure;
3278 }
3279
3280 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
3281 if (rt->rt6i_pmtu)
3282 metrics[RTAX_MTU - 1] = rt->rt6i_pmtu;
3283 if (rtnetlink_put_metrics(skb, metrics) < 0)
3284 goto nla_put_failure;
3285
3286 if (rt->rt6i_flags & RTF_GATEWAY) {
3287 if (nla_put_in6_addr(skb, RTA_GATEWAY, &rt->rt6i_gateway) < 0)
3288 goto nla_put_failure;
3289 }
3290
3291 if (rt->dst.dev &&
3292 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
3293 goto nla_put_failure;
3294 if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
3295 goto nla_put_failure;
3296
3297 expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
3298
3299 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
3300 goto nla_put_failure;
3301
3302 if (nla_put_u8(skb, RTA_PREF, IPV6_EXTRACT_PREF(rt->rt6i_flags)))
3303 goto nla_put_failure;
3304
3305 lwtunnel_fill_encap(skb, rt->dst.lwtstate);
3306
3307 nlmsg_end(skb, nlh);
3308 return 0;
3309
3310 nla_put_failure:
3311 nlmsg_cancel(skb, nlh);
3312 return -EMSGSIZE;
3313 }
3314
3315 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
3316 {
3317 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
3318 int prefix;
3319
3320 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
3321 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
3322 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
3323 } else
3324 prefix = 0;
3325
3326 return rt6_fill_node(arg->net,
3327 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
3328 NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
3329 prefix, 0, NLM_F_MULTI);
3330 }
3331
3332 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
3333 {
3334 struct net *net = sock_net(in_skb->sk);
3335 struct nlattr *tb[RTA_MAX+1];
3336 struct rt6_info *rt;
3337 struct sk_buff *skb;
3338 struct rtmsg *rtm;
3339 struct flowi6 fl6;
3340 int err, iif = 0, oif = 0;
3341
3342 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
3343 if (err < 0)
3344 goto errout;
3345
3346 err = -EINVAL;
3347 memset(&fl6, 0, sizeof(fl6));
3348 rtm = nlmsg_data(nlh);
3349 fl6.flowlabel = ip6_make_flowinfo(rtm->rtm_tos, 0);
3350
3351 if (tb[RTA_SRC]) {
3352 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
3353 goto errout;
3354
3355 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
3356 }
3357
3358 if (tb[RTA_DST]) {
3359 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
3360 goto errout;
3361
3362 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
3363 }
3364
3365 if (tb[RTA_IIF])
3366 iif = nla_get_u32(tb[RTA_IIF]);
3367
3368 if (tb[RTA_OIF])
3369 oif = nla_get_u32(tb[RTA_OIF]);
3370
3371 if (tb[RTA_MARK])
3372 fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);
3373
3374 if (iif) {
3375 struct net_device *dev;
3376 int flags = 0;
3377
3378 dev = __dev_get_by_index(net, iif);
3379 if (!dev) {
3380 err = -ENODEV;
3381 goto errout;
3382 }
3383
3384 fl6.flowi6_iif = iif;
3385
3386 if (!ipv6_addr_any(&fl6.saddr))
3387 flags |= RT6_LOOKUP_F_HAS_SADDR;
3388
3389 rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
3390 flags);
3391 } else {
3392 fl6.flowi6_oif = oif;
3393
3394 rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
3395 }
3396
3397 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
3398 if (!skb) {
3399 ip6_rt_put(rt);
3400 err = -ENOBUFS;
3401 goto errout;
3402 }
3403
3404 /* Reserve room for dummy headers, this skb can pass
3405 through good chunk of routing engine.
3406 */
3407 skb_reset_mac_header(skb);
3408 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
3409
3410 skb_dst_set(skb, &rt->dst);
3411
3412 err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
3413 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
3414 nlh->nlmsg_seq, 0, 0, 0);
3415 if (err < 0) {
3416 kfree_skb(skb);
3417 goto errout;
3418 }
3419
3420 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
3421 errout:
3422 return err;
3423 }
3424
3425 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info,
3426 unsigned int nlm_flags)
3427 {
3428 struct sk_buff *skb;
3429 struct net *net = info->nl_net;
3430 u32 seq;
3431 int err;
3432
3433 err = -ENOBUFS;
3434 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
3435
3436 skb = nlmsg_new(rt6_nlmsg_size(rt), gfp_any());
3437 if (!skb)
3438 goto errout;
3439
3440 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
3441 event, info->portid, seq, 0, 0, nlm_flags);
3442 if (err < 0) {
3443 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
3444 WARN_ON(err == -EMSGSIZE);
3445 kfree_skb(skb);
3446 goto errout;
3447 }
3448 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
3449 info->nlh, gfp_any());
3450 return;
3451 errout:
3452 if (err < 0)
3453 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
3454 }
3455
3456 static int ip6_route_dev_notify(struct notifier_block *this,
3457 unsigned long event, void *ptr)
3458 {
3459 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3460 struct net *net = dev_net(dev);
3461
3462 if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
3463 net->ipv6.ip6_null_entry->dst.dev = dev;
3464 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
3465 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3466 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
3467 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
3468 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
3469 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
3470 #endif
3471 }
3472
3473 return NOTIFY_OK;
3474 }
3475
3476 /*
3477 * /proc
3478 */
3479
3480 #ifdef CONFIG_PROC_FS
3481
3482 static const struct file_operations ipv6_route_proc_fops = {
3483 .owner = THIS_MODULE,
3484 .open = ipv6_route_open,
3485 .read = seq_read,
3486 .llseek = seq_lseek,
3487 .release = seq_release_net,
3488 };
3489
3490 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
3491 {
3492 struct net *net = (struct net *)seq->private;
3493 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
3494 net->ipv6.rt6_stats->fib_nodes,
3495 net->ipv6.rt6_stats->fib_route_nodes,
3496 net->ipv6.rt6_stats->fib_rt_alloc,
3497 net->ipv6.rt6_stats->fib_rt_entries,
3498 net->ipv6.rt6_stats->fib_rt_cache,
3499 dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
3500 net->ipv6.rt6_stats->fib_discarded_routes);
3501
3502 return 0;
3503 }
3504
3505 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
3506 {
3507 return single_open_net(inode, file, rt6_stats_seq_show);
3508 }
3509
3510 static const struct file_operations rt6_stats_seq_fops = {
3511 .owner = THIS_MODULE,
3512 .open = rt6_stats_seq_open,
3513 .read = seq_read,
3514 .llseek = seq_lseek,
3515 .release = single_release_net,
3516 };
3517 #endif /* CONFIG_PROC_FS */
3518
3519 #ifdef CONFIG_SYSCTL
3520
3521 static
3522 int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,
3523 void __user *buffer, size_t *lenp, loff_t *ppos)
3524 {
3525 struct net *net;
3526 int delay;
3527 if (!write)
3528 return -EINVAL;
3529
3530 net = (struct net *)ctl->extra1;
3531 delay = net->ipv6.sysctl.flush_delay;
3532 proc_dointvec(ctl, write, buffer, lenp, ppos);
3533 fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
3534 return 0;
3535 }
3536
3537 struct ctl_table ipv6_route_table_template[] = {
3538 {
3539 .procname = "flush",
3540 .data = &init_net.ipv6.sysctl.flush_delay,
3541 .maxlen = sizeof(int),
3542 .mode = 0200,
3543 .proc_handler = ipv6_sysctl_rtcache_flush
3544 },
3545 {
3546 .procname = "gc_thresh",
3547 .data = &ip6_dst_ops_template.gc_thresh,
3548 .maxlen = sizeof(int),
3549 .mode = 0644,
3550 .proc_handler = proc_dointvec,
3551 },
3552 {
3553 .procname = "max_size",
3554 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
3555 .maxlen = sizeof(int),
3556 .mode = 0644,
3557 .proc_handler = proc_dointvec,
3558 },
3559 {
3560 .procname = "gc_min_interval",
3561 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
3562 .maxlen = sizeof(int),
3563 .mode = 0644,
3564 .proc_handler = proc_dointvec_jiffies,
3565 },
3566 {
3567 .procname = "gc_timeout",
3568 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
3569 .maxlen = sizeof(int),
3570 .mode = 0644,
3571 .proc_handler = proc_dointvec_jiffies,
3572 },
3573 {
3574 .procname = "gc_interval",
3575 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
3576 .maxlen = sizeof(int),
3577 .mode = 0644,
3578 .proc_handler = proc_dointvec_jiffies,
3579 },
3580 {
3581 .procname = "gc_elasticity",
3582 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
3583 .maxlen = sizeof(int),
3584 .mode = 0644,
3585 .proc_handler = proc_dointvec,
3586 },
3587 {
3588 .procname = "mtu_expires",
3589 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
3590 .maxlen = sizeof(int),
3591 .mode = 0644,
3592 .proc_handler = proc_dointvec_jiffies,
3593 },
3594 {
3595 .procname = "min_adv_mss",
3596 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
3597 .maxlen = sizeof(int),
3598 .mode = 0644,
3599 .proc_handler = proc_dointvec,
3600 },
3601 {
3602 .procname = "gc_min_interval_ms",
3603 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
3604 .maxlen = sizeof(int),
3605 .mode = 0644,
3606 .proc_handler = proc_dointvec_ms_jiffies,
3607 },
3608 { }
3609 };
3610
3611 struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
3612 {
3613 struct ctl_table *table;
3614
3615 table = kmemdup(ipv6_route_table_template,
3616 sizeof(ipv6_route_table_template),
3617 GFP_KERNEL);
3618
3619 if (table) {
3620 table[0].data = &net->ipv6.sysctl.flush_delay;
3621 table[0].extra1 = net;
3622 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
3623 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
3624 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
3625 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
3626 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
3627 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
3628 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
3629 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
3630 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
3631
3632 /* Don't export sysctls to unprivileged users */
3633 if (net->user_ns != &init_user_ns)
3634 table[0].procname = NULL;
3635 }
3636
3637 return table;
3638 }
3639 #endif
3640
3641 static int __net_init ip6_route_net_init(struct net *net)
3642 {
3643 int ret = -ENOMEM;
3644
3645 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
3646 sizeof(net->ipv6.ip6_dst_ops));
3647
3648 if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
3649 goto out_ip6_dst_ops;
3650
3651 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
3652 sizeof(*net->ipv6.ip6_null_entry),
3653 GFP_KERNEL);
3654 if (!net->ipv6.ip6_null_entry)
3655 goto out_ip6_dst_entries;
3656 net->ipv6.ip6_null_entry->dst.path =
3657 (struct dst_entry *)net->ipv6.ip6_null_entry;
3658 net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3659 dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
3660 ip6_template_metrics, true);
3661
3662 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3663 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
3664 sizeof(*net->ipv6.ip6_prohibit_entry),
3665 GFP_KERNEL);
3666 if (!net->ipv6.ip6_prohibit_entry)
3667 goto out_ip6_null_entry;
3668 net->ipv6.ip6_prohibit_entry->dst.path =
3669 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
3670 net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3671 dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
3672 ip6_template_metrics, true);
3673
3674 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
3675 sizeof(*net->ipv6.ip6_blk_hole_entry),
3676 GFP_KERNEL);
3677 if (!net->ipv6.ip6_blk_hole_entry)
3678 goto out_ip6_prohibit_entry;
3679 net->ipv6.ip6_blk_hole_entry->dst.path =
3680 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
3681 net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3682 dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
3683 ip6_template_metrics, true);
3684 #endif
3685
3686 net->ipv6.sysctl.flush_delay = 0;
3687 net->ipv6.sysctl.ip6_rt_max_size = 4096;
3688 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
3689 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
3690 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
3691 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
3692 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
3693 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
3694
3695 net->ipv6.ip6_rt_gc_expire = 30*HZ;
3696
3697 ret = 0;
3698 out:
3699 return ret;
3700
3701 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3702 out_ip6_prohibit_entry:
3703 kfree(net->ipv6.ip6_prohibit_entry);
3704 out_ip6_null_entry:
3705 kfree(net->ipv6.ip6_null_entry);
3706 #endif
3707 out_ip6_dst_entries:
3708 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3709 out_ip6_dst_ops:
3710 goto out;
3711 }
3712
3713 static void __net_exit ip6_route_net_exit(struct net *net)
3714 {
3715 kfree(net->ipv6.ip6_null_entry);
3716 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3717 kfree(net->ipv6.ip6_prohibit_entry);
3718 kfree(net->ipv6.ip6_blk_hole_entry);
3719 #endif
3720 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3721 }
3722
3723 static int __net_init ip6_route_net_init_late(struct net *net)
3724 {
3725 #ifdef CONFIG_PROC_FS
3726 proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
3727 proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
3728 #endif
3729 return 0;
3730 }
3731
3732 static void __net_exit ip6_route_net_exit_late(struct net *net)
3733 {
3734 #ifdef CONFIG_PROC_FS
3735 remove_proc_entry("ipv6_route", net->proc_net);
3736 remove_proc_entry("rt6_stats", net->proc_net);
3737 #endif
3738 }
3739
3740 static struct pernet_operations ip6_route_net_ops = {
3741 .init = ip6_route_net_init,
3742 .exit = ip6_route_net_exit,
3743 };
3744
3745 static int __net_init ipv6_inetpeer_init(struct net *net)
3746 {
3747 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3748
3749 if (!bp)
3750 return -ENOMEM;
3751 inet_peer_base_init(bp);
3752 net->ipv6.peers = bp;
3753 return 0;
3754 }
3755
3756 static void __net_exit ipv6_inetpeer_exit(struct net *net)
3757 {
3758 struct inet_peer_base *bp = net->ipv6.peers;
3759
3760 net->ipv6.peers = NULL;
3761 inetpeer_invalidate_tree(bp);
3762 kfree(bp);
3763 }
3764
3765 static struct pernet_operations ipv6_inetpeer_ops = {
3766 .init = ipv6_inetpeer_init,
3767 .exit = ipv6_inetpeer_exit,
3768 };
3769
3770 static struct pernet_operations ip6_route_net_late_ops = {
3771 .init = ip6_route_net_init_late,
3772 .exit = ip6_route_net_exit_late,
3773 };
3774
3775 static struct notifier_block ip6_route_dev_notifier = {
3776 .notifier_call = ip6_route_dev_notify,
3777 .priority = 0,
3778 };
3779
3780 int __init ip6_route_init(void)
3781 {
3782 int ret;
3783 int cpu;
3784
3785 ret = -ENOMEM;
3786 ip6_dst_ops_template.kmem_cachep =
3787 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
3788 SLAB_HWCACHE_ALIGN, NULL);
3789 if (!ip6_dst_ops_template.kmem_cachep)
3790 goto out;
3791
3792 ret = dst_entries_init(&ip6_dst_blackhole_ops);
3793 if (ret)
3794 goto out_kmem_cache;
3795
3796 ret = register_pernet_subsys(&ipv6_inetpeer_ops);
3797 if (ret)
3798 goto out_dst_entries;
3799
3800 ret = register_pernet_subsys(&ip6_route_net_ops);
3801 if (ret)
3802 goto out_register_inetpeer;
3803
3804 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
3805
3806 /* Registering of the loopback is done before this portion of code,
3807 * the loopback reference in rt6_info will not be taken, do it
3808 * manually for init_net */
3809 init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
3810 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3811 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3812 init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
3813 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3814 init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
3815 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3816 #endif
3817 ret = fib6_init();
3818 if (ret)
3819 goto out_register_subsys;
3820
3821 ret = xfrm6_init();
3822 if (ret)
3823 goto out_fib6_init;
3824
3825 ret = fib6_rules_init();
3826 if (ret)
3827 goto xfrm6_init;
3828
3829 ret = register_pernet_subsys(&ip6_route_net_late_ops);
3830 if (ret)
3831 goto fib6_rules_init;
3832
3833 ret = -ENOBUFS;
3834 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
3835 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
3836 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
3837 goto out_register_late_subsys;
3838
3839 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
3840 if (ret)
3841 goto out_register_late_subsys;
3842
3843 for_each_possible_cpu(cpu) {
3844 struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
3845
3846 INIT_LIST_HEAD(&ul->head);
3847 spin_lock_init(&ul->lock);
3848 }
3849
3850 out:
3851 return ret;
3852
3853 out_register_late_subsys:
3854 unregister_pernet_subsys(&ip6_route_net_late_ops);
3855 fib6_rules_init:
3856 fib6_rules_cleanup();
3857 xfrm6_init:
3858 xfrm6_fini();
3859 out_fib6_init:
3860 fib6_gc_cleanup();
3861 out_register_subsys:
3862 unregister_pernet_subsys(&ip6_route_net_ops);
3863 out_register_inetpeer:
3864 unregister_pernet_subsys(&ipv6_inetpeer_ops);
3865 out_dst_entries:
3866 dst_entries_destroy(&ip6_dst_blackhole_ops);
3867 out_kmem_cache:
3868 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3869 goto out;
3870 }
3871
3872 void ip6_route_cleanup(void)
3873 {
3874 unregister_netdevice_notifier(&ip6_route_dev_notifier);
3875 unregister_pernet_subsys(&ip6_route_net_late_ops);
3876 fib6_rules_cleanup();
3877 xfrm6_fini();
3878 fib6_gc_cleanup();
3879 unregister_pernet_subsys(&ipv6_inetpeer_ops);
3880 unregister_pernet_subsys(&ip6_route_net_ops);
3881 dst_entries_destroy(&ip6_dst_blackhole_ops);
3882 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3883 }
(deprecated) Btrfs devel tree