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