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