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