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