projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ipv6: Remove redundant route flushing during namespace dismantle
[linux-block.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{
3a2232e9 189 return dst_metrics_write_ptr(&rt->from->dst);
d52d3997
MKL		 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;
3a2232e9 394 struct rt6_info *from = rt->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
3a2232e9
DM		 412 rt->from = NULL;
413 dst_release(&from->dst);
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;
3a2232e9 446 } else if (rt->from) {
1e2ea8ad 447 return rt->dst.obsolete != DST_OBSOLETE_FORCE_CHK ||
3a2232e9 448 rt6_check_expired(rt->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
071fb37e 505 for (sprt = rt; sprt; sprt = rcu_dereference(sprt->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;
071fb37e 724 for (rt = rr_head; rt; rt = rcu_dereference(rt->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 733 for (rt = leaf; rt && rt != rr_head;
071fb37e 734 rt = rcu_dereference(rt->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
071fb37e 746 for (rt = cont; rt; rt = rcu_dereference(rt->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) {
071fb37e 784 struct rt6_info *next = rcu_dereference(rt0->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))
3a2232e9 1057 ort = ort->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))
3a2232e9 1277 ort = ort->from;
35732d01
WW		 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{
35732d01 1418 struct rt6_exception_bucket *bucket;
3a2232e9 1419 struct rt6_info *from = rt->from;
35732d01
WW		 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{
35732d01 1463 struct rt6_exception_bucket *bucket;
3a2232e9 1464 struct rt6_info *from = rt->from;
35732d01
WW		 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{
3a2232e9
DM		 1932 if (rt->from &&
1933 dst_metrics_ptr(&rt->dst) != dst_metrics_ptr(&rt->from->dst))
1934 dst_init_metrics(&rt->dst, dst_metrics_ptr(&rt->from->dst), true);
4b32b5ad
MKL		 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 &&
3a2232e9 1954 rt6_check(rt->from, cookie))
3da59bd9
MKL		 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 ||
3a2232e9 1974 (unlikely(!list_empty(&rt->rt6i_uncached)) && rt->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{
3a2232e9 3059 BUG_ON(from->from);
4b32b5ad
MKL		 3060
3061 rt->rt6i_flags &= ~RTF_EXPIRES;
3062 dst_hold(&from->dst);
3a2232e9 3063 rt->from = from;
4b32b5ad
MKL		 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
9fcb0714 3473 if (rt->dst.dev == dev &&
a1a22c12 3474 rt != adn->net->ipv6.ip6_null_entry &&
9fcb0714 3475 (rt->rt6i_nsiblings == 0 || netdev_unregistering(dev) ||
a1a22c12 3476 !rt->rt6i_idev->cnf.ignore_routes_with_linkdown))
1da177e4 3477 return -1;
c159d30c 3478
1da177e4
LT		 3479 return 0;
3480}
3481
f3db4851 3482void rt6_ifdown(struct net *net, struct net_device *dev)
1da177e4 3483{
8ed67789
DL		 3484 struct arg_dev_net adn = {
3485 .dev = dev,
3486 .net = net,
3487 };
3488
0c3584d5 3489 fib6_clean_all(net, fib6_ifdown, &adn);
9fcb0714 3490 rt6_uncached_list_flush_dev(net, dev);
1da177e4
LT		 3491}
3492
95c96174 3493struct rt6_mtu_change_arg {
1da177e4 3494 struct net_device *dev;
95c96174 3495 unsigned int mtu;
1da177e4
LT		 3496};
3497
3498static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
3499{
3500 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
3501 struct inet6_dev *idev;
3502
3503 /* In IPv6 pmtu discovery is not optional,
3504 so that RTAX_MTU lock cannot disable it.
3505 We still use this lock to block changes
3506 caused by addrconf/ndisc.
3507 */
3508
3509 idev = __in6_dev_get(arg->dev);
38308473 3510 if (!idev)
1da177e4
LT		 3511 return 0;
3512
3513 /* For administrative MTU increase, there is no way to discover
3514 IPv6 PMTU increase, so PMTU increase should be updated here.
3515 Since RFC 1981 doesn't include administrative MTU increase
3516 update PMTU increase is a MUST. (i.e. jumbo frame)
3517 */
3518 /*
3519 If new MTU is less than route PMTU, this new MTU will be the
3520 lowest MTU in the path, update the route PMTU to reflect PMTU
3521 decreases; if new MTU is greater than route PMTU, and the
3522 old MTU is the lowest MTU in the path, update the route PMTU
3523 to reflect the increase. In this case if the other nodes' MTU
3524 also have the lowest MTU, TOO BIG MESSAGE will be lead to
67c408cf 3525 PMTU discovery.
1da177e4 3526 */
d1918542 3527 if (rt->dst.dev == arg->dev &&
fb56be83 3528 dst_metric_raw(&rt->dst, RTAX_MTU) &&
4b32b5ad 3529 !dst_metric_locked(&rt->dst, RTAX_MTU)) {
f5bbe7ee 3530 spin_lock_bh(&rt6_exception_lock);
2b760fcf
WW		 3531 if (dst_mtu(&rt->dst) >= arg->mtu ||
3532 (dst_mtu(&rt->dst) < arg->mtu &&
3533 dst_mtu(&rt->dst) == idev->cnf.mtu6)) {
4b32b5ad
MKL		 3534 dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
3535 }
f5bbe7ee
WW		 3536 rt6_exceptions_update_pmtu(rt, arg->mtu);
3537 spin_unlock_bh(&rt6_exception_lock);
566cfd8f 3538 }
1da177e4
LT		 3539 return 0;
3540}
3541
95c96174 3542void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
1da177e4 3543{
c71099ac
TG		 3544 struct rt6_mtu_change_arg arg = {
3545 .dev = dev,
3546 .mtu = mtu,
3547 };
1da177e4 3548
0c3584d5 3549 fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);
1da177e4
LT		 3550}
3551
ef7c79ed 3552static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
5176f91e 3553 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
86872cb5 3554 [RTA_OIF] = { .type = NLA_U32 },
ab364a6f 3555 [RTA_IIF] = { .type = NLA_U32 },
86872cb5
TG		 3556 [RTA_PRIORITY] = { .type = NLA_U32 },
3557 [RTA_METRICS] = { .type = NLA_NESTED },
51ebd318 3558 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
c78ba6d6 3559 [RTA_PREF] = { .type = NLA_U8 },
19e42e45
RP		 3560 [RTA_ENCAP_TYPE] = { .type = NLA_U16 },
3561 [RTA_ENCAP] = { .type = NLA_NESTED },
32bc201e 3562 [RTA_EXPIRES] = { .type = NLA_U32 },
622ec2c9 3563 [RTA_UID] = { .type = NLA_U32 },
3b45a410 3564 [RTA_MARK] = { .type = NLA_U32 },
86872cb5
TG		 3565};
3566
3567static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
333c4301
DA		 3568 struct fib6_config *cfg,
3569 struct netlink_ext_ack *extack)
1da177e4 3570{
86872cb5
TG		 3571 struct rtmsg *rtm;
3572 struct nlattr *tb[RTA_MAX+1];
c78ba6d6 3573 unsigned int pref;
86872cb5 3574 int err;
1da177e4 3575
fceb6435
JB		 3576 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy,
3577 NULL);
86872cb5
TG		 3578 if (err < 0)
3579 goto errout;
1da177e4 3580
86872cb5
TG		 3581 err = -EINVAL;
3582 rtm = nlmsg_data(nlh);
3583 memset(cfg, 0, sizeof(*cfg));
3584
3585 cfg->fc_table = rtm->rtm_table;
3586 cfg->fc_dst_len = rtm->rtm_dst_len;
3587 cfg->fc_src_len = rtm->rtm_src_len;
3588 cfg->fc_flags = RTF_UP;
3589 cfg->fc_protocol = rtm->rtm_protocol;
ef2c7d7b 3590 cfg->fc_type = rtm->rtm_type;
86872cb5 3591
ef2c7d7b
ND		 3592 if (rtm->rtm_type == RTN_UNREACHABLE ||
3593 rtm->rtm_type == RTN_BLACKHOLE ||
b4949ab2
ND		 3594 rtm->rtm_type == RTN_PROHIBIT ||
3595 rtm->rtm_type == RTN_THROW)
86872cb5
TG		 3596 cfg->fc_flags |= RTF_REJECT;
3597
ab79ad14
MŻ		 3598 if (rtm->rtm_type == RTN_LOCAL)
3599 cfg->fc_flags |= RTF_LOCAL;
3600
1f56a01f
MKL		 3601 if (rtm->rtm_flags & RTM_F_CLONED)
3602 cfg->fc_flags |= RTF_CACHE;
3603
15e47304 3604 cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
86872cb5 3605 cfg->fc_nlinfo.nlh = nlh;
3b1e0a65 3606 cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
86872cb5
TG		 3607
3608 if (tb[RTA_GATEWAY]) {
67b61f6c 3609 cfg->fc_gateway = nla_get_in6_addr(tb[RTA_GATEWAY]);
86872cb5 3610 cfg->fc_flags |= RTF_GATEWAY;
1da177e4 3611 }
86872cb5
TG		 3612
3613 if (tb[RTA_DST]) {
3614 int plen = (rtm->rtm_dst_len + 7) >> 3;
3615
3616 if (nla_len(tb[RTA_DST]) < plen)
3617 goto errout;
3618
3619 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
1da177e4 3620 }
86872cb5
TG		 3621
3622 if (tb[RTA_SRC]) {
3623 int plen = (rtm->rtm_src_len + 7) >> 3;
3624
3625 if (nla_len(tb[RTA_SRC]) < plen)
3626 goto errout;
3627
3628 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
1da177e4 3629 }
86872cb5 3630
c3968a85 3631 if (tb[RTA_PREFSRC])
67b61f6c 3632 cfg->fc_prefsrc = nla_get_in6_addr(tb[RTA_PREFSRC]);
c3968a85 3633
86872cb5
TG		 3634 if (tb[RTA_OIF])
3635 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
3636
3637 if (tb[RTA_PRIORITY])
3638 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
3639
3640 if (tb[RTA_METRICS]) {
3641 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
3642 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
1da177e4 3643 }
86872cb5
TG		 3644
3645 if (tb[RTA_TABLE])
3646 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
3647
51ebd318
ND		 3648 if (tb[RTA_MULTIPATH]) {
3649 cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
3650 cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);
9ed59592
DA		 3651
3652 err = lwtunnel_valid_encap_type_attr(cfg->fc_mp,
c255bd68 3653 cfg->fc_mp_len, extack);
9ed59592
DA		 3654 if (err < 0)
3655 goto errout;
51ebd318
ND		 3656 }
3657
c78ba6d6
LR		 3658 if (tb[RTA_PREF]) {
3659 pref = nla_get_u8(tb[RTA_PREF]);
3660 if (pref != ICMPV6_ROUTER_PREF_LOW &&
3661 pref != ICMPV6_ROUTER_PREF_HIGH)
3662 pref = ICMPV6_ROUTER_PREF_MEDIUM;
3663 cfg->fc_flags |= RTF_PREF(pref);
3664 }
3665
19e42e45
RP		 3666 if (tb[RTA_ENCAP])
3667 cfg->fc_encap = tb[RTA_ENCAP];
3668
9ed59592 3669 if (tb[RTA_ENCAP_TYPE]) {
19e42e45
RP		 3670 cfg->fc_encap_type = nla_get_u16(tb[RTA_ENCAP_TYPE]);
3671
c255bd68 3672 err = lwtunnel_valid_encap_type(cfg->fc_encap_type, extack);
9ed59592
DA		 3673 if (err < 0)
3674 goto errout;
3675 }
3676
32bc201e
XL		 3677 if (tb[RTA_EXPIRES]) {
3678 unsigned long timeout = addrconf_timeout_fixup(nla_get_u32(tb[RTA_EXPIRES]), HZ);
3679
3680 if (addrconf_finite_timeout(timeout)) {
3681 cfg->fc_expires = jiffies_to_clock_t(timeout * HZ);
3682 cfg->fc_flags |= RTF_EXPIRES;
3683 }
3684 }
3685
86872cb5
TG		 3686 err = 0;
3687errout:
3688 return err;
1da177e4
LT		 3689}
3690
6b9ea5a6
RP		 3691struct rt6_nh {
3692 struct rt6_info *rt6_info;
3693 struct fib6_config r_cfg;
3694 struct mx6_config mxc;
3695 struct list_head next;
3696};
3697
3698static void ip6_print_replace_route_err(struct list_head *rt6_nh_list)
3699{
3700 struct rt6_nh *nh;
3701
3702 list_for_each_entry(nh, rt6_nh_list, next) {
7d4d5065 3703 pr_warn("IPV6: multipath route replace failed (check consistency of installed routes): %pI6c nexthop %pI6c ifi %d\n",
6b9ea5a6
RP		 3704 &nh->r_cfg.fc_dst, &nh->r_cfg.fc_gateway,
3705 nh->r_cfg.fc_ifindex);
3706 }
3707}
3708
3709static int ip6_route_info_append(struct list_head *rt6_nh_list,
3710 struct rt6_info *rt, struct fib6_config *r_cfg)
3711{
3712 struct rt6_nh *nh;
6b9ea5a6
RP		 3713 int err = -EEXIST;
3714
3715 list_for_each_entry(nh, rt6_nh_list, next) {
3716 /* check if rt6_info already exists */
f06b7549 3717 if (rt6_duplicate_nexthop(nh->rt6_info, rt))
6b9ea5a6
RP		 3718 return err;
3719 }
3720
3721 nh = kzalloc(sizeof(*nh), GFP_KERNEL);
3722 if (!nh)
3723 return -ENOMEM;
3724 nh->rt6_info = rt;
3725 err = ip6_convert_metrics(&nh->mxc, r_cfg);
3726 if (err) {
3727 kfree(nh);
3728 return err;
3729 }
3730 memcpy(&nh->r_cfg, r_cfg, sizeof(*r_cfg));
3731 list_add_tail(&nh->next, rt6_nh_list);
3732
3733 return 0;
3734}
3735
3b1137fe
DA		 3736static void ip6_route_mpath_notify(struct rt6_info *rt,
3737 struct rt6_info *rt_last,
3738 struct nl_info *info,
3739 __u16 nlflags)
3740{
3741 /* if this is an APPEND route, then rt points to the first route
3742 * inserted and rt_last points to last route inserted. Userspace
3743 * wants a consistent dump of the route which starts at the first
3744 * nexthop. Since sibling routes are always added at the end of
3745 * the list, find the first sibling of the last route appended
3746 */
3747 if ((nlflags & NLM_F_APPEND) && rt_last && rt_last->rt6i_nsiblings) {
3748 rt = list_first_entry(&rt_last->rt6i_siblings,
3749 struct rt6_info,
3750 rt6i_siblings);
3751 }
3752
3753 if (rt)
3754 inet6_rt_notify(RTM_NEWROUTE, rt, info, nlflags);
3755}
3756
333c4301
DA		 3757static int ip6_route_multipath_add(struct fib6_config *cfg,
3758 struct netlink_ext_ack *extack)
51ebd318 3759{
3b1137fe
DA		 3760 struct rt6_info *rt_notif = NULL, *rt_last = NULL;
3761 struct nl_info *info = &cfg->fc_nlinfo;
51ebd318
ND		 3762 struct fib6_config r_cfg;
3763 struct rtnexthop *rtnh;
6b9ea5a6
RP		 3764 struct rt6_info *rt;
3765 struct rt6_nh *err_nh;
3766 struct rt6_nh *nh, *nh_safe;
3b1137fe 3767 __u16 nlflags;
51ebd318
ND		 3768 int remaining;
3769 int attrlen;
6b9ea5a6
RP		 3770 int err = 1;
3771 int nhn = 0;
3772 int replace = (cfg->fc_nlinfo.nlh &&
3773 (cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_REPLACE));
3774 LIST_HEAD(rt6_nh_list);
51ebd318 3775
3b1137fe
DA		 3776 nlflags = replace ? NLM_F_REPLACE : NLM_F_CREATE;
3777 if (info->nlh && info->nlh->nlmsg_flags & NLM_F_APPEND)
3778 nlflags |= NLM_F_APPEND;
3779
35f1b4e9 3780 remaining = cfg->fc_mp_len;
51ebd318 3781 rtnh = (struct rtnexthop *)cfg->fc_mp;
51ebd318 3782
6b9ea5a6
RP		 3783 /* Parse a Multipath Entry and build a list (rt6_nh_list) of
3784 * rt6_info structs per nexthop
3785 */
51ebd318
ND		 3786 while (rtnh_ok(rtnh, remaining)) {
3787 memcpy(&r_cfg, cfg, sizeof(*cfg));
3788 if (rtnh->rtnh_ifindex)
3789 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
3790
3791 attrlen = rtnh_attrlen(rtnh);
3792 if (attrlen > 0) {
3793 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
3794
3795 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
3796 if (nla) {
67b61f6c 3797 r_cfg.fc_gateway = nla_get_in6_addr(nla);
51ebd318
ND		 3798 r_cfg.fc_flags |= RTF_GATEWAY;
3799 }
19e42e45
RP		 3800 r_cfg.fc_encap = nla_find(attrs, attrlen, RTA_ENCAP);
3801 nla = nla_find(attrs, attrlen, RTA_ENCAP_TYPE);
3802 if (nla)
3803 r_cfg.fc_encap_type = nla_get_u16(nla);
51ebd318 3804 }
6b9ea5a6 3805
333c4301 3806 rt = ip6_route_info_create(&r_cfg, extack);
8c5b83f0
RP		 3807 if (IS_ERR(rt)) {
3808 err = PTR_ERR(rt);
3809 rt = NULL;
6b9ea5a6 3810 goto cleanup;
8c5b83f0 3811 }
6b9ea5a6
RP		 3812
3813 err = ip6_route_info_append(&rt6_nh_list, rt, &r_cfg);
51ebd318 3814 if (err) {
587fea74 3815 dst_release_immediate(&rt->dst);
6b9ea5a6
RP		 3816 goto cleanup;
3817 }
3818
3819 rtnh = rtnh_next(rtnh, &remaining);
3820 }
3821
3b1137fe
DA		 3822 /* for add and replace send one notification with all nexthops.
3823 * Skip the notification in fib6_add_rt2node and send one with
3824 * the full route when done
3825 */
3826 info->skip_notify = 1;
3827
6b9ea5a6
RP		 3828 err_nh = NULL;
3829 list_for_each_entry(nh, &rt6_nh_list, next) {
3b1137fe 3830 rt_last = nh->rt6_info;
333c4301 3831 err = __ip6_ins_rt(nh->rt6_info, info, &nh->mxc, extack);
3b1137fe
DA		 3832 /* save reference to first route for notification */
3833 if (!rt_notif && !err)
3834 rt_notif = nh->rt6_info;
3835
6b9ea5a6
RP		 3836 /* nh->rt6_info is used or freed at this point, reset to NULL*/
3837 nh->rt6_info = NULL;
3838 if (err) {
3839 if (replace && nhn)
3840 ip6_print_replace_route_err(&rt6_nh_list);
3841 err_nh = nh;
3842 goto add_errout;
51ebd318 3843 }
6b9ea5a6 3844
1a72418b 3845 /* Because each route is added like a single route we remove
27596472
MK		 3846 * these flags after the first nexthop: if there is a collision,
3847 * we have already failed to add the first nexthop:
3848 * fib6_add_rt2node() has rejected it; when replacing, old
3849 * nexthops have been replaced by first new, the rest should
3850 * be added to it.
1a72418b 3851 */
27596472
MK		 3852 cfg->fc_nlinfo.nlh->nlmsg_flags &= ~(NLM_F_EXCL |
3853 NLM_F_REPLACE);
6b9ea5a6
RP		 3854 nhn++;
3855 }
3856
3b1137fe
DA		 3857 /* success ... tell user about new route */
3858 ip6_route_mpath_notify(rt_notif, rt_last, info, nlflags);
6b9ea5a6
RP		 3859 goto cleanup;
3860
3861add_errout:
3b1137fe
DA		 3862 /* send notification for routes that were added so that
3863 * the delete notifications sent by ip6_route_del are
3864 * coherent
3865 */
3866 if (rt_notif)
3867 ip6_route_mpath_notify(rt_notif, rt_last, info, nlflags);
3868
6b9ea5a6
RP		 3869 /* Delete routes that were already added */
3870 list_for_each_entry(nh, &rt6_nh_list, next) {
3871 if (err_nh == nh)
3872 break;
333c4301 3873 ip6_route_del(&nh->r_cfg, extack);
6b9ea5a6
RP		 3874 }
3875
3876cleanup:
3877 list_for_each_entry_safe(nh, nh_safe, &rt6_nh_list, next) {
587fea74
WW		 3878 if (nh->rt6_info)
3879 dst_release_immediate(&nh->rt6_info->dst);
52fe51f8 3880 kfree(nh->mxc.mx);
6b9ea5a6
RP		 3881 list_del(&nh->next);
3882 kfree(nh);
3883 }
3884
3885 return err;
3886}
3887
333c4301
DA		 3888static int ip6_route_multipath_del(struct fib6_config *cfg,
3889 struct netlink_ext_ack *extack)
6b9ea5a6
RP		 3890{
3891 struct fib6_config r_cfg;
3892 struct rtnexthop *rtnh;
3893 int remaining;
3894 int attrlen;
3895 int err = 1, last_err = 0;
3896
3897 remaining = cfg->fc_mp_len;
3898 rtnh = (struct rtnexthop *)cfg->fc_mp;
3899
3900 /* Parse a Multipath Entry */
3901 while (rtnh_ok(rtnh, remaining)) {
3902 memcpy(&r_cfg, cfg, sizeof(*cfg));
3903 if (rtnh->rtnh_ifindex)
3904 r_cfg.fc_ifindex = rtnh->rtnh_ifindex;
3905
3906 attrlen = rtnh_attrlen(rtnh);
3907 if (attrlen > 0) {
3908 struct nlattr *nla, *attrs = rtnh_attrs(rtnh);
3909
3910 nla = nla_find(attrs, attrlen, RTA_GATEWAY);
3911 if (nla) {
3912 nla_memcpy(&r_cfg.fc_gateway, nla, 16);
3913 r_cfg.fc_flags |= RTF_GATEWAY;
3914 }
3915 }
333c4301 3916 err = ip6_route_del(&r_cfg, extack);
6b9ea5a6
RP		 3917 if (err)
3918 last_err = err;
3919
51ebd318
ND		 3920 rtnh = rtnh_next(rtnh, &remaining);
3921 }
3922
3923 return last_err;
3924}
3925
c21ef3e3
DA		 3926static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh,
3927 struct netlink_ext_ack *extack)
1da177e4 3928{
86872cb5
TG		 3929 struct fib6_config cfg;
3930 int err;
1da177e4 3931
333c4301 3932 err = rtm_to_fib6_config(skb, nlh, &cfg, extack);
86872cb5
TG		 3933 if (err < 0)
3934 return err;
3935
51ebd318 3936 if (cfg.fc_mp)
333c4301 3937 return ip6_route_multipath_del(&cfg, extack);
0ae81335
DA		 3938 else {
3939 cfg.fc_delete_all_nh = 1;
333c4301 3940 return ip6_route_del(&cfg, extack);
0ae81335 3941 }
1da177e4
LT		 3942}
3943
c21ef3e3
DA		 3944static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh,
3945 struct netlink_ext_ack *extack)
1da177e4 3946{
86872cb5
TG		 3947 struct fib6_config cfg;
3948 int err;
1da177e4 3949
333c4301 3950 err = rtm_to_fib6_config(skb, nlh, &cfg, extack);
86872cb5
TG		 3951 if (err < 0)
3952 return err;
3953
51ebd318 3954 if (cfg.fc_mp)
333c4301 3955 return ip6_route_multipath_add(&cfg, extack);
51ebd318 3956 else
333c4301 3957 return ip6_route_add(&cfg, extack);
1da177e4
LT		 3958}
3959
beb1afac 3960static size_t rt6_nlmsg_size(struct rt6_info *rt)
339bf98f 3961{
beb1afac
DA		 3962 int nexthop_len = 0;
3963
3964 if (rt->rt6i_nsiblings) {
3965 nexthop_len = nla_total_size(0) /* RTA_MULTIPATH */
3966 + NLA_ALIGN(sizeof(struct rtnexthop))
3967 + nla_total_size(16) /* RTA_GATEWAY */
beb1afac
DA		 3968 + lwtunnel_get_encap_size(rt->dst.lwtstate);
3969
3970 nexthop_len *= rt->rt6i_nsiblings;
3971 }
3972
339bf98f
TG		 3973 return NLMSG_ALIGN(sizeof(struct rtmsg))
3974 + nla_total_size(16) /* RTA_SRC */
3975 + nla_total_size(16) /* RTA_DST */
3976 + nla_total_size(16) /* RTA_GATEWAY */
3977 + nla_total_size(16) /* RTA_PREFSRC */
3978 + nla_total_size(4) /* RTA_TABLE */
3979 + nla_total_size(4) /* RTA_IIF */
3980 + nla_total_size(4) /* RTA_OIF */
3981 + nla_total_size(4) /* RTA_PRIORITY */
6a2b9ce0 3982 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
ea697639 3983 + nla_total_size(sizeof(struct rta_cacheinfo))
c78ba6d6 3984 + nla_total_size(TCP_CA_NAME_MAX) /* RTAX_CC_ALGO */
19e42e45 3985 + nla_total_size(1) /* RTA_PREF */
beb1afac
DA		 3986 + lwtunnel_get_encap_size(rt->dst.lwtstate)
3987 + nexthop_len;
3988}
3989
3990static int rt6_nexthop_info(struct sk_buff *skb, struct rt6_info *rt,
5be083ce 3991 unsigned int *flags, bool skip_oif)
beb1afac
DA		 3992{
3993 if (!netif_running(rt->dst.dev) || !netif_carrier_ok(rt->dst.dev)) {
3994 *flags |= RTNH_F_LINKDOWN;
3995 if (rt->rt6i_idev->cnf.ignore_routes_with_linkdown)
3996 *flags |= RTNH_F_DEAD;
3997 }
3998
3999 if (rt->rt6i_flags & RTF_GATEWAY) {
4000 if (nla_put_in6_addr(skb, RTA_GATEWAY, &rt->rt6i_gateway) < 0)
4001 goto nla_put_failure;
4002 }
4003
fe400799 4004 if (rt->rt6i_nh_flags & RTNH_F_OFFLOAD)
61e4d01e
IS		 4005 *flags |= RTNH_F_OFFLOAD;
4006
5be083ce
DA		 4007 /* not needed for multipath encoding b/c it has a rtnexthop struct */
4008 if (!skip_oif && rt->dst.dev &&
beb1afac
DA		 4009 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
4010 goto nla_put_failure;
4011
4012 if (rt->dst.lwtstate &&
4013 lwtunnel_fill_encap(skb, rt->dst.lwtstate) < 0)
4014 goto nla_put_failure;
4015
4016 return 0;
4017
4018nla_put_failure:
4019 return -EMSGSIZE;
4020}
4021
5be083ce 4022/* add multipath next hop */
beb1afac
DA		 4023static int rt6_add_nexthop(struct sk_buff *skb, struct rt6_info *rt)
4024{
4025 struct rtnexthop *rtnh;
4026 unsigned int flags = 0;
4027
4028 rtnh = nla_reserve_nohdr(skb, sizeof(*rtnh));
4029 if (!rtnh)
4030 goto nla_put_failure;
4031
4032 rtnh->rtnh_hops = 0;
4033 rtnh->rtnh_ifindex = rt->dst.dev ? rt->dst.dev->ifindex : 0;
4034
5be083ce 4035 if (rt6_nexthop_info(skb, rt, &flags, true) < 0)
beb1afac
DA		 4036 goto nla_put_failure;
4037
4038 rtnh->rtnh_flags = flags;
4039
4040 /* length of rtnetlink header + attributes */
4041 rtnh->rtnh_len = nlmsg_get_pos(skb) - (void *)rtnh;
4042
4043 return 0;
4044
4045nla_put_failure:
4046 return -EMSGSIZE;
339bf98f
TG		 4047}
4048
191cd582
BH		 4049static int rt6_fill_node(struct net *net,
4050 struct sk_buff *skb, struct rt6_info *rt,
0d51aa80 4051 struct in6_addr *dst, struct in6_addr *src,
15e47304 4052 int iif, int type, u32 portid, u32 seq,
f8cfe2ce 4053 unsigned int flags)
1da177e4 4054{
4b32b5ad 4055 u32 metrics[RTAX_MAX];
1da177e4 4056 struct rtmsg *rtm;
2d7202bf 4057 struct nlmsghdr *nlh;
e3703b3d 4058 long expires;
9e762a4a 4059 u32 table;
1da177e4 4060
15e47304 4061 nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
38308473 4062 if (!nlh)
26932566 4063 return -EMSGSIZE;
2d7202bf
TG		 4064
4065 rtm = nlmsg_data(nlh);
1da177e4
LT		 4066 rtm->rtm_family = AF_INET6;
4067 rtm->rtm_dst_len = rt->rt6i_dst.plen;
4068 rtm->rtm_src_len = rt->rt6i_src.plen;
4069 rtm->rtm_tos = 0;
c71099ac 4070 if (rt->rt6i_table)
9e762a4a 4071 table = rt->rt6i_table->tb6_id;
c71099ac 4072 else
9e762a4a
PM		 4073 table = RT6_TABLE_UNSPEC;
4074 rtm->rtm_table = table;
c78679e8
DM		 4075 if (nla_put_u32(skb, RTA_TABLE, table))
4076 goto nla_put_failure;
ef2c7d7b
ND		 4077 if (rt->rt6i_flags & RTF_REJECT) {
4078 switch (rt->dst.error) {
4079 case -EINVAL:
4080 rtm->rtm_type = RTN_BLACKHOLE;
4081 break;
4082 case -EACCES:
4083 rtm->rtm_type = RTN_PROHIBIT;
4084 break;
b4949ab2
ND		 4085 case -EAGAIN:
4086 rtm->rtm_type = RTN_THROW;
4087 break;
ef2c7d7b
ND		 4088 default:
4089 rtm->rtm_type = RTN_UNREACHABLE;
4090 break;
4091 }
4092 }
38308473 4093 else if (rt->rt6i_flags & RTF_LOCAL)
ab79ad14 4094 rtm->rtm_type = RTN_LOCAL;
4ee39733
DA		 4095 else if (rt->rt6i_flags & RTF_ANYCAST)
4096 rtm->rtm_type = RTN_ANYCAST;
d1918542 4097 else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
1da177e4
LT		 4098 rtm->rtm_type = RTN_LOCAL;
4099 else
4100 rtm->rtm_type = RTN_UNICAST;
4101 rtm->rtm_flags = 0;
4102 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
4103 rtm->rtm_protocol = rt->rt6i_protocol;
1da177e4 4104
38308473 4105 if (rt->rt6i_flags & RTF_CACHE)
1da177e4
LT		 4106 rtm->rtm_flags |= RTM_F_CLONED;
4107
4108 if (dst) {
930345ea 4109 if (nla_put_in6_addr(skb, RTA_DST, dst))
c78679e8 4110 goto nla_put_failure;
1ab1457c 4111 rtm->rtm_dst_len = 128;
1da177e4 4112 } else if (rtm->rtm_dst_len)
930345ea 4113 if (nla_put_in6_addr(skb, RTA_DST, &rt->rt6i_dst.addr))
c78679e8 4114 goto nla_put_failure;
1da177e4
LT		 4115#ifdef CONFIG_IPV6_SUBTREES
4116 if (src) {
930345ea 4117 if (nla_put_in6_addr(skb, RTA_SRC, src))
c78679e8 4118 goto nla_put_failure;
1ab1457c 4119 rtm->rtm_src_len = 128;
c78679e8 4120 } else if (rtm->rtm_src_len &&
930345ea 4121 nla_put_in6_addr(skb, RTA_SRC, &rt->rt6i_src.addr))
c78679e8 4122 goto nla_put_failure;
1da177e4 4123#endif
7bc570c8
YH		 4124 if (iif) {
4125#ifdef CONFIG_IPV6_MROUTE
4126 if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
fd61c6ba
DA		 4127 int err = ip6mr_get_route(net, skb, rtm, portid);
4128
4129 if (err == 0)
4130 return 0;
4131 if (err < 0)
4132 goto nla_put_failure;
7bc570c8
YH		 4133 } else
4134#endif
c78679e8
DM		 4135 if (nla_put_u32(skb, RTA_IIF, iif))
4136 goto nla_put_failure;
7bc570c8 4137 } else if (dst) {
1da177e4 4138 struct in6_addr saddr_buf;
c78679e8 4139 if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
930345ea 4140 nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
c78679e8 4141 goto nla_put_failure;
1da177e4 4142 }
2d7202bf 4143
c3968a85
DW		 4144 if (rt->rt6i_prefsrc.plen) {
4145 struct in6_addr saddr_buf;
4e3fd7a0 4146 saddr_buf = rt->rt6i_prefsrc.addr;
930345ea 4147 if (nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
c78679e8 4148 goto nla_put_failure;
c3968a85
DW		 4149 }
4150
4b32b5ad
MKL		 4151 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
4152 if (rt->rt6i_pmtu)
4153 metrics[RTAX_MTU - 1] = rt->rt6i_pmtu;
4154 if (rtnetlink_put_metrics(skb, metrics) < 0)
2d7202bf
TG		 4155 goto nla_put_failure;
4156
c78679e8
DM		 4157 if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
4158 goto nla_put_failure;
8253947e 4159
beb1afac
DA		 4160 /* For multipath routes, walk the siblings list and add
4161 * each as a nexthop within RTA_MULTIPATH.
4162 */
4163 if (rt->rt6i_nsiblings) {
4164 struct rt6_info *sibling, *next_sibling;
4165 struct nlattr *mp;
4166
4167 mp = nla_nest_start(skb, RTA_MULTIPATH);
4168 if (!mp)
4169 goto nla_put_failure;
4170
4171 if (rt6_add_nexthop(skb, rt) < 0)
4172 goto nla_put_failure;
4173
4174 list_for_each_entry_safe(sibling, next_sibling,
4175 &rt->rt6i_siblings, rt6i_siblings) {
4176 if (rt6_add_nexthop(skb, sibling) < 0)
4177 goto nla_put_failure;
4178 }
4179
4180 nla_nest_end(skb, mp);
4181 } else {
5be083ce 4182 if (rt6_nexthop_info(skb, rt, &rtm->rtm_flags, false) < 0)
beb1afac
DA		 4183 goto nla_put_failure;
4184 }
4185
8253947e 4186 expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;
69cdf8f9 4187
87a50699 4188 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
e3703b3d 4189 goto nla_put_failure;
2d7202bf 4190
c78ba6d6
LR		 4191 if (nla_put_u8(skb, RTA_PREF, IPV6_EXTRACT_PREF(rt->rt6i_flags)))
4192 goto nla_put_failure;
4193
19e42e45 4194
053c095a
JB		 4195 nlmsg_end(skb, nlh);
4196 return 0;
2d7202bf
TG		 4197
4198nla_put_failure:
26932566
PM		 4199 nlmsg_cancel(skb, nlh);
4200 return -EMSGSIZE;
1da177e4
LT		 4201}
4202
1b43af54 4203int rt6_dump_route(struct rt6_info *rt, void *p_arg)
1da177e4
LT		 4204{
4205 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
1f17e2f2
DA		 4206 struct net *net = arg->net;
4207
4208 if (rt == net->ipv6.ip6_null_entry)
4209 return 0;
1da177e4 4210
2d7202bf
TG		 4211 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
4212 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
f8cfe2ce
DA		 4213
4214 /* user wants prefix routes only */
4215 if (rtm->rtm_flags & RTM_F_PREFIX &&
4216 !(rt->rt6i_flags & RTF_PREFIX_RT)) {
4217 /* success since this is not a prefix route */
4218 return 1;
4219 }
4220 }
1da177e4 4221
1f17e2f2 4222 return rt6_fill_node(net,
191cd582 4223 arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
15e47304 4224 NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
f8cfe2ce 4225 NLM_F_MULTI);
1da177e4
LT		 4226}
4227
c21ef3e3
DA		 4228static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh,
4229 struct netlink_ext_ack *extack)
1da177e4 4230{
3b1e0a65 4231 struct net *net = sock_net(in_skb->sk);
ab364a6f 4232 struct nlattr *tb[RTA_MAX+1];
18c3a61c
RP		 4233 int err, iif = 0, oif = 0;
4234 struct dst_entry *dst;
ab364a6f 4235 struct rt6_info *rt;
1da177e4 4236 struct sk_buff *skb;
ab364a6f 4237 struct rtmsg *rtm;
4c9483b2 4238 struct flowi6 fl6;
18c3a61c 4239 bool fibmatch;
1da177e4 4240
fceb6435 4241 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy,
c21ef3e3 4242 extack);
ab364a6f
TG		 4243 if (err < 0)
4244 goto errout;
1da177e4 4245
ab364a6f 4246 err = -EINVAL;
4c9483b2 4247 memset(&fl6, 0, sizeof(fl6));
38b7097b
HFS		 4248 rtm = nlmsg_data(nlh);
4249 fl6.flowlabel = ip6_make_flowinfo(rtm->rtm_tos, 0);
18c3a61c 4250 fibmatch = !!(rtm->rtm_flags & RTM_F_FIB_MATCH);
1da177e4 4251
ab364a6f
TG		 4252 if (tb[RTA_SRC]) {
4253 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
4254 goto errout;
4255
4e3fd7a0 4256 fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
ab364a6f
TG		 4257 }
4258
4259 if (tb[RTA_DST]) {
4260 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
4261 goto errout;
4262
4e3fd7a0 4263 fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
ab364a6f
TG		 4264 }
4265
4266 if (tb[RTA_IIF])
4267 iif = nla_get_u32(tb[RTA_IIF]);
4268
4269 if (tb[RTA_OIF])
72331bc0 4270 oif = nla_get_u32(tb[RTA_OIF]);
1da177e4 4271
2e47b291
LC		 4272 if (tb[RTA_MARK])
4273 fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);
4274
622ec2c9
LC		 4275 if (tb[RTA_UID])
4276 fl6.flowi6_uid = make_kuid(current_user_ns(),
4277 nla_get_u32(tb[RTA_UID]));
4278 else
4279 fl6.flowi6_uid = iif ? INVALID_UID : current_uid();
4280
1da177e4
LT		 4281 if (iif) {
4282 struct net_device *dev;
72331bc0
SL		 4283 int flags = 0;
4284
121622db
FW		 4285 rcu_read_lock();
4286
4287 dev = dev_get_by_index_rcu(net, iif);
1da177e4 4288 if (!dev) {
121622db 4289 rcu_read_unlock();
1da177e4 4290 err = -ENODEV;
ab364a6f 4291 goto errout;
1da177e4 4292 }
72331bc0
SL		 4293
4294 fl6.flowi6_iif = iif;
4295
4296 if (!ipv6_addr_any(&fl6.saddr))
4297 flags |= RT6_LOOKUP_F_HAS_SADDR;
4298
58acfd71 4299 dst = ip6_route_input_lookup(net, dev, &fl6, flags);
121622db
FW		 4300
4301 rcu_read_unlock();
72331bc0
SL		 4302 } else {
4303 fl6.flowi6_oif = oif;
4304
58acfd71 4305 dst = ip6_route_output(net, NULL, &fl6);
18c3a61c
RP		 4306 }
4307
18c3a61c
RP		 4308
4309 rt = container_of(dst, struct rt6_info, dst);
4310 if (rt->dst.error) {
4311 err = rt->dst.error;
4312 ip6_rt_put(rt);
4313 goto errout;
1da177e4
LT		 4314 }
4315
9d6acb3b
WC		 4316 if (rt == net->ipv6.ip6_null_entry) {
4317 err = rt->dst.error;
4318 ip6_rt_put(rt);
4319 goto errout;
4320 }
4321
fba961ab
DM		 4322 if (fibmatch && rt->from) {
4323 struct rt6_info *ort = rt->from;
58acfd71
IS		 4324
4325 dst_hold(&ort->dst);
4326 ip6_rt_put(rt);
4327 rt = ort;
4328 }
4329
ab364a6f 4330 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
38308473 4331 if (!skb) {
94e187c0 4332 ip6_rt_put(rt);
ab364a6f
TG		 4333 err = -ENOBUFS;
4334 goto errout;
4335 }
1da177e4 4336
d8d1f30b 4337 skb_dst_set(skb, &rt->dst);
18c3a61c
RP		 4338 if (fibmatch)
4339 err = rt6_fill_node(net, skb, rt, NULL, NULL, iif,
4340 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
4341 nlh->nlmsg_seq, 0);
4342 else
4343 err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
4344 RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
4345 nlh->nlmsg_seq, 0);
1da177e4 4346 if (err < 0) {
ab364a6f
TG		 4347 kfree_skb(skb);
4348 goto errout;
1da177e4
LT		 4349 }
4350
15e47304 4351 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
ab364a6f 4352errout:
1da177e4 4353 return err;
1da177e4
LT		 4354}
4355
37a1d361
RP		 4356void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info,
4357 unsigned int nlm_flags)
1da177e4
LT		 4358{
4359 struct sk_buff *skb;
5578689a 4360 struct net *net = info->nl_net;
528c4ceb
DL		 4361 u32 seq;
4362 int err;
4363
4364 err = -ENOBUFS;
38308473 4365 seq = info->nlh ? info->nlh->nlmsg_seq : 0;
86872cb5 4366
19e42e45 4367 skb = nlmsg_new(rt6_nlmsg_size(rt), gfp_any());
38308473 4368 if (!skb)
21713ebc
TG		 4369 goto errout;
4370
191cd582 4371 err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
f8cfe2ce 4372 event, info->portid, seq, nlm_flags);
26932566
PM		 4373 if (err < 0) {
4374 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
4375 WARN_ON(err == -EMSGSIZE);
4376 kfree_skb(skb);
4377 goto errout;
4378 }
15e47304 4379 rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
1ce85fe4
PNA		 4380 info->nlh, gfp_any());
4381 return;
21713ebc
TG		 4382errout:
4383 if (err < 0)
5578689a 4384 rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
1da177e4
LT		 4385}
4386
8ed67789 4387static int ip6_route_dev_notify(struct notifier_block *this,
351638e7 4388 unsigned long event, void *ptr)
8ed67789 4389{
351638e7 4390 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
c346dca1 4391 struct net *net = dev_net(dev);
8ed67789 4392
242d3a49
WC		 4393 if (!(dev->flags & IFF_LOOPBACK))
4394 return NOTIFY_OK;
4395
4396 if (event == NETDEV_REGISTER) {
d8d1f30b 4397 net->ipv6.ip6_null_entry->dst.dev = dev;
8ed67789
DL		 4398 net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
4399#ifdef CONFIG_IPV6_MULTIPLE_TABLES
d8d1f30b 4400 net->ipv6.ip6_prohibit_entry->dst.dev = dev;
8ed67789 4401 net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
d8d1f30b 4402 net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
8ed67789 4403 net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
242d3a49 4404#endif
76da0704
WC		 4405 } else if (event == NETDEV_UNREGISTER &&
4406 dev->reg_state != NETREG_UNREGISTERED) {
4407 /* NETDEV_UNREGISTER could be fired for multiple times by
4408 * netdev_wait_allrefs(). Make sure we only call this once.
4409 */
12d94a80 4410 in6_dev_put_clear(&net->ipv6.ip6_null_entry->rt6i_idev);
242d3a49 4411#ifdef CONFIG_IPV6_MULTIPLE_TABLES
12d94a80
ED		 4412 in6_dev_put_clear(&net->ipv6.ip6_prohibit_entry->rt6i_idev);
4413 in6_dev_put_clear(&net->ipv6.ip6_blk_hole_entry->rt6i_idev);
8ed67789
DL		 4414#endif
4415 }
4416
4417 return NOTIFY_OK;
4418}
4419
1da177e4
LT		 4420/*
4421 * /proc
4422 */
4423
4424#ifdef CONFIG_PROC_FS
4425
33120b30
AD		 4426static const struct file_operations ipv6_route_proc_fops = {
4427 .owner = THIS_MODULE,
4428 .open = ipv6_route_open,
4429 .read = seq_read,
4430 .llseek = seq_lseek,
8d2ca1d7 4431 .release = seq_release_net,
33120b30
AD		 4432};
4433
1da177e4
LT		 4434static int rt6_stats_seq_show(struct seq_file *seq, void *v)
4435{
69ddb805 4436 struct net *net = (struct net *)seq->private;
1da177e4 4437 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
69ddb805
DL		 4438 net->ipv6.rt6_stats->fib_nodes,
4439 net->ipv6.rt6_stats->fib_route_nodes,
81eb8447 4440 atomic_read(&net->ipv6.rt6_stats->fib_rt_alloc),
69ddb805
DL		 4441 net->ipv6.rt6_stats->fib_rt_entries,
4442 net->ipv6.rt6_stats->fib_rt_cache,
fc66f95c 4443 dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
69ddb805 4444 net->ipv6.rt6_stats->fib_discarded_routes);
1da177e4
LT		 4445
4446 return 0;
4447}
4448
4449static int rt6_stats_seq_open(struct inode *inode, struct file *file)
4450{
de05c557 4451 return single_open_net(inode, file, rt6_stats_seq_show);
69ddb805
DL		 4452}
4453
9a32144e 4454static const struct file_operations rt6_stats_seq_fops = {
1da177e4
LT		 4455 .owner = THIS_MODULE,
4456 .open = rt6_stats_seq_open,
4457 .read = seq_read,
4458 .llseek = seq_lseek,
b6fcbdb4 4459 .release = single_release_net,
1da177e4
LT		 4460};
4461#endif /* CONFIG_PROC_FS */
4462
4463#ifdef CONFIG_SYSCTL
4464
1da177e4 4465static
fe2c6338 4466int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,
1da177e4
LT		 4467 void __user *buffer, size_t *lenp, loff_t *ppos)
4468{
c486da34
LAG		 4469 struct net *net;
4470 int delay;
4471 if (!write)
1da177e4 4472 return -EINVAL;
c486da34
LAG		 4473
4474 net = (struct net *)ctl->extra1;
4475 delay = net->ipv6.sysctl.flush_delay;
4476 proc_dointvec(ctl, write, buffer, lenp, ppos);
2ac3ac8f 4477 fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
c486da34 4478 return 0;
1da177e4
LT		 4479}
4480
fe2c6338 4481struct ctl_table ipv6_route_table_template[] = {
1ab1457c 4482 {
1da177e4 4483 .procname = "flush",
4990509f 4484 .data = &init_net.ipv6.sysctl.flush_delay,
1da177e4 4485 .maxlen = sizeof(int),
89c8b3a1 4486 .mode = 0200,
6d9f239a 4487 .proc_handler = ipv6_sysctl_rtcache_flush
1da177e4
LT		 4488 },
4489 {
1da177e4 4490 .procname = "gc_thresh",
9a7ec3a9 4491 .data = &ip6_dst_ops_template.gc_thresh,
1da177e4
LT		 4492 .maxlen = sizeof(int),
4493 .mode = 0644,
6d9f239a 4494 .proc_handler = proc_dointvec,
1da177e4
LT		 4495 },
4496 {
1da177e4 4497 .procname = "max_size",
4990509f 4498 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
1da177e4
LT		 4499 .maxlen = sizeof(int),
4500 .mode = 0644,
6d9f239a 4501 .proc_handler = proc_dointvec,
1da177e4
LT		 4502 },
4503 {
1da177e4 4504 .procname = "gc_min_interval",
4990509f 4505 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
1da177e4
LT		 4506 .maxlen = sizeof(int),
4507 .mode = 0644,
6d9f239a 4508 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 4509 },
4510 {
1da177e4 4511 .procname = "gc_timeout",
4990509f 4512 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
1da177e4
LT		 4513 .maxlen = sizeof(int),
4514 .mode = 0644,
6d9f239a 4515 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 4516 },
4517 {
1da177e4 4518 .procname = "gc_interval",
4990509f 4519 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
1da177e4
LT		 4520 .maxlen = sizeof(int),
4521 .mode = 0644,
6d9f239a 4522 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 4523 },
4524 {
1da177e4 4525 .procname = "gc_elasticity",
4990509f 4526 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
1da177e4
LT		 4527 .maxlen = sizeof(int),
4528 .mode = 0644,
f3d3f616 4529 .proc_handler = proc_dointvec,
1da177e4
LT		 4530 },
4531 {
1da177e4 4532 .procname = "mtu_expires",
4990509f 4533 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
1da177e4
LT		 4534 .maxlen = sizeof(int),
4535 .mode = 0644,
6d9f239a 4536 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 4537 },
4538 {
1da177e4 4539 .procname = "min_adv_mss",
4990509f 4540 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
1da177e4
LT		 4541 .maxlen = sizeof(int),
4542 .mode = 0644,
f3d3f616 4543 .proc_handler = proc_dointvec,
1da177e4
LT		 4544 },
4545 {
1da177e4 4546 .procname = "gc_min_interval_ms",
4990509f 4547 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
1da177e4
LT		 4548 .maxlen = sizeof(int),
4549 .mode = 0644,
6d9f239a 4550 .proc_handler = proc_dointvec_ms_jiffies,
1da177e4 4551 },
f8572d8f 4552 { }
1da177e4
LT		 4553};
4554
2c8c1e72 4555struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
760f2d01
DL		 4556{
4557 struct ctl_table *table;
4558
4559 table = kmemdup(ipv6_route_table_template,
4560 sizeof(ipv6_route_table_template),
4561 GFP_KERNEL);
5ee09105
YH		 4562
4563 if (table) {
4564 table[0].data = &net->ipv6.sysctl.flush_delay;
c486da34 4565 table[0].extra1 = net;
86393e52 4566 table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
5ee09105
YH		 4567 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
4568 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
4569 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
4570 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
4571 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
4572 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
4573 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
9c69fabe 4574 table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
464dc801
EB		 4575
4576 /* Don't export sysctls to unprivileged users */
4577 if (net->user_ns != &init_user_ns)
4578 table[0].procname = NULL;
5ee09105
YH		 4579 }
4580
760f2d01
DL		 4581 return table;
4582}
1da177e4
LT		 4583#endif
4584
2c8c1e72 4585static int __net_init ip6_route_net_init(struct net *net)
cdb18761 4586{
633d424b 4587 int ret = -ENOMEM;
8ed67789 4588
86393e52
AD		 4589 memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
4590 sizeof(net->ipv6.ip6_dst_ops));
f2fc6a54 4591
fc66f95c
ED		 4592 if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
4593 goto out_ip6_dst_ops;
4594
8ed67789
DL		 4595 net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
4596 sizeof(*net->ipv6.ip6_null_entry),
4597 GFP_KERNEL);
4598 if (!net->ipv6.ip6_null_entry)
fc66f95c 4599 goto out_ip6_dst_entries;
d8d1f30b 4600 net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
62fa8a84
DM		 4601 dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
4602 ip6_template_metrics, true);
8ed67789
DL		 4603
4604#ifdef CONFIG_IPV6_MULTIPLE_TABLES
feca7d8c 4605 net->ipv6.fib6_has_custom_rules = false;
8ed67789
DL		 4606 net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
4607 sizeof(*net->ipv6.ip6_prohibit_entry),
4608 GFP_KERNEL);
68fffc67
PZ		 4609 if (!net->ipv6.ip6_prohibit_entry)
4610 goto out_ip6_null_entry;
d8d1f30b 4611 net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
62fa8a84
DM		 4612 dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
4613 ip6_template_metrics, true);
8ed67789
DL		 4614
4615 net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
4616 sizeof(*net->ipv6.ip6_blk_hole_entry),
4617 GFP_KERNEL);
68fffc67
PZ		 4618 if (!net->ipv6.ip6_blk_hole_entry)
4619 goto out_ip6_prohibit_entry;
d8d1f30b 4620 net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
62fa8a84
DM		 4621 dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
4622 ip6_template_metrics, true);
8ed67789
DL		 4623#endif
4624
b339a47c
PZ		 4625 net->ipv6.sysctl.flush_delay = 0;
4626 net->ipv6.sysctl.ip6_rt_max_size = 4096;
4627 net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
4628 net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
4629 net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
4630 net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
4631 net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
4632 net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
4633
6891a346
BT		 4634 net->ipv6.ip6_rt_gc_expire = 30*HZ;
4635
8ed67789
DL		 4636 ret = 0;
4637out:
4638 return ret;
f2fc6a54 4639
68fffc67
PZ		 4640#ifdef CONFIG_IPV6_MULTIPLE_TABLES
4641out_ip6_prohibit_entry:
4642 kfree(net->ipv6.ip6_prohibit_entry);
4643out_ip6_null_entry:
4644 kfree(net->ipv6.ip6_null_entry);
4645#endif
fc66f95c
ED		 4646out_ip6_dst_entries:
4647 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
f2fc6a54 4648out_ip6_dst_ops:
f2fc6a54 4649 goto out;
cdb18761
DL		 4650}
4651
2c8c1e72 4652static void __net_exit ip6_route_net_exit(struct net *net)
cdb18761 4653{
8ed67789
DL		 4654 kfree(net->ipv6.ip6_null_entry);
4655#ifdef CONFIG_IPV6_MULTIPLE_TABLES
4656 kfree(net->ipv6.ip6_prohibit_entry);
4657 kfree(net->ipv6.ip6_blk_hole_entry);
4658#endif
41bb78b4 4659 dst_entries_destroy(&net->ipv6.ip6_dst_ops);
cdb18761
DL		 4660}
4661
d189634e
TG		 4662static int __net_init ip6_route_net_init_late(struct net *net)
4663{
4664#ifdef CONFIG_PROC_FS
d4beaa66
G		 4665 proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
4666 proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
d189634e
TG		 4667#endif
4668 return 0;
4669}
4670
4671static void __net_exit ip6_route_net_exit_late(struct net *net)
4672{
4673#ifdef CONFIG_PROC_FS
ece31ffd
G		 4674 remove_proc_entry("ipv6_route", net->proc_net);
4675 remove_proc_entry("rt6_stats", net->proc_net);
d189634e
TG		 4676#endif
4677}
4678
cdb18761
DL		 4679static struct pernet_operations ip6_route_net_ops = {
4680 .init = ip6_route_net_init,
4681 .exit = ip6_route_net_exit,
4682};
4683
c3426b47
DM		 4684static int __net_init ipv6_inetpeer_init(struct net *net)
4685{
4686 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
4687
4688 if (!bp)
4689 return -ENOMEM;
4690 inet_peer_base_init(bp);
4691 net->ipv6.peers = bp;
4692 return 0;
4693}
4694
4695static void __net_exit ipv6_inetpeer_exit(struct net *net)
4696{
4697 struct inet_peer_base *bp = net->ipv6.peers;
4698
4699 net->ipv6.peers = NULL;
56a6b248 4700 inetpeer_invalidate_tree(bp);
c3426b47
DM		 4701 kfree(bp);
4702}
4703
2b823f72 4704static struct pernet_operations ipv6_inetpeer_ops = {
c3426b47
DM		 4705 .init = ipv6_inetpeer_init,
4706 .exit = ipv6_inetpeer_exit,
4707};
4708
d189634e
TG		 4709static struct pernet_operations ip6_route_net_late_ops = {
4710 .init = ip6_route_net_init_late,
4711 .exit = ip6_route_net_exit_late,
4712};
4713
8ed67789
DL		 4714static struct notifier_block ip6_route_dev_notifier = {
4715 .notifier_call = ip6_route_dev_notify,
242d3a49 4716 .priority = ADDRCONF_NOTIFY_PRIORITY - 10,
8ed67789
DL		 4717};
4718
2f460933
WC		 4719void __init ip6_route_init_special_entries(void)
4720{
4721 /* Registering of the loopback is done before this portion of code,
4722 * the loopback reference in rt6_info will not be taken, do it
4723 * manually for init_net */
4724 init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
4725 init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
4726 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
4727 init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
4728 init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
4729 init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
4730 init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
4731 #endif
4732}
4733
433d49c3 4734int __init ip6_route_init(void)
1da177e4 4735{
433d49c3 4736 int ret;
8d0b94af 4737 int cpu;
433d49c3 4738
9a7ec3a9
DL		 4739 ret = -ENOMEM;
4740 ip6_dst_ops_template.kmem_cachep =
e5d679f3 4741 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
f845ab6b 4742 SLAB_HWCACHE_ALIGN, NULL);
9a7ec3a9 4743 if (!ip6_dst_ops_template.kmem_cachep)
c19a28e1 4744 goto out;
14e50e57 4745
fc66f95c 4746 ret = dst_entries_init(&ip6_dst_blackhole_ops);
8ed67789 4747 if (ret)
bdb3289f 4748 goto out_kmem_cache;
bdb3289f 4749
c3426b47
DM		 4750 ret = register_pernet_subsys(&ipv6_inetpeer_ops);
4751 if (ret)
e8803b6c 4752 goto out_dst_entries;
2a0c451a 4753
7e52b33b
DM		 4754 ret = register_pernet_subsys(&ip6_route_net_ops);
4755 if (ret)
4756 goto out_register_inetpeer;
c3426b47 4757
5dc121e9
AE		 4758 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
4759
e8803b6c 4760 ret = fib6_init();
433d49c3 4761 if (ret)
8ed67789 4762 goto out_register_subsys;
433d49c3 4763
433d49c3
DL		 4764 ret = xfrm6_init();
4765 if (ret)
e8803b6c 4766 goto out_fib6_init;
c35b7e72 4767
433d49c3
DL		 4768 ret = fib6_rules_init();
4769 if (ret)
4770 goto xfrm6_init;
7e5449c2 4771
d189634e
TG		 4772 ret = register_pernet_subsys(&ip6_route_net_late_ops);
4773 if (ret)
4774 goto fib6_rules_init;
4775
16feebcf
FW		 4776 ret = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_NEWROUTE,
4777 inet6_rtm_newroute, NULL, 0);
4778 if (ret < 0)
4779 goto out_register_late_subsys;
4780
4781 ret = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_DELROUTE,
4782 inet6_rtm_delroute, NULL, 0);
4783 if (ret < 0)
4784 goto out_register_late_subsys;
4785
4786 ret = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETROUTE,
4787 inet6_rtm_getroute, NULL,
4788 RTNL_FLAG_DOIT_UNLOCKED);
4789 if (ret < 0)
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 4806out_register_late_subsys:
16feebcf 4807 rtnl_unregister_all(PF_INET6);
d189634e 4808 unregister_pernet_subsys(&ip6_route_net_late_ops);
433d49c3 4809fib6_rules_init:
433d49c3
DL		 4810 fib6_rules_cleanup();
4811xfrm6_init:
433d49c3 4812 xfrm6_fini();
2a0c451a
TG		 4813out_fib6_init:
4814 fib6_gc_cleanup();
8ed67789
DL		 4815out_register_subsys:
4816 unregister_pernet_subsys(&ip6_route_net_ops);
7e52b33b
DM		 4817out_register_inetpeer:
4818 unregister_pernet_subsys(&ipv6_inetpeer_ops);
fc66f95c
ED		 4819out_dst_entries:
4820 dst_entries_destroy(&ip6_dst_blackhole_ops);
433d49c3 4821out_kmem_cache:
f2fc6a54 4822 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
433d49c3 4823 goto out;
1da177e4
LT		 4824}
4825
4826void ip6_route_cleanup(void)
4827{
8ed67789 4828 unregister_netdevice_notifier(&ip6_route_dev_notifier);
d189634e 4829 unregister_pernet_subsys(&ip6_route_net_late_ops);
101367c2 4830 fib6_rules_cleanup();
1da177e4 4831 xfrm6_fini();
1da177e4 4832 fib6_gc_cleanup();
c3426b47 4833 unregister_pernet_subsys(&ipv6_inetpeer_ops);
8ed67789 4834 unregister_pernet_subsys(&ip6_route_net_ops);
41bb78b4 4835 dst_entries_destroy(&ip6_dst_blackhole_ops);
f2fc6a54 4836 kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
1da177e4 4837}
Linux 6.x block layer and io_uring tree(s)