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