?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ALSA: usb-audio: Fix an out-of-bound read in create_composite_quirks
[linux/fpc-iii.git] / net / ipv6 / route.c
blob1cb8954885ec145e49d74af1c2022b5703472adc
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 int oif = sk->sk_bound_dev_if;
1424
1425 if (!oif && skb->dev)
1426 oif = l3mdev_master_ifindex(skb->dev);
1427
1428 ip6_update_pmtu(skb, sock_net(sk), mtu, oif, sk->sk_mark);
1429 }
1430 EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);
1431
1432 /* Handle redirects */
1433 struct ip6rd_flowi {
1434 struct flowi6 fl6;
1435 struct in6_addr gateway;
1436 };
1437
1438 static struct rt6_info *__ip6_route_redirect(struct net *net,
1439 struct fib6_table *table,
1440 struct flowi6 *fl6,
1441 int flags)
1442 {
1443 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl6;
1444 struct rt6_info *rt;
1445 struct fib6_node *fn;
1446
1447 /* Get the "current" route for this destination and
1448 * check if the redirect has come from approriate router.
1449 *
1450 * RFC 4861 specifies that redirects should only be
1451 * accepted if they come from the nexthop to the target.
1452 * Due to the way the routes are chosen, this notion
1453 * is a bit fuzzy and one might need to check all possible
1454 * routes.
1455 */
1456
1457 read_lock_bh(&table->tb6_lock);
1458 fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
1459 restart:
1460 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1461 if (rt6_check_expired(rt))
1462 continue;
1463 if (rt->dst.error)
1464 break;
1465 if (!(rt->rt6i_flags & RTF_GATEWAY))
1466 continue;
1467 if (fl6->flowi6_oif != rt->dst.dev->ifindex)
1468 continue;
1469 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1470 continue;
1471 break;
1472 }
1473
1474 if (!rt)
1475 rt = net->ipv6.ip6_null_entry;
1476 else if (rt->dst.error) {
1477 rt = net->ipv6.ip6_null_entry;
1478 goto out;
1479 }
1480
1481 if (rt == net->ipv6.ip6_null_entry) {
1482 fn = fib6_backtrack(fn, &fl6->saddr);
1483 if (fn)
1484 goto restart;
1485 }
1486
1487 out:
1488 dst_hold(&rt->dst);
1489
1490 read_unlock_bh(&table->tb6_lock);
1491
1492 return rt;
1493 };
1494
1495 static struct dst_entry *ip6_route_redirect(struct net *net,
1496 const struct flowi6 *fl6,
1497 const struct in6_addr *gateway)
1498 {
1499 int flags = RT6_LOOKUP_F_HAS_SADDR;
1500 struct ip6rd_flowi rdfl;
1501
1502 rdfl.fl6 = *fl6;
1503 rdfl.gateway = *gateway;
1504
1505 return fib6_rule_lookup(net, &rdfl.fl6,
1506 flags, __ip6_route_redirect);
1507 }
1508
1509 void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark)
1510 {
1511 const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
1512 struct dst_entry *dst;
1513 struct flowi6 fl6;
1514
1515 memset(&fl6, 0, sizeof(fl6));
1516 fl6.flowi6_iif = LOOPBACK_IFINDEX;
1517 fl6.flowi6_oif = oif;
1518 fl6.flowi6_mark = mark;
1519 fl6.daddr = iph->daddr;
1520 fl6.saddr = iph->saddr;
1521 fl6.flowlabel = ip6_flowinfo(iph);
1522
1523 dst = ip6_route_redirect(net, &fl6, &ipv6_hdr(skb)->saddr);
1524 rt6_do_redirect(dst, NULL, skb);
1525 dst_release(dst);
1526 }
1527 EXPORT_SYMBOL_GPL(ip6_redirect);
1528
1529 void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif,
1530 u32 mark)
1531 {
1532 const struct ipv6hdr *iph = ipv6_hdr(skb);
1533 const struct rd_msg *msg = (struct rd_msg *)icmp6_hdr(skb);
1534 struct dst_entry *dst;
1535 struct flowi6 fl6;
1536
1537 memset(&fl6, 0, sizeof(fl6));
1538 fl6.flowi6_iif = LOOPBACK_IFINDEX;
1539 fl6.flowi6_oif = oif;
1540 fl6.flowi6_mark = mark;
1541 fl6.daddr = msg->dest;
1542 fl6.saddr = iph->daddr;
1543
1544 dst = ip6_route_redirect(net, &fl6, &iph->saddr);
1545 rt6_do_redirect(dst, NULL, skb);
1546 dst_release(dst);
1547 }
1548
1549 void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
1550 {
1551 ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark);
1552 }
1553 EXPORT_SYMBOL_GPL(ip6_sk_redirect);
1554
1555 static unsigned int ip6_default_advmss(const struct dst_entry *dst)
1556 {
1557 struct net_device *dev = dst->dev;
1558 unsigned int mtu = dst_mtu(dst);
1559 struct net *net = dev_net(dev);
1560
1561 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
1562
1563 if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
1564 mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
1565
1566 /*
1567 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
1568 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
1569 * IPV6_MAXPLEN is also valid and means: "any MSS,
1570 * rely only on pmtu discovery"
1571 */
1572 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
1573 mtu = IPV6_MAXPLEN;
1574 return mtu;
1575 }
1576
1577 static unsigned int ip6_mtu(const struct dst_entry *dst)
1578 {
1579 const struct rt6_info *rt = (const struct rt6_info *)dst;
1580 unsigned int mtu = rt->rt6i_pmtu;
1581 struct inet6_dev *idev;
1582
1583 if (mtu)
1584 goto out;
1585
1586 mtu = dst_metric_raw(dst, RTAX_MTU);
1587 if (mtu)
1588 goto out;
1589
1590 mtu = IPV6_MIN_MTU;
1591
1592 rcu_read_lock();
1593 idev = __in6_dev_get(dst->dev);
1594 if (idev)
1595 mtu = idev->cnf.mtu6;
1596 rcu_read_unlock();
1597
1598 out:
1599 return min_t(unsigned int, mtu, IP6_MAX_MTU);
1600 }
1601
1602 static struct dst_entry *icmp6_dst_gc_list;
1603 static DEFINE_SPINLOCK(icmp6_dst_lock);
1604
1605 struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
1606 struct flowi6 *fl6)
1607 {
1608 struct dst_entry *dst;
1609 struct rt6_info *rt;
1610 struct inet6_dev *idev = in6_dev_get(dev);
1611 struct net *net = dev_net(dev);
1612
1613 if (unlikely(!idev))
1614 return ERR_PTR(-ENODEV);
1615
1616 rt = ip6_dst_alloc(net, dev, 0);
1617 if (unlikely(!rt)) {
1618 in6_dev_put(idev);
1619 dst = ERR_PTR(-ENOMEM);
1620 goto out;
1621 }
1622
1623 rt->dst.flags |= DST_HOST;
1624 rt->dst.input = ip6_input;
1625 rt->dst.output = ip6_output;
1626 atomic_set(&rt->dst.__refcnt, 1);
1627 rt->rt6i_gateway = fl6->daddr;
1628 rt->rt6i_dst.addr = fl6->daddr;
1629 rt->rt6i_dst.plen = 128;
1630 rt->rt6i_idev = idev;
1631 dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
1632
1633 spin_lock_bh(&icmp6_dst_lock);
1634 rt->dst.next = icmp6_dst_gc_list;
1635 icmp6_dst_gc_list = &rt->dst;
1636 spin_unlock_bh(&icmp6_dst_lock);
1637
1638 fib6_force_start_gc(net);
1639
1640 dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);
1641
1642 out:
1643 return dst;
1644 }
1645
1646 int icmp6_dst_gc(void)
1647 {
1648 struct dst_entry *dst, **pprev;
1649 int more = 0;
1650
1651 spin_lock_bh(&icmp6_dst_lock);
1652 pprev = &icmp6_dst_gc_list;
1653
1654 while ((dst = *pprev) != NULL) {
1655 if (!atomic_read(&dst->__refcnt)) {
1656 *pprev = dst->next;
1657 dst_free(dst);
1658 } else {
1659 pprev = &dst->next;
1660 ++more;
1661 }
1662 }
1663
1664 spin_unlock_bh(&icmp6_dst_lock);
1665
1666 return more;
1667 }
1668
1669 static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1670 void *arg)
1671 {
1672 struct dst_entry *dst, **pprev;
1673
1674 spin_lock_bh(&icmp6_dst_lock);
1675 pprev = &icmp6_dst_gc_list;
1676 while ((dst = *pprev) != NULL) {
1677 struct rt6_info *rt = (struct rt6_info *) dst;
1678 if (func(rt, arg)) {
1679 *pprev = dst->next;
1680 dst_free(dst);
1681 } else {
1682 pprev = &dst->next;
1683 }
1684 }
1685 spin_unlock_bh(&icmp6_dst_lock);
1686 }
1687
1688 static int ip6_dst_gc(struct dst_ops *ops)
1689 {
1690 struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
1691 int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1692 int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1693 int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1694 int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1695 unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
1696 int entries;
1697
1698 entries = dst_entries_get_fast(ops);
1699 if (time_after(rt_last_gc + rt_min_interval, jiffies) &&
1700 entries <= rt_max_size)
1701 goto out;
1702
1703 net->ipv6.ip6_rt_gc_expire++;
1704 fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, true);
1705 entries = dst_entries_get_slow(ops);
1706 if (entries < ops->gc_thresh)
1707 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1708 out:
1709 net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
1710 return entries > rt_max_size;
1711 }
1712
1713 static int ip6_convert_metrics(struct mx6_config *mxc,
1714 const struct fib6_config *cfg)
1715 {
1716 bool ecn_ca = false;
1717 struct nlattr *nla;
1718 int remaining;
1719 u32 *mp;
1720
1721 if (!cfg->fc_mx)
1722 return 0;
1723
1724 mp = kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);
1725 if (unlikely(!mp))
1726 return -ENOMEM;
1727
1728 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1729 int type = nla_type(nla);
1730 u32 val;
1731
1732 if (!type)
1733 continue;
1734 if (unlikely(type > RTAX_MAX))
1735 goto err;
1736
1737 if (type == RTAX_CC_ALGO) {
1738 char tmp[TCP_CA_NAME_MAX];
1739
1740 nla_strlcpy(tmp, nla, sizeof(tmp));
1741 val = tcp_ca_get_key_by_name(tmp, &ecn_ca);
1742 if (val == TCP_CA_UNSPEC)
1743 goto err;
1744 } else {
1745 val = nla_get_u32(nla);
1746 }
1747 if (type == RTAX_HOPLIMIT && val > 255)
1748 val = 255;
1749 if (type == RTAX_FEATURES && (val & ~RTAX_FEATURE_MASK))
1750 goto err;
1751
1752 mp[type - 1] = val;
1753 __set_bit(type - 1, mxc->mx_valid);
1754 }
1755
1756 if (ecn_ca) {
1757 __set_bit(RTAX_FEATURES - 1, mxc->mx_valid);
1758 mp[RTAX_FEATURES - 1] |= DST_FEATURE_ECN_CA;
1759 }
1760
1761 mxc->mx = mp;
1762 return 0;
1763 err:
1764 kfree(mp);
1765 return -EINVAL;
1766 }
1767
1768 static struct rt6_info *ip6_route_info_create(struct fib6_config *cfg)
1769 {
1770 struct net *net = cfg->fc_nlinfo.nl_net;
1771 struct rt6_info *rt = NULL;
1772 struct net_device *dev = NULL;
1773 struct inet6_dev *idev = NULL;
1774 struct fib6_table *table;
1775 int addr_type;
1776 int err = -EINVAL;
1777
1778 /* RTF_PCPU is an internal flag; can not be set by userspace */
1779 if (cfg->fc_flags & RTF_PCPU)
1780 goto out;
1781
1782 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1783 goto out;
1784 #ifndef CONFIG_IPV6_SUBTREES
1785 if (cfg->fc_src_len)
1786 goto out;
1787 #endif
1788 if (cfg->fc_ifindex) {
1789 err = -ENODEV;
1790 dev = dev_get_by_index(net, cfg->fc_ifindex);
1791 if (!dev)
1792 goto out;
1793 idev = in6_dev_get(dev);
1794 if (!idev)
1795 goto out;
1796 }
1797
1798 if (cfg->fc_metric == 0)
1799 cfg->fc_metric = IP6_RT_PRIO_USER;
1800
1801 err = -ENOBUFS;
1802 if (cfg->fc_nlinfo.nlh &&
1803 !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
1804 table = fib6_get_table(net, cfg->fc_table);
1805 if (!table) {
1806 pr_warn("NLM_F_CREATE should be specified when creating new route\n");
1807 table = fib6_new_table(net, cfg->fc_table);
1808 }
1809 } else {
1810 table = fib6_new_table(net, cfg->fc_table);
1811 }
1812
1813 if (!table)
1814 goto out;
1815
1816 rt = ip6_dst_alloc(net, NULL,
1817 (cfg->fc_flags & RTF_ADDRCONF) ? 0 : DST_NOCOUNT);
1818
1819 if (!rt) {
1820 err = -ENOMEM;
1821 goto out;
1822 }
1823
1824 if (cfg->fc_flags & RTF_EXPIRES)
1825 rt6_set_expires(rt, jiffies +
1826 clock_t_to_jiffies(cfg->fc_expires));
1827 else
1828 rt6_clean_expires(rt);
1829
1830 if (cfg->fc_protocol == RTPROT_UNSPEC)
1831 cfg->fc_protocol = RTPROT_BOOT;
1832 rt->rt6i_protocol = cfg->fc_protocol;
1833
1834 addr_type = ipv6_addr_type(&cfg->fc_dst);
1835
1836 if (addr_type & IPV6_ADDR_MULTICAST)
1837 rt->dst.input = ip6_mc_input;
1838 else if (cfg->fc_flags & RTF_LOCAL)
1839 rt->dst.input = ip6_input;
1840 else
1841 rt->dst.input = ip6_forward;
1842
1843 rt->dst.output = ip6_output;
1844
1845 if (cfg->fc_encap) {
1846 struct lwtunnel_state *lwtstate;
1847
1848 err = lwtunnel_build_state(dev, cfg->fc_encap_type,
1849 cfg->fc_encap, AF_INET6, cfg,
1850 &lwtstate);
1851 if (err)
1852 goto out;
1853 rt->dst.lwtstate = lwtstate_get(lwtstate);
1854 if (lwtunnel_output_redirect(rt->dst.lwtstate)) {
1855 rt->dst.lwtstate->orig_output = rt->dst.output;
1856 rt->dst.output = lwtunnel_output;
1857 }
1858 if (lwtunnel_input_redirect(rt->dst.lwtstate)) {
1859 rt->dst.lwtstate->orig_input = rt->dst.input;
1860 rt->dst.input = lwtunnel_input;
1861 }
1862 }
1863
1864 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1865 rt->rt6i_dst.plen = cfg->fc_dst_len;
1866 if (rt->rt6i_dst.plen == 128)
1867 rt->dst.flags |= DST_HOST;
1868
1869 #ifdef CONFIG_IPV6_SUBTREES
1870 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1871 rt->rt6i_src.plen = cfg->fc_src_len;
1872 #endif
1873
1874 rt->rt6i_metric = cfg->fc_metric;
1875
1876 /* We cannot add true routes via loopback here,
1877 they would result in kernel looping; promote them to reject routes
1878 */
1879 if ((cfg->fc_flags & RTF_REJECT) ||
1880 (dev && (dev->flags & IFF_LOOPBACK) &&
1881 !(addr_type & IPV6_ADDR_LOOPBACK) &&
1882 !(cfg->fc_flags & RTF_LOCAL))) {
1883 /* hold loopback dev/idev if we haven't done so. */
1884 if (dev != net->loopback_dev) {
1885 if (dev) {
1886 dev_put(dev);
1887 in6_dev_put(idev);
1888 }
1889 dev = net->loopback_dev;
1890 dev_hold(dev);
1891 idev = in6_dev_get(dev);
1892 if (!idev) {
1893 err = -ENODEV;
1894 goto out;
1895 }
1896 }
1897 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1898 switch (cfg->fc_type) {
1899 case RTN_BLACKHOLE:
1900 rt->dst.error = -EINVAL;
1901 rt->dst.output = dst_discard_out;
1902 rt->dst.input = dst_discard;
1903 break;
1904 case RTN_PROHIBIT:
1905 rt->dst.error = -EACCES;
1906 rt->dst.output = ip6_pkt_prohibit_out;
1907 rt->dst.input = ip6_pkt_prohibit;
1908 break;
1909 case RTN_THROW:
1910 case RTN_UNREACHABLE:
1911 default:
1912 rt->dst.error = (cfg->fc_type == RTN_THROW) ? -EAGAIN
1913 : (cfg->fc_type == RTN_UNREACHABLE)
1914 ? -EHOSTUNREACH : -ENETUNREACH;
1915 rt->dst.output = ip6_pkt_discard_out;
1916 rt->dst.input = ip6_pkt_discard;
1917 break;
1918 }
1919 goto install_route;
1920 }
1921
1922 if (cfg->fc_flags & RTF_GATEWAY) {
1923 const struct in6_addr *gw_addr;
1924 int gwa_type;
1925
1926 gw_addr = &cfg->fc_gateway;
1927 gwa_type = ipv6_addr_type(gw_addr);
1928
1929 /* if gw_addr is local we will fail to detect this in case
1930 * address is still TENTATIVE (DAD in progress). rt6_lookup()
1931 * will return already-added prefix route via interface that
1932 * prefix route was assigned to, which might be non-loopback.
1933 */
1934 err = -EINVAL;
1935 if (ipv6_chk_addr_and_flags(net, gw_addr,
1936 gwa_type & IPV6_ADDR_LINKLOCAL ?
1937 dev : NULL, 0, 0))
1938 goto out;
1939
1940 rt->rt6i_gateway = *gw_addr;
1941
1942 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1943 struct rt6_info *grt;
1944
1945 /* IPv6 strictly inhibits using not link-local
1946 addresses as nexthop address.
1947 Otherwise, router will not able to send redirects.
1948 It is very good, but in some (rare!) circumstances
1949 (SIT, PtP, NBMA NOARP links) it is handy to allow
1950 some exceptions. --ANK
1951 */
1952 if (!(gwa_type & IPV6_ADDR_UNICAST))
1953 goto out;
1954
1955 grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
1956
1957 err = -EHOSTUNREACH;
1958 if (!grt)
1959 goto out;
1960 if (dev) {
1961 if (dev != grt->dst.dev) {
1962 ip6_rt_put(grt);
1963 goto out;
1964 }
1965 } else {
1966 dev = grt->dst.dev;
1967 idev = grt->rt6i_idev;
1968 dev_hold(dev);
1969 in6_dev_hold(grt->rt6i_idev);
1970 }
1971 if (!(grt->rt6i_flags & RTF_GATEWAY))
1972 err = 0;
1973 ip6_rt_put(grt);
1974
1975 if (err)
1976 goto out;
1977 }
1978 err = -EINVAL;
1979 if (!dev || (dev->flags & IFF_LOOPBACK))
1980 goto out;
1981 }
1982
1983 err = -ENODEV;
1984 if (!dev)
1985 goto out;
1986
1987 if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
1988 if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
1989 err = -EINVAL;
1990 goto out;
1991 }
1992 rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
1993 rt->rt6i_prefsrc.plen = 128;
1994 } else
1995 rt->rt6i_prefsrc.plen = 0;
1996
1997 rt->rt6i_flags = cfg->fc_flags;
1998
1999 install_route:
2000 rt->dst.dev = dev;
2001 rt->rt6i_idev = idev;
2002 rt->rt6i_table = table;
2003
2004 cfg->fc_nlinfo.nl_net = dev_net(dev);
2005
2006 return rt;
2007 out:
2008 if (dev)
2009 dev_put(dev);
2010 if (idev)
2011 in6_dev_put(idev);
2012 if (rt)
2013 dst_free(&rt->dst);
2014
2015 return ERR_PTR(err);
2016 }
2017
2018 int ip6_route_add(struct fib6_config *cfg)
2019 {
2020 struct mx6_config mxc = { .mx = NULL, };
2021 struct rt6_info *rt;
2022 int err;
2023
2024 rt = ip6_route_info_create(cfg);
2025 if (IS_ERR(rt)) {
2026 err = PTR_ERR(rt);
2027 rt = NULL;
2028 goto out;
2029 }
2030
2031 err = ip6_convert_metrics(&mxc, cfg);
2032 if (err)
2033 goto out;
2034
2035 err = __ip6_ins_rt(rt, &cfg->fc_nlinfo, &mxc);
2036
2037 kfree(mxc.mx);
2038
2039 return err;
2040 out:
2041 if (rt)
2042 dst_free(&rt->dst);
2043
2044 return err;
2045 }
2046
2047 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
2048 {
2049 int err;
2050 struct fib6_table *table;
2051 struct net *net = dev_net(rt->dst.dev);
2052
2053 if (rt == net->ipv6.ip6_null_entry ||
2054 rt->dst.flags & DST_NOCACHE) {
2055 err = -ENOENT;
2056 goto out;
2057 }
2058
2059 table = rt->rt6i_table;
2060 write_lock_bh(&table->tb6_lock);
2061 err = fib6_del(rt, info);
2062 write_unlock_bh(&table->tb6_lock);
2063
2064 out:
2065 ip6_rt_put(rt);
2066 return err;
2067 }
2068
2069 int ip6_del_rt(struct rt6_info *rt)
2070 {
2071 struct nl_info info = {
2072 .nl_net = dev_net(rt->dst.dev),
2073 };
2074 return __ip6_del_rt(rt, &info);
2075 }
2076
2077 static int ip6_route_del(struct fib6_config *cfg)
2078 {
2079 struct fib6_table *table;
2080 struct fib6_node *fn;
2081 struct rt6_info *rt;
2082 int err = -ESRCH;
2083
2084 table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
2085 if (!table)
2086 return err;
2087
2088 read_lock_bh(&table->tb6_lock);
2089
2090 fn = fib6_locate(&table->tb6_root,
2091 &cfg->fc_dst, cfg->fc_dst_len,
2092 &cfg->fc_src, cfg->fc_src_len);
2093
2094 if (fn) {
2095 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
2096 if ((rt->rt6i_flags & RTF_CACHE) &&
2097 !(cfg->fc_flags & RTF_CACHE))
2098 continue;
2099 if (cfg->fc_ifindex &&
2100 (!rt->dst.dev ||
2101 rt->dst.dev->ifindex != cfg->fc_ifindex))
2102 continue;
2103 if (cfg->fc_flags & RTF_GATEWAY &&
2104 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
2105 continue;
2106 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
2107 continue;
2108 if (cfg->fc_protocol && cfg->fc_protocol != rt->rt6i_protocol)
2109 continue;
2110 dst_hold(&rt->dst);
2111 read_unlock_bh(&table->tb6_lock);
2112
2113 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
2114 }
2115 }
2116 read_unlock_bh(&table->tb6_lock);
2117
2118 return err;
2119 }
2120
2121 static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
2122 {
2123 struct netevent_redirect netevent;
2124 struct rt6_info *rt, *nrt = NULL;
2125 struct ndisc_options ndopts;
2126 struct inet6_dev *in6_dev;
2127 struct neighbour *neigh;
2128 struct rd_msg *msg;
2129 int optlen, on_link;
2130 u8 *lladdr;
2131
2132 optlen = skb_tail_pointer(skb) - skb_transport_header(skb);
2133 optlen -= sizeof(*msg);
2134
2135 if (optlen < 0) {
2136 net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
2137 return;
2138 }
2139
2140 msg = (struct rd_msg *)icmp6_hdr(skb);
2141
2142 if (ipv6_addr_is_multicast(&msg->dest)) {
2143 net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
2144 return;
2145 }
2146
2147 on_link = 0;
2148 if (ipv6_addr_equal(&msg->dest, &msg->target)) {
2149 on_link = 1;
2150 } else if (ipv6_addr_type(&msg->target) !=
2151 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
2152 net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
2153 return;
2154 }
2155
2156 in6_dev = __in6_dev_get(skb->dev);
2157 if (!in6_dev)
2158 return;
2159 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
2160 return;
2161
2162 /* RFC2461 8.1:
2163 * The IP source address of the Redirect MUST be the same as the current
2164 * first-hop router for the specified ICMP Destination Address.
2165 */
2166
2167 if (!ndisc_parse_options(msg->opt, optlen, &ndopts)) {
2168 net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
2169 return;
2170 }
2171
2172 lladdr = NULL;
2173 if (ndopts.nd_opts_tgt_lladdr) {
2174 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
2175 skb->dev);
2176 if (!lladdr) {
2177 net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
2178 return;
2179 }
2180 }
2181
2182 rt = (struct rt6_info *) dst;
2183 if (rt->rt6i_flags & RTF_REJECT) {
2184 net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
2185 return;
2186 }
2187
2188 /* Redirect received -> path was valid.
2189 * Look, redirects are sent only in response to data packets,
2190 * so that this nexthop apparently is reachable. --ANK
2191 */
2192 dst_confirm(&rt->dst);
2193
2194 neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
2195 if (!neigh)
2196 return;
2197
2198 /*
2199 * We have finally decided to accept it.
2200 */
2201
2202 neigh_update(neigh, lladdr, NUD_STALE,
2203 NEIGH_UPDATE_F_WEAK_OVERRIDE|
2204 NEIGH_UPDATE_F_OVERRIDE|
2205 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
2206 NEIGH_UPDATE_F_ISROUTER))
2207 );
2208
2209 nrt = ip6_rt_cache_alloc(rt, &msg->dest, NULL);
2210 if (!nrt)
2211 goto out;
2212
2213 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
2214 if (on_link)
2215 nrt->rt6i_flags &= ~RTF_GATEWAY;
2216
2217 nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;
2218
2219 if (ip6_ins_rt(nrt))
2220 goto out;
2221
2222 netevent.old = &rt->dst;
2223 netevent.new = &nrt->dst;
2224 netevent.daddr = &msg->dest;
2225 netevent.neigh = neigh;
2226 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
2227
2228 if (rt->rt6i_flags & RTF_CACHE) {
2229 rt = (struct rt6_info *) dst_clone(&rt->dst);
2230 ip6_del_rt(rt);
2231 }
2232
2233 out:
2234 neigh_release(neigh);
2235 }
2236
2237 /*
2238 * Misc support functions
2239 */
2240
2241 static void rt6_set_from(struct rt6_info *rt, struct rt6_info *from)
2242 {
2243 BUG_ON(from->dst.from);
2244
2245 rt->rt6i_flags &= ~RTF_EXPIRES;
2246 dst_hold(&from->dst);
2247 rt->dst.from = &from->dst;
2248 dst_init_metrics(&rt->dst, dst_metrics_ptr(&from->dst), true);
2249 }
2250
2251 static void ip6_rt_copy_init(struct rt6_info *rt, struct rt6_info *ort)
2252 {
2253 rt->dst.input = ort->dst.input;
2254 rt->dst.output = ort->dst.output;
2255 rt->rt6i_dst = ort->rt6i_dst;
2256 rt->dst.error = ort->dst.error;
2257 rt->rt6i_idev = ort->rt6i_idev;
2258 if (rt->rt6i_idev)
2259 in6_dev_hold(rt->rt6i_idev);
2260 rt->dst.lastuse = jiffies;
2261 rt->rt6i_gateway = ort->rt6i_gateway;
2262 rt->rt6i_flags = ort->rt6i_flags;
2263 rt6_set_from(rt, ort);
2264 rt->rt6i_metric = ort->rt6i_metric;
2265 #ifdef CONFIG_IPV6_SUBTREES
2266 rt->rt6i_src = ort->rt6i_src;
2267 #endif
2268 rt->rt6i_prefsrc = ort->rt6i_prefsrc;
2269 rt->rt6i_table = ort->rt6i_table;
2270 rt->dst.lwtstate = lwtstate_get(ort->dst.lwtstate);
2271 }
2272
2273 #ifdef CONFIG_IPV6_ROUTE_INFO
2274 static struct rt6_info *rt6_get_route_info(struct net *net,
2275 const struct in6_addr *prefix, int prefixlen,
2276 const struct in6_addr *gwaddr, int ifindex)
2277 {
2278 struct fib6_node *fn;
2279 struct rt6_info *rt = NULL;
2280 struct fib6_table *table;
2281
2282 table = fib6_get_table(net, RT6_TABLE_INFO);
2283 if (!table)
2284 return NULL;
2285
2286 read_lock_bh(&table->tb6_lock);
2287 fn = fib6_locate(&table->tb6_root, prefix, prefixlen, NULL, 0);
2288 if (!fn)
2289 goto out;
2290
2291 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
2292 if (rt->dst.dev->ifindex != ifindex)
2293 continue;
2294 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
2295 continue;
2296 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
2297 continue;
2298 dst_hold(&rt->dst);
2299 break;
2300 }
2301 out:
2302 read_unlock_bh(&table->tb6_lock);
2303 return rt;
2304 }
2305
2306 static struct rt6_info *rt6_add_route_info(struct net *net,
2307 const struct in6_addr *prefix, int prefixlen,
2308 const struct in6_addr *gwaddr, int ifindex,
2309 unsigned int pref)
2310 {
2311 struct fib6_config cfg = {
2312 .fc_metric = IP6_RT_PRIO_USER,
2313 .fc_ifindex = ifindex,
2314 .fc_dst_len = prefixlen,
2315 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
2316 RTF_UP | RTF_PREF(pref),
2317 .fc_nlinfo.portid = 0,
2318 .fc_nlinfo.nlh = NULL,
2319 .fc_nlinfo.nl_net = net,
2320 };
2321
2322 cfg.fc_table = l3mdev_fib_table_by_index(net, ifindex) ? : RT6_TABLE_INFO;
2323 cfg.fc_dst = *prefix;
2324 cfg.fc_gateway = *gwaddr;
2325
2326 /* We should treat it as a default route if prefix length is 0. */
2327 if (!prefixlen)
2328 cfg.fc_flags |= RTF_DEFAULT;
2329
2330 ip6_route_add(&cfg);
2331
2332 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
2333 }
2334 #endif
2335
2336 struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
2337 {
2338 struct rt6_info *rt;
2339 struct fib6_table *table;
2340
2341 table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
2342 if (!table)
2343 return NULL;
2344
2345 read_lock_bh(&table->tb6_lock);
2346 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
2347 if (dev == rt->dst.dev &&
2348 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
2349 ipv6_addr_equal(&rt->rt6i_gateway, addr))
2350 break;
2351 }
2352 if (rt)
2353 dst_hold(&rt->dst);
2354 read_unlock_bh(&table->tb6_lock);
2355 return rt;
2356 }
2357
2358 struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
2359 struct net_device *dev,
2360 unsigned int pref)
2361 {
2362 struct fib6_config cfg = {
2363 .fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_DFLT,
2364 .fc_metric = IP6_RT_PRIO_USER,
2365 .fc_ifindex = dev->ifindex,
2366 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
2367 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
2368 .fc_nlinfo.portid = 0,
2369 .fc_nlinfo.nlh = NULL,
2370 .fc_nlinfo.nl_net = dev_net(dev),
2371 };
2372
2373 cfg.fc_gateway = *gwaddr;
2374
2375 ip6_route_add(&cfg);
2376
2377 return rt6_get_dflt_router(gwaddr, dev);
2378 }
2379
2380 void rt6_purge_dflt_routers(struct net *net)
2381 {
2382 struct rt6_info *rt;
2383 struct fib6_table *table;
2384
2385 /* NOTE: Keep consistent with rt6_get_dflt_router */
2386 table = fib6_get_table(net, RT6_TABLE_DFLT);
2387 if (!table)
2388 return;
2389
2390 restart:
2391 read_lock_bh(&table->tb6_lock);
2392 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
2393 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
2394 (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) {
2395 dst_hold(&rt->dst);
2396 read_unlock_bh(&table->tb6_lock);
2397 ip6_del_rt(rt);
2398 goto restart;
2399 }
2400 }
2401 read_unlock_bh(&table->tb6_lock);
2402 }
2403
2404 static void rtmsg_to_fib6_config(struct net *net,
2405 struct in6_rtmsg *rtmsg,
2406 struct fib6_config *cfg)
2407 {
2408 memset(cfg, 0, sizeof(*cfg));
2409
2410 cfg->fc_table = l3mdev_fib_table_by_index(net, rtmsg->rtmsg_ifindex) ?
2411 : RT6_TABLE_MAIN;
2412 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
2413 cfg->fc_metric = rtmsg->rtmsg_metric;
2414 cfg->fc_expires = rtmsg->rtmsg_info;
2415 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
2416 cfg->fc_src_len = rtmsg->rtmsg_src_len;
2417 cfg->fc_flags = rtmsg->rtmsg_flags;
2418
2419 cfg->fc_nlinfo.nl_net = net;
2420
2421 cfg->fc_dst = rtmsg->rtmsg_dst;
2422 cfg->fc_src = rtmsg->rtmsg_src;
2423 cfg->fc_gateway = rtmsg->rtmsg_gateway;
2424 }
2425
2426 int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
2427 {
2428 struct fib6_config cfg;
2429 struct in6_rtmsg rtmsg;
2430 int err;
2431
2432 switch (cmd) {
2433 case SIOCADDRT: /* Add a route */
2434 case SIOCDELRT: /* Delete a route */
2435 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
2436 return -EPERM;
2437 err = copy_from_user(&rtmsg, arg,
2438 sizeof(struct in6_rtmsg));
2439 if (err)
2440 return -EFAULT;
2441
2442 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
2443
2444 rtnl_lock();
2445 switch (cmd) {
2446 case SIOCADDRT:
2447 err = ip6_route_add(&cfg);
2448 break;
2449 case SIOCDELRT:
2450 err = ip6_route_del(&cfg);
2451 break;
2452 default:
2453 err = -EINVAL;
2454 }
2455 rtnl_unlock();
2456
2457 return err;
2458 }
2459
2460 return -EINVAL;
2461 }
2462
2463 /*
2464 * Drop the packet on the floor
2465 */
2466
2467 static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
2468 {
2469 int type;
2470 struct dst_entry *dst = skb_dst(skb);
2471 switch (ipstats_mib_noroutes) {
2472 case IPSTATS_MIB_INNOROUTES:
2473 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
2474 if (type == IPV6_ADDR_ANY) {
2475 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2476 IPSTATS_MIB_INADDRERRORS);
2477 break;
2478 }
2479 /* FALLTHROUGH */
2480 case IPSTATS_MIB_OUTNOROUTES:
2481 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
2482 ipstats_mib_noroutes);
2483 break;
2484 }
2485 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
2486 kfree_skb(skb);
2487 return 0;
2488 }
2489
2490 static int ip6_pkt_discard(struct sk_buff *skb)
2491 {
2492 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
2493 }
2494
2495 static int ip6_pkt_discard_out(struct net *net, struct sock *sk, struct sk_buff *skb)
2496 {
2497 skb->dev = skb_dst(skb)->dev;
2498 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
2499 }
2500
2501 static int ip6_pkt_prohibit(struct sk_buff *skb)
2502 {
2503 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
2504 }
2505
2506 static int ip6_pkt_prohibit_out(struct net *net, struct sock *sk, struct sk_buff *skb)
2507 {
2508 skb->dev = skb_dst(skb)->dev;
2509 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
2510 }
2511
2512 /*
2513 * Allocate a dst for local (unicast / anycast) address.
2514 */
2515
2516 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
2517 const struct in6_addr *addr,
2518 bool anycast)
2519 {
2520 u32 tb_id;
2521 struct net *net = dev_net(idev->dev);
2522 struct rt6_info *rt = ip6_dst_alloc(net, net->loopback_dev,
2523 DST_NOCOUNT);
2524 if (!rt)
2525 return ERR_PTR(-ENOMEM);
2526
2527 in6_dev_hold(idev);
2528
2529 rt->dst.flags |= DST_HOST;
2530 rt->dst.input = ip6_input;
2531 rt->dst.output = ip6_output;
2532 rt->rt6i_idev = idev;
2533
2534 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
2535 if (anycast)
2536 rt->rt6i_flags |= RTF_ANYCAST;
2537 else
2538 rt->rt6i_flags |= RTF_LOCAL;
2539
2540 rt->rt6i_gateway = *addr;
2541 rt->rt6i_dst.addr = *addr;
2542 rt->rt6i_dst.plen = 128;
2543 tb_id = l3mdev_fib_table(idev->dev) ? : RT6_TABLE_LOCAL;
2544 rt->rt6i_table = fib6_get_table(net, tb_id);
2545 rt->dst.flags |= DST_NOCACHE;
2546
2547 atomic_set(&rt->dst.__refcnt, 1);
2548
2549 return rt;
2550 }
2551
2552 int ip6_route_get_saddr(struct net *net,
2553 struct rt6_info *rt,
2554 const struct in6_addr *daddr,
2555 unsigned int prefs,
2556 struct in6_addr *saddr)
2557 {
2558 struct inet6_dev *idev =
2559 rt ? ip6_dst_idev((struct dst_entry *)rt) : NULL;
2560 int err = 0;
2561 if (rt && rt->rt6i_prefsrc.plen)
2562 *saddr = rt->rt6i_prefsrc.addr;
2563 else
2564 err = ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
2565 daddr, prefs, saddr);
2566 return err;
2567 }
2568
2569 /* remove deleted ip from prefsrc entries */
2570 struct arg_dev_net_ip {
2571 struct net_device *dev;
2572 struct net *net;
2573 struct in6_addr *addr;
2574 };
2575
2576 static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
2577 {
2578 struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
2579 struct net *net = ((struct arg_dev_net_ip *)arg)->net;
2580 struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;
2581
2582 if (((void *)rt->dst.dev == dev || !dev) &&
2583 rt != net->ipv6.ip6_null_entry &&
2584 ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
2585 /* remove prefsrc entry */
2586 rt->rt6i_prefsrc.plen = 0;
2587 }
2588 return 0;
2589 }
2590
2591 void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
2592 {
2593 struct net *net = dev_net(ifp->idev->dev);
2594 struct arg_dev_net_ip adni = {
2595 .dev = ifp->idev->dev,
2596 .net = net,
2597 .addr = &ifp->addr,
2598 };
2599 fib6_clean_all(net, fib6_remove_prefsrc, &adni);
2600 }
2601
2602 #define RTF_RA_ROUTER (RTF_ADDRCONF | RTF_DEFAULT | RTF_GATEWAY)
2603 #define RTF_CACHE_GATEWAY (RTF_GATEWAY | RTF_CACHE)
2604
2605 /* Remove routers and update dst entries when gateway turn into host. */
2606 static int fib6_clean_tohost(struct rt6_info *rt, void *arg)
2607 {
2608 struct in6_addr *gateway = (struct in6_addr *)arg;
2609
2610 if ((((rt->rt6i_flags & RTF_RA_ROUTER) == RTF_RA_ROUTER) ||
2611 ((rt->rt6i_flags & RTF_CACHE_GATEWAY) == RTF_CACHE_GATEWAY)) &&
2612 ipv6_addr_equal(gateway, &rt->rt6i_gateway)) {
2613 return -1;
2614 }
2615 return 0;
2616 }
2617
2618 void rt6_clean_tohost(struct net *net, struct in6_addr *gateway)
2619 {
2620 fib6_clean_all(net, fib6_clean_tohost, gateway);
2621 }
2622
2623 struct arg_dev_net {
2624 struct net_device *dev;
2625 struct net *net;
2626 };
2627
2628 static int fib6_ifdown(struct rt6_info *rt, void *arg)
2629 {
2630 const struct arg_dev_net *adn = arg;
2631 const struct net_device *dev = adn->dev;
2632
2633 if ((rt->dst.dev == dev || !dev) &&
2634 rt != adn->net->ipv6.ip6_null_entry)
2635 return -1;
2636
2637 return 0;
2638 }
2639
2640 void rt6_ifdown(struct net *net, struct net_device *dev)
2641 {
2642 struct arg_dev_net adn = {
2643 .dev = dev,
2644 .net = net,
2645 };
2646
2647 fib6_clean_all(net, fib6_ifdown, &adn);
2648 icmp6_clean_all(fib6_ifdown, &adn);
2649 if (dev)
2650 rt6_uncached_list_flush_dev(net, dev);
2651 }
2652
2653 struct rt6_mtu_change_arg {
2654 struct net_device *dev;
2655 unsigned int mtu;
2656 };
2657
2658 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
2659 {
2660 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
2661 struct inet6_dev *idev;
2662
2663 /* In IPv6 pmtu discovery is not optional,
2664 so that RTAX_MTU lock cannot disable it.
2665 We still use this lock to block changes
2666 caused by addrconf/ndisc.
2667 */
2668
2669 idev = __in6_dev_get(arg->dev);
2670 if (!idev)
2671 return 0;
2672
2673 /* For administrative MTU increase, there is no way to discover
2674 IPv6 PMTU increase, so PMTU increase should be updated here.
2675 Since RFC 1981 doesn't include administrative MTU increase
2676 update PMTU increase is a MUST. (i.e. jumbo frame)
2677 */
2678 /*
2679 If new MTU is less than route PMTU, this new MTU will be the
2680 lowest MTU in the path, update the route PMTU to reflect PMTU
2681 decreases; if new MTU is greater than route PMTU, and the
2682 old MTU is the lowest MTU in the path, update the route PMTU
2683 to reflect the increase. In this case if the other nodes' MTU
2684 also have the lowest MTU, TOO BIG MESSAGE will be lead to
2685 PMTU discouvery.
2686 */
2687 if (rt->dst.dev == arg->dev &&
2688 !dst_metric_locked(&rt->dst, RTAX_MTU)) {
2689 if (rt->rt6i_flags & RTF_CACHE) {
2690 /* For RTF_CACHE with rt6i_pmtu == 0
2691 * (i.e. a redirected route),
2692 * the metrics of its rt->dst.from has already
2693 * been updated.
2694 */
2695 if (rt->rt6i_pmtu && rt->rt6i_pmtu > arg->mtu)
2696 rt->rt6i_pmtu = arg->mtu;
2697 } else if (dst_mtu(&rt->dst) >= arg->mtu ||
2698 (dst_mtu(&rt->dst) < arg->mtu &&
2699 dst_mtu(&rt->dst) == idev->cnf.mtu6)) {
2700 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
2701 }
2702 }
2703 return 0;
2704 }
2705
2706 void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
2707 {
2708 struct rt6_mtu_change_arg arg = {
2709 .dev = dev,
2710 .mtu = mtu,
2711 };
2712
2713 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);
2714 }
2715
2716 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
2717 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
2718 [RTA_PREFSRC] = { .len = sizeof(struct in6_addr) },
2719 [RTA_OIF] = { .type = NLA_U32 },
2720 [RTA_IIF] = { .type = NLA_U32 },
2721 [RTA_PRIORITY] = { .type = NLA_U32 },
2722 [RTA_METRICS] = { .type = NLA_NESTED },
2723 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
2724 [RTA_PREF] = { .type = NLA_U8 },
2725 [RTA_ENCAP_TYPE] = { .type = NLA_U16 },
2726 [RTA_ENCAP] = { .type = NLA_NESTED },
2727 [RTA_TABLE] = { .type = NLA_U32 },
2728 };
2729
2730 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
2731 struct fib6_config *cfg)
2732 {
2733 struct rtmsg *rtm;
2734 struct nlattr *tb[RTA_MAX+1];
2735 unsigned int pref;
2736 int err;
2737
2738 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2739 if (err < 0)
2740 goto errout;
2741
2742 err = -EINVAL;
2743 rtm = nlmsg_data(nlh);
2744 memset(cfg, 0, sizeof(*cfg));
2745
2746 cfg->fc_table = rtm->rtm_table;
2747 cfg->fc_dst_len = rtm->rtm_dst_len;
2748 cfg->fc_src_len = rtm->rtm_src_len;
2749 cfg->fc_flags = RTF_UP;
2750 cfg->fc_protocol = rtm->rtm_protocol;
2751 cfg->fc_type = rtm->rtm_type;
2752
2753 if (rtm->rtm_type == RTN_UNREACHABLE ||
2754 rtm->rtm_type == RTN_BLACKHOLE ||
2755 rtm->rtm_type == RTN_PROHIBIT ||
2756 rtm->rtm_type == RTN_THROW)
2757 cfg->fc_flags |= RTF_REJECT;
2758
2759 if (rtm->rtm_type == RTN_LOCAL)
2760 cfg->fc_flags |= RTF_LOCAL;
2761
2762 if (rtm->rtm_flags & RTM_F_CLONED)
2763 cfg->fc_flags |= RTF_CACHE;
2764
2765 cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
2766 cfg->fc_nlinfo.nlh = nlh;
2767 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
2768
2769 if (tb[RTA_GATEWAY]) {
2770 cfg->fc_gateway = nla_get_in6_addr(tb[RTA_GATEWAY]);
2771 cfg->fc_flags |= RTF_GATEWAY;
2772 }
2773
2774 if (tb[RTA_DST]) {
2775 int plen = (rtm->rtm_dst_len + 7) >> 3;
2776
2777 if (nla_len(tb[RTA_DST]) < plen)
2778 goto errout;
2779
2780 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
2781 }
2782
2783 if (tb[RTA_SRC]) {
2784 int plen = (rtm->rtm_src_len + 7) >> 3;
2785
2786 if (nla_len(tb[RTA_SRC]) < plen)
2787 goto errout;
2788
2789 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
2790 }
2791
2792 if (tb[RTA_PREFSRC])
2793 cfg->fc_prefsrc = nla_get_in6_addr(tb[RTA_PREFSRC]);
2794
2795 if (tb[RTA_OIF])
2796 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
2797
2798 if (tb[RTA_PRIORITY])
2799 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
2800
2801 if (tb[RTA_METRICS]) {
2802 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2803 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
2804 }
2805
2806 if (tb[RTA_TABLE])
2807 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2808
2809 if (tb[RTA_MULTIPATH]) {
2810 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
2811 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
2812 }
2813
2814 if (tb[RTA_PREF]) {
2815 pref = nla_get_u8(tb[RTA_PREF]);
2816 if (pref != ICMPV6_ROUTER_PREF_LOW &&
2817 pref != ICMPV6_ROUTER_PREF_HIGH)
2818 pref = ICMPV6_ROUTER_PREF_MEDIUM;
2819 cfg->fc_flags |= RTF_PREF(pref);
2820 }
2821
2822 if (tb[RTA_ENCAP])
2823 cfg->fc_encap = tb[RTA_ENCAP];
2824
2825 if (tb[RTA_ENCAP_TYPE])
2826 cfg->fc_encap_type = nla_get_u16(tb[RTA_ENCAP_TYPE]);
2827
2828 err = 0;
2829 errout:
2830 return err;
2831 }
2832
2833 struct rt6_nh {
2834 struct rt6_info *rt6_info;
2835 struct fib6_config r_cfg;
2836 struct mx6_config mxc;
2837 struct list_head next;
2838 };
2839
2840 static void ip6_print_replace_route_err(struct list_head *rt6_nh_list)
2841 {
2842 struct rt6_nh *nh;
2843
2844 list_for_each_entry(nh, rt6_nh_list, next) {
2845 pr_warn("IPV6: multipath route replace failed (check consistency of installed routes): %pI6 nexthop %pI6 ifi %d\n",
2846 &nh->r_cfg.fc_dst, &nh->r_cfg.fc_gateway,
2847 nh->r_cfg.fc_ifindex);
2848 }
2849 }
2850
2851 static int ip6_route_info_append(struct list_head *rt6_nh_list,
2852 struct rt6_info *rt, struct fib6_config *r_cfg)
2853 {
2854 struct rt6_nh *nh;
2855 int err = -EEXIST;
2856
2857 list_for_each_entry(nh, rt6_nh_list, next) {
2858 /* check if rt6_info already exists */
2859 if (rt6_duplicate_nexthop(nh->rt6_info, rt))
2860 return err;
2861 }
2862
2863 nh = kzalloc(sizeof(*nh), GFP_KERNEL);
2864 if (!nh)
2865 return -ENOMEM;
2866 nh->rt6_info = rt;
2867 err = ip6_convert_metrics(&nh->mxc, r_cfg);
2868 if (err) {
2869 kfree(nh);
2870 return err;
2871 }
2872 memcpy(&nh->r_cfg, r_cfg, sizeof(*r_cfg));
2873 list_add_tail(&nh->next, rt6_nh_list);
2874
2875 return 0;
2876 }
2877
2878 static int ip6_route_multipath_add(struct fib6_config *cfg)
2879 {
2880 struct fib6_config r_cfg;
2881 struct rtnexthop *rtnh;
2882 struct rt6_info *rt;
2883 struct rt6_nh *err_nh;
2884 struct rt6_nh *nh, *nh_safe;
2885 int remaining;
2886 int attrlen;
2887 int err = 1;
2888 int nhn = 0;
2889 int replace = (cfg->fc_nlinfo.nlh &&
2890 (cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_REPLACE));
2891 LIST_HEAD(rt6_nh_list);
2892
2893 remaining = cfg->fc_mp_len;
2894 rtnh = (struct rtnexthop *)cfg->fc_mp;
2895
2896 /* Parse a Multipath Entry and build a list (rt6_nh_list) of
2897 * rt6_info structs per nexthop
2898 */
2899 while (rtnh_ok(rtnh, remaining)) {
2900 memcpy(&r_cfg, cfg, sizeof(*cfg));
2901 if (rtnh->rtnh_ifindex)
2902 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
2903
2904 attrlen = rtnh_attrlen(rtnh);
2905 if (attrlen > 0) {
2906 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
2907
2908 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
2909 if (nla) {
2910 r_cfg.fc_gateway = nla_get_in6_addr(nla);
2911 r_cfg.fc_flags |= RTF_GATEWAY;
2912 }
2913 r_cfg.fc_encap = nla_find(attrs, attrlen, RTA_ENCAP);
2914 nla = nla_find(attrs, attrlen, RTA_ENCAP_TYPE);
2915 if (nla)
2916 r_cfg.fc_encap_type = nla_get_u16(nla);
2917 }
2918
2919 rt = ip6_route_info_create(&r_cfg);
2920 if (IS_ERR(rt)) {
2921 err = PTR_ERR(rt);
2922 rt = NULL;
2923 goto cleanup;
2924 }
2925
2926 err = ip6_route_info_append(&rt6_nh_list, rt, &r_cfg);
2927 if (err) {
2928 dst_free(&rt->dst);
2929 goto cleanup;
2930 }
2931
2932 rtnh = rtnh_next(rtnh, &remaining);
2933 }
2934
2935 err_nh = NULL;
2936 list_for_each_entry(nh, &rt6_nh_list, next) {
2937 err = __ip6_ins_rt(nh->rt6_info, &cfg->fc_nlinfo, &nh->mxc);
2938 /* nh->rt6_info is used or freed at this point, reset to NULL*/
2939 nh->rt6_info = NULL;
2940 if (err) {
2941 if (replace && nhn)
2942 ip6_print_replace_route_err(&rt6_nh_list);
2943 err_nh = nh;
2944 goto add_errout;
2945 }
2946
2947 /* Because each route is added like a single route we remove
2948 * these flags after the first nexthop: if there is a collision,
2949 * we have already failed to add the first nexthop:
2950 * fib6_add_rt2node() has rejected it; when replacing, old
2951 * nexthops have been replaced by first new, the rest should
2952 * be added to it.
2953 */
2954 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~(NLM_F_EXCL |
2955 NLM_F_REPLACE);
2956 nhn++;
2957 }
2958
2959 goto cleanup;
2960
2961 add_errout:
2962 /* Delete routes that were already added */
2963 list_for_each_entry(nh, &rt6_nh_list, next) {
2964 if (err_nh == nh)
2965 break;
2966 ip6_route_del(&nh->r_cfg);
2967 }
2968
2969 cleanup:
2970 list_for_each_entry_safe(nh, nh_safe, &rt6_nh_list, next) {
2971 if (nh->rt6_info)
2972 dst_free(&nh->rt6_info->dst);
2973 kfree(nh->mxc.mx);
2974 list_del(&nh->next);
2975 kfree(nh);
2976 }
2977
2978 return err;
2979 }
2980
2981 static int ip6_route_multipath_del(struct fib6_config *cfg)
2982 {
2983 struct fib6_config r_cfg;
2984 struct rtnexthop *rtnh;
2985 int remaining;
2986 int attrlen;
2987 int err = 1, last_err = 0;
2988
2989 remaining = cfg->fc_mp_len;
2990 rtnh = (struct rtnexthop *)cfg->fc_mp;
2991
2992 /* Parse a Multipath Entry */
2993 while (rtnh_ok(rtnh, remaining)) {
2994 memcpy(&r_cfg, cfg, sizeof(*cfg));
2995 if (rtnh->rtnh_ifindex)
2996 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
2997
2998 attrlen = rtnh_attrlen(rtnh);
2999 if (attrlen > 0) {
3000 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
3001
3002 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
3003 if (nla) {
3004 nla_memcpy(&r_cfg.fc_gateway, nla, 16);
3005 r_cfg.fc_flags |= RTF_GATEWAY;
3006 }
3007 }
3008 err = ip6_route_del(&r_cfg);
3009 if (err)
3010 last_err = err;
3011
3012 rtnh = rtnh_next(rtnh, &remaining);
3013 }
3014
3015 return last_err;
3016 }
3017
3018 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh)
3019 {
3020 struct fib6_config cfg;
3021 int err;
3022
3023 err = rtm_to_fib6_config(skb, nlh, &cfg);
3024 if (err < 0)
3025 return err;
3026
3027 if (cfg.fc_mp)
3028 return ip6_route_multipath_del(&cfg);
3029 else
3030 return ip6_route_del(&cfg);
3031 }
3032
3033 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh)
3034 {
3035 struct fib6_config cfg;
3036 int err;
3037
3038 err = rtm_to_fib6_config(skb, nlh, &cfg);
3039 if (err < 0)
3040 return err;
3041
3042 if (cfg.fc_mp)
3043 return ip6_route_multipath_add(&cfg);
3044 else
3045 return ip6_route_add(&cfg);
3046 }
3047
3048 static inline size_t rt6_nlmsg_size(struct rt6_info *rt)
3049 {
3050 return NLMSG_ALIGN(sizeof(struct rtmsg))
3051 + nla_total_size(16) /* RTA_SRC */
3052 + nla_total_size(16) /* RTA_DST */
3053 + nla_total_size(16) /* RTA_GATEWAY */
3054 + nla_total_size(16) /* RTA_PREFSRC */
3055 + nla_total_size(4) /* RTA_TABLE */
3056 + nla_total_size(4) /* RTA_IIF */
3057 + nla_total_size(4) /* RTA_OIF */
3058 + nla_total_size(4) /* RTA_PRIORITY */
3059 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
3060 + nla_total_size(sizeof(struct rta_cacheinfo))
3061 + nla_total_size(TCP_CA_NAME_MAX) /* RTAX_CC_ALGO */
3062 + nla_total_size(1) /* RTA_PREF */
3063 + lwtunnel_get_encap_size(rt->dst.lwtstate);
3064 }
3065
3066 static int rt6_fill_node(struct net *net,
3067 struct sk_buff *skb, struct rt6_info *rt,
3068 struct in6_addr *dst, struct in6_addr *src,
3069 int iif, int type, u32 portid, u32 seq,
3070 int prefix, int nowait, unsigned int flags)
3071 {
3072 u32 metrics[RTAX_MAX];
3073 struct rtmsg *rtm;
3074 struct nlmsghdr *nlh;
3075 long expires;
3076 u32 table;
3077
3078 if (prefix) { /* user wants prefix routes only */
3079 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
3080 /* success since this is not a prefix route */
3081 return 1;
3082 }
3083 }
3084
3085 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
3086 if (!nlh)
3087 return -EMSGSIZE;
3088
3089 rtm = nlmsg_data(nlh);
3090 rtm->rtm_family = AF_INET6;
3091 rtm->rtm_dst_len = rt->rt6i_dst.plen;
3092 rtm->rtm_src_len = rt->rt6i_src.plen;
3093 rtm->rtm_tos = 0;
3094 if (rt->rt6i_table)
3095 table = rt->rt6i_table->tb6_id;
3096 else
3097 table = RT6_TABLE_UNSPEC;
3098 rtm->rtm_table = table;
3099 if (nla_put_u32(skb, RTA_TABLE, table))
3100 goto nla_put_failure;
3101 if (rt->rt6i_flags & RTF_REJECT) {
3102 switch (rt->dst.error) {
3103 case -EINVAL:
3104 rtm->rtm_type = RTN_BLACKHOLE;
3105 break;
3106 case -EACCES:
3107 rtm->rtm_type = RTN_PROHIBIT;
3108 break;
3109 case -EAGAIN:
3110 rtm->rtm_type = RTN_THROW;
3111 break;
3112 default:
3113 rtm->rtm_type = RTN_UNREACHABLE;
3114 break;
3115 }
3116 }
3117 else if (rt->rt6i_flags & RTF_LOCAL)
3118 rtm->rtm_type = RTN_LOCAL;
3119 else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
3120 rtm->rtm_type = RTN_LOCAL;
3121 else
3122 rtm->rtm_type = RTN_UNICAST;
3123 rtm->rtm_flags = 0;
3124 if (!netif_carrier_ok(rt->dst.dev)) {
3125 rtm->rtm_flags |= RTNH_F_LINKDOWN;
3126 if (rt->rt6i_idev->cnf.ignore_routes_with_linkdown)
3127 rtm->rtm_flags |= RTNH_F_DEAD;
3128 }
3129 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
3130 rtm->rtm_protocol = rt->rt6i_protocol;
3131 if (rt->rt6i_flags & RTF_DYNAMIC)
3132 rtm->rtm_protocol = RTPROT_REDIRECT;
3133 else if (rt->rt6i_flags & RTF_ADDRCONF) {
3134 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
3135 rtm->rtm_protocol = RTPROT_RA;
3136 else
3137 rtm->rtm_protocol = RTPROT_KERNEL;
3138 }
3139
3140 if (rt->rt6i_flags & RTF_CACHE)
3141 rtm->rtm_flags |= RTM_F_CLONED;
3142
3143 if (dst) {
3144 if (nla_put_in6_addr(skb, RTA_DST, dst))
3145 goto nla_put_failure;
3146 rtm->rtm_dst_len = 128;
3147 } else if (rtm->rtm_dst_len)
3148 if (nla_put_in6_addr(skb, RTA_DST, &rt->rt6i_dst.addr))
3149 goto nla_put_failure;
3150 #ifdef CONFIG_IPV6_SUBTREES
3151 if (src) {
3152 if (nla_put_in6_addr(skb, RTA_SRC, src))
3153 goto nla_put_failure;
3154 rtm->rtm_src_len = 128;
3155 } else if (rtm->rtm_src_len &&
3156 nla_put_in6_addr(skb, RTA_SRC, &rt->rt6i_src.addr))
3157 goto nla_put_failure;
3158 #endif
3159 if (iif) {
3160 #ifdef CONFIG_IPV6_MROUTE
3161 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
3162 int err = ip6mr_get_route(net, skb, rtm, nowait,
3163 portid);
3164
3165 if (err <= 0) {
3166 if (!nowait) {
3167 if (err == 0)
3168 return 0;
3169 goto nla_put_failure;
3170 } else {
3171 if (err == -EMSGSIZE)
3172 goto nla_put_failure;
3173 }
3174 }
3175 } else
3176 #endif
3177 if (nla_put_u32(skb, RTA_IIF, iif))
3178 goto nla_put_failure;
3179 } else if (dst) {
3180 struct in6_addr saddr_buf;
3181 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
3182 nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
3183 goto nla_put_failure;
3184 }
3185
3186 if (rt->rt6i_prefsrc.plen) {
3187 struct in6_addr saddr_buf;
3188 saddr_buf = rt->rt6i_prefsrc.addr;
3189 if (nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
3190 goto nla_put_failure;
3191 }
3192
3193 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
3194 if (rt->rt6i_pmtu)
3195 metrics[RTAX_MTU - 1] = rt->rt6i_pmtu;
3196 if (rtnetlink_put_metrics(skb, metrics) < 0)
3197 goto nla_put_failure;
3198
3199 if (rt->rt6i_flags & RTF_GATEWAY) {
3200 if (nla_put_in6_addr(skb, RTA_GATEWAY, &rt->rt6i_gateway) < 0)
3201 goto nla_put_failure;
3202 }
3203
3204 if (rt->dst.dev &&
3205 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
3206 goto nla_put_failure;
3207 if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
3208 goto nla_put_failure;
3209
3210 expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
3211
3212 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
3213 goto nla_put_failure;
3214
3215 if (nla_put_u8(skb, RTA_PREF, IPV6_EXTRACT_PREF(rt->rt6i_flags)))
3216 goto nla_put_failure;
3217
3218 if (lwtunnel_fill_encap(skb, rt->dst.lwtstate) < 0)
3219 goto nla_put_failure;
3220
3221 nlmsg_end(skb, nlh);
3222 return 0;
3223
3224 nla_put_failure:
3225 nlmsg_cancel(skb, nlh);
3226 return -EMSGSIZE;
3227 }
3228
3229 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
3230 {
3231 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
3232 int prefix;
3233
3234 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
3235 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
3236 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
3237 } else
3238 prefix = 0;
3239
3240 return rt6_fill_node(arg->net,
3241 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
3242 NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
3243 prefix, 0, NLM_F_MULTI);
3244 }
3245
3246 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
3247 {
3248 struct net *net = sock_net(in_skb->sk);
3249 struct nlattr *tb[RTA_MAX+1];
3250 struct rt6_info *rt;
3251 struct sk_buff *skb;
3252 struct rtmsg *rtm;
3253 struct flowi6 fl6;
3254 int err, iif = 0, oif = 0;
3255
3256 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
3257 if (err < 0)
3258 goto errout;
3259
3260 err = -EINVAL;
3261 memset(&fl6, 0, sizeof(fl6));
3262
3263 if (tb[RTA_SRC]) {
3264 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
3265 goto errout;
3266
3267 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
3268 }
3269
3270 if (tb[RTA_DST]) {
3271 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
3272 goto errout;
3273
3274 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
3275 }
3276
3277 if (tb[RTA_IIF])
3278 iif = nla_get_u32(tb[RTA_IIF]);
3279
3280 if (tb[RTA_OIF])
3281 oif = nla_get_u32(tb[RTA_OIF]);
3282
3283 if (tb[RTA_MARK])
3284 fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);
3285
3286 if (iif) {
3287 struct net_device *dev;
3288 int flags = 0;
3289
3290 dev = __dev_get_by_index(net, iif);
3291 if (!dev) {
3292 err = -ENODEV;
3293 goto errout;
3294 }
3295
3296 fl6.flowi6_iif = iif;
3297
3298 if (!ipv6_addr_any(&fl6.saddr))
3299 flags |= RT6_LOOKUP_F_HAS_SADDR;
3300
3301 rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
3302 flags);
3303 } else {
3304 fl6.flowi6_oif = oif;
3305
3306 if (netif_index_is_l3_master(net, oif)) {
3307 fl6.flowi6_flags = FLOWI_FLAG_L3MDEV_SRC |
3308 FLOWI_FLAG_SKIP_NH_OIF;
3309 }
3310
3311 rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
3312 }
3313
3314 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
3315 if (!skb) {
3316 ip6_rt_put(rt);
3317 err = -ENOBUFS;
3318 goto errout;
3319 }
3320
3321 /* Reserve room for dummy headers, this skb can pass
3322 through good chunk of routing engine.
3323 */
3324 skb_reset_mac_header(skb);
3325 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
3326
3327 skb_dst_set(skb, &rt->dst);
3328
3329 err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
3330 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
3331 nlh->nlmsg_seq, 0, 0, 0);
3332 if (err < 0) {
3333 kfree_skb(skb);
3334 goto errout;
3335 }
3336
3337 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
3338 errout:
3339 return err;
3340 }
3341
3342 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info,
3343 unsigned int nlm_flags)
3344 {
3345 struct sk_buff *skb;
3346 struct net *net = info->nl_net;
3347 u32 seq;
3348 int err;
3349
3350 err = -ENOBUFS;
3351 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
3352
3353 skb = nlmsg_new(rt6_nlmsg_size(rt), gfp_any());
3354 if (!skb)
3355 goto errout;
3356
3357 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
3358 event, info->portid, seq, 0, 0, nlm_flags);
3359 if (err < 0) {
3360 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
3361 WARN_ON(err == -EMSGSIZE);
3362 kfree_skb(skb);
3363 goto errout;
3364 }
3365 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
3366 info->nlh, gfp_any());
3367 return;
3368 errout:
3369 if (err < 0)
3370 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
3371 }
3372
3373 static int ip6_route_dev_notify(struct notifier_block *this,
3374 unsigned long event, void *ptr)
3375 {
3376 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3377 struct net *net = dev_net(dev);
3378
3379 if (!(dev->flags & IFF_LOOPBACK))
3380 return NOTIFY_OK;
3381
3382 if (event == NETDEV_REGISTER) {
3383 net->ipv6.ip6_null_entry->dst.dev = dev;
3384 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
3385 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3386 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
3387 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
3388 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
3389 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
3390 #endif
3391 } else if (event == NETDEV_UNREGISTER &&
3392 dev->reg_state != NETREG_UNREGISTERED) {
3393 /* NETDEV_UNREGISTER could be fired for multiple times by
3394 * netdev_wait_allrefs(). Make sure we only call this once.
3395 */
3396 in6_dev_put(net->ipv6.ip6_null_entry->rt6i_idev);
3397 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3398 in6_dev_put(net->ipv6.ip6_prohibit_entry->rt6i_idev);
3399 in6_dev_put(net->ipv6.ip6_blk_hole_entry->rt6i_idev);
3400 #endif
3401 }
3402
3403 return NOTIFY_OK;
3404 }
3405
3406 /*
3407 * /proc
3408 */
3409
3410 #ifdef CONFIG_PROC_FS
3411
3412 static const struct file_operations ipv6_route_proc_fops = {
3413 .owner = THIS_MODULE,
3414 .open = ipv6_route_open,
3415 .read = seq_read,
3416 .llseek = seq_lseek,
3417 .release = seq_release_net,
3418 };
3419
3420 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
3421 {
3422 struct net *net = (struct net *)seq->private;
3423 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
3424 net->ipv6.rt6_stats->fib_nodes,
3425 net->ipv6.rt6_stats->fib_route_nodes,
3426 net->ipv6.rt6_stats->fib_rt_alloc,
3427 net->ipv6.rt6_stats->fib_rt_entries,
3428 net->ipv6.rt6_stats->fib_rt_cache,
3429 dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
3430 net->ipv6.rt6_stats->fib_discarded_routes);
3431
3432 return 0;
3433 }
3434
3435 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
3436 {
3437 return single_open_net(inode, file, rt6_stats_seq_show);
3438 }
3439
3440 static const struct file_operations rt6_stats_seq_fops = {
3441 .owner = THIS_MODULE,
3442 .open = rt6_stats_seq_open,
3443 .read = seq_read,
3444 .llseek = seq_lseek,
3445 .release = single_release_net,
3446 };
3447 #endif /* CONFIG_PROC_FS */
3448
3449 #ifdef CONFIG_SYSCTL
3450
3451 static
3452 int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,
3453 void __user *buffer, size_t *lenp, loff_t *ppos)
3454 {
3455 struct net *net;
3456 int delay;
3457 if (!write)
3458 return -EINVAL;
3459
3460 net = (struct net *)ctl->extra1;
3461 delay = net->ipv6.sysctl.flush_delay;
3462 proc_dointvec(ctl, write, buffer, lenp, ppos);
3463 fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
3464 return 0;
3465 }
3466
3467 struct ctl_table ipv6_route_table_template[] = {
3468 {
3469 .procname = "flush",
3470 .data = &init_net.ipv6.sysctl.flush_delay,
3471 .maxlen = sizeof(int),
3472 .mode = 0200,
3473 .proc_handler = ipv6_sysctl_rtcache_flush
3474 },
3475 {
3476 .procname = "gc_thresh",
3477 .data = &ip6_dst_ops_template.gc_thresh,
3478 .maxlen = sizeof(int),
3479 .mode = 0644,
3480 .proc_handler = proc_dointvec,
3481 },
3482 {
3483 .procname = "max_size",
3484 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
3485 .maxlen = sizeof(int),
3486 .mode = 0644,
3487 .proc_handler = proc_dointvec,
3488 },
3489 {
3490 .procname = "gc_min_interval",
3491 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
3492 .maxlen = sizeof(int),
3493 .mode = 0644,
3494 .proc_handler = proc_dointvec_jiffies,
3495 },
3496 {
3497 .procname = "gc_timeout",
3498 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
3499 .maxlen = sizeof(int),
3500 .mode = 0644,
3501 .proc_handler = proc_dointvec_jiffies,
3502 },
3503 {
3504 .procname = "gc_interval",
3505 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
3506 .maxlen = sizeof(int),
3507 .mode = 0644,
3508 .proc_handler = proc_dointvec_jiffies,
3509 },
3510 {
3511 .procname = "gc_elasticity",
3512 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
3513 .maxlen = sizeof(int),
3514 .mode = 0644,
3515 .proc_handler = proc_dointvec,
3516 },
3517 {
3518 .procname = "mtu_expires",
3519 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
3520 .maxlen = sizeof(int),
3521 .mode = 0644,
3522 .proc_handler = proc_dointvec_jiffies,
3523 },
3524 {
3525 .procname = "min_adv_mss",
3526 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
3527 .maxlen = sizeof(int),
3528 .mode = 0644,
3529 .proc_handler = proc_dointvec,
3530 },
3531 {
3532 .procname = "gc_min_interval_ms",
3533 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
3534 .maxlen = sizeof(int),
3535 .mode = 0644,
3536 .proc_handler = proc_dointvec_ms_jiffies,
3537 },
3538 { }
3539 };
3540
3541 struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
3542 {
3543 struct ctl_table *table;
3544
3545 table = kmemdup(ipv6_route_table_template,
3546 sizeof(ipv6_route_table_template),
3547 GFP_KERNEL);
3548
3549 if (table) {
3550 table[0].data = &net->ipv6.sysctl.flush_delay;
3551 table[0].extra1 = net;
3552 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
3553 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
3554 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
3555 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
3556 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
3557 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
3558 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
3559 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
3560 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
3561
3562 /* Don't export sysctls to unprivileged users */
3563 if (net->user_ns != &init_user_ns)
3564 table[0].procname = NULL;
3565 }
3566
3567 return table;
3568 }
3569 #endif
3570
3571 static int __net_init ip6_route_net_init(struct net *net)
3572 {
3573 int ret = -ENOMEM;
3574
3575 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
3576 sizeof(net->ipv6.ip6_dst_ops));
3577
3578 if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
3579 goto out_ip6_dst_ops;
3580
3581 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
3582 sizeof(*net->ipv6.ip6_null_entry),
3583 GFP_KERNEL);
3584 if (!net->ipv6.ip6_null_entry)
3585 goto out_ip6_dst_entries;
3586 net->ipv6.ip6_null_entry->dst.path =
3587 (struct dst_entry *)net->ipv6.ip6_null_entry;
3588 net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3589 dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
3590 ip6_template_metrics, true);
3591
3592 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3593 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
3594 sizeof(*net->ipv6.ip6_prohibit_entry),
3595 GFP_KERNEL);
3596 if (!net->ipv6.ip6_prohibit_entry)
3597 goto out_ip6_null_entry;
3598 net->ipv6.ip6_prohibit_entry->dst.path =
3599 (struct dst_entry *)net->ipv6.ip6_prohibit_entry;
3600 net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3601 dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
3602 ip6_template_metrics, true);
3603
3604 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
3605 sizeof(*net->ipv6.ip6_blk_hole_entry),
3606 GFP_KERNEL);
3607 if (!net->ipv6.ip6_blk_hole_entry)
3608 goto out_ip6_prohibit_entry;
3609 net->ipv6.ip6_blk_hole_entry->dst.path =
3610 (struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
3611 net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
3612 dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
3613 ip6_template_metrics, true);
3614 #endif
3615
3616 net->ipv6.sysctl.flush_delay = 0;
3617 net->ipv6.sysctl.ip6_rt_max_size = 4096;
3618 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
3619 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
3620 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
3621 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
3622 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
3623 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
3624
3625 net->ipv6.ip6_rt_gc_expire = 30*HZ;
3626
3627 ret = 0;
3628 out:
3629 return ret;
3630
3631 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3632 out_ip6_prohibit_entry:
3633 kfree(net->ipv6.ip6_prohibit_entry);
3634 out_ip6_null_entry:
3635 kfree(net->ipv6.ip6_null_entry);
3636 #endif
3637 out_ip6_dst_entries:
3638 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3639 out_ip6_dst_ops:
3640 goto out;
3641 }
3642
3643 static void __net_exit ip6_route_net_exit(struct net *net)
3644 {
3645 kfree(net->ipv6.ip6_null_entry);
3646 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3647 kfree(net->ipv6.ip6_prohibit_entry);
3648 kfree(net->ipv6.ip6_blk_hole_entry);
3649 #endif
3650 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
3651 }
3652
3653 static int __net_init ip6_route_net_init_late(struct net *net)
3654 {
3655 #ifdef CONFIG_PROC_FS
3656 proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
3657 proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
3658 #endif
3659 return 0;
3660 }
3661
3662 static void __net_exit ip6_route_net_exit_late(struct net *net)
3663 {
3664 #ifdef CONFIG_PROC_FS
3665 remove_proc_entry("ipv6_route", net->proc_net);
3666 remove_proc_entry("rt6_stats", net->proc_net);
3667 #endif
3668 }
3669
3670 static struct pernet_operations ip6_route_net_ops = {
3671 .init = ip6_route_net_init,
3672 .exit = ip6_route_net_exit,
3673 };
3674
3675 static int __net_init ipv6_inetpeer_init(struct net *net)
3676 {
3677 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
3678
3679 if (!bp)
3680 return -ENOMEM;
3681 inet_peer_base_init(bp);
3682 net->ipv6.peers = bp;
3683 return 0;
3684 }
3685
3686 static void __net_exit ipv6_inetpeer_exit(struct net *net)
3687 {
3688 struct inet_peer_base *bp = net->ipv6.peers;
3689
3690 net->ipv6.peers = NULL;
3691 inetpeer_invalidate_tree(bp);
3692 kfree(bp);
3693 }
3694
3695 static struct pernet_operations ipv6_inetpeer_ops = {
3696 .init = ipv6_inetpeer_init,
3697 .exit = ipv6_inetpeer_exit,
3698 };
3699
3700 static struct pernet_operations ip6_route_net_late_ops = {
3701 .init = ip6_route_net_init_late,
3702 .exit = ip6_route_net_exit_late,
3703 };
3704
3705 static struct notifier_block ip6_route_dev_notifier = {
3706 .notifier_call = ip6_route_dev_notify,
3707 .priority = ADDRCONF_NOTIFY_PRIORITY - 10,
3708 };
3709
3710 void __init ip6_route_init_special_entries(void)
3711 {
3712 /* Registering of the loopback is done before this portion of code,
3713 * the loopback reference in rt6_info will not be taken, do it
3714 * manually for init_net */
3715 init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
3716 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3717 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
3718 init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
3719 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3720 init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
3721 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
3722 #endif
3723 }
3724
3725 int __init ip6_route_init(void)
3726 {
3727 int ret;
3728 int cpu;
3729
3730 ret = -ENOMEM;
3731 ip6_dst_ops_template.kmem_cachep =
3732 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
3733 SLAB_HWCACHE_ALIGN, NULL);
3734 if (!ip6_dst_ops_template.kmem_cachep)
3735 goto out;
3736
3737 ret = dst_entries_init(&ip6_dst_blackhole_ops);
3738 if (ret)
3739 goto out_kmem_cache;
3740
3741 ret = register_pernet_subsys(&ipv6_inetpeer_ops);
3742 if (ret)
3743 goto out_dst_entries;
3744
3745 ret = register_pernet_subsys(&ip6_route_net_ops);
3746 if (ret)
3747 goto out_register_inetpeer;
3748
3749 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
3750
3751 ret = fib6_init();
3752 if (ret)
3753 goto out_register_subsys;
3754
3755 ret = xfrm6_init();
3756 if (ret)
3757 goto out_fib6_init;
3758
3759 ret = fib6_rules_init();
3760 if (ret)
3761 goto xfrm6_init;
3762
3763 ret = register_pernet_subsys(&ip6_route_net_late_ops);
3764 if (ret)
3765 goto fib6_rules_init;
3766
3767 ret = -ENOBUFS;
3768 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
3769 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
3770 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
3771 goto out_register_late_subsys;
3772
3773 ret = register_netdevice_notifier(&ip6_route_dev_notifier);
3774 if (ret)
3775 goto out_register_late_subsys;
3776
3777 for_each_possible_cpu(cpu) {
3778 struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
3779
3780 INIT_LIST_HEAD(&ul->head);
3781 spin_lock_init(&ul->lock);
3782 }
3783
3784 out:
3785 return ret;
3786
3787 out_register_late_subsys:
3788 unregister_pernet_subsys(&ip6_route_net_late_ops);
3789 fib6_rules_init:
3790 fib6_rules_cleanup();
3791 xfrm6_init:
3792 xfrm6_fini();
3793 out_fib6_init:
3794 fib6_gc_cleanup();
3795 out_register_subsys:
3796 unregister_pernet_subsys(&ip6_route_net_ops);
3797 out_register_inetpeer:
3798 unregister_pernet_subsys(&ipv6_inetpeer_ops);
3799 out_dst_entries:
3800 dst_entries_destroy(&ip6_dst_blackhole_ops);
3801 out_kmem_cache:
3802 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3803 goto out;
3804 }
3805
3806 void ip6_route_cleanup(void)
3807 {
3808 unregister_netdevice_notifier(&ip6_route_dev_notifier);
3809 unregister_pernet_subsys(&ip6_route_net_late_ops);
3810 fib6_rules_cleanup();
3811 xfrm6_fini();
3812 fib6_gc_cleanup();
3813 unregister_pernet_subsys(&ipv6_inetpeer_ops);
3814 unregister_pernet_subsys(&ip6_route_net_ops);
3815 dst_entries_destroy(&ip6_dst_blackhole_ops);
3816 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
3817 }
Linux with added FPC-III support