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