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