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