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