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