?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[NETNS][IPV6] ip6_fib - add net to gc timer parameter
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / net / ipv6 / route.c
blobfd44721abebbbf0b616228a4ca45054331cfd13a
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
77 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort);
78 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
79 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
80 static void ip6_dst_destroy(struct dst_entry *);
81 static void ip6_dst_ifdown(struct dst_entry *,
82 struct net_device *dev, int how);
83 static int ip6_dst_gc(struct dst_ops *ops);
84
85 static int ip6_pkt_discard(struct sk_buff *skb);
86 static int ip6_pkt_discard_out(struct sk_buff *skb);
87 static void ip6_link_failure(struct sk_buff *skb);
88 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
89
90 #ifdef CONFIG_IPV6_ROUTE_INFO
91 static struct rt6_info *rt6_add_route_info(struct in6_addr *prefix, int prefixlen,
92 struct in6_addr *gwaddr, int ifindex,
93 unsigned pref);
94 static struct rt6_info *rt6_get_route_info(struct in6_addr *prefix, int prefixlen,
95 struct in6_addr *gwaddr, int ifindex);
96 #endif
97
98 static 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
114 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu)
115 {
116 }
117
118 static 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
128 struct 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
149 static int ip6_pkt_prohibit(struct sk_buff *skb);
150 static int ip6_pkt_prohibit_out(struct sk_buff *skb);
151
152 struct 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
171 struct 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 */
193 static __inline__ struct rt6_info *ip6_dst_alloc(void)
194 {
195 return (struct rt6_info *)dst_alloc(&ip6_dst_ops);
196 }
197
198 static 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
209 static 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
227 static __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
233 static 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
243 static __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
278 static 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
307 static 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 */
316 static 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
327 static 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
350 static 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
367 static 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
388 out:
389 return match;
390 }
391
392 static 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
410 static 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
442 int 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) \
520 do { \
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
537 static 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);
545 restart:
546 rt = fn->leaf;
547 rt = rt6_device_match(rt, fl->oif, flags);
548 BACKTRACK(&fl->fl6_src);
549 out:
550 dst_use(&rt->u.dst, jiffies);
551 read_unlock_bh(&table->tb6_lock);
552 return rt;
553
554 }
555
556 struct rt6_info *rt6_lookup(struct in6_addr *daddr, struct in6_addr *saddr,
557 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(&init_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
584 EXPORT_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
592 static 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
605 int 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
613 static 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
651 static 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
664 static 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
676 relookup:
677 read_lock_bh(&table->tb6_lock);
678
679 restart_2:
680 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
681
682 restart:
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
722 out:
723 if (reachable) {
724 reachable = 0;
725 goto restart_2;
726 }
727 dst_hold(&rt->u.dst);
728 read_unlock_bh(&table->tb6_lock);
729 out2:
730 rt->u.dst.lastuse = jiffies;
731 rt->u.dst.__use++;
732
733 return rt;
734 }
735
736 static 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
742 void 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
765 static 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
771 struct 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
784 EXPORT_SYMBOL(ip6_route_output);
785
786 int 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 }
826 EXPORT_SYMBOL_GPL(ip6_dst_blackhole);
827
828 /*
829 * Destination cache support functions
830 */
831
832 static 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
844 static 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
857 static 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
873 static 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
888 static int ipv6_get_mtu(struct net_device *dev);
889
890 static 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
908 static struct dst_entry *icmp6_dst_gc_list;
909 static DEFINE_SPINLOCK(icmp6_dst_lock);
910
911 struct 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();
956
957 out:
958 return &rt->u.dst;
959 }
960
961 int 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
988 static 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
1004 out:
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
1015 static 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
1028 int 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
1045 int 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(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
1205 install_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 return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
1234
1235 out:
1236 if (dev)
1237 dev_put(dev);
1238 if (idev)
1239 in6_dev_put(idev);
1240 if (rt)
1241 dst_free(&rt->u.dst);
1242 return err;
1243 }
1244
1245 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1246 {
1247 int err;
1248 struct fib6_table *table;
1249
1250 if (rt == &ip6_null_entry)
1251 return -ENOENT;
1252
1253 table = rt->rt6i_table;
1254 write_lock_bh(&table->tb6_lock);
1255
1256 err = fib6_del(rt, info);
1257 dst_release(&rt->u.dst);
1258
1259 write_unlock_bh(&table->tb6_lock);
1260
1261 return err;
1262 }
1263
1264 int ip6_del_rt(struct rt6_info *rt)
1265 {
1266 struct nl_info info = {
1267 .nl_net = &init_net,
1268 };
1269 return __ip6_del_rt(rt, &info);
1270 }
1271
1272 static int ip6_route_del(struct fib6_config *cfg)
1273 {
1274 struct fib6_table *table;
1275 struct fib6_node *fn;
1276 struct rt6_info *rt;
1277 int err = -ESRCH;
1278
1279 table = fib6_get_table(&init_net, cfg->fc_table);
1280 if (table == NULL)
1281 return err;
1282
1283 read_lock_bh(&table->tb6_lock);
1284
1285 fn = fib6_locate(&table->tb6_root,
1286 &cfg->fc_dst, cfg->fc_dst_len,
1287 &cfg->fc_src, cfg->fc_src_len);
1288
1289 if (fn) {
1290 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
1291 if (cfg->fc_ifindex &&
1292 (rt->rt6i_dev == NULL ||
1293 rt->rt6i_dev->ifindex != cfg->fc_ifindex))
1294 continue;
1295 if (cfg->fc_flags & RTF_GATEWAY &&
1296 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1297 continue;
1298 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1299 continue;
1300 dst_hold(&rt->u.dst);
1301 read_unlock_bh(&table->tb6_lock);
1302
1303 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1304 }
1305 }
1306 read_unlock_bh(&table->tb6_lock);
1307
1308 return err;
1309 }
1310
1311 /*
1312 * Handle redirects
1313 */
1314 struct ip6rd_flowi {
1315 struct flowi fl;
1316 struct in6_addr gateway;
1317 };
1318
1319 static struct rt6_info *__ip6_route_redirect(struct fib6_table *table,
1320 struct flowi *fl,
1321 int flags)
1322 {
1323 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl;
1324 struct rt6_info *rt;
1325 struct fib6_node *fn;
1326
1327 /*
1328 * Get the "current" route for this destination and
1329 * check if the redirect has come from approriate router.
1330 *
1331 * RFC 2461 specifies that redirects should only be
1332 * accepted if they come from the nexthop to the target.
1333 * Due to the way the routes are chosen, this notion
1334 * is a bit fuzzy and one might need to check all possible
1335 * routes.
1336 */
1337
1338 read_lock_bh(&table->tb6_lock);
1339 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
1340 restart:
1341 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
1342 /*
1343 * Current route is on-link; redirect is always invalid.
1344 *
1345 * Seems, previous statement is not true. It could
1346 * be node, which looks for us as on-link (f.e. proxy ndisc)
1347 * But then router serving it might decide, that we should
1348 * know truth 8)8) --ANK (980726).
1349 */
1350 if (rt6_check_expired(rt))
1351 continue;
1352 if (!(rt->rt6i_flags & RTF_GATEWAY))
1353 continue;
1354 if (fl->oif != rt->rt6i_dev->ifindex)
1355 continue;
1356 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1357 continue;
1358 break;
1359 }
1360
1361 if (!rt)
1362 rt = &ip6_null_entry;
1363 BACKTRACK(&fl->fl6_src);
1364 out:
1365 dst_hold(&rt->u.dst);
1366
1367 read_unlock_bh(&table->tb6_lock);
1368
1369 return rt;
1370 };
1371
1372 static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,
1373 struct in6_addr *src,
1374 struct in6_addr *gateway,
1375 struct net_device *dev)
1376 {
1377 int flags = RT6_LOOKUP_F_HAS_SADDR;
1378 struct ip6rd_flowi rdfl = {
1379 .fl = {
1380 .oif = dev->ifindex,
1381 .nl_u = {
1382 .ip6_u = {
1383 .daddr = *dest,
1384 .saddr = *src,
1385 },
1386 },
1387 },
1388 .gateway = *gateway,
1389 };
1390
1391 if (rt6_need_strict(dest))
1392 flags |= RT6_LOOKUP_F_IFACE;
1393
1394 return (struct rt6_info *)fib6_rule_lookup(&init_net,
1395 (struct flowi *)&rdfl,
1396 flags, __ip6_route_redirect);
1397 }
1398
1399 void rt6_redirect(struct in6_addr *dest, struct in6_addr *src,
1400 struct in6_addr *saddr,
1401 struct neighbour *neigh, u8 *lladdr, int on_link)
1402 {
1403 struct rt6_info *rt, *nrt = NULL;
1404 struct netevent_redirect netevent;
1405
1406 rt = ip6_route_redirect(dest, src, saddr, neigh->dev);
1407
1408 if (rt == &ip6_null_entry) {
1409 if (net_ratelimit())
1410 printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
1411 "for redirect target\n");
1412 goto out;
1413 }
1414
1415 /*
1416 * We have finally decided to accept it.
1417 */
1418
1419 neigh_update(neigh, lladdr, NUD_STALE,
1420 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1421 NEIGH_UPDATE_F_OVERRIDE|
1422 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1423 NEIGH_UPDATE_F_ISROUTER))
1424 );
1425
1426 /*
1427 * Redirect received -> path was valid.
1428 * Look, redirects are sent only in response to data packets,
1429 * so that this nexthop apparently is reachable. --ANK
1430 */
1431 dst_confirm(&rt->u.dst);
1432
1433 /* Duplicate redirect: silently ignore. */
1434 if (neigh == rt->u.dst.neighbour)
1435 goto out;
1436
1437 nrt = ip6_rt_copy(rt);
1438 if (nrt == NULL)
1439 goto out;
1440
1441 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1442 if (on_link)
1443 nrt->rt6i_flags &= ~RTF_GATEWAY;
1444
1445 ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
1446 nrt->rt6i_dst.plen = 128;
1447 nrt->u.dst.flags |= DST_HOST;
1448
1449 ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
1450 nrt->rt6i_nexthop = neigh_clone(neigh);
1451 /* Reset pmtu, it may be better */
1452 nrt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(neigh->dev);
1453 nrt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&nrt->u.dst));
1454
1455 if (ip6_ins_rt(nrt))
1456 goto out;
1457
1458 netevent.old = &rt->u.dst;
1459 netevent.new = &nrt->u.dst;
1460 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1461
1462 if (rt->rt6i_flags&RTF_CACHE) {
1463 ip6_del_rt(rt);
1464 return;
1465 }
1466
1467 out:
1468 dst_release(&rt->u.dst);
1469 return;
1470 }
1471
1472 /*
1473 * Handle ICMP "packet too big" messages
1474 * i.e. Path MTU discovery
1475 */
1476
1477 void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
1478 struct net_device *dev, u32 pmtu)
1479 {
1480 struct rt6_info *rt, *nrt;
1481 int allfrag = 0;
1482
1483 rt = rt6_lookup(daddr, saddr, dev->ifindex, 0);
1484 if (rt == NULL)
1485 return;
1486
1487 if (pmtu >= dst_mtu(&rt->u.dst))
1488 goto out;
1489
1490 if (pmtu < IPV6_MIN_MTU) {
1491 /*
1492 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
1493 * MTU (1280) and a fragment header should always be included
1494 * after a node receiving Too Big message reporting PMTU is
1495 * less than the IPv6 Minimum Link MTU.
1496 */
1497 pmtu = IPV6_MIN_MTU;
1498 allfrag = 1;
1499 }
1500
1501 /* New mtu received -> path was valid.
1502 They are sent only in response to data packets,
1503 so that this nexthop apparently is reachable. --ANK
1504 */
1505 dst_confirm(&rt->u.dst);
1506
1507 /* Host route. If it is static, it would be better
1508 not to override it, but add new one, so that
1509 when cache entry will expire old pmtu
1510 would return automatically.
1511 */
1512 if (rt->rt6i_flags & RTF_CACHE) {
1513 rt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1514 if (allfrag)
1515 rt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1516 dst_set_expires(&rt->u.dst, init_net.ipv6.sysctl.ip6_rt_mtu_expires);
1517 rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
1518 goto out;
1519 }
1520
1521 /* Network route.
1522 Two cases are possible:
1523 1. It is connected route. Action: COW
1524 2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1525 */
1526 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
1527 nrt = rt6_alloc_cow(rt, daddr, saddr);
1528 else
1529 nrt = rt6_alloc_clone(rt, daddr);
1530
1531 if (nrt) {
1532 nrt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1533 if (allfrag)
1534 nrt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1535
1536 /* According to RFC 1981, detecting PMTU increase shouldn't be
1537 * happened within 5 mins, the recommended timer is 10 mins.
1538 * Here this route expiration time is set to ip6_rt_mtu_expires
1539 * which is 10 mins. After 10 mins the decreased pmtu is expired
1540 * and detecting PMTU increase will be automatically happened.
1541 */
1542 dst_set_expires(&nrt->u.dst, init_net.ipv6.sysctl.ip6_rt_mtu_expires);
1543 nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
1544
1545 ip6_ins_rt(nrt);
1546 }
1547 out:
1548 dst_release(&rt->u.dst);
1549 }
1550
1551 /*
1552 * Misc support functions
1553 */
1554
1555 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
1556 {
1557 struct rt6_info *rt = ip6_dst_alloc();
1558
1559 if (rt) {
1560 rt->u.dst.input = ort->u.dst.input;
1561 rt->u.dst.output = ort->u.dst.output;
1562
1563 memcpy(rt->u.dst.metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
1564 rt->u.dst.error = ort->u.dst.error;
1565 rt->u.dst.dev = ort->u.dst.dev;
1566 if (rt->u.dst.dev)
1567 dev_hold(rt->u.dst.dev);
1568 rt->rt6i_idev = ort->rt6i_idev;
1569 if (rt->rt6i_idev)
1570 in6_dev_hold(rt->rt6i_idev);
1571 rt->u.dst.lastuse = jiffies;
1572 rt->rt6i_expires = 0;
1573
1574 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
1575 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
1576 rt->rt6i_metric = 0;
1577
1578 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1579 #ifdef CONFIG_IPV6_SUBTREES
1580 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1581 #endif
1582 rt->rt6i_table = ort->rt6i_table;
1583 }
1584 return rt;
1585 }
1586
1587 #ifdef CONFIG_IPV6_ROUTE_INFO
1588 static struct rt6_info *rt6_get_route_info(struct in6_addr *prefix, int prefixlen,
1589 struct in6_addr *gwaddr, int ifindex)
1590 {
1591 struct fib6_node *fn;
1592 struct rt6_info *rt = NULL;
1593 struct fib6_table *table;
1594
1595 table = fib6_get_table(&init_net, RT6_TABLE_INFO);
1596 if (table == NULL)
1597 return NULL;
1598
1599 write_lock_bh(&table->tb6_lock);
1600 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
1601 if (!fn)
1602 goto out;
1603
1604 for (rt = fn->leaf; rt; rt = rt->u.dst.rt6_next) {
1605 if (rt->rt6i_dev->ifindex != ifindex)
1606 continue;
1607 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1608 continue;
1609 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1610 continue;
1611 dst_hold(&rt->u.dst);
1612 break;
1613 }
1614 out:
1615 write_unlock_bh(&table->tb6_lock);
1616 return rt;
1617 }
1618
1619 static struct rt6_info *rt6_add_route_info(struct in6_addr *prefix, int prefixlen,
1620 struct in6_addr *gwaddr, int ifindex,
1621 unsigned pref)
1622 {
1623 struct fib6_config cfg = {
1624 .fc_table = RT6_TABLE_INFO,
1625 .fc_metric = IP6_RT_PRIO_USER,
1626 .fc_ifindex = ifindex,
1627 .fc_dst_len = prefixlen,
1628 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1629 RTF_UP | RTF_PREF(pref),
1630 };
1631
1632 ipv6_addr_copy(&cfg.fc_dst, prefix);
1633 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1634
1635 /* We should treat it as a default route if prefix length is 0. */
1636 if (!prefixlen)
1637 cfg.fc_flags |= RTF_DEFAULT;
1638
1639 ip6_route_add(&cfg);
1640
1641 return rt6_get_route_info(prefix, prefixlen, gwaddr, ifindex);
1642 }
1643 #endif
1644
1645 struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
1646 {
1647 struct rt6_info *rt;
1648 struct fib6_table *table;
1649
1650 table = fib6_get_table(&init_net, RT6_TABLE_DFLT);
1651 if (table == NULL)
1652 return NULL;
1653
1654 write_lock_bh(&table->tb6_lock);
1655 for (rt = table->tb6_root.leaf; rt; rt=rt->u.dst.rt6_next) {
1656 if (dev == rt->rt6i_dev &&
1657 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1658 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1659 break;
1660 }
1661 if (rt)
1662 dst_hold(&rt->u.dst);
1663 write_unlock_bh(&table->tb6_lock);
1664 return rt;
1665 }
1666
1667 EXPORT_SYMBOL(rt6_get_dflt_router);
1668
1669 struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
1670 struct net_device *dev,
1671 unsigned int pref)
1672 {
1673 struct fib6_config cfg = {
1674 .fc_table = RT6_TABLE_DFLT,
1675 .fc_metric = IP6_RT_PRIO_USER,
1676 .fc_ifindex = dev->ifindex,
1677 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1678 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
1679 };
1680
1681 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1682
1683 ip6_route_add(&cfg);
1684
1685 return rt6_get_dflt_router(gwaddr, dev);
1686 }
1687
1688 void rt6_purge_dflt_routers(void)
1689 {
1690 struct rt6_info *rt;
1691 struct fib6_table *table;
1692
1693 /* NOTE: Keep consistent with rt6_get_dflt_router */
1694 table = fib6_get_table(&init_net, RT6_TABLE_DFLT);
1695 if (table == NULL)
1696 return;
1697
1698 restart:
1699 read_lock_bh(&table->tb6_lock);
1700 for (rt = table->tb6_root.leaf; rt; rt = rt->u.dst.rt6_next) {
1701 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1702 dst_hold(&rt->u.dst);
1703 read_unlock_bh(&table->tb6_lock);
1704 ip6_del_rt(rt);
1705 goto restart;
1706 }
1707 }
1708 read_unlock_bh(&table->tb6_lock);
1709 }
1710
1711 static void rtmsg_to_fib6_config(struct in6_rtmsg *rtmsg,
1712 struct fib6_config *cfg)
1713 {
1714 memset(cfg, 0, sizeof(*cfg));
1715
1716 cfg->fc_table = RT6_TABLE_MAIN;
1717 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1718 cfg->fc_metric = rtmsg->rtmsg_metric;
1719 cfg->fc_expires = rtmsg->rtmsg_info;
1720 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1721 cfg->fc_src_len = rtmsg->rtmsg_src_len;
1722 cfg->fc_flags = rtmsg->rtmsg_flags;
1723
1724 cfg->fc_nlinfo.nl_net = &init_net;
1725
1726 ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst);
1727 ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src);
1728 ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway);
1729 }
1730
1731 int ipv6_route_ioctl(unsigned int cmd, void __user *arg)
1732 {
1733 struct fib6_config cfg;
1734 struct in6_rtmsg rtmsg;
1735 int err;
1736
1737 switch(cmd) {
1738 case SIOCADDRT: /* Add a route */
1739 case SIOCDELRT: /* Delete a route */
1740 if (!capable(CAP_NET_ADMIN))
1741 return -EPERM;
1742 err = copy_from_user(&rtmsg, arg,
1743 sizeof(struct in6_rtmsg));
1744 if (err)
1745 return -EFAULT;
1746
1747 rtmsg_to_fib6_config(&rtmsg, &cfg);
1748
1749 rtnl_lock();
1750 switch (cmd) {
1751 case SIOCADDRT:
1752 err = ip6_route_add(&cfg);
1753 break;
1754 case SIOCDELRT:
1755 err = ip6_route_del(&cfg);
1756 break;
1757 default:
1758 err = -EINVAL;
1759 }
1760 rtnl_unlock();
1761
1762 return err;
1763 }
1764
1765 return -EINVAL;
1766 }
1767
1768 /*
1769 * Drop the packet on the floor
1770 */
1771
1772 static int ip6_pkt_drop(struct sk_buff *skb, int code, int ipstats_mib_noroutes)
1773 {
1774 int type;
1775 switch (ipstats_mib_noroutes) {
1776 case IPSTATS_MIB_INNOROUTES:
1777 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
1778 if (type == IPV6_ADDR_ANY || type == IPV6_ADDR_RESERVED) {
1779 IP6_INC_STATS(ip6_dst_idev(skb->dst), IPSTATS_MIB_INADDRERRORS);
1780 break;
1781 }
1782 /* FALLTHROUGH */
1783 case IPSTATS_MIB_OUTNOROUTES:
1784 IP6_INC_STATS(ip6_dst_idev(skb->dst), ipstats_mib_noroutes);
1785 break;
1786 }
1787 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0, skb->dev);
1788 kfree_skb(skb);
1789 return 0;
1790 }
1791
1792 static int ip6_pkt_discard(struct sk_buff *skb)
1793 {
1794 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
1795 }
1796
1797 static int ip6_pkt_discard_out(struct sk_buff *skb)
1798 {
1799 skb->dev = skb->dst->dev;
1800 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
1801 }
1802
1803 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
1804
1805 static int ip6_pkt_prohibit(struct sk_buff *skb)
1806 {
1807 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
1808 }
1809
1810 static int ip6_pkt_prohibit_out(struct sk_buff *skb)
1811 {
1812 skb->dev = skb->dst->dev;
1813 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
1814 }
1815
1816 #endif
1817
1818 /*
1819 * Allocate a dst for local (unicast / anycast) address.
1820 */
1821
1822 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
1823 const struct in6_addr *addr,
1824 int anycast)
1825 {
1826 struct rt6_info *rt = ip6_dst_alloc();
1827
1828 if (rt == NULL)
1829 return ERR_PTR(-ENOMEM);
1830
1831 dev_hold(init_net.loopback_dev);
1832 in6_dev_hold(idev);
1833
1834 rt->u.dst.flags = DST_HOST;
1835 rt->u.dst.input = ip6_input;
1836 rt->u.dst.output = ip6_output;
1837 rt->rt6i_dev = init_net.loopback_dev;
1838 rt->rt6i_idev = idev;
1839 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
1840 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1841 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1842 rt->u.dst.obsolete = -1;
1843
1844 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
1845 if (anycast)
1846 rt->rt6i_flags |= RTF_ANYCAST;
1847 else
1848 rt->rt6i_flags |= RTF_LOCAL;
1849 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
1850 if (rt->rt6i_nexthop == NULL) {
1851 dst_free(&rt->u.dst);
1852 return ERR_PTR(-ENOMEM);
1853 }
1854
1855 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1856 rt->rt6i_dst.plen = 128;
1857 rt->rt6i_table = fib6_get_table(&init_net, RT6_TABLE_LOCAL);
1858
1859 atomic_set(&rt->u.dst.__refcnt, 1);
1860
1861 return rt;
1862 }
1863
1864 static int fib6_ifdown(struct rt6_info *rt, void *arg)
1865 {
1866 if (((void*)rt->rt6i_dev == arg || arg == NULL) &&
1867 rt != &ip6_null_entry) {
1868 RT6_TRACE("deleted by ifdown %p\n", rt);
1869 return -1;
1870 }
1871 return 0;
1872 }
1873
1874 void rt6_ifdown(struct net *net, struct net_device *dev)
1875 {
1876 fib6_clean_all(net, fib6_ifdown, 0, dev);
1877 }
1878
1879 struct rt6_mtu_change_arg
1880 {
1881 struct net_device *dev;
1882 unsigned mtu;
1883 };
1884
1885 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
1886 {
1887 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
1888 struct inet6_dev *idev;
1889
1890 /* In IPv6 pmtu discovery is not optional,
1891 so that RTAX_MTU lock cannot disable it.
1892 We still use this lock to block changes
1893 caused by addrconf/ndisc.
1894 */
1895
1896 idev = __in6_dev_get(arg->dev);
1897 if (idev == NULL)
1898 return 0;
1899
1900 /* For administrative MTU increase, there is no way to discover
1901 IPv6 PMTU increase, so PMTU increase should be updated here.
1902 Since RFC 1981 doesn't include administrative MTU increase
1903 update PMTU increase is a MUST. (i.e. jumbo frame)
1904 */
1905 /*
1906 If new MTU is less than route PMTU, this new MTU will be the
1907 lowest MTU in the path, update the route PMTU to reflect PMTU
1908 decreases; if new MTU is greater than route PMTU, and the
1909 old MTU is the lowest MTU in the path, update the route PMTU
1910 to reflect the increase. In this case if the other nodes' MTU
1911 also have the lowest MTU, TOO BIG MESSAGE will be lead to
1912 PMTU discouvery.
1913 */
1914 if (rt->rt6i_dev == arg->dev &&
1915 !dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
1916 (dst_mtu(&rt->u.dst) >= arg->mtu ||
1917 (dst_mtu(&rt->u.dst) < arg->mtu &&
1918 dst_mtu(&rt->u.dst) == idev->cnf.mtu6))) {
1919 rt->u.dst.metrics[RTAX_MTU-1] = arg->mtu;
1920 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(arg->mtu);
1921 }
1922 return 0;
1923 }
1924
1925 void rt6_mtu_change(struct net_device *dev, unsigned mtu)
1926 {
1927 struct rt6_mtu_change_arg arg = {
1928 .dev = dev,
1929 .mtu = mtu,
1930 };
1931
1932 fib6_clean_all(dev->nd_net, rt6_mtu_change_route, 0, &arg);
1933 }
1934
1935 static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
1936 [RTA_GATEWAY] = { .len = sizeof(struct in6_addr) },
1937 [RTA_OIF] = { .type = NLA_U32 },
1938 [RTA_IIF] = { .type = NLA_U32 },
1939 [RTA_PRIORITY] = { .type = NLA_U32 },
1940 [RTA_METRICS] = { .type = NLA_NESTED },
1941 };
1942
1943 static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
1944 struct fib6_config *cfg)
1945 {
1946 struct rtmsg *rtm;
1947 struct nlattr *tb[RTA_MAX+1];
1948 int err;
1949
1950 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
1951 if (err < 0)
1952 goto errout;
1953
1954 err = -EINVAL;
1955 rtm = nlmsg_data(nlh);
1956 memset(cfg, 0, sizeof(*cfg));
1957
1958 cfg->fc_table = rtm->rtm_table;
1959 cfg->fc_dst_len = rtm->rtm_dst_len;
1960 cfg->fc_src_len = rtm->rtm_src_len;
1961 cfg->fc_flags = RTF_UP;
1962 cfg->fc_protocol = rtm->rtm_protocol;
1963
1964 if (rtm->rtm_type == RTN_UNREACHABLE)
1965 cfg->fc_flags |= RTF_REJECT;
1966
1967 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
1968 cfg->fc_nlinfo.nlh = nlh;
1969 cfg->fc_nlinfo.nl_net = skb->sk->sk_net;
1970
1971 if (tb[RTA_GATEWAY]) {
1972 nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
1973 cfg->fc_flags |= RTF_GATEWAY;
1974 }
1975
1976 if (tb[RTA_DST]) {
1977 int plen = (rtm->rtm_dst_len + 7) >> 3;
1978
1979 if (nla_len(tb[RTA_DST]) < plen)
1980 goto errout;
1981
1982 nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
1983 }
1984
1985 if (tb[RTA_SRC]) {
1986 int plen = (rtm->rtm_src_len + 7) >> 3;
1987
1988 if (nla_len(tb[RTA_SRC]) < plen)
1989 goto errout;
1990
1991 nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
1992 }
1993
1994 if (tb[RTA_OIF])
1995 cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
1996
1997 if (tb[RTA_PRIORITY])
1998 cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
1999
2000 if (tb[RTA_METRICS]) {
2001 cfg->fc_mx = nla_data(tb[RTA_METRICS]);
2002 cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
2003 }
2004
2005 if (tb[RTA_TABLE])
2006 cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
2007
2008 err = 0;
2009 errout:
2010 return err;
2011 }
2012
2013 static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2014 {
2015 struct net *net = skb->sk->sk_net;
2016 struct fib6_config cfg;
2017 int err;
2018
2019 if (net != &init_net)
2020 return -EINVAL;
2021
2022 err = rtm_to_fib6_config(skb, nlh, &cfg);
2023 if (err < 0)
2024 return err;
2025
2026 return ip6_route_del(&cfg);
2027 }
2028
2029 static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
2030 {
2031 struct net *net = skb->sk->sk_net;
2032 struct fib6_config cfg;
2033 int err;
2034
2035 if (net != &init_net)
2036 return -EINVAL;
2037
2038 err = rtm_to_fib6_config(skb, nlh, &cfg);
2039 if (err < 0)
2040 return err;
2041
2042 return ip6_route_add(&cfg);
2043 }
2044
2045 static inline size_t rt6_nlmsg_size(void)
2046 {
2047 return NLMSG_ALIGN(sizeof(struct rtmsg))
2048 + nla_total_size(16) /* RTA_SRC */
2049 + nla_total_size(16) /* RTA_DST */
2050 + nla_total_size(16) /* RTA_GATEWAY */
2051 + nla_total_size(16) /* RTA_PREFSRC */
2052 + nla_total_size(4) /* RTA_TABLE */
2053 + nla_total_size(4) /* RTA_IIF */
2054 + nla_total_size(4) /* RTA_OIF */
2055 + nla_total_size(4) /* RTA_PRIORITY */
2056 + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
2057 + nla_total_size(sizeof(struct rta_cacheinfo));
2058 }
2059
2060 static int rt6_fill_node(struct sk_buff *skb, struct rt6_info *rt,
2061 struct in6_addr *dst, struct in6_addr *src,
2062 int iif, int type, u32 pid, u32 seq,
2063 int prefix, unsigned int flags)
2064 {
2065 struct rtmsg *rtm;
2066 struct nlmsghdr *nlh;
2067 long expires;
2068 u32 table;
2069
2070 if (prefix) { /* user wants prefix routes only */
2071 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
2072 /* success since this is not a prefix route */
2073 return 1;
2074 }
2075 }
2076
2077 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags);
2078 if (nlh == NULL)
2079 return -EMSGSIZE;
2080
2081 rtm = nlmsg_data(nlh);
2082 rtm->rtm_family = AF_INET6;
2083 rtm->rtm_dst_len = rt->rt6i_dst.plen;
2084 rtm->rtm_src_len = rt->rt6i_src.plen;
2085 rtm->rtm_tos = 0;
2086 if (rt->rt6i_table)
2087 table = rt->rt6i_table->tb6_id;
2088 else
2089 table = RT6_TABLE_UNSPEC;
2090 rtm->rtm_table = table;
2091 NLA_PUT_U32(skb, RTA_TABLE, table);
2092 if (rt->rt6i_flags&RTF_REJECT)
2093 rtm->rtm_type = RTN_UNREACHABLE;
2094 else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))
2095 rtm->rtm_type = RTN_LOCAL;
2096 else
2097 rtm->rtm_type = RTN_UNICAST;
2098 rtm->rtm_flags = 0;
2099 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2100 rtm->rtm_protocol = rt->rt6i_protocol;
2101 if (rt->rt6i_flags&RTF_DYNAMIC)
2102 rtm->rtm_protocol = RTPROT_REDIRECT;
2103 else if (rt->rt6i_flags & RTF_ADDRCONF)
2104 rtm->rtm_protocol = RTPROT_KERNEL;
2105 else if (rt->rt6i_flags&RTF_DEFAULT)
2106 rtm->rtm_protocol = RTPROT_RA;
2107
2108 if (rt->rt6i_flags&RTF_CACHE)
2109 rtm->rtm_flags |= RTM_F_CLONED;
2110
2111 if (dst) {
2112 NLA_PUT(skb, RTA_DST, 16, dst);
2113 rtm->rtm_dst_len = 128;
2114 } else if (rtm->rtm_dst_len)
2115 NLA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);
2116 #ifdef CONFIG_IPV6_SUBTREES
2117 if (src) {
2118 NLA_PUT(skb, RTA_SRC, 16, src);
2119 rtm->rtm_src_len = 128;
2120 } else if (rtm->rtm_src_len)
2121 NLA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);
2122 #endif
2123 if (iif)
2124 NLA_PUT_U32(skb, RTA_IIF, iif);
2125 else if (dst) {
2126 struct in6_addr saddr_buf;
2127 if (ipv6_dev_get_saddr(ip6_dst_idev(&rt->u.dst)->dev,
2128 dst, &saddr_buf) == 0)
2129 NLA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);
2130 }
2131
2132 if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
2133 goto nla_put_failure;
2134
2135 if (rt->u.dst.neighbour)
2136 NLA_PUT(skb, RTA_GATEWAY, 16, &rt->u.dst.neighbour->primary_key);
2137
2138 if (rt->u.dst.dev)
2139 NLA_PUT_U32(skb, RTA_OIF, rt->rt6i_dev->ifindex);
2140
2141 NLA_PUT_U32(skb, RTA_PRIORITY, rt->rt6i_metric);
2142
2143 expires = rt->rt6i_expires ? rt->rt6i_expires - jiffies : 0;
2144 if (rtnl_put_cacheinfo(skb, &rt->u.dst, 0, 0, 0,
2145 expires, rt->u.dst.error) < 0)
2146 goto nla_put_failure;
2147
2148 return nlmsg_end(skb, nlh);
2149
2150 nla_put_failure:
2151 nlmsg_cancel(skb, nlh);
2152 return -EMSGSIZE;
2153 }
2154
2155 int rt6_dump_route(struct rt6_info *rt, void *p_arg)
2156 {
2157 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
2158 int prefix;
2159
2160 if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
2161 struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
2162 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
2163 } else
2164 prefix = 0;
2165
2166 return rt6_fill_node(arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
2167 NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
2168 prefix, NLM_F_MULTI);
2169 }
2170
2171 static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
2172 {
2173 struct net *net = in_skb->sk->sk_net;
2174 struct nlattr *tb[RTA_MAX+1];
2175 struct rt6_info *rt;
2176 struct sk_buff *skb;
2177 struct rtmsg *rtm;
2178 struct flowi fl;
2179 int err, iif = 0;
2180
2181 if (net != &init_net)
2182 return -EINVAL;
2183
2184 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2185 if (err < 0)
2186 goto errout;
2187
2188 err = -EINVAL;
2189 memset(&fl, 0, sizeof(fl));
2190
2191 if (tb[RTA_SRC]) {
2192 if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2193 goto errout;
2194
2195 ipv6_addr_copy(&fl.fl6_src, nla_data(tb[RTA_SRC]));
2196 }
2197
2198 if (tb[RTA_DST]) {
2199 if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2200 goto errout;
2201
2202 ipv6_addr_copy(&fl.fl6_dst, nla_data(tb[RTA_DST]));
2203 }
2204
2205 if (tb[RTA_IIF])
2206 iif = nla_get_u32(tb[RTA_IIF]);
2207
2208 if (tb[RTA_OIF])
2209 fl.oif = nla_get_u32(tb[RTA_OIF]);
2210
2211 if (iif) {
2212 struct net_device *dev;
2213 dev = __dev_get_by_index(&init_net, iif);
2214 if (!dev) {
2215 err = -ENODEV;
2216 goto errout;
2217 }
2218 }
2219
2220 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2221 if (skb == NULL) {
2222 err = -ENOBUFS;
2223 goto errout;
2224 }
2225
2226 /* Reserve room for dummy headers, this skb can pass
2227 through good chunk of routing engine.
2228 */
2229 skb_reset_mac_header(skb);
2230 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
2231
2232 rt = (struct rt6_info*) ip6_route_output(NULL, &fl);
2233 skb->dst = &rt->u.dst;
2234
2235 err = rt6_fill_node(skb, rt, &fl.fl6_dst, &fl.fl6_src, iif,
2236 RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
2237 nlh->nlmsg_seq, 0, 0);
2238 if (err < 0) {
2239 kfree_skb(skb);
2240 goto errout;
2241 }
2242
2243 err = rtnl_unicast(skb, &init_net, NETLINK_CB(in_skb).pid);
2244 errout:
2245 return err;
2246 }
2247
2248 void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
2249 {
2250 struct sk_buff *skb;
2251 u32 seq;
2252 int err;
2253
2254 err = -ENOBUFS;
2255 seq = info->nlh != NULL ? info->nlh->nlmsg_seq : 0;
2256
2257 skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
2258 if (skb == NULL)
2259 goto errout;
2260
2261 err = rt6_fill_node(skb, rt, NULL, NULL, 0,
2262 event, info->pid, seq, 0, 0);
2263 if (err < 0) {
2264 /* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
2265 WARN_ON(err == -EMSGSIZE);
2266 kfree_skb(skb);
2267 goto errout;
2268 }
2269 err = rtnl_notify(skb, &init_net, info->pid,
2270 RTNLGRP_IPV6_ROUTE, info->nlh, gfp_any());
2271 errout:
2272 if (err < 0)
2273 rtnl_set_sk_err(&init_net, RTNLGRP_IPV6_ROUTE, err);
2274 }
2275
2276 /*
2277 * /proc
2278 */
2279
2280 #ifdef CONFIG_PROC_FS
2281
2282 #define RT6_INFO_LEN (32 + 4 + 32 + 4 + 32 + 40 + 5 + 1)
2283
2284 struct rt6_proc_arg
2285 {
2286 char *buffer;
2287 int offset;
2288 int length;
2289 int skip;
2290 int len;
2291 };
2292
2293 static int rt6_info_route(struct rt6_info *rt, void *p_arg)
2294 {
2295 struct seq_file *m = p_arg;
2296
2297 seq_printf(m, NIP6_SEQFMT " %02x ", NIP6(rt->rt6i_dst.addr),
2298 rt->rt6i_dst.plen);
2299
2300 #ifdef CONFIG_IPV6_SUBTREES
2301 seq_printf(m, NIP6_SEQFMT " %02x ", NIP6(rt->rt6i_src.addr),
2302 rt->rt6i_src.plen);
2303 #else
2304 seq_puts(m, "00000000000000000000000000000000 00 ");
2305 #endif
2306
2307 if (rt->rt6i_nexthop) {
2308 seq_printf(m, NIP6_SEQFMT,
2309 NIP6(*((struct in6_addr *)rt->rt6i_nexthop->primary_key)));
2310 } else {
2311 seq_puts(m, "00000000000000000000000000000000");
2312 }
2313 seq_printf(m, " %08x %08x %08x %08x %8s\n",
2314 rt->rt6i_metric, atomic_read(&rt->u.dst.__refcnt),
2315 rt->u.dst.__use, rt->rt6i_flags,
2316 rt->rt6i_dev ? rt->rt6i_dev->name : "");
2317 return 0;
2318 }
2319
2320 static int ipv6_route_show(struct seq_file *m, void *v)
2321 {
2322 struct net *net = (struct net *)m->private;
2323 fib6_clean_all(net, rt6_info_route, 0, m);
2324 return 0;
2325 }
2326
2327 static int ipv6_route_open(struct inode *inode, struct file *file)
2328 {
2329 struct net *net = get_proc_net(inode);
2330 if (!net)
2331 return -ENXIO;
2332 return single_open(file, ipv6_route_show, net);
2333 }
2334
2335 static int ipv6_route_release(struct inode *inode, struct file *file)
2336 {
2337 struct seq_file *seq = file->private_data;
2338 struct net *net = seq->private;
2339 put_net(net);
2340 return single_release(inode, file);
2341 }
2342
2343 static const struct file_operations ipv6_route_proc_fops = {
2344 .owner = THIS_MODULE,
2345 .open = ipv6_route_open,
2346 .read = seq_read,
2347 .llseek = seq_lseek,
2348 .release = ipv6_route_release,
2349 };
2350
2351 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
2352 {
2353 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
2354 rt6_stats.fib_nodes, rt6_stats.fib_route_nodes,
2355 rt6_stats.fib_rt_alloc, rt6_stats.fib_rt_entries,
2356 rt6_stats.fib_rt_cache,
2357 atomic_read(&ip6_dst_ops.entries),
2358 rt6_stats.fib_discarded_routes);
2359
2360 return 0;
2361 }
2362
2363 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
2364 {
2365 return single_open(file, rt6_stats_seq_show, NULL);
2366 }
2367
2368 static const struct file_operations rt6_stats_seq_fops = {
2369 .owner = THIS_MODULE,
2370 .open = rt6_stats_seq_open,
2371 .read = seq_read,
2372 .llseek = seq_lseek,
2373 .release = single_release,
2374 };
2375
2376 static int ipv6_route_proc_init(struct net *net)
2377 {
2378 int ret = -ENOMEM;
2379 if (!proc_net_fops_create(net, "ipv6_route",
2380 0, &ipv6_route_proc_fops))
2381 goto out;
2382
2383 if (!proc_net_fops_create(net, "rt6_stats",
2384 S_IRUGO, &rt6_stats_seq_fops))
2385 goto out_ipv6_route;
2386
2387 ret = 0;
2388 out:
2389 return ret;
2390 out_ipv6_route:
2391 proc_net_remove(net, "ipv6_route");
2392 goto out;
2393 }
2394
2395 static void ipv6_route_proc_fini(struct net *net)
2396 {
2397 proc_net_remove(net, "ipv6_route");
2398 proc_net_remove(net, "rt6_stats");
2399 }
2400 #else
2401 static inline int ipv6_route_proc_init(struct net *net)
2402 {
2403 return 0;
2404 }
2405 static inline void ipv6_route_proc_fini(struct net *net)
2406 {
2407 return ;
2408 }
2409 #endif /* CONFIG_PROC_FS */
2410
2411 #ifdef CONFIG_SYSCTL
2412
2413 static
2414 int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write, struct file * filp,
2415 void __user *buffer, size_t *lenp, loff_t *ppos)
2416 {
2417 struct net *net = current->nsproxy->net_ns;
2418 int delay = net->ipv6.sysctl.flush_delay;
2419 if (write) {
2420 proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
2421 fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay, net);
2422 return 0;
2423 } else
2424 return -EINVAL;
2425 }
2426
2427 ctl_table ipv6_route_table_template[] = {
2428 {
2429 .procname = "flush",
2430 .data = &init_net.ipv6.sysctl.flush_delay,
2431 .maxlen = sizeof(int),
2432 .mode = 0200,
2433 .proc_handler = &ipv6_sysctl_rtcache_flush
2434 },
2435 {
2436 .ctl_name = NET_IPV6_ROUTE_GC_THRESH,
2437 .procname = "gc_thresh",
2438 .data = &ip6_dst_ops.gc_thresh,
2439 .maxlen = sizeof(int),
2440 .mode = 0644,
2441 .proc_handler = &proc_dointvec,
2442 },
2443 {
2444 .ctl_name = NET_IPV6_ROUTE_MAX_SIZE,
2445 .procname = "max_size",
2446 .data = &init_net.ipv6.sysctl.ip6_rt_max_size,
2447 .maxlen = sizeof(int),
2448 .mode = 0644,
2449 .proc_handler = &proc_dointvec,
2450 },
2451 {
2452 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL,
2453 .procname = "gc_min_interval",
2454 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2455 .maxlen = sizeof(int),
2456 .mode = 0644,
2457 .proc_handler = &proc_dointvec_jiffies,
2458 .strategy = &sysctl_jiffies,
2459 },
2460 {
2461 .ctl_name = NET_IPV6_ROUTE_GC_TIMEOUT,
2462 .procname = "gc_timeout",
2463 .data = &init_net.ipv6.sysctl.ip6_rt_gc_timeout,
2464 .maxlen = sizeof(int),
2465 .mode = 0644,
2466 .proc_handler = &proc_dointvec_jiffies,
2467 .strategy = &sysctl_jiffies,
2468 },
2469 {
2470 .ctl_name = NET_IPV6_ROUTE_GC_INTERVAL,
2471 .procname = "gc_interval",
2472 .data = &init_net.ipv6.sysctl.ip6_rt_gc_interval,
2473 .maxlen = sizeof(int),
2474 .mode = 0644,
2475 .proc_handler = &proc_dointvec_jiffies,
2476 .strategy = &sysctl_jiffies,
2477 },
2478 {
2479 .ctl_name = NET_IPV6_ROUTE_GC_ELASTICITY,
2480 .procname = "gc_elasticity",
2481 .data = &init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
2482 .maxlen = sizeof(int),
2483 .mode = 0644,
2484 .proc_handler = &proc_dointvec_jiffies,
2485 .strategy = &sysctl_jiffies,
2486 },
2487 {
2488 .ctl_name = NET_IPV6_ROUTE_MTU_EXPIRES,
2489 .procname = "mtu_expires",
2490 .data = &init_net.ipv6.sysctl.ip6_rt_mtu_expires,
2491 .maxlen = sizeof(int),
2492 .mode = 0644,
2493 .proc_handler = &proc_dointvec_jiffies,
2494 .strategy = &sysctl_jiffies,
2495 },
2496 {
2497 .ctl_name = NET_IPV6_ROUTE_MIN_ADVMSS,
2498 .procname = "min_adv_mss",
2499 .data = &init_net.ipv6.sysctl.ip6_rt_min_advmss,
2500 .maxlen = sizeof(int),
2501 .mode = 0644,
2502 .proc_handler = &proc_dointvec_jiffies,
2503 .strategy = &sysctl_jiffies,
2504 },
2505 {
2506 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS,
2507 .procname = "gc_min_interval_ms",
2508 .data = &init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
2509 .maxlen = sizeof(int),
2510 .mode = 0644,
2511 .proc_handler = &proc_dointvec_ms_jiffies,
2512 .strategy = &sysctl_ms_jiffies,
2513 },
2514 { .ctl_name = 0 }
2515 };
2516
2517 struct ctl_table *ipv6_route_sysctl_init(struct net *net)
2518 {
2519 struct ctl_table *table;
2520
2521 table = kmemdup(ipv6_route_table_template,
2522 sizeof(ipv6_route_table_template),
2523 GFP_KERNEL);
2524
2525 if (table) {
2526 table[0].data = &net->ipv6.sysctl.flush_delay;
2527 /* table[1].data will be handled when we have
2528 routes per namespace */
2529 table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
2530 table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
2531 table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
2532 table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
2533 table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
2534 table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
2535 table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
2536 }
2537
2538 return table;
2539 }
2540 #endif
2541
2542 int __init ip6_route_init(void)
2543 {
2544 int ret;
2545
2546 ip6_dst_ops.kmem_cachep =
2547 kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
2548 SLAB_HWCACHE_ALIGN, NULL);
2549 if (!ip6_dst_ops.kmem_cachep)
2550 return -ENOMEM;
2551
2552 ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops.kmem_cachep;
2553
2554 ret = fib6_init();
2555 if (ret)
2556 goto out_kmem_cache;
2557
2558 ret = ipv6_route_proc_init(&init_net);
2559 if (ret)
2560 goto out_fib6_init;
2561
2562 ret = xfrm6_init();
2563 if (ret)
2564 goto out_proc_init;
2565
2566 ret = fib6_rules_init();
2567 if (ret)
2568 goto xfrm6_init;
2569
2570 ret = -ENOBUFS;
2571 if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL) ||
2572 __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL) ||
2573 __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL))
2574 goto fib6_rules_init;
2575
2576 ret = 0;
2577 out:
2578 return ret;
2579
2580 fib6_rules_init:
2581 fib6_rules_cleanup();
2582 xfrm6_init:
2583 xfrm6_fini();
2584 out_proc_init:
2585 ipv6_route_proc_fini(&init_net);
2586 out_fib6_init:
2587 rt6_ifdown(&init_net, NULL);
2588 fib6_gc_cleanup();
2589 out_kmem_cache:
2590 kmem_cache_destroy(ip6_dst_ops.kmem_cachep);
2591 goto out;
2592 }
2593
2594 void ip6_route_cleanup(void)
2595 {
2596 fib6_rules_cleanup();
2597 ipv6_route_proc_fini(&init_net);
2598 xfrm6_fini();
2599 rt6_ifdown(&init_net, NULL);
2600 fib6_gc_cleanup();
2601 kmem_cache_destroy(ip6_dst_ops.kmem_cachep);
2602 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree