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