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