]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - net/ipv6/route.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[NET]: Turn nfmark into generic mark
[mirror_ubuntu-bionic-kernel.git] / net / ipv6 / route.c
CommitLineData
1da177e4
LT		 1/*
2 * Linux INET6 implementation
3 * FIB front-end.
4 *
5 * Authors:
6 * Pedro Roque <roque@di.fc.ul.pt>
7 *
8 * $Id: route.c,v 1.56 2001/10/31 21:55:55 davem Exp $
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
14 */
15
16/* Changes:
17 *
18 * YOSHIFUJI Hideaki @USAGI
19 * reworked default router selection.
20 * - respect outgoing interface
21 * - select from (probably) reachable routers (i.e.
22 * routers in REACHABLE, STALE, DELAY or PROBE states).
23 * - always select the same router if it is (probably)
24 * reachable. otherwise, round-robin the list.
c0bece9f
YH		 25 * Ville Nuorvala
26 * Fixed routing subtrees.
1da177e4
LT		 27 */
28
4fc268d2 29#include <linux/capability.h>
1da177e4
LT		 30#include <linux/errno.h>
31#include <linux/types.h>
32#include <linux/times.h>
33#include <linux/socket.h>
34#include <linux/sockios.h>
35#include <linux/net.h>
36#include <linux/route.h>
37#include <linux/netdevice.h>
38#include <linux/in6.h>
39#include <linux/init.h>
1da177e4
LT		 40#include <linux/if_arp.h>
41
42#ifdef CONFIG_PROC_FS
43#include <linux/proc_fs.h>
44#include <linux/seq_file.h>
45#endif
46
47#include <net/snmp.h>
48#include <net/ipv6.h>
49#include <net/ip6_fib.h>
50#include <net/ip6_route.h>
51#include <net/ndisc.h>
52#include <net/addrconf.h>
53#include <net/tcp.h>
54#include <linux/rtnetlink.h>
55#include <net/dst.h>
56#include <net/xfrm.h>
8d71740c 57#include <net/netevent.h>
21713ebc 58#include <net/netlink.h>
1da177e4
LT		 59
60#include <asm/uaccess.h>
61
62#ifdef CONFIG_SYSCTL
63#include <linux/sysctl.h>
64#endif
65
66/* Set to 3 to get tracing. */
67#define RT6_DEBUG 2
68
69#if RT6_DEBUG >= 3
70#define RDBG(x) printk x
71#define RT6_TRACE(x...) printk(KERN_DEBUG x)
72#else
73#define RDBG(x)
74#define RT6_TRACE(x...) do { ; } while (0)
75#endif
76
519fbd87 77#define CLONE_OFFLINK_ROUTE 0
1da177e4
LT		 78
79static int ip6_rt_max_size = 4096;
80static int ip6_rt_gc_min_interval = HZ / 2;
81static int ip6_rt_gc_timeout = 60*HZ;
82int ip6_rt_gc_interval = 30*HZ;
83static int ip6_rt_gc_elasticity = 9;
84static int ip6_rt_mtu_expires = 10*60*HZ;
85static int ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
86
87static struct rt6_info * ip6_rt_copy(struct rt6_info *ort);
88static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
89static struct dst_entry *ip6_negative_advice(struct dst_entry *);
90static void ip6_dst_destroy(struct dst_entry *);
91static void ip6_dst_ifdown(struct dst_entry *,
92 struct net_device *dev, int how);
93static int ip6_dst_gc(void);
94
95static int ip6_pkt_discard(struct sk_buff *skb);
96static int ip6_pkt_discard_out(struct sk_buff *skb);
97static void ip6_link_failure(struct sk_buff *skb);
98static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
99
70ceb4f5
YH		 100#ifdef CONFIG_IPV6_ROUTE_INFO
101static struct rt6_info *rt6_add_route_info(struct in6_addr *prefix, int prefixlen,
102 struct in6_addr *gwaddr, int ifindex,
103 unsigned pref);
104static struct rt6_info *rt6_get_route_info(struct in6_addr *prefix, int prefixlen,
105 struct in6_addr *gwaddr, int ifindex);
106#endif
107
1da177e4
LT		 108static struct dst_ops ip6_dst_ops = {
109 .family = AF_INET6,
110 .protocol = __constant_htons(ETH_P_IPV6),
111 .gc = ip6_dst_gc,
112 .gc_thresh = 1024,
113 .check = ip6_dst_check,
114 .destroy = ip6_dst_destroy,
115 .ifdown = ip6_dst_ifdown,
116 .negative_advice = ip6_negative_advice,
117 .link_failure = ip6_link_failure,
118 .update_pmtu = ip6_rt_update_pmtu,
119 .entry_size = sizeof(struct rt6_info),
120};
121
122struct rt6_info ip6_null_entry = {
123 .u = {
124 .dst = {
125 .__refcnt = ATOMIC_INIT(1),
126 .__use = 1,
127 .dev = &loopback_dev,
128 .obsolete = -1,
129 .error = -ENETUNREACH,
130 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
131 .input = ip6_pkt_discard,
132 .output = ip6_pkt_discard_out,
133 .ops = &ip6_dst_ops,
134 .path = (struct dst_entry*)&ip6_null_entry,
135 }
136 },
137 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
138 .rt6i_metric = ~(u32) 0,
139 .rt6i_ref = ATOMIC_INIT(1),
140};
141
101367c2
TG		 142#ifdef CONFIG_IPV6_MULTIPLE_TABLES
143
6723ab54
DM		 144static int ip6_pkt_prohibit(struct sk_buff *skb);
145static int ip6_pkt_prohibit_out(struct sk_buff *skb);
146static int ip6_pkt_blk_hole(struct sk_buff *skb);
147
101367c2
TG		 148struct rt6_info ip6_prohibit_entry = {
149 .u = {
150 .dst = {
151 .__refcnt = ATOMIC_INIT(1),
152 .__use = 1,
153 .dev = &loopback_dev,
154 .obsolete = -1,
155 .error = -EACCES,
156 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
9ce8ade0
TG		 157 .input = ip6_pkt_prohibit,
158 .output = ip6_pkt_prohibit_out,
101367c2
TG		 159 .ops = &ip6_dst_ops,
160 .path = (struct dst_entry*)&ip6_prohibit_entry,
161 }
162 },
163 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
164 .rt6i_metric = ~(u32) 0,
165 .rt6i_ref = ATOMIC_INIT(1),
166};
167
168struct rt6_info ip6_blk_hole_entry = {
169 .u = {
170 .dst = {
171 .__refcnt = ATOMIC_INIT(1),
172 .__use = 1,
173 .dev = &loopback_dev,
174 .obsolete = -1,
175 .error = -EINVAL,
176 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
9ce8ade0
TG		 177 .input = ip6_pkt_blk_hole,
178 .output = ip6_pkt_blk_hole,
101367c2
TG		 179 .ops = &ip6_dst_ops,
180 .path = (struct dst_entry*)&ip6_blk_hole_entry,
181 }
182 },
183 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
184 .rt6i_metric = ~(u32) 0,
185 .rt6i_ref = ATOMIC_INIT(1),
186};
187
188#endif
189
1da177e4
LT		 190/* allocate dst with ip6_dst_ops */
191static __inline__ struct rt6_info *ip6_dst_alloc(void)
192{
193 return (struct rt6_info *)dst_alloc(&ip6_dst_ops);
194}
195
196static void ip6_dst_destroy(struct dst_entry *dst)
197{
198 struct rt6_info *rt = (struct rt6_info *)dst;
199 struct inet6_dev *idev = rt->rt6i_idev;
200
201 if (idev != NULL) {
202 rt->rt6i_idev = NULL;
203 in6_dev_put(idev);
204 }
205}
206
207static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
208 int how)
209{
210 struct rt6_info *rt = (struct rt6_info *)dst;
211 struct inet6_dev *idev = rt->rt6i_idev;
212
213 if (dev != &loopback_dev && idev != NULL && idev->dev == dev) {
214 struct inet6_dev *loopback_idev = in6_dev_get(&loopback_dev);
215 if (loopback_idev != NULL) {
216 rt->rt6i_idev = loopback_idev;
217 in6_dev_put(idev);
218 }
219 }
220}
221
222static __inline__ int rt6_check_expired(const struct rt6_info *rt)
223{
224 return (rt->rt6i_flags & RTF_EXPIRES &&
225 time_after(jiffies, rt->rt6i_expires));
226}
227
c71099ac
TG		 228static inline int rt6_need_strict(struct in6_addr *daddr)
229{
230 return (ipv6_addr_type(daddr) &
231 (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL));
232}
233
1da177e4 234/*
c71099ac 235 * Route lookup. Any table->tb6_lock is implied.
1da177e4
LT		 236 */
237
238static __inline__ struct rt6_info *rt6_device_match(struct rt6_info *rt,
239 int oif,
240 int strict)
241{
242 struct rt6_info *local = NULL;
243 struct rt6_info *sprt;
244
245 if (oif) {
246 for (sprt = rt; sprt; sprt = sprt->u.next) {
247 struct net_device *dev = sprt->rt6i_dev;
248 if (dev->ifindex == oif)
249 return sprt;
250 if (dev->flags & IFF_LOOPBACK) {
251 if (sprt->rt6i_idev == NULL ||
252 sprt->rt6i_idev->dev->ifindex != oif) {
253 if (strict && oif)
254 continue;
255 if (local && (!oif ||
256 local->rt6i_idev->dev->ifindex == oif))
257 continue;
258 }
259 local = sprt;
260 }
261 }
262
263 if (local)
264 return local;
265
266 if (strict)
267 return &ip6_null_entry;
268 }
269 return rt;
270}
271
27097255
YH		 272#ifdef CONFIG_IPV6_ROUTER_PREF
273static void rt6_probe(struct rt6_info *rt)
274{
275 struct neighbour *neigh = rt ? rt->rt6i_nexthop : NULL;
276 /*
277 * Okay, this does not seem to be appropriate
278 * for now, however, we need to check if it
279 * is really so; aka Router Reachability Probing.
280 *
281 * Router Reachability Probe MUST be rate-limited
282 * to no more than one per minute.
283 */
284 if (!neigh || (neigh->nud_state & NUD_VALID))
285 return;
286 read_lock_bh(&neigh->lock);
287 if (!(neigh->nud_state & NUD_VALID) &&
52e16356 288 time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
27097255
YH		 289 struct in6_addr mcaddr;
290 struct in6_addr *target;
291
292 neigh->updated = jiffies;
293 read_unlock_bh(&neigh->lock);
294
295 target = (struct in6_addr *)&neigh->primary_key;
296 addrconf_addr_solict_mult(target, &mcaddr);
297 ndisc_send_ns(rt->rt6i_dev, NULL, target, &mcaddr, NULL);
298 } else
299 read_unlock_bh(&neigh->lock);
300}
301#else
302static inline void rt6_probe(struct rt6_info *rt)
303{
304 return;
305}
306#endif
307
1da177e4 308/*
554cfb7e 309 * Default Router Selection (RFC 2461 6.3.6)
1da177e4 310 */
554cfb7e
YH		 311static int inline rt6_check_dev(struct rt6_info *rt, int oif)
312{
313 struct net_device *dev = rt->rt6i_dev;
314 if (!oif || dev->ifindex == oif)
315 return 2;
316 if ((dev->flags & IFF_LOOPBACK) &&
317 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
318 return 1;
319 return 0;
320}
1da177e4 321
554cfb7e 322static int inline rt6_check_neigh(struct rt6_info *rt)
1da177e4 323{
554cfb7e
YH		 324 struct neighbour *neigh = rt->rt6i_nexthop;
325 int m = 0;
4d0c5911
YH		 326 if (rt->rt6i_flags & RTF_NONEXTHOP ||
327 !(rt->rt6i_flags & RTF_GATEWAY))
328 m = 1;
329 else if (neigh) {
554cfb7e
YH		 330 read_lock_bh(&neigh->lock);
331 if (neigh->nud_state & NUD_VALID)
4d0c5911 332 m = 2;
ea73ee23
YH		 333 else if (!(neigh->nud_state & NUD_FAILED))
334 m = 1;
554cfb7e 335 read_unlock_bh(&neigh->lock);
1da177e4 336 }
554cfb7e 337 return m;
1da177e4
LT		 338}
339
554cfb7e
YH		 340static int rt6_score_route(struct rt6_info *rt, int oif,
341 int strict)
1da177e4 342{
4d0c5911
YH		 343 int m, n;
344
345 m = rt6_check_dev(rt, oif);
77d16f45 346 if (!m && (strict & RT6_LOOKUP_F_IFACE))
554cfb7e 347 return -1;
ebacaaa0
YH		 348#ifdef CONFIG_IPV6_ROUTER_PREF
349 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
350#endif
4d0c5911 351 n = rt6_check_neigh(rt);
557e92ef 352 if (!n && (strict & RT6_LOOKUP_F_REACHABLE))
554cfb7e
YH		 353 return -1;
354 return m;
355}
356
357static struct rt6_info *rt6_select(struct rt6_info **head, int oif,
358 int strict)
359{
360 struct rt6_info *match = NULL, *last = NULL;
361 struct rt6_info *rt, *rt0 = *head;
362 u32 metric;
363 int mpri = -1;
1da177e4 364
554cfb7e
YH		 365 RT6_TRACE("%s(head=%p(*head=%p), oif=%d)\n",
366 __FUNCTION__, head, head ? *head : NULL, oif);
1da177e4 367
554cfb7e 368 for (rt = rt0, metric = rt0->rt6i_metric;
c302e6d5 369 rt && rt->rt6i_metric == metric && (!last || rt != rt0);
554cfb7e
YH		 370 rt = rt->u.next) {
371 int m;
1da177e4 372
554cfb7e 373 if (rt6_check_expired(rt))
1da177e4
LT		 374 continue;
375
554cfb7e
YH		 376 last = rt;
377
378 m = rt6_score_route(rt, oif, strict);
379 if (m < 0)
1da177e4 380 continue;
1da177e4 381
554cfb7e 382 if (m > mpri) {
ea659e07
YH		 383 if (strict & RT6_LOOKUP_F_REACHABLE)
384 rt6_probe(match);
554cfb7e 385 match = rt;
1da177e4 386 mpri = m;
ea659e07 387 } else if (strict & RT6_LOOKUP_F_REACHABLE) {
27097255 388 rt6_probe(rt);
1da177e4
LT		 389 }
390 }
391
554cfb7e 392 if (!match &&
77d16f45 393 (strict & RT6_LOOKUP_F_REACHABLE) &&
554cfb7e
YH		 394 last && last != rt0) {
395 /* no entries matched; do round-robin */
34af946a 396 static DEFINE_SPINLOCK(lock);
c302e6d5 397 spin_lock(&lock);
554cfb7e
YH		 398 *head = rt0->u.next;
399 rt0->u.next = last->u.next;
400 last->u.next = rt0;
c302e6d5 401 spin_unlock(&lock);
1da177e4 402 }
1da177e4 403
554cfb7e
YH		 404 RT6_TRACE("%s() => %p, score=%d\n",
405 __FUNCTION__, match, mpri);
1da177e4 406
554cfb7e 407 return (match ? match : &ip6_null_entry);
1da177e4
LT		 408}
409
70ceb4f5
YH		 410#ifdef CONFIG_IPV6_ROUTE_INFO
411int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
412 struct in6_addr *gwaddr)
413{
414 struct route_info *rinfo = (struct route_info *) opt;
415 struct in6_addr prefix_buf, *prefix;
416 unsigned int pref;
417 u32 lifetime;
418 struct rt6_info *rt;
419
420 if (len < sizeof(struct route_info)) {
421 return -EINVAL;
422 }
423
424 /* Sanity check for prefix_len and length */
425 if (rinfo->length > 3) {
426 return -EINVAL;
427 } else if (rinfo->prefix_len > 128) {
428 return -EINVAL;
429 } else if (rinfo->prefix_len > 64) {
430 if (rinfo->length < 2) {
431 return -EINVAL;
432 }
433 } else if (rinfo->prefix_len > 0) {
434 if (rinfo->length < 1) {
435 return -EINVAL;
436 }
437 }
438
439 pref = rinfo->route_pref;
440 if (pref == ICMPV6_ROUTER_PREF_INVALID)
441 pref = ICMPV6_ROUTER_PREF_MEDIUM;
442
443 lifetime = htonl(rinfo->lifetime);
444 if (lifetime == 0xffffffff) {
445 /* infinity */
446 } else if (lifetime > 0x7fffffff/HZ) {
447 /* Avoid arithmetic overflow */
448 lifetime = 0x7fffffff/HZ - 1;
449 }
450
451 if (rinfo->length == 3)
452 prefix = (struct in6_addr *)rinfo->prefix;
453 else {
454 /* this function is safe */
455 ipv6_addr_prefix(&prefix_buf,
456 (struct in6_addr *)rinfo->prefix,
457 rinfo->prefix_len);
458 prefix = &prefix_buf;
459 }
460
461 rt = rt6_get_route_info(prefix, rinfo->prefix_len, gwaddr, dev->ifindex);
462
463 if (rt && !lifetime) {
e0a1ad73 464 ip6_del_rt(rt);
70ceb4f5
YH		 465 rt = NULL;
466 }
467
468 if (!rt && lifetime)
469 rt = rt6_add_route_info(prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
470 pref);
471 else if (rt)
472 rt->rt6i_flags = RTF_ROUTEINFO |
473 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
474
475 if (rt) {
476 if (lifetime == 0xffffffff) {
477 rt->rt6i_flags &= ~RTF_EXPIRES;
478 } else {
479 rt->rt6i_expires = jiffies + HZ * lifetime;
480 rt->rt6i_flags |= RTF_EXPIRES;
481 }
482 dst_release(&rt->u.dst);
483 }
484 return 0;
485}
486#endif
487
982f56f3
YH		 488#define BACKTRACK(saddr) \
489do { \
490 if (rt == &ip6_null_entry) { \
491 struct fib6_node *pn; \
e0eda7bb 492 while (1) { \
982f56f3
YH		 493 if (fn->fn_flags & RTN_TL_ROOT) \
494 goto out; \
495 pn = fn->parent; \
496 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
497 fn = fib6_lookup(pn->subtree, NULL, saddr); \
498 else \
499 fn = pn; \
500 if (fn->fn_flags & RTN_RTINFO) \
501 goto restart; \
c71099ac 502 } \
c71099ac 503 } \
982f56f3 504} while(0)
c71099ac
TG		 505
506static struct rt6_info *ip6_pol_route_lookup(struct fib6_table *table,
507 struct flowi *fl, int flags)
1da177e4
LT		 508{
509 struct fib6_node *fn;
510 struct rt6_info *rt;
511
c71099ac
TG		 512 read_lock_bh(&table->tb6_lock);
513 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
514restart:
515 rt = fn->leaf;
77d16f45 516 rt = rt6_device_match(rt, fl->oif, flags);
982f56f3 517 BACKTRACK(&fl->fl6_src);
c71099ac 518out:
33cc4896 519 dst_hold(&rt->u.dst);
c71099ac 520 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 521
522 rt->u.dst.lastuse = jiffies;
c71099ac
TG		 523 rt->u.dst.__use++;
524
525 return rt;
526
527}
528
529struct rt6_info *rt6_lookup(struct in6_addr *daddr, struct in6_addr *saddr,
530 int oif, int strict)
531{
532 struct flowi fl = {
533 .oif = oif,
534 .nl_u = {
535 .ip6_u = {
536 .daddr = *daddr,
c71099ac
TG		 537 },
538 },
539 };
540 struct dst_entry *dst;
77d16f45 541 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
c71099ac 542
adaa70bb
TG		 543 if (saddr) {
544 memcpy(&fl.fl6_src, saddr, sizeof(*saddr));
545 flags |= RT6_LOOKUP_F_HAS_SADDR;
546 }
547
c71099ac
TG		 548 dst = fib6_rule_lookup(&fl, flags, ip6_pol_route_lookup);
549 if (dst->error == 0)
550 return (struct rt6_info *) dst;
551
552 dst_release(dst);
553
1da177e4
LT		 554 return NULL;
555}
556
c71099ac 557/* ip6_ins_rt is called with FREE table->tb6_lock.
1da177e4
LT		 558 It takes new route entry, the addition fails by any reason the
559 route is freed. In any case, if caller does not hold it, it may
560 be destroyed.
561 */
562
86872cb5 563static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
1da177e4
LT		 564{
565 int err;
c71099ac 566 struct fib6_table *table;
1da177e4 567
c71099ac
TG		 568 table = rt->rt6i_table;
569 write_lock_bh(&table->tb6_lock);
86872cb5 570 err = fib6_add(&table->tb6_root, rt, info);
c71099ac 571 write_unlock_bh(&table->tb6_lock);
1da177e4
LT		 572
573 return err;
574}
575
40e22e8f
TG		 576int ip6_ins_rt(struct rt6_info *rt)
577{
86872cb5 578 return __ip6_ins_rt(rt, NULL);
40e22e8f
TG		 579}
580
95a9a5ba
YH		 581static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,
582 struct in6_addr *saddr)
1da177e4 583{
1da177e4
LT		 584 struct rt6_info *rt;
585
586 /*
587 * Clone the route.
588 */
589
590 rt = ip6_rt_copy(ort);
591
592 if (rt) {
58c4fb86
YH		 593 if (!(rt->rt6i_flags&RTF_GATEWAY)) {
594 if (rt->rt6i_dst.plen != 128 &&
595 ipv6_addr_equal(&rt->rt6i_dst.addr, daddr))
596 rt->rt6i_flags |= RTF_ANYCAST;
1da177e4 597 ipv6_addr_copy(&rt->rt6i_gateway, daddr);
58c4fb86 598 }
1da177e4 599
58c4fb86 600 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
1da177e4
LT		 601 rt->rt6i_dst.plen = 128;
602 rt->rt6i_flags |= RTF_CACHE;
603 rt->u.dst.flags |= DST_HOST;
604
605#ifdef CONFIG_IPV6_SUBTREES
606 if (rt->rt6i_src.plen && saddr) {
607 ipv6_addr_copy(&rt->rt6i_src.addr, saddr);
608 rt->rt6i_src.plen = 128;
609 }
610#endif
611
612 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
613
95a9a5ba 614 }
1da177e4 615
95a9a5ba
YH		 616 return rt;
617}
1da177e4 618
299d9939
YH		 619static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)
620{
621 struct rt6_info *rt = ip6_rt_copy(ort);
622 if (rt) {
623 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
624 rt->rt6i_dst.plen = 128;
625 rt->rt6i_flags |= RTF_CACHE;
299d9939
YH		 626 rt->u.dst.flags |= DST_HOST;
627 rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);
628 }
629 return rt;
630}
631
8ce11e6a
AB		 632static struct rt6_info *ip6_pol_route_input(struct fib6_table *table,
633 struct flowi *fl, int flags)
1da177e4
LT		 634{
635 struct fib6_node *fn;
519fbd87 636 struct rt6_info *rt, *nrt;
c71099ac 637 int strict = 0;
1da177e4 638 int attempts = 3;
519fbd87 639 int err;
ea659e07 640 int reachable = ipv6_devconf.forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
1da177e4 641
77d16f45 642 strict |= flags & RT6_LOOKUP_F_IFACE;
1da177e4
LT		 643
644relookup:
c71099ac 645 read_lock_bh(&table->tb6_lock);
1da177e4 646
8238dd06 647restart_2:
c71099ac 648 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
1da177e4
LT		 649
650restart:
c71099ac 651 rt = rt6_select(&fn->leaf, fl->iif, strict | reachable);
982f56f3 652 BACKTRACK(&fl->fl6_src);
8238dd06
YH		 653 if (rt == &ip6_null_entry ||
654 rt->rt6i_flags & RTF_CACHE)
1ddef044 655 goto out;
1da177e4 656
fb9de91e 657 dst_hold(&rt->u.dst);
c71099ac 658 read_unlock_bh(&table->tb6_lock);
fb9de91e 659
519fbd87 660 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
c71099ac 661 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
519fbd87
YH		 662 else {
663#if CLONE_OFFLINK_ROUTE
c71099ac 664 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
519fbd87
YH		 665#else
666 goto out2;
667#endif
668 }
e40cf353 669
519fbd87
YH		 670 dst_release(&rt->u.dst);
671 rt = nrt ? : &ip6_null_entry;
1da177e4 672
519fbd87
YH		 673 dst_hold(&rt->u.dst);
674 if (nrt) {
40e22e8f 675 err = ip6_ins_rt(nrt);
519fbd87 676 if (!err)
1da177e4 677 goto out2;
1da177e4 678 }
1da177e4 679
519fbd87
YH		 680 if (--attempts <= 0)
681 goto out2;
682
683 /*
c71099ac 684 * Race condition! In the gap, when table->tb6_lock was
519fbd87
YH		 685 * released someone could insert this route. Relookup.
686 */
687 dst_release(&rt->u.dst);
688 goto relookup;
689
690out:
8238dd06
YH		 691 if (reachable) {
692 reachable = 0;
693 goto restart_2;
694 }
519fbd87 695 dst_hold(&rt->u.dst);
c71099ac 696 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 697out2:
698 rt->u.dst.lastuse = jiffies;
699 rt->u.dst.__use++;
c71099ac
TG		 700
701 return rt;
1da177e4
LT		 702}
703
c71099ac
TG		 704void ip6_route_input(struct sk_buff *skb)
705{
706 struct ipv6hdr *iph = skb->nh.ipv6h;
adaa70bb 707 int flags = RT6_LOOKUP_F_HAS_SADDR;
c71099ac
TG		 708 struct flowi fl = {
709 .iif = skb->dev->ifindex,
710 .nl_u = {
711 .ip6_u = {
712 .daddr = iph->daddr,
713 .saddr = iph->saddr,
267935b1 714#ifdef CONFIG_IPV6_ROUTE_FWMARK
82e91ffe 715 .fwmark = skb->mark,
267935b1 716#endif
90bcaf7b 717 .flowlabel = (* (__be32 *) iph)&IPV6_FLOWINFO_MASK,
c71099ac
TG		 718 },
719 },
720 .proto = iph->nexthdr,
721 };
adaa70bb
TG		 722
723 if (rt6_need_strict(&iph->daddr))
724 flags |= RT6_LOOKUP_F_IFACE;
c71099ac
TG		 725
726 skb->dst = fib6_rule_lookup(&fl, flags, ip6_pol_route_input);
727}
728
729static struct rt6_info *ip6_pol_route_output(struct fib6_table *table,
730 struct flowi *fl, int flags)
1da177e4
LT		 731{
732 struct fib6_node *fn;
519fbd87 733 struct rt6_info *rt, *nrt;
c71099ac 734 int strict = 0;
1da177e4 735 int attempts = 3;
519fbd87 736 int err;
ea659e07 737 int reachable = ipv6_devconf.forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
1da177e4 738
77d16f45 739 strict |= flags & RT6_LOOKUP_F_IFACE;
1da177e4
LT		 740
741relookup:
c71099ac 742 read_lock_bh(&table->tb6_lock);
1da177e4 743
8238dd06 744restart_2:
c71099ac 745 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
1da177e4
LT		 746
747restart:
8238dd06 748 rt = rt6_select(&fn->leaf, fl->oif, strict | reachable);
982f56f3 749 BACKTRACK(&fl->fl6_src);
8238dd06
YH		 750 if (rt == &ip6_null_entry ||
751 rt->rt6i_flags & RTF_CACHE)
1da177e4 752 goto out;
1da177e4 753
fb9de91e 754 dst_hold(&rt->u.dst);
c71099ac 755 read_unlock_bh(&table->tb6_lock);
fb9de91e 756
519fbd87 757 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
e40cf353 758 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
519fbd87
YH		 759 else {
760#if CLONE_OFFLINK_ROUTE
761 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
762#else
763 goto out2;
764#endif
765 }
1da177e4 766
519fbd87
YH		 767 dst_release(&rt->u.dst);
768 rt = nrt ? : &ip6_null_entry;
1da177e4 769
519fbd87
YH		 770 dst_hold(&rt->u.dst);
771 if (nrt) {
40e22e8f 772 err = ip6_ins_rt(nrt);
519fbd87 773 if (!err)
1da177e4 774 goto out2;
1da177e4 775 }
e40cf353 776
519fbd87
YH		 777 if (--attempts <= 0)
778 goto out2;
779
780 /*
c71099ac 781 * Race condition! In the gap, when table->tb6_lock was
519fbd87
YH		 782 * released someone could insert this route. Relookup.
783 */
784 dst_release(&rt->u.dst);
785 goto relookup;
786
787out:
8238dd06
YH		 788 if (reachable) {
789 reachable = 0;
790 goto restart_2;
791 }
519fbd87 792 dst_hold(&rt->u.dst);
c71099ac 793 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 794out2:
795 rt->u.dst.lastuse = jiffies;
796 rt->u.dst.__use++;
c71099ac
TG		 797 return rt;
798}
799
800struct dst_entry * ip6_route_output(struct sock *sk, struct flowi *fl)
801{
802 int flags = 0;
803
804 if (rt6_need_strict(&fl->fl6_dst))
77d16f45 805 flags |= RT6_LOOKUP_F_IFACE;
c71099ac 806
adaa70bb
TG		 807 if (!ipv6_addr_any(&fl->fl6_src))
808 flags |= RT6_LOOKUP_F_HAS_SADDR;
809
c71099ac 810 return fib6_rule_lookup(fl, flags, ip6_pol_route_output);
1da177e4
LT		 811}
812
813
814/*
815 * Destination cache support functions
816 */
817
818static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
819{
820 struct rt6_info *rt;
821
822 rt = (struct rt6_info *) dst;
823
824 if (rt && rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
825 return dst;
826
827 return NULL;
828}
829
830static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
831{
832 struct rt6_info *rt = (struct rt6_info *) dst;
833
834 if (rt) {
835 if (rt->rt6i_flags & RTF_CACHE)
e0a1ad73 836 ip6_del_rt(rt);
1da177e4
LT		 837 else
838 dst_release(dst);
839 }
840 return NULL;
841}
842
843static void ip6_link_failure(struct sk_buff *skb)
844{
845 struct rt6_info *rt;
846
847 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0, skb->dev);
848
849 rt = (struct rt6_info *) skb->dst;
850 if (rt) {
851 if (rt->rt6i_flags&RTF_CACHE) {
852 dst_set_expires(&rt->u.dst, 0);
853 rt->rt6i_flags |= RTF_EXPIRES;
854 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
855 rt->rt6i_node->fn_sernum = -1;
856 }
857}
858
859static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
860{
861 struct rt6_info *rt6 = (struct rt6_info*)dst;
862
863 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
864 rt6->rt6i_flags |= RTF_MODIFIED;
865 if (mtu < IPV6_MIN_MTU) {
866 mtu = IPV6_MIN_MTU;
867 dst->metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
868 }
869 dst->metrics[RTAX_MTU-1] = mtu;
8d71740c 870 call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);
1da177e4
LT		 871 }
872}
873
1da177e4
LT		 874static int ipv6_get_mtu(struct net_device *dev);
875
876static inline unsigned int ipv6_advmss(unsigned int mtu)
877{
878 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
879
880 if (mtu < ip6_rt_min_advmss)
881 mtu = ip6_rt_min_advmss;
882
883 /*
884 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
885 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
886 * IPV6_MAXPLEN is also valid and means: "any MSS,
887 * rely only on pmtu discovery"
888 */
889 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
890 mtu = IPV6_MAXPLEN;
891 return mtu;
892}
893
5d0bbeeb 894static struct dst_entry *ndisc_dst_gc_list;
8ce11e6a 895static DEFINE_SPINLOCK(ndisc_lock);
5d0bbeeb 896
1da177e4
LT		 897struct dst_entry *ndisc_dst_alloc(struct net_device *dev,
898 struct neighbour *neigh,
899 struct in6_addr *addr,
900 int (*output)(struct sk_buff *))
901{
902 struct rt6_info *rt;
903 struct inet6_dev *idev = in6_dev_get(dev);
904
905 if (unlikely(idev == NULL))
906 return NULL;
907
908 rt = ip6_dst_alloc();
909 if (unlikely(rt == NULL)) {
910 in6_dev_put(idev);
911 goto out;
912 }
913
914 dev_hold(dev);
915 if (neigh)
916 neigh_hold(neigh);
917 else
918 neigh = ndisc_get_neigh(dev, addr);
919
920 rt->rt6i_dev = dev;
921 rt->rt6i_idev = idev;
922 rt->rt6i_nexthop = neigh;
923 atomic_set(&rt->u.dst.__refcnt, 1);
924 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = 255;
925 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
926 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
927 rt->u.dst.output = output;
928
929#if 0 /* there's no chance to use these for ndisc */
930 rt->u.dst.flags = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST
931 ? DST_HOST
932 : 0;
933 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
934 rt->rt6i_dst.plen = 128;
935#endif
936
5d0bbeeb 937 spin_lock_bh(&ndisc_lock);
1da177e4
LT		 938 rt->u.dst.next = ndisc_dst_gc_list;
939 ndisc_dst_gc_list = &rt->u.dst;
5d0bbeeb 940 spin_unlock_bh(&ndisc_lock);
1da177e4
LT		 941
942 fib6_force_start_gc();
943
944out:
945 return (struct dst_entry *)rt;
946}
947
948int ndisc_dst_gc(int *more)
949{
950 struct dst_entry *dst, *next, **pprev;
951 int freed;
952
953 next = NULL;
5d0bbeeb
TG		 954 freed = 0;
955
956 spin_lock_bh(&ndisc_lock);
1da177e4 957 pprev = &ndisc_dst_gc_list;
5d0bbeeb 958
1da177e4
LT		 959 while ((dst = *pprev) != NULL) {
960 if (!atomic_read(&dst->__refcnt)) {
961 *pprev = dst->next;
962 dst_free(dst);
963 freed++;
964 } else {
965 pprev = &dst->next;
966 (*more)++;
967 }
968 }
969
5d0bbeeb
TG		 970 spin_unlock_bh(&ndisc_lock);
971
1da177e4
LT		 972 return freed;
973}
974
975static int ip6_dst_gc(void)
976{
977 static unsigned expire = 30*HZ;
978 static unsigned long last_gc;
979 unsigned long now = jiffies;
980
981 if (time_after(last_gc + ip6_rt_gc_min_interval, now) &&
982 atomic_read(&ip6_dst_ops.entries) <= ip6_rt_max_size)
983 goto out;
984
985 expire++;
986 fib6_run_gc(expire);
987 last_gc = now;
988 if (atomic_read(&ip6_dst_ops.entries) < ip6_dst_ops.gc_thresh)
989 expire = ip6_rt_gc_timeout>>1;
990
991out:
992 expire -= expire>>ip6_rt_gc_elasticity;
993 return (atomic_read(&ip6_dst_ops.entries) > ip6_rt_max_size);
994}
995
996/* Clean host part of a prefix. Not necessary in radix tree,
997 but results in cleaner routing tables.
998
999 Remove it only when all the things will work!
1000 */
1001
1002static int ipv6_get_mtu(struct net_device *dev)
1003{
1004 int mtu = IPV6_MIN_MTU;
1005 struct inet6_dev *idev;
1006
1007 idev = in6_dev_get(dev);
1008 if (idev) {
1009 mtu = idev->cnf.mtu6;
1010 in6_dev_put(idev);
1011 }
1012 return mtu;
1013}
1014
1015int ipv6_get_hoplimit(struct net_device *dev)
1016{
1017 int hoplimit = ipv6_devconf.hop_limit;
1018 struct inet6_dev *idev;
1019
1020 idev = in6_dev_get(dev);
1021 if (idev) {
1022 hoplimit = idev->cnf.hop_limit;
1023 in6_dev_put(idev);
1024 }
1025 return hoplimit;
1026}
1027
1028/*
1029 *
1030 */
1031
86872cb5 1032int ip6_route_add(struct fib6_config *cfg)
1da177e4
LT		 1033{
1034 int err;
1da177e4
LT		 1035 struct rt6_info *rt = NULL;
1036 struct net_device *dev = NULL;
1037 struct inet6_dev *idev = NULL;
c71099ac 1038 struct fib6_table *table;
1da177e4
LT		 1039 int addr_type;
1040
86872cb5 1041 if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
1da177e4
LT		 1042 return -EINVAL;
1043#ifndef CONFIG_IPV6_SUBTREES
86872cb5 1044 if (cfg->fc_src_len)
1da177e4
LT		 1045 return -EINVAL;
1046#endif
86872cb5 1047 if (cfg->fc_ifindex) {
1da177e4 1048 err = -ENODEV;
86872cb5 1049 dev = dev_get_by_index(cfg->fc_ifindex);
1da177e4
LT		 1050 if (!dev)
1051 goto out;
1052 idev = in6_dev_get(dev);
1053 if (!idev)
1054 goto out;
1055 }
1056
86872cb5
TG		 1057 if (cfg->fc_metric == 0)
1058 cfg->fc_metric = IP6_RT_PRIO_USER;
1da177e4 1059
86872cb5 1060 table = fib6_new_table(cfg->fc_table);
c71099ac
TG		 1061 if (table == NULL) {
1062 err = -ENOBUFS;
1063 goto out;
1064 }
1065
1da177e4
LT		 1066 rt = ip6_dst_alloc();
1067
1068 if (rt == NULL) {
1069 err = -ENOMEM;
1070 goto out;
1071 }
1072
1073 rt->u.dst.obsolete = -1;
86872cb5 1074 rt->rt6i_expires = jiffies + clock_t_to_jiffies(cfg->fc_expires);
1da177e4 1075
86872cb5
TG		 1076 if (cfg->fc_protocol == RTPROT_UNSPEC)
1077 cfg->fc_protocol = RTPROT_BOOT;
1078 rt->rt6i_protocol = cfg->fc_protocol;
1079
1080 addr_type = ipv6_addr_type(&cfg->fc_dst);
1da177e4
LT		 1081
1082 if (addr_type & IPV6_ADDR_MULTICAST)
1083 rt->u.dst.input = ip6_mc_input;
1084 else
1085 rt->u.dst.input = ip6_forward;
1086
1087 rt->u.dst.output = ip6_output;
1088
86872cb5
TG		 1089 ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
1090 rt->rt6i_dst.plen = cfg->fc_dst_len;
1da177e4
LT		 1091 if (rt->rt6i_dst.plen == 128)
1092 rt->u.dst.flags = DST_HOST;
1093
1094#ifdef CONFIG_IPV6_SUBTREES
86872cb5
TG		 1095 ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
1096 rt->rt6i_src.plen = cfg->fc_src_len;
1da177e4
LT		 1097#endif
1098
86872cb5 1099 rt->rt6i_metric = cfg->fc_metric;
1da177e4
LT		 1100
1101 /* We cannot add true routes via loopback here,
1102 they would result in kernel looping; promote them to reject routes
1103 */
86872cb5 1104 if ((cfg->fc_flags & RTF_REJECT) ||
1da177e4
LT		 1105 (dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK))) {
1106 /* hold loopback dev/idev if we haven't done so. */
1107 if (dev != &loopback_dev) {
1108 if (dev) {
1109 dev_put(dev);
1110 in6_dev_put(idev);
1111 }
1112 dev = &loopback_dev;
1113 dev_hold(dev);
1114 idev = in6_dev_get(dev);
1115 if (!idev) {
1116 err = -ENODEV;
1117 goto out;
1118 }
1119 }
1120 rt->u.dst.output = ip6_pkt_discard_out;
1121 rt->u.dst.input = ip6_pkt_discard;
1122 rt->u.dst.error = -ENETUNREACH;
1123 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
1124 goto install_route;
1125 }
1126
86872cb5 1127 if (cfg->fc_flags & RTF_GATEWAY) {
1da177e4
LT		 1128 struct in6_addr *gw_addr;
1129 int gwa_type;
1130
86872cb5
TG		 1131 gw_addr = &cfg->fc_gateway;
1132 ipv6_addr_copy(&rt->rt6i_gateway, gw_addr);
1da177e4
LT		 1133 gwa_type = ipv6_addr_type(gw_addr);
1134
1135 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
1136 struct rt6_info *grt;
1137
1138 /* IPv6 strictly inhibits using not link-local
1139 addresses as nexthop address.
1140 Otherwise, router will not able to send redirects.
1141 It is very good, but in some (rare!) circumstances
1142 (SIT, PtP, NBMA NOARP links) it is handy to allow
1143 some exceptions. --ANK
1144 */
1145 err = -EINVAL;
1146 if (!(gwa_type&IPV6_ADDR_UNICAST))
1147 goto out;
1148
86872cb5 1149 grt = rt6_lookup(gw_addr, NULL, cfg->fc_ifindex, 1);
1da177e4
LT		 1150
1151 err = -EHOSTUNREACH;
1152 if (grt == NULL)
1153 goto out;
1154 if (dev) {
1155 if (dev != grt->rt6i_dev) {
1156 dst_release(&grt->u.dst);
1157 goto out;
1158 }
1159 } else {
1160 dev = grt->rt6i_dev;
1161 idev = grt->rt6i_idev;
1162 dev_hold(dev);
1163 in6_dev_hold(grt->rt6i_idev);
1164 }
1165 if (!(grt->rt6i_flags&RTF_GATEWAY))
1166 err = 0;
1167 dst_release(&grt->u.dst);
1168
1169 if (err)
1170 goto out;
1171 }
1172 err = -EINVAL;
1173 if (dev == NULL || (dev->flags&IFF_LOOPBACK))
1174 goto out;
1175 }
1176
1177 err = -ENODEV;
1178 if (dev == NULL)
1179 goto out;
1180
86872cb5 1181 if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {
1da177e4
LT		 1182 rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);
1183 if (IS_ERR(rt->rt6i_nexthop)) {
1184 err = PTR_ERR(rt->rt6i_nexthop);
1185 rt->rt6i_nexthop = NULL;
1186 goto out;
1187 }
1188 }
1189
86872cb5 1190 rt->rt6i_flags = cfg->fc_flags;
1da177e4
LT		 1191
1192install_route:
86872cb5
TG		 1193 if (cfg->fc_mx) {
1194 struct nlattr *nla;
1195 int remaining;
1196
1197 nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
1198 int type = nla->nla_type;
1199
1200 if (type) {
1201 if (type > RTAX_MAX) {
1da177e4
LT		 1202 err = -EINVAL;
1203 goto out;
1204 }
86872cb5
TG		 1205
1206 rt->u.dst.metrics[type - 1] = nla_get_u32(nla);
1da177e4 1207 }
1da177e4
LT		 1208 }
1209 }
1210
1211 if (rt->u.dst.metrics[RTAX_HOPLIMIT-1] == 0)
1212 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1213 if (!rt->u.dst.metrics[RTAX_MTU-1])
1214 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(dev);
1215 if (!rt->u.dst.metrics[RTAX_ADVMSS-1])
1216 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1217 rt->u.dst.dev = dev;
1218 rt->rt6i_idev = idev;
c71099ac 1219 rt->rt6i_table = table;
86872cb5 1220 return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
1da177e4
LT		 1221
1222out:
1223 if (dev)
1224 dev_put(dev);
1225 if (idev)
1226 in6_dev_put(idev);
1227 if (rt)
1228 dst_free((struct dst_entry *) rt);
1229 return err;
1230}
1231
86872cb5 1232static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1da177e4
LT		 1233{
1234 int err;
c71099ac 1235 struct fib6_table *table;
1da177e4 1236
6c813a72
PM		 1237 if (rt == &ip6_null_entry)
1238 return -ENOENT;
1239
c71099ac
TG		 1240 table = rt->rt6i_table;
1241 write_lock_bh(&table->tb6_lock);
1da177e4 1242
86872cb5 1243 err = fib6_del(rt, info);
1da177e4
LT		 1244 dst_release(&rt->u.dst);
1245
c71099ac 1246 write_unlock_bh(&table->tb6_lock);
1da177e4
LT		 1247
1248 return err;
1249}
1250
e0a1ad73
TG		 1251int ip6_del_rt(struct rt6_info *rt)
1252{
86872cb5 1253 return __ip6_del_rt(rt, NULL);
e0a1ad73
TG		 1254}
1255
86872cb5 1256static int ip6_route_del(struct fib6_config *cfg)
1da177e4 1257{
c71099ac 1258 struct fib6_table *table;
1da177e4
LT		 1259 struct fib6_node *fn;
1260 struct rt6_info *rt;
1261 int err = -ESRCH;
1262
86872cb5 1263 table = fib6_get_table(cfg->fc_table);
c71099ac
TG		 1264 if (table == NULL)
1265 return err;
1266
1267 read_lock_bh(&table->tb6_lock);
1da177e4 1268
c71099ac 1269 fn = fib6_locate(&table->tb6_root,
86872cb5
TG		 1270 &cfg->fc_dst, cfg->fc_dst_len,
1271 &cfg->fc_src, cfg->fc_src_len);
1da177e4
LT		 1272
1273 if (fn) {
1274 for (rt = fn->leaf; rt; rt = rt->u.next) {
86872cb5 1275 if (cfg->fc_ifindex &&
1da177e4 1276 (rt->rt6i_dev == NULL ||
86872cb5 1277 rt->rt6i_dev->ifindex != cfg->fc_ifindex))
1da177e4 1278 continue;
86872cb5
TG		 1279 if (cfg->fc_flags & RTF_GATEWAY &&
1280 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1da177e4 1281 continue;
86872cb5 1282 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1da177e4
LT		 1283 continue;
1284 dst_hold(&rt->u.dst);
c71099ac 1285 read_unlock_bh(&table->tb6_lock);
1da177e4 1286
86872cb5 1287 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1da177e4
LT		 1288 }
1289 }
c71099ac 1290 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 1291
1292 return err;
1293}
1294
1295/*
1296 * Handle redirects
1297 */
a6279458
YH		 1298struct ip6rd_flowi {
1299 struct flowi fl;
1300 struct in6_addr gateway;
1301};
1302
1303static struct rt6_info *__ip6_route_redirect(struct fib6_table *table,
1304 struct flowi *fl,
1305 int flags)
1da177e4 1306{
a6279458
YH		 1307 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl;
1308 struct rt6_info *rt;
e843b9e1 1309 struct fib6_node *fn;
c71099ac 1310
1da177e4 1311 /*
e843b9e1
YH		 1312 * Get the "current" route for this destination and
1313 * check if the redirect has come from approriate router.
1314 *
1315 * RFC 2461 specifies that redirects should only be
1316 * accepted if they come from the nexthop to the target.
1317 * Due to the way the routes are chosen, this notion
1318 * is a bit fuzzy and one might need to check all possible
1319 * routes.
1da177e4 1320 */
1da177e4 1321
c71099ac 1322 read_lock_bh(&table->tb6_lock);
a6279458 1323 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
e843b9e1
YH		 1324restart:
1325 for (rt = fn->leaf; rt; rt = rt->u.next) {
1326 /*
1327 * Current route is on-link; redirect is always invalid.
1328 *
1329 * Seems, previous statement is not true. It could
1330 * be node, which looks for us as on-link (f.e. proxy ndisc)
1331 * But then router serving it might decide, that we should
1332 * know truth 8)8) --ANK (980726).
1333 */
1334 if (rt6_check_expired(rt))
1335 continue;
1336 if (!(rt->rt6i_flags & RTF_GATEWAY))
1337 continue;
a6279458 1338 if (fl->oif != rt->rt6i_dev->ifindex)
e843b9e1 1339 continue;
a6279458 1340 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
e843b9e1
YH		 1341 continue;
1342 break;
1343 }
a6279458 1344
cb15d9c2 1345 if (!rt)
a6279458 1346 rt = &ip6_null_entry;
cb15d9c2
YH		 1347 BACKTRACK(&fl->fl6_src);
1348out:
a6279458
YH		 1349 dst_hold(&rt->u.dst);
1350
c71099ac 1351 read_unlock_bh(&table->tb6_lock);
e843b9e1 1352
a6279458
YH		 1353 return rt;
1354};
1355
1356static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,
1357 struct in6_addr *src,
1358 struct in6_addr *gateway,
1359 struct net_device *dev)
1360{
adaa70bb 1361 int flags = RT6_LOOKUP_F_HAS_SADDR;
a6279458
YH		 1362 struct ip6rd_flowi rdfl = {
1363 .fl = {
1364 .oif = dev->ifindex,
1365 .nl_u = {
1366 .ip6_u = {
1367 .daddr = *dest,
1368 .saddr = *src,
1369 },
1370 },
1371 },
1372 .gateway = *gateway,
1373 };
adaa70bb
TG		 1374
1375 if (rt6_need_strict(dest))
1376 flags |= RT6_LOOKUP_F_IFACE;
a6279458
YH		 1377
1378 return (struct rt6_info *)fib6_rule_lookup((struct flowi *)&rdfl, flags, __ip6_route_redirect);
1379}
1380
1381void rt6_redirect(struct in6_addr *dest, struct in6_addr *src,
1382 struct in6_addr *saddr,
1383 struct neighbour *neigh, u8 *lladdr, int on_link)
1384{
1385 struct rt6_info *rt, *nrt = NULL;
1386 struct netevent_redirect netevent;
1387
1388 rt = ip6_route_redirect(dest, src, saddr, neigh->dev);
1389
1390 if (rt == &ip6_null_entry) {
1da177e4
LT		 1391 if (net_ratelimit())
1392 printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
1393 "for redirect target\n");
a6279458 1394 goto out;
1da177e4
LT		 1395 }
1396
1da177e4
LT		 1397 /*
1398 * We have finally decided to accept it.
1399 */
1400
1401 neigh_update(neigh, lladdr, NUD_STALE,
1402 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1403 NEIGH_UPDATE_F_OVERRIDE|
1404 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1405 NEIGH_UPDATE_F_ISROUTER))
1406 );
1407
1408 /*
1409 * Redirect received -> path was valid.
1410 * Look, redirects are sent only in response to data packets,
1411 * so that this nexthop apparently is reachable. --ANK
1412 */
1413 dst_confirm(&rt->u.dst);
1414
1415 /* Duplicate redirect: silently ignore. */
1416 if (neigh == rt->u.dst.neighbour)
1417 goto out;
1418
1419 nrt = ip6_rt_copy(rt);
1420 if (nrt == NULL)
1421 goto out;
1422
1423 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1424 if (on_link)
1425 nrt->rt6i_flags &= ~RTF_GATEWAY;
1426
1427 ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
1428 nrt->rt6i_dst.plen = 128;
1429 nrt->u.dst.flags |= DST_HOST;
1430
1431 ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
1432 nrt->rt6i_nexthop = neigh_clone(neigh);
1433 /* Reset pmtu, it may be better */
1434 nrt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(neigh->dev);
1435 nrt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&nrt->u.dst));
1436
40e22e8f 1437 if (ip6_ins_rt(nrt))
1da177e4
LT		 1438 goto out;
1439
8d71740c
TT		 1440 netevent.old = &rt->u.dst;
1441 netevent.new = &nrt->u.dst;
1442 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1443
1da177e4 1444 if (rt->rt6i_flags&RTF_CACHE) {
e0a1ad73 1445 ip6_del_rt(rt);
1da177e4
LT		 1446 return;
1447 }
1448
1449out:
1450 dst_release(&rt->u.dst);
1451 return;
1452}
1453
1454/*
1455 * Handle ICMP "packet too big" messages
1456 * i.e. Path MTU discovery
1457 */
1458
1459void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
1460 struct net_device *dev, u32 pmtu)
1461{
1462 struct rt6_info *rt, *nrt;
1463 int allfrag = 0;
1464
1465 rt = rt6_lookup(daddr, saddr, dev->ifindex, 0);
1466 if (rt == NULL)
1467 return;
1468
1469 if (pmtu >= dst_mtu(&rt->u.dst))
1470 goto out;
1471
1472 if (pmtu < IPV6_MIN_MTU) {
1473 /*
1474 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
1475 * MTU (1280) and a fragment header should always be included
1476 * after a node receiving Too Big message reporting PMTU is
1477 * less than the IPv6 Minimum Link MTU.
1478 */
1479 pmtu = IPV6_MIN_MTU;
1480 allfrag = 1;
1481 }
1482
1483 /* New mtu received -> path was valid.
1484 They are sent only in response to data packets,
1485 so that this nexthop apparently is reachable. --ANK
1486 */
1487 dst_confirm(&rt->u.dst);
1488
1489 /* Host route. If it is static, it would be better
1490 not to override it, but add new one, so that
1491 when cache entry will expire old pmtu
1492 would return automatically.
1493 */
1494 if (rt->rt6i_flags & RTF_CACHE) {
1495 rt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1496 if (allfrag)
1497 rt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1498 dst_set_expires(&rt->u.dst, ip6_rt_mtu_expires);
1499 rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
1500 goto out;
1501 }
1502
1503 /* Network route.
1504 Two cases are possible:
1505 1. It is connected route. Action: COW
1506 2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1507 */
d5315b50 1508 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
a1e78363 1509 nrt = rt6_alloc_cow(rt, daddr, saddr);
d5315b50
YH		 1510 else
1511 nrt = rt6_alloc_clone(rt, daddr);
a1e78363 1512
d5315b50 1513 if (nrt) {
a1e78363
YH		 1514 nrt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1515 if (allfrag)
1516 nrt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1517
1518 /* According to RFC 1981, detecting PMTU increase shouldn't be
1519 * happened within 5 mins, the recommended timer is 10 mins.
1520 * Here this route expiration time is set to ip6_rt_mtu_expires
1521 * which is 10 mins. After 10 mins the decreased pmtu is expired
1522 * and detecting PMTU increase will be automatically happened.
1523 */
1524 dst_set_expires(&nrt->u.dst, ip6_rt_mtu_expires);
1525 nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
1526
40e22e8f 1527 ip6_ins_rt(nrt);
1da177e4 1528 }
1da177e4
LT		 1529out:
1530 dst_release(&rt->u.dst);
1531}
1532
1533/*
1534 * Misc support functions
1535 */
1536
1537static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
1538{
1539 struct rt6_info *rt = ip6_dst_alloc();
1540
1541 if (rt) {
1542 rt->u.dst.input = ort->u.dst.input;
1543 rt->u.dst.output = ort->u.dst.output;
1544
1545 memcpy(rt->u.dst.metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
22e1e4d8 1546 rt->u.dst.error = ort->u.dst.error;
1da177e4
LT		 1547 rt->u.dst.dev = ort->u.dst.dev;
1548 if (rt->u.dst.dev)
1549 dev_hold(rt->u.dst.dev);
1550 rt->rt6i_idev = ort->rt6i_idev;
1551 if (rt->rt6i_idev)
1552 in6_dev_hold(rt->rt6i_idev);
1553 rt->u.dst.lastuse = jiffies;
1554 rt->rt6i_expires = 0;
1555
1556 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
1557 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
1558 rt->rt6i_metric = 0;
1559
1560 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1561#ifdef CONFIG_IPV6_SUBTREES
1562 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1563#endif
c71099ac 1564 rt->rt6i_table = ort->rt6i_table;
1da177e4
LT		 1565 }
1566 return rt;
1567}
1568
70ceb4f5
YH		 1569#ifdef CONFIG_IPV6_ROUTE_INFO
1570static struct rt6_info *rt6_get_route_info(struct in6_addr *prefix, int prefixlen,
1571 struct in6_addr *gwaddr, int ifindex)
1572{
1573 struct fib6_node *fn;
1574 struct rt6_info *rt = NULL;
c71099ac
TG		 1575 struct fib6_table *table;
1576
1577 table = fib6_get_table(RT6_TABLE_INFO);
1578 if (table == NULL)
1579 return NULL;
70ceb4f5 1580
c71099ac
TG		 1581 write_lock_bh(&table->tb6_lock);
1582 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
70ceb4f5
YH		 1583 if (!fn)
1584 goto out;
1585
1586 for (rt = fn->leaf; rt; rt = rt->u.next) {
1587 if (rt->rt6i_dev->ifindex != ifindex)
1588 continue;
1589 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1590 continue;
1591 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1592 continue;
1593 dst_hold(&rt->u.dst);
1594 break;
1595 }
1596out:
c71099ac 1597 write_unlock_bh(&table->tb6_lock);
70ceb4f5
YH		 1598 return rt;
1599}
1600
1601static struct rt6_info *rt6_add_route_info(struct in6_addr *prefix, int prefixlen,
1602 struct in6_addr *gwaddr, int ifindex,
1603 unsigned pref)
1604{
86872cb5
TG		 1605 struct fib6_config cfg = {
1606 .fc_table = RT6_TABLE_INFO,
1607 .fc_metric = 1024,
1608 .fc_ifindex = ifindex,
1609 .fc_dst_len = prefixlen,
1610 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1611 RTF_UP | RTF_PREF(pref),
1612 };
1613
1614 ipv6_addr_copy(&cfg.fc_dst, prefix);
1615 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
70ceb4f5 1616
e317da96
YH		 1617 /* We should treat it as a default route if prefix length is 0. */
1618 if (!prefixlen)
86872cb5 1619 cfg.fc_flags |= RTF_DEFAULT;
70ceb4f5 1620
86872cb5 1621 ip6_route_add(&cfg);
70ceb4f5
YH		 1622
1623 return rt6_get_route_info(prefix, prefixlen, gwaddr, ifindex);
1624}
1625#endif
1626
1da177e4
LT		 1627struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
1628{
1629 struct rt6_info *rt;
c71099ac 1630 struct fib6_table *table;
1da177e4 1631
c71099ac
TG		 1632 table = fib6_get_table(RT6_TABLE_DFLT);
1633 if (table == NULL)
1634 return NULL;
1da177e4 1635
c71099ac
TG		 1636 write_lock_bh(&table->tb6_lock);
1637 for (rt = table->tb6_root.leaf; rt; rt=rt->u.next) {
1da177e4 1638 if (dev == rt->rt6i_dev &&
045927ff 1639 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1da177e4
LT		 1640 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1641 break;
1642 }
1643 if (rt)
1644 dst_hold(&rt->u.dst);
c71099ac 1645 write_unlock_bh(&table->tb6_lock);
1da177e4
LT		 1646 return rt;
1647}
1648
1649struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
ebacaaa0
YH		 1650 struct net_device *dev,
1651 unsigned int pref)
1da177e4 1652{
86872cb5
TG		 1653 struct fib6_config cfg = {
1654 .fc_table = RT6_TABLE_DFLT,
1655 .fc_metric = 1024,
1656 .fc_ifindex = dev->ifindex,
1657 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1658 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
1659 };
1da177e4 1660
86872cb5 1661 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1da177e4 1662
86872cb5 1663 ip6_route_add(&cfg);
1da177e4 1664
1da177e4
LT		 1665 return rt6_get_dflt_router(gwaddr, dev);
1666}
1667
1668void rt6_purge_dflt_routers(void)
1669{
1670 struct rt6_info *rt;
c71099ac
TG		 1671 struct fib6_table *table;
1672
1673 /* NOTE: Keep consistent with rt6_get_dflt_router */
1674 table = fib6_get_table(RT6_TABLE_DFLT);
1675 if (table == NULL)
1676 return;
1da177e4
LT		 1677
1678restart:
c71099ac
TG		 1679 read_lock_bh(&table->tb6_lock);
1680 for (rt = table->tb6_root.leaf; rt; rt = rt->u.next) {
1da177e4
LT		 1681 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1682 dst_hold(&rt->u.dst);
c71099ac 1683 read_unlock_bh(&table->tb6_lock);
e0a1ad73 1684 ip6_del_rt(rt);
1da177e4
LT		 1685 goto restart;
1686 }
1687 }
c71099ac 1688 read_unlock_bh(&table->tb6_lock);
1da177e4
LT		 1689}
1690
86872cb5
TG		 1691static void rtmsg_to_fib6_config(struct in6_rtmsg *rtmsg,
1692 struct fib6_config *cfg)
1693{
1694 memset(cfg, 0, sizeof(*cfg));
1695
1696 cfg->fc_table = RT6_TABLE_MAIN;
1697 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1698 cfg->fc_metric = rtmsg->rtmsg_metric;
1699 cfg->fc_expires = rtmsg->rtmsg_info;
1700 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1701 cfg->fc_src_len = rtmsg->rtmsg_src_len;
1702 cfg->fc_flags = rtmsg->rtmsg_flags;
1703
1704 ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst);
1705 ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src);
1706 ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway);
1707}
1708
1da177e4
LT		 1709int ipv6_route_ioctl(unsigned int cmd, void __user *arg)
1710{
86872cb5 1711 struct fib6_config cfg;
1da177e4
LT		 1712 struct in6_rtmsg rtmsg;
1713 int err;
1714
1715 switch(cmd) {
1716 case SIOCADDRT: /* Add a route */
1717 case SIOCDELRT: /* Delete a route */
1718 if (!capable(CAP_NET_ADMIN))
1719 return -EPERM;
1720 err = copy_from_user(&rtmsg, arg,
1721 sizeof(struct in6_rtmsg));
1722 if (err)
1723 return -EFAULT;
86872cb5
TG		 1724
1725 rtmsg_to_fib6_config(&rtmsg, &cfg);
1726
1da177e4
LT		 1727 rtnl_lock();
1728 switch (cmd) {
1729 case SIOCADDRT:
86872cb5 1730 err = ip6_route_add(&cfg);
1da177e4
LT		 1731 break;
1732 case SIOCDELRT:
86872cb5 1733 err = ip6_route_del(&cfg);
1da177e4
LT		 1734 break;
1735 default:
1736 err = -EINVAL;
1737 }
1738 rtnl_unlock();
1739
1740 return err;
1741 };
1742
1743 return -EINVAL;
1744}
1745
1746/*
1747 * Drop the packet on the floor
1748 */
1749
9ce8ade0 1750static inline int ip6_pkt_drop(struct sk_buff *skb, int code)
1da177e4 1751{
76d0cc1b
LL		 1752 int type = ipv6_addr_type(&skb->nh.ipv6h->daddr);
1753 if (type == IPV6_ADDR_ANY || type == IPV6_ADDR_RESERVED)
1754 IP6_INC_STATS(IPSTATS_MIB_INADDRERRORS);
1755
1da177e4 1756 IP6_INC_STATS(IPSTATS_MIB_OUTNOROUTES);
9ce8ade0 1757 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0, skb->dev);
1da177e4
LT		 1758 kfree_skb(skb);
1759 return 0;
1760}
1761
9ce8ade0
TG		 1762static int ip6_pkt_discard(struct sk_buff *skb)
1763{
1764 return ip6_pkt_drop(skb, ICMPV6_NOROUTE);
1765}
1766
20380731 1767static int ip6_pkt_discard_out(struct sk_buff *skb)
1da177e4
LT		 1768{
1769 skb->dev = skb->dst->dev;
1770 return ip6_pkt_discard(skb);
1771}
1772
6723ab54
DM		 1773#ifdef CONFIG_IPV6_MULTIPLE_TABLES
1774
9ce8ade0
TG		 1775static int ip6_pkt_prohibit(struct sk_buff *skb)
1776{
1777 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED);
1778}
1779
1780static int ip6_pkt_prohibit_out(struct sk_buff *skb)
1781{
1782 skb->dev = skb->dst->dev;
1783 return ip6_pkt_prohibit(skb);
1784}
1785
1786static int ip6_pkt_blk_hole(struct sk_buff *skb)
1787{
1788 kfree_skb(skb);
1789 return 0;
1790}
1791
6723ab54
DM		 1792#endif
1793
1da177e4
LT		 1794/*
1795 * Allocate a dst for local (unicast / anycast) address.
1796 */
1797
1798struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
1799 const struct in6_addr *addr,
1800 int anycast)
1801{
1802 struct rt6_info *rt = ip6_dst_alloc();
1803
1804 if (rt == NULL)
1805 return ERR_PTR(-ENOMEM);
1806
1807 dev_hold(&loopback_dev);
1808 in6_dev_hold(idev);
1809
1810 rt->u.dst.flags = DST_HOST;
1811 rt->u.dst.input = ip6_input;
1812 rt->u.dst.output = ip6_output;
1813 rt->rt6i_dev = &loopback_dev;
1814 rt->rt6i_idev = idev;
1815 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
1816 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1817 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1818 rt->u.dst.obsolete = -1;
1819
1820 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
58c4fb86
YH		 1821 if (anycast)
1822 rt->rt6i_flags |= RTF_ANYCAST;
1823 else
1da177e4
LT		 1824 rt->rt6i_flags |= RTF_LOCAL;
1825 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
1826 if (rt->rt6i_nexthop == NULL) {
1827 dst_free((struct dst_entry *) rt);
1828 return ERR_PTR(-ENOMEM);
1829 }
1830
1831 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1832 rt->rt6i_dst.plen = 128;
c71099ac 1833 rt->rt6i_table = fib6_get_table(RT6_TABLE_LOCAL);
1da177e4
LT		 1834
1835 atomic_set(&rt->u.dst.__refcnt, 1);
1836
1837 return rt;
1838}
1839
1840static int fib6_ifdown(struct rt6_info *rt, void *arg)
1841{
1842 if (((void*)rt->rt6i_dev == arg || arg == NULL) &&
1843 rt != &ip6_null_entry) {
1844 RT6_TRACE("deleted by ifdown %p\n", rt);
1845 return -1;
1846 }
1847 return 0;
1848}
1849
1850void rt6_ifdown(struct net_device *dev)
1851{
c71099ac 1852 fib6_clean_all(fib6_ifdown, 0, dev);
1da177e4
LT		 1853}
1854
1855struct rt6_mtu_change_arg
1856{
1857 struct net_device *dev;
1858 unsigned mtu;
1859};
1860
1861static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
1862{
1863 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
1864 struct inet6_dev *idev;
1865
1866 /* In IPv6 pmtu discovery is not optional,
1867 so that RTAX_MTU lock cannot disable it.
1868 We still use this lock to block changes
1869 caused by addrconf/ndisc.
1870 */
1871
1872 idev = __in6_dev_get(arg->dev);
1873 if (idev == NULL)
1874 return 0;
1875
1876 /* For administrative MTU increase, there is no way to discover
1877 IPv6 PMTU increase, so PMTU increase should be updated here.
1878 Since RFC 1981 doesn't include administrative MTU increase
1879 update PMTU increase is a MUST. (i.e. jumbo frame)
1880 */
1881 /*
1882 If new MTU is less than route PMTU, this new MTU will be the
1883 lowest MTU in the path, update the route PMTU to reflect PMTU
1884 decreases; if new MTU is greater than route PMTU, and the
1885 old MTU is the lowest MTU in the path, update the route PMTU
1886 to reflect the increase. In this case if the other nodes' MTU
1887 also have the lowest MTU, TOO BIG MESSAGE will be lead to
1888 PMTU discouvery.
1889 */
1890 if (rt->rt6i_dev == arg->dev &&
1891 !dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
1892 (dst_mtu(&rt->u.dst) > arg->mtu ||
1893 (dst_mtu(&rt->u.dst) < arg->mtu &&
1894 dst_mtu(&rt->u.dst) == idev->cnf.mtu6)))
1895 rt->u.dst.metrics[RTAX_MTU-1] = arg->mtu;
1896 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(arg->mtu);
1897 return 0;
1898}
1899
1900void rt6_mtu_change(struct net_device *dev, unsigned mtu)
1901{
c71099ac
TG		 1902 struct rt6_mtu_change_arg arg = {
1903 .dev = dev,
1904 .mtu = mtu,
1905 };
1da177e4 1906
c71099ac 1907 fib6_clean_all(rt6_mtu_change_route, 0, &arg);
1da177e4
LT		 1908}
1909
86872cb5 1910static struct nla_policy rtm_ipv6_policy[RTA_MAX+1] __read_mostly = {
5176f91e 1911 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
86872cb5 1912 [RTA_OIF] = { .type = NLA_U32 },
ab364a6f 1913 [RTA_IIF] = { .type = NLA_U32 },
86872cb5
TG		 1914 [RTA_PRIORITY] = { .type = NLA_U32 },
1915 [RTA_METRICS] = { .type = NLA_NESTED },
1916};
1917
1918static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
1919 struct fib6_config *cfg)
1da177e4 1920{
86872cb5
TG		 1921 struct rtmsg *rtm;
1922 struct nlattr *tb[RTA_MAX+1];
1923 int err;
1da177e4 1924
86872cb5
TG		 1925 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
1926 if (err < 0)
1927 goto errout;
1da177e4 1928
86872cb5
TG		 1929 err = -EINVAL;
1930 rtm = nlmsg_data(nlh);
1931 memset(cfg, 0, sizeof(*cfg));
1932
1933 cfg->fc_table = rtm->rtm_table;
1934 cfg->fc_dst_len = rtm->rtm_dst_len;
1935 cfg->fc_src_len = rtm->rtm_src_len;
1936 cfg->fc_flags = RTF_UP;
1937 cfg->fc_protocol = rtm->rtm_protocol;
1938
1939 if (rtm->rtm_type == RTN_UNREACHABLE)
1940 cfg->fc_flags |= RTF_REJECT;
1941
1942 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
1943 cfg->fc_nlinfo.nlh = nlh;
1944
1945 if (tb[RTA_GATEWAY]) {
1946 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
1947 cfg->fc_flags |= RTF_GATEWAY;
1da177e4 1948 }
86872cb5
TG		 1949
1950 if (tb[RTA_DST]) {
1951 int plen = (rtm->rtm_dst_len + 7) >> 3;
1952
1953 if (nla_len(tb[RTA_DST]) < plen)
1954 goto errout;
1955
1956 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
1da177e4 1957 }
86872cb5
TG		 1958
1959 if (tb[RTA_SRC]) {
1960 int plen = (rtm->rtm_src_len + 7) >> 3;
1961
1962 if (nla_len(tb[RTA_SRC]) < plen)
1963 goto errout;
1964
1965 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
1da177e4 1966 }
86872cb5
TG		 1967
1968 if (tb[RTA_OIF])
1969 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
1970
1971 if (tb[RTA_PRIORITY])
1972 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
1973
1974 if (tb[RTA_METRICS]) {
1975 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
1976 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
1da177e4 1977 }
86872cb5
TG		 1978
1979 if (tb[RTA_TABLE])
1980 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
1981
1982 err = 0;
1983errout:
1984 return err;
1da177e4
LT		 1985}
1986
1987int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
1988{
86872cb5
TG		 1989 struct fib6_config cfg;
1990 int err;
1da177e4 1991
86872cb5
TG		 1992 err = rtm_to_fib6_config(skb, nlh, &cfg);
1993 if (err < 0)
1994 return err;
1995
1996 return ip6_route_del(&cfg);
1da177e4
LT		 1997}
1998
1999int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2000{
86872cb5
TG		 2001 struct fib6_config cfg;
2002 int err;
1da177e4 2003
86872cb5
TG		 2004 err = rtm_to_fib6_config(skb, nlh, &cfg);
2005 if (err < 0)
2006 return err;
2007
2008 return ip6_route_add(&cfg);
1da177e4
LT		 2009}
2010
1da177e4 2011static int rt6_fill_node(struct sk_buff *skb, struct rt6_info *rt,
0d51aa80
JHS		 2012 struct in6_addr *dst, struct in6_addr *src,
2013 int iif, int type, u32 pid, u32 seq,
2014 int prefix, unsigned int flags)
1da177e4
LT		 2015{
2016 struct rtmsg *rtm;
2d7202bf 2017 struct nlmsghdr *nlh;
1da177e4 2018 struct rta_cacheinfo ci;
9e762a4a 2019 u32 table;
1da177e4
LT		 2020
2021 if (prefix) { /* user wants prefix routes only */
2022 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2023 /* success since this is not a prefix route */
2024 return 1;
2025 }
2026 }
2027
2d7202bf
TG		 2028 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags);
2029 if (nlh == NULL)
2030 return -ENOBUFS;
2031
2032 rtm = nlmsg_data(nlh);
1da177e4
LT		 2033 rtm->rtm_family = AF_INET6;
2034 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2035 rtm->rtm_src_len = rt->rt6i_src.plen;
2036 rtm->rtm_tos = 0;
c71099ac 2037 if (rt->rt6i_table)
9e762a4a 2038 table = rt->rt6i_table->tb6_id;
c71099ac 2039 else
9e762a4a
PM		 2040 table = RT6_TABLE_UNSPEC;
2041 rtm->rtm_table = table;
2d7202bf 2042 NLA_PUT_U32(skb, RTA_TABLE, table);
1da177e4
LT		 2043 if (rt->rt6i_flags&RTF_REJECT)
2044 rtm->rtm_type = RTN_UNREACHABLE;
2045 else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))
2046 rtm->rtm_type = RTN_LOCAL;
2047 else
2048 rtm->rtm_type = RTN_UNICAST;
2049 rtm->rtm_flags = 0;
2050 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2051 rtm->rtm_protocol = rt->rt6i_protocol;
2052 if (rt->rt6i_flags&RTF_DYNAMIC)
2053 rtm->rtm_protocol = RTPROT_REDIRECT;
2054 else if (rt->rt6i_flags & RTF_ADDRCONF)
2055 rtm->rtm_protocol = RTPROT_KERNEL;
2056 else if (rt->rt6i_flags&RTF_DEFAULT)
2057 rtm->rtm_protocol = RTPROT_RA;
2058
2059 if (rt->rt6i_flags&RTF_CACHE)
2060 rtm->rtm_flags |= RTM_F_CLONED;
2061
2062 if (dst) {
2d7202bf 2063 NLA_PUT(skb, RTA_DST, 16, dst);
1da177e4
LT		 2064 rtm->rtm_dst_len = 128;
2065 } else if (rtm->rtm_dst_len)
2d7202bf 2066 NLA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);
1da177e4
LT		 2067#ifdef CONFIG_IPV6_SUBTREES
2068 if (src) {
2d7202bf 2069 NLA_PUT(skb, RTA_SRC, 16, src);
1da177e4
LT		 2070 rtm->rtm_src_len = 128;
2071 } else if (rtm->rtm_src_len)
2d7202bf 2072 NLA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);
1da177e4
LT		 2073#endif
2074 if (iif)
2d7202bf 2075 NLA_PUT_U32(skb, RTA_IIF, iif);
1da177e4
LT		 2076 else if (dst) {
2077 struct in6_addr saddr_buf;
2078 if (ipv6_get_saddr(&rt->u.dst, dst, &saddr_buf) == 0)
2d7202bf 2079 NLA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);
1da177e4 2080 }
2d7202bf 2081
1da177e4 2082 if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
2d7202bf
TG		 2083 goto nla_put_failure;
2084
1da177e4 2085 if (rt->u.dst.neighbour)
2d7202bf
TG		 2086 NLA_PUT(skb, RTA_GATEWAY, 16, &rt->u.dst.neighbour->primary_key);
2087
1da177e4 2088 if (rt->u.dst.dev)
2d7202bf
TG		 2089 NLA_PUT_U32(skb, RTA_OIF, rt->rt6i_dev->ifindex);
2090
2091 NLA_PUT_U32(skb, RTA_PRIORITY, rt->rt6i_metric);
1da177e4
LT		 2092 ci.rta_lastuse = jiffies_to_clock_t(jiffies - rt->u.dst.lastuse);
2093 if (rt->rt6i_expires)
2094 ci.rta_expires = jiffies_to_clock_t(rt->rt6i_expires - jiffies);
2095 else
2096 ci.rta_expires = 0;
2097 ci.rta_used = rt->u.dst.__use;
2098 ci.rta_clntref = atomic_read(&rt->u.dst.__refcnt);
2099 ci.rta_error = rt->u.dst.error;
2100 ci.rta_id = 0;
2101 ci.rta_ts = 0;
2102 ci.rta_tsage = 0;
2d7202bf
TG		 2103 NLA_PUT(skb, RTA_CACHEINFO, sizeof(ci), &ci);
2104
2105 return nlmsg_end(skb, nlh);
2106
2107nla_put_failure:
2108 return nlmsg_cancel(skb, nlh);
1da177e4
LT		 2109}
2110
1b43af54 2111int rt6_dump_route(struct rt6_info *rt, void *p_arg)
1da177e4
LT		 2112{
2113 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2114 int prefix;
2115
2d7202bf
TG		 2116 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2117 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
1da177e4
LT		 2118 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2119 } else
2120 prefix = 0;
2121
2122 return rt6_fill_node(arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2123 NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
0d51aa80 2124 prefix, NLM_F_MULTI);
1da177e4
LT		 2125}
2126
1da177e4
LT		 2127int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
2128{
ab364a6f
TG		 2129 struct nlattr *tb[RTA_MAX+1];
2130 struct rt6_info *rt;
1da177e4 2131 struct sk_buff *skb;
ab364a6f 2132 struct rtmsg *rtm;
1da177e4 2133 struct flowi fl;
ab364a6f 2134 int err, iif = 0;
1da177e4 2135
ab364a6f
TG		 2136 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2137 if (err < 0)
2138 goto errout;
1da177e4 2139
ab364a6f 2140 err = -EINVAL;
1da177e4 2141 memset(&fl, 0, sizeof(fl));
1da177e4 2142
ab364a6f
TG		 2143 if (tb[RTA_SRC]) {
2144 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2145 goto errout;
2146
2147 ipv6_addr_copy(&fl.fl6_src, nla_data(tb[RTA_SRC]));
2148 }
2149
2150 if (tb[RTA_DST]) {
2151 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2152 goto errout;
2153
2154 ipv6_addr_copy(&fl.fl6_dst, nla_data(tb[RTA_DST]));
2155 }
2156
2157 if (tb[RTA_IIF])
2158 iif = nla_get_u32(tb[RTA_IIF]);
2159
2160 if (tb[RTA_OIF])
2161 fl.oif = nla_get_u32(tb[RTA_OIF]);
1da177e4
LT		 2162
2163 if (iif) {
2164 struct net_device *dev;
2165 dev = __dev_get_by_index(iif);
2166 if (!dev) {
2167 err = -ENODEV;
ab364a6f 2168 goto errout;
1da177e4
LT		 2169 }
2170 }
2171
ab364a6f
TG		 2172 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2173 if (skb == NULL) {
2174 err = -ENOBUFS;
2175 goto errout;
2176 }
1da177e4 2177
ab364a6f
TG		 2178 /* Reserve room for dummy headers, this skb can pass
2179 through good chunk of routing engine.
2180 */
2181 skb->mac.raw = skb->data;
2182 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
1da177e4 2183
ab364a6f 2184 rt = (struct rt6_info*) ip6_route_output(NULL, &fl);
1da177e4
LT		 2185 skb->dst = &rt->u.dst;
2186
ab364a6f 2187 err = rt6_fill_node(skb, rt, &fl.fl6_dst, &fl.fl6_src, iif,
1da177e4 2188 RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
0d51aa80 2189 nlh->nlmsg_seq, 0, 0);
1da177e4 2190 if (err < 0) {
ab364a6f
TG		 2191 kfree_skb(skb);
2192 goto errout;
1da177e4
LT		 2193 }
2194
2942e900 2195 err = rtnl_unicast(skb, NETLINK_CB(in_skb).pid);
ab364a6f 2196errout:
1da177e4 2197 return err;
1da177e4
LT		 2198}
2199
86872cb5 2200void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
1da177e4
LT		 2201{
2202 struct sk_buff *skb;
86872cb5
TG		 2203 u32 pid = 0, seq = 0;
2204 struct nlmsghdr *nlh = NULL;
21713ebc
TG		 2205 int payload = sizeof(struct rtmsg) + 256;
2206 int err = -ENOBUFS;
2207
86872cb5
TG		 2208 if (info) {
2209 pid = info->pid;
2210 nlh = info->nlh;
2211 if (nlh)
2212 seq = nlh->nlmsg_seq;
2213 }
2214
21713ebc
TG		 2215 skb = nlmsg_new(nlmsg_total_size(payload), gfp_any());
2216 if (skb == NULL)
2217 goto errout;
2218
2219 err = rt6_fill_node(skb, rt, NULL, NULL, 0, event, pid, seq, 0, 0);
2220 if (err < 0) {
1da177e4 2221 kfree_skb(skb);
21713ebc 2222 goto errout;
1da177e4 2223 }
21713ebc
TG		 2224
2225 err = rtnl_notify(skb, pid, RTNLGRP_IPV6_ROUTE, nlh, gfp_any());
2226errout:
2227 if (err < 0)
2228 rtnl_set_sk_err(RTNLGRP_IPV6_ROUTE, err);
1da177e4
LT		 2229}
2230
2231/*
2232 * /proc
2233 */
2234
2235#ifdef CONFIG_PROC_FS
2236
2237#define RT6_INFO_LEN (32 + 4 + 32 + 4 + 32 + 40 + 5 + 1)
2238
2239struct rt6_proc_arg
2240{
2241 char *buffer;
2242 int offset;
2243 int length;
2244 int skip;
2245 int len;
2246};
2247
2248static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2249{
2250 struct rt6_proc_arg *arg = (struct rt6_proc_arg *) p_arg;
2251 int i;
2252
2253 if (arg->skip < arg->offset / RT6_INFO_LEN) {
2254 arg->skip++;
2255 return 0;
2256 }
2257
2258 if (arg->len >= arg->length)
2259 return 0;
2260
2261 for (i=0; i<16; i++) {
2262 sprintf(arg->buffer + arg->len, "%02x",
2263 rt->rt6i_dst.addr.s6_addr[i]);
2264 arg->len += 2;
2265 }
2266 arg->len += sprintf(arg->buffer + arg->len, " %02x ",
2267 rt->rt6i_dst.plen);
2268
2269#ifdef CONFIG_IPV6_SUBTREES
2270 for (i=0; i<16; i++) {
2271 sprintf(arg->buffer + arg->len, "%02x",
2272 rt->rt6i_src.addr.s6_addr[i]);
2273 arg->len += 2;
2274 }
2275 arg->len += sprintf(arg->buffer + arg->len, " %02x ",
2276 rt->rt6i_src.plen);
2277#else
2278 sprintf(arg->buffer + arg->len,
2279 "00000000000000000000000000000000 00 ");
2280 arg->len += 36;
2281#endif
2282
2283 if (rt->rt6i_nexthop) {
2284 for (i=0; i<16; i++) {
2285 sprintf(arg->buffer + arg->len, "%02x",
2286 rt->rt6i_nexthop->primary_key[i]);
2287 arg->len += 2;
2288 }
2289 } else {
2290 sprintf(arg->buffer + arg->len,
2291 "00000000000000000000000000000000");
2292 arg->len += 32;
2293 }
2294 arg->len += sprintf(arg->buffer + arg->len,
2295 " %08x %08x %08x %08x %8s\n",
2296 rt->rt6i_metric, atomic_read(&rt->u.dst.__refcnt),
2297 rt->u.dst.__use, rt->rt6i_flags,
2298 rt->rt6i_dev ? rt->rt6i_dev->name : "");
2299 return 0;
2300}
2301
2302static int rt6_proc_info(char *buffer, char **start, off_t offset, int length)
2303{
c71099ac
TG		 2304 struct rt6_proc_arg arg = {
2305 .buffer = buffer,
2306 .offset = offset,
2307 .length = length,
2308 };
1da177e4 2309
c71099ac 2310 fib6_clean_all(rt6_info_route, 0, &arg);
1da177e4
LT		 2311
2312 *start = buffer;
2313 if (offset)
2314 *start += offset % RT6_INFO_LEN;
2315
2316 arg.len -= offset % RT6_INFO_LEN;
2317
2318 if (arg.len > length)
2319 arg.len = length;
2320 if (arg.len < 0)
2321 arg.len = 0;
2322
2323 return arg.len;
2324}
2325
1da177e4
LT		 2326static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2327{
2328 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2329 rt6_stats.fib_nodes, rt6_stats.fib_route_nodes,
2330 rt6_stats.fib_rt_alloc, rt6_stats.fib_rt_entries,
2331 rt6_stats.fib_rt_cache,
2332 atomic_read(&ip6_dst_ops.entries),
2333 rt6_stats.fib_discarded_routes);
2334
2335 return 0;
2336}
2337
2338static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2339{
2340 return single_open(file, rt6_stats_seq_show, NULL);
2341}
2342
2343static struct file_operations rt6_stats_seq_fops = {
2344 .owner = THIS_MODULE,
2345 .open = rt6_stats_seq_open,
2346 .read = seq_read,
2347 .llseek = seq_lseek,
2348 .release = single_release,
2349};
2350#endif /* CONFIG_PROC_FS */
2351
2352#ifdef CONFIG_SYSCTL
2353
2354static int flush_delay;
2355
2356static
2357int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write, struct file * filp,
2358 void __user *buffer, size_t *lenp, loff_t *ppos)
2359{
2360 if (write) {
2361 proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
2362 fib6_run_gc(flush_delay <= 0 ? ~0UL : (unsigned long)flush_delay);
2363 return 0;
2364 } else
2365 return -EINVAL;
2366}
2367
2368ctl_table ipv6_route_table[] = {
2369 {
2370 .ctl_name = NET_IPV6_ROUTE_FLUSH,
2371 .procname = "flush",
2372 .data = &flush_delay,
2373 .maxlen = sizeof(int),
89c8b3a1 2374 .mode = 0200,
1da177e4
LT		 2375 .proc_handler = &ipv6_sysctl_rtcache_flush
2376 },
2377 {
2378 .ctl_name = NET_IPV6_ROUTE_GC_THRESH,
2379 .procname = "gc_thresh",
2380 .data = &ip6_dst_ops.gc_thresh,
2381 .maxlen = sizeof(int),
2382 .mode = 0644,
2383 .proc_handler = &proc_dointvec,
2384 },
2385 {
2386 .ctl_name = NET_IPV6_ROUTE_MAX_SIZE,
2387 .procname = "max_size",
2388 .data = &ip6_rt_max_size,
2389 .maxlen = sizeof(int),
2390 .mode = 0644,
2391 .proc_handler = &proc_dointvec,
2392 },
2393 {
2394 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL,
2395 .procname = "gc_min_interval",
2396 .data = &ip6_rt_gc_min_interval,
2397 .maxlen = sizeof(int),
2398 .mode = 0644,
2399 .proc_handler = &proc_dointvec_jiffies,
2400 .strategy = &sysctl_jiffies,
2401 },
2402 {
2403 .ctl_name = NET_IPV6_ROUTE_GC_TIMEOUT,
2404 .procname = "gc_timeout",
2405 .data = &ip6_rt_gc_timeout,
2406 .maxlen = sizeof(int),
2407 .mode = 0644,
2408 .proc_handler = &proc_dointvec_jiffies,
2409 .strategy = &sysctl_jiffies,
2410 },
2411 {
2412 .ctl_name = NET_IPV6_ROUTE_GC_INTERVAL,
2413 .procname = "gc_interval",
2414 .data = &ip6_rt_gc_interval,
2415 .maxlen = sizeof(int),
2416 .mode = 0644,
2417 .proc_handler = &proc_dointvec_jiffies,
2418 .strategy = &sysctl_jiffies,
2419 },
2420 {
2421 .ctl_name = NET_IPV6_ROUTE_GC_ELASTICITY,
2422 .procname = "gc_elasticity",
2423 .data = &ip6_rt_gc_elasticity,
2424 .maxlen = sizeof(int),
2425 .mode = 0644,
2426 .proc_handler = &proc_dointvec_jiffies,
2427 .strategy = &sysctl_jiffies,
2428 },
2429 {
2430 .ctl_name = NET_IPV6_ROUTE_MTU_EXPIRES,
2431 .procname = "mtu_expires",
2432 .data = &ip6_rt_mtu_expires,
2433 .maxlen = sizeof(int),
2434 .mode = 0644,
2435 .proc_handler = &proc_dointvec_jiffies,
2436 .strategy = &sysctl_jiffies,
2437 },
2438 {
2439 .ctl_name = NET_IPV6_ROUTE_MIN_ADVMSS,
2440 .procname = "min_adv_mss",
2441 .data = &ip6_rt_min_advmss,
2442 .maxlen = sizeof(int),
2443 .mode = 0644,
2444 .proc_handler = &proc_dointvec_jiffies,
2445 .strategy = &sysctl_jiffies,
2446 },
2447 {
2448 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS,
2449 .procname = "gc_min_interval_ms",
2450 .data = &ip6_rt_gc_min_interval,
2451 .maxlen = sizeof(int),
2452 .mode = 0644,
2453 .proc_handler = &proc_dointvec_ms_jiffies,
2454 .strategy = &sysctl_ms_jiffies,
2455 },
2456 { .ctl_name = 0 }
2457};
2458
2459#endif
2460
2461void __init ip6_route_init(void)
2462{
2463 struct proc_dir_entry *p;
2464
e5d679f3
AD		 2465 ip6_dst_ops.kmem_cachep =
2466 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
2467 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
1da177e4
LT		 2468 fib6_init();
2469#ifdef CONFIG_PROC_FS
2470 p = proc_net_create("ipv6_route", 0, rt6_proc_info);
2471 if (p)
2472 p->owner = THIS_MODULE;
2473
2474 proc_net_fops_create("rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
2475#endif
2476#ifdef CONFIG_XFRM
2477 xfrm6_init();
2478#endif
101367c2
TG		 2479#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2480 fib6_rules_init();
2481#endif
1da177e4
LT		 2482}
2483
2484void ip6_route_cleanup(void)
2485{
101367c2
TG		 2486#ifdef CONFIG_IPV6_MULTIPLE_TABLES
2487 fib6_rules_cleanup();
2488#endif
1da177e4
LT		 2489#ifdef CONFIG_PROC_FS
2490 proc_net_remove("ipv6_route");
2491 proc_net_remove("rt6_stats");
2492#endif
2493#ifdef CONFIG_XFRM
2494 xfrm6_fini();
2495#endif
2496 rt6_ifdown(NULL);
2497 fib6_gc_cleanup();
2498 kmem_cache_destroy(ip6_dst_ops.kmem_cachep);
2499}
ubuntu-bionic-kernel mirror