?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] uml: remove a dead file
[linux-2.6/x86.git] / net / ipv6 / route.c
blobe0d3ad02ffb5afc5d412da05c7986942e7780685
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 */
26
27 #include <linux/capability.h>
28 #include <linux/config.h>
29 #include <linux/errno.h>
30 #include <linux/types.h>
31 #include <linux/times.h>
32 #include <linux/socket.h>
33 #include <linux/sockios.h>
34 #include <linux/net.h>
35 #include <linux/route.h>
36 #include <linux/netdevice.h>
37 #include <linux/in6.h>
38 #include <linux/init.h>
39 #include <linux/netlink.h>
40 #include <linux/if_arp.h>
41
42 #ifdef CONFIG_PROC_FS
43 #include <linux/proc_fs.h>
44 #include <linux/seq_file.h>
45 #endif
46
47 #include <net/snmp.h>
48 #include <net/ipv6.h>
49 #include <net/ip6_fib.h>
50 #include <net/ip6_route.h>
51 #include <net/ndisc.h>
52 #include <net/addrconf.h>
53 #include <net/tcp.h>
54 #include <linux/rtnetlink.h>
55 #include <net/dst.h>
56 #include <net/xfrm.h>
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
76 static int ip6_rt_max_size = 4096;
77 static int ip6_rt_gc_min_interval = HZ / 2;
78 static int ip6_rt_gc_timeout = 60*HZ;
79 int ip6_rt_gc_interval = 30*HZ;
80 static int ip6_rt_gc_elasticity = 9;
81 static int ip6_rt_mtu_expires = 10*60*HZ;
82 static int ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
83
84 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort);
85 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie);
86 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
87 static void ip6_dst_destroy(struct dst_entry *);
88 static void ip6_dst_ifdown(struct dst_entry *,
89 struct net_device *dev, int how);
90 static int ip6_dst_gc(void);
91
92 static int ip6_pkt_discard(struct sk_buff *skb);
93 static int ip6_pkt_discard_out(struct sk_buff *skb);
94 static void ip6_link_failure(struct sk_buff *skb);
95 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
96
97 static struct dst_ops ip6_dst_ops = {
98 .family = AF_INET6,
99 .protocol = __constant_htons(ETH_P_IPV6),
100 .gc = ip6_dst_gc,
101 .gc_thresh = 1024,
102 .check = ip6_dst_check,
103 .destroy = ip6_dst_destroy,
104 .ifdown = ip6_dst_ifdown,
105 .negative_advice = ip6_negative_advice,
106 .link_failure = ip6_link_failure,
107 .update_pmtu = ip6_rt_update_pmtu,
108 .entry_size = sizeof(struct rt6_info),
109 };
110
111 struct rt6_info ip6_null_entry = {
112 .u = {
113 .dst = {
114 .__refcnt = ATOMIC_INIT(1),
115 .__use = 1,
116 .dev = &loopback_dev,
117 .obsolete = -1,
118 .error = -ENETUNREACH,
119 .metrics = { [RTAX_HOPLIMIT - 1] = 255, },
120 .input = ip6_pkt_discard,
121 .output = ip6_pkt_discard_out,
122 .ops = &ip6_dst_ops,
123 .path = (struct dst_entry*)&ip6_null_entry,
124 }
125 },
126 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
127 .rt6i_metric = ~(u32) 0,
128 .rt6i_ref = ATOMIC_INIT(1),
129 };
130
131 struct fib6_node ip6_routing_table = {
132 .leaf = &ip6_null_entry,
133 .fn_flags = RTN_ROOT | RTN_TL_ROOT | RTN_RTINFO,
134 };
135
136 /* Protects all the ip6 fib */
137
138 DEFINE_RWLOCK(rt6_lock);
139
140
141 /* allocate dst with ip6_dst_ops */
142 static __inline__ struct rt6_info *ip6_dst_alloc(void)
143 {
144 return (struct rt6_info *)dst_alloc(&ip6_dst_ops);
145 }
146
147 static void ip6_dst_destroy(struct dst_entry *dst)
148 {
149 struct rt6_info *rt = (struct rt6_info *)dst;
150 struct inet6_dev *idev = rt->rt6i_idev;
151
152 if (idev != NULL) {
153 rt->rt6i_idev = NULL;
154 in6_dev_put(idev);
155 }
156 }
157
158 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
159 int how)
160 {
161 struct rt6_info *rt = (struct rt6_info *)dst;
162 struct inet6_dev *idev = rt->rt6i_idev;
163
164 if (dev != &loopback_dev && idev != NULL && idev->dev == dev) {
165 struct inet6_dev *loopback_idev = in6_dev_get(&loopback_dev);
166 if (loopback_idev != NULL) {
167 rt->rt6i_idev = loopback_idev;
168 in6_dev_put(idev);
169 }
170 }
171 }
172
173 static __inline__ int rt6_check_expired(const struct rt6_info *rt)
174 {
175 return (rt->rt6i_flags & RTF_EXPIRES &&
176 time_after(jiffies, rt->rt6i_expires));
177 }
178
179 /*
180 * Route lookup. Any rt6_lock is implied.
181 */
182
183 static __inline__ struct rt6_info *rt6_device_match(struct rt6_info *rt,
184 int oif,
185 int strict)
186 {
187 struct rt6_info *local = NULL;
188 struct rt6_info *sprt;
189
190 if (oif) {
191 for (sprt = rt; sprt; sprt = sprt->u.next) {
192 struct net_device *dev = sprt->rt6i_dev;
193 if (dev->ifindex == oif)
194 return sprt;
195 if (dev->flags & IFF_LOOPBACK) {
196 if (sprt->rt6i_idev == NULL ||
197 sprt->rt6i_idev->dev->ifindex != oif) {
198 if (strict && oif)
199 continue;
200 if (local && (!oif ||
201 local->rt6i_idev->dev->ifindex == oif))
202 continue;
203 }
204 local = sprt;
205 }
206 }
207
208 if (local)
209 return local;
210
211 if (strict)
212 return &ip6_null_entry;
213 }
214 return rt;
215 }
216
217 /*
218 * pointer to the last default router chosen. BH is disabled locally.
219 */
220 static struct rt6_info *rt6_dflt_pointer;
221 static DEFINE_SPINLOCK(rt6_dflt_lock);
222
223 void rt6_reset_dflt_pointer(struct rt6_info *rt)
224 {
225 spin_lock_bh(&rt6_dflt_lock);
226 if (rt == NULL || rt == rt6_dflt_pointer) {
227 RT6_TRACE("reset default router: %p->NULL\n", rt6_dflt_pointer);
228 rt6_dflt_pointer = NULL;
229 }
230 spin_unlock_bh(&rt6_dflt_lock);
231 }
232
233 /* Default Router Selection (RFC 2461 6.3.6) */
234 static struct rt6_info *rt6_best_dflt(struct rt6_info *rt, int oif)
235 {
236 struct rt6_info *match = NULL;
237 struct rt6_info *sprt;
238 int mpri = 0;
239
240 for (sprt = rt; sprt; sprt = sprt->u.next) {
241 struct neighbour *neigh;
242 int m = 0;
243
244 if (!oif ||
245 (sprt->rt6i_dev &&
246 sprt->rt6i_dev->ifindex == oif))
247 m += 8;
248
249 if (rt6_check_expired(sprt))
250 continue;
251
252 if (sprt == rt6_dflt_pointer)
253 m += 4;
254
255 if ((neigh = sprt->rt6i_nexthop) != NULL) {
256 read_lock_bh(&neigh->lock);
257 switch (neigh->nud_state) {
258 case NUD_REACHABLE:
259 m += 3;
260 break;
261
262 case NUD_STALE:
263 case NUD_DELAY:
264 case NUD_PROBE:
265 m += 2;
266 break;
267
268 case NUD_NOARP:
269 case NUD_PERMANENT:
270 m += 1;
271 break;
272
273 case NUD_INCOMPLETE:
274 default:
275 read_unlock_bh(&neigh->lock);
276 continue;
277 }
278 read_unlock_bh(&neigh->lock);
279 } else {
280 continue;
281 }
282
283 if (m > mpri || m >= 12) {
284 match = sprt;
285 mpri = m;
286 if (m >= 12) {
287 /* we choose the last default router if it
288 * is in (probably) reachable state.
289 * If route changed, we should do pmtu
290 * discovery. --yoshfuji
291 */
292 break;
293 }
294 }
295 }
296
297 spin_lock(&rt6_dflt_lock);
298 if (!match) {
299 /*
300 * No default routers are known to be reachable.
301 * SHOULD round robin
302 */
303 if (rt6_dflt_pointer) {
304 for (sprt = rt6_dflt_pointer->u.next;
305 sprt; sprt = sprt->u.next) {
306 if (sprt->u.dst.obsolete <= 0 &&
307 sprt->u.dst.error == 0 &&
308 !rt6_check_expired(sprt)) {
309 match = sprt;
310 break;
311 }
312 }
313 for (sprt = rt;
314 !match && sprt;
315 sprt = sprt->u.next) {
316 if (sprt->u.dst.obsolete <= 0 &&
317 sprt->u.dst.error == 0 &&
318 !rt6_check_expired(sprt)) {
319 match = sprt;
320 break;
321 }
322 if (sprt == rt6_dflt_pointer)
323 break;
324 }
325 }
326 }
327
328 if (match) {
329 if (rt6_dflt_pointer != match)
330 RT6_TRACE("changed default router: %p->%p\n",
331 rt6_dflt_pointer, match);
332 rt6_dflt_pointer = match;
333 }
334 spin_unlock(&rt6_dflt_lock);
335
336 if (!match) {
337 /*
338 * Last Resort: if no default routers found,
339 * use addrconf default route.
340 * We don't record this route.
341 */
342 for (sprt = ip6_routing_table.leaf;
343 sprt; sprt = sprt->u.next) {
344 if (!rt6_check_expired(sprt) &&
345 (sprt->rt6i_flags & RTF_DEFAULT) &&
346 (!oif ||
347 (sprt->rt6i_dev &&
348 sprt->rt6i_dev->ifindex == oif))) {
349 match = sprt;
350 break;
351 }
352 }
353 if (!match) {
354 /* no default route. give up. */
355 match = &ip6_null_entry;
356 }
357 }
358
359 return match;
360 }
361
362 struct rt6_info *rt6_lookup(struct in6_addr *daddr, struct in6_addr *saddr,
363 int oif, int strict)
364 {
365 struct fib6_node *fn;
366 struct rt6_info *rt;
367
368 read_lock_bh(&rt6_lock);
369 fn = fib6_lookup(&ip6_routing_table, daddr, saddr);
370 rt = rt6_device_match(fn->leaf, oif, strict);
371 dst_hold(&rt->u.dst);
372 rt->u.dst.__use++;
373 read_unlock_bh(&rt6_lock);
374
375 rt->u.dst.lastuse = jiffies;
376 if (rt->u.dst.error == 0)
377 return rt;
378 dst_release(&rt->u.dst);
379 return NULL;
380 }
381
382 /* ip6_ins_rt is called with FREE rt6_lock.
383 It takes new route entry, the addition fails by any reason the
384 route is freed. In any case, if caller does not hold it, it may
385 be destroyed.
386 */
387
388 int ip6_ins_rt(struct rt6_info *rt, struct nlmsghdr *nlh,
389 void *_rtattr, struct netlink_skb_parms *req)
390 {
391 int err;
392
393 write_lock_bh(&rt6_lock);
394 err = fib6_add(&ip6_routing_table, rt, nlh, _rtattr, req);
395 write_unlock_bh(&rt6_lock);
396
397 return err;
398 }
399
400 /* No rt6_lock! If COW failed, the function returns dead route entry
401 with dst->error set to errno value.
402 */
403
404 static struct rt6_info *rt6_cow(struct rt6_info *ort, struct in6_addr *daddr,
405 struct in6_addr *saddr, struct netlink_skb_parms *req)
406 {
407 int err;
408 struct rt6_info *rt;
409
410 /*
411 * Clone the route.
412 */
413
414 rt = ip6_rt_copy(ort);
415
416 if (rt) {
417 if (!(rt->rt6i_flags&RTF_GATEWAY)) {
418 if (rt->rt6i_dst.plen != 128 &&
419 ipv6_addr_equal(&rt->rt6i_dst.addr, daddr))
420 rt->rt6i_flags |= RTF_ANYCAST;
421 ipv6_addr_copy(&rt->rt6i_gateway, daddr);
422 }
423
424 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
425 rt->rt6i_dst.plen = 128;
426 rt->rt6i_flags |= RTF_CACHE;
427 rt->u.dst.flags |= DST_HOST;
428
429 #ifdef CONFIG_IPV6_SUBTREES
430 if (rt->rt6i_src.plen && saddr) {
431 ipv6_addr_copy(&rt->rt6i_src.addr, saddr);
432 rt->rt6i_src.plen = 128;
433 }
434 #endif
435
436 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
437
438 dst_hold(&rt->u.dst);
439
440 err = ip6_ins_rt(rt, NULL, NULL, req);
441 if (err == 0)
442 return rt;
443
444 rt->u.dst.error = err;
445
446 return rt;
447 }
448 dst_hold(&ip6_null_entry.u.dst);
449 return &ip6_null_entry;
450 }
451
452 #define BACKTRACK() \
453 if (rt == &ip6_null_entry && strict) { \
454 while ((fn = fn->parent) != NULL) { \
455 if (fn->fn_flags & RTN_ROOT) { \
456 dst_hold(&rt->u.dst); \
457 goto out; \
458 } \
459 if (fn->fn_flags & RTN_RTINFO) \
460 goto restart; \
461 } \
462 }
463
464
465 void ip6_route_input(struct sk_buff *skb)
466 {
467 struct fib6_node *fn;
468 struct rt6_info *rt;
469 int strict;
470 int attempts = 3;
471
472 strict = ipv6_addr_type(&skb->nh.ipv6h->daddr) & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL);
473
474 relookup:
475 read_lock_bh(&rt6_lock);
476
477 fn = fib6_lookup(&ip6_routing_table, &skb->nh.ipv6h->daddr,
478 &skb->nh.ipv6h->saddr);
479
480 restart:
481 rt = fn->leaf;
482
483 if ((rt->rt6i_flags & RTF_CACHE)) {
484 rt = rt6_device_match(rt, skb->dev->ifindex, strict);
485 BACKTRACK();
486 dst_hold(&rt->u.dst);
487 goto out;
488 }
489
490 rt = rt6_device_match(rt, skb->dev->ifindex, strict);
491 BACKTRACK();
492
493 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP)) {
494 struct rt6_info *nrt;
495 dst_hold(&rt->u.dst);
496 read_unlock_bh(&rt6_lock);
497
498 nrt = rt6_cow(rt, &skb->nh.ipv6h->daddr,
499 &skb->nh.ipv6h->saddr,
500 &NETLINK_CB(skb));
501
502 dst_release(&rt->u.dst);
503 rt = nrt;
504
505 if (rt->u.dst.error != -EEXIST || --attempts <= 0)
506 goto out2;
507
508 /* Race condition! In the gap, when rt6_lock was
509 released someone could insert this route. Relookup.
510 */
511 dst_release(&rt->u.dst);
512 goto relookup;
513 }
514 dst_hold(&rt->u.dst);
515
516 out:
517 read_unlock_bh(&rt6_lock);
518 out2:
519 rt->u.dst.lastuse = jiffies;
520 rt->u.dst.__use++;
521 skb->dst = (struct dst_entry *) rt;
522 }
523
524 struct dst_entry * ip6_route_output(struct sock *sk, struct flowi *fl)
525 {
526 struct fib6_node *fn;
527 struct rt6_info *rt;
528 int strict;
529 int attempts = 3;
530
531 strict = ipv6_addr_type(&fl->fl6_dst) & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL);
532
533 relookup:
534 read_lock_bh(&rt6_lock);
535
536 fn = fib6_lookup(&ip6_routing_table, &fl->fl6_dst, &fl->fl6_src);
537
538 restart:
539 rt = fn->leaf;
540
541 if ((rt->rt6i_flags & RTF_CACHE)) {
542 rt = rt6_device_match(rt, fl->oif, strict);
543 BACKTRACK();
544 dst_hold(&rt->u.dst);
545 goto out;
546 }
547 if (rt->rt6i_flags & RTF_DEFAULT) {
548 if (rt->rt6i_metric >= IP6_RT_PRIO_ADDRCONF)
549 rt = rt6_best_dflt(rt, fl->oif);
550 } else {
551 rt = rt6_device_match(rt, fl->oif, strict);
552 BACKTRACK();
553 }
554
555 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP)) {
556 struct rt6_info *nrt;
557 dst_hold(&rt->u.dst);
558 read_unlock_bh(&rt6_lock);
559
560 nrt = rt6_cow(rt, &fl->fl6_dst, &fl->fl6_src, NULL);
561
562 dst_release(&rt->u.dst);
563 rt = nrt;
564
565 if (rt->u.dst.error != -EEXIST || --attempts <= 0)
566 goto out2;
567
568 /* Race condition! In the gap, when rt6_lock was
569 released someone could insert this route. Relookup.
570 */
571 dst_release(&rt->u.dst);
572 goto relookup;
573 }
574 dst_hold(&rt->u.dst);
575
576 out:
577 read_unlock_bh(&rt6_lock);
578 out2:
579 rt->u.dst.lastuse = jiffies;
580 rt->u.dst.__use++;
581 return &rt->u.dst;
582 }
583
584
585 /*
586 * Destination cache support functions
587 */
588
589 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
590 {
591 struct rt6_info *rt;
592
593 rt = (struct rt6_info *) dst;
594
595 if (rt && rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
596 return dst;
597
598 return NULL;
599 }
600
601 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
602 {
603 struct rt6_info *rt = (struct rt6_info *) dst;
604
605 if (rt) {
606 if (rt->rt6i_flags & RTF_CACHE)
607 ip6_del_rt(rt, NULL, NULL, NULL);
608 else
609 dst_release(dst);
610 }
611 return NULL;
612 }
613
614 static void ip6_link_failure(struct sk_buff *skb)
615 {
616 struct rt6_info *rt;
617
618 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0, skb->dev);
619
620 rt = (struct rt6_info *) skb->dst;
621 if (rt) {
622 if (rt->rt6i_flags&RTF_CACHE) {
623 dst_set_expires(&rt->u.dst, 0);
624 rt->rt6i_flags |= RTF_EXPIRES;
625 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
626 rt->rt6i_node->fn_sernum = -1;
627 }
628 }
629
630 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
631 {
632 struct rt6_info *rt6 = (struct rt6_info*)dst;
633
634 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
635 rt6->rt6i_flags |= RTF_MODIFIED;
636 if (mtu < IPV6_MIN_MTU) {
637 mtu = IPV6_MIN_MTU;
638 dst->metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
639 }
640 dst->metrics[RTAX_MTU-1] = mtu;
641 }
642 }
643
644 /* Protected by rt6_lock. */
645 static struct dst_entry *ndisc_dst_gc_list;
646 static int ipv6_get_mtu(struct net_device *dev);
647
648 static inline unsigned int ipv6_advmss(unsigned int mtu)
649 {
650 mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
651
652 if (mtu < ip6_rt_min_advmss)
653 mtu = ip6_rt_min_advmss;
654
655 /*
656 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
657 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
658 * IPV6_MAXPLEN is also valid and means: "any MSS,
659 * rely only on pmtu discovery"
660 */
661 if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
662 mtu = IPV6_MAXPLEN;
663 return mtu;
664 }
665
666 struct dst_entry *ndisc_dst_alloc(struct net_device *dev,
667 struct neighbour *neigh,
668 struct in6_addr *addr,
669 int (*output)(struct sk_buff *))
670 {
671 struct rt6_info *rt;
672 struct inet6_dev *idev = in6_dev_get(dev);
673
674 if (unlikely(idev == NULL))
675 return NULL;
676
677 rt = ip6_dst_alloc();
678 if (unlikely(rt == NULL)) {
679 in6_dev_put(idev);
680 goto out;
681 }
682
683 dev_hold(dev);
684 if (neigh)
685 neigh_hold(neigh);
686 else
687 neigh = ndisc_get_neigh(dev, addr);
688
689 rt->rt6i_dev = dev;
690 rt->rt6i_idev = idev;
691 rt->rt6i_nexthop = neigh;
692 atomic_set(&rt->u.dst.__refcnt, 1);
693 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = 255;
694 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
695 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
696 rt->u.dst.output = output;
697
698 #if 0 /* there's no chance to use these for ndisc */
699 rt->u.dst.flags = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST
700 ? DST_HOST
701 : 0;
702 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
703 rt->rt6i_dst.plen = 128;
704 #endif
705
706 write_lock_bh(&rt6_lock);
707 rt->u.dst.next = ndisc_dst_gc_list;
708 ndisc_dst_gc_list = &rt->u.dst;
709 write_unlock_bh(&rt6_lock);
710
711 fib6_force_start_gc();
712
713 out:
714 return (struct dst_entry *)rt;
715 }
716
717 int ndisc_dst_gc(int *more)
718 {
719 struct dst_entry *dst, *next, **pprev;
720 int freed;
721
722 next = NULL;
723 pprev = &ndisc_dst_gc_list;
724 freed = 0;
725 while ((dst = *pprev) != NULL) {
726 if (!atomic_read(&dst->__refcnt)) {
727 *pprev = dst->next;
728 dst_free(dst);
729 freed++;
730 } else {
731 pprev = &dst->next;
732 (*more)++;
733 }
734 }
735
736 return freed;
737 }
738
739 static int ip6_dst_gc(void)
740 {
741 static unsigned expire = 30*HZ;
742 static unsigned long last_gc;
743 unsigned long now = jiffies;
744
745 if (time_after(last_gc + ip6_rt_gc_min_interval, now) &&
746 atomic_read(&ip6_dst_ops.entries) <= ip6_rt_max_size)
747 goto out;
748
749 expire++;
750 fib6_run_gc(expire);
751 last_gc = now;
752 if (atomic_read(&ip6_dst_ops.entries) < ip6_dst_ops.gc_thresh)
753 expire = ip6_rt_gc_timeout>>1;
754
755 out:
756 expire -= expire>>ip6_rt_gc_elasticity;
757 return (atomic_read(&ip6_dst_ops.entries) > ip6_rt_max_size);
758 }
759
760 /* Clean host part of a prefix. Not necessary in radix tree,
761 but results in cleaner routing tables.
762
763 Remove it only when all the things will work!
764 */
765
766 static int ipv6_get_mtu(struct net_device *dev)
767 {
768 int mtu = IPV6_MIN_MTU;
769 struct inet6_dev *idev;
770
771 idev = in6_dev_get(dev);
772 if (idev) {
773 mtu = idev->cnf.mtu6;
774 in6_dev_put(idev);
775 }
776 return mtu;
777 }
778
779 int ipv6_get_hoplimit(struct net_device *dev)
780 {
781 int hoplimit = ipv6_devconf.hop_limit;
782 struct inet6_dev *idev;
783
784 idev = in6_dev_get(dev);
785 if (idev) {
786 hoplimit = idev->cnf.hop_limit;
787 in6_dev_put(idev);
788 }
789 return hoplimit;
790 }
791
792 /*
793 *
794 */
795
796 int ip6_route_add(struct in6_rtmsg *rtmsg, struct nlmsghdr *nlh,
797 void *_rtattr, struct netlink_skb_parms *req)
798 {
799 int err;
800 struct rtmsg *r;
801 struct rtattr **rta;
802 struct rt6_info *rt = NULL;
803 struct net_device *dev = NULL;
804 struct inet6_dev *idev = NULL;
805 int addr_type;
806
807 rta = (struct rtattr **) _rtattr;
808
809 if (rtmsg->rtmsg_dst_len > 128 || rtmsg->rtmsg_src_len > 128)
810 return -EINVAL;
811 #ifndef CONFIG_IPV6_SUBTREES
812 if (rtmsg->rtmsg_src_len)
813 return -EINVAL;
814 #endif
815 if (rtmsg->rtmsg_ifindex) {
816 err = -ENODEV;
817 dev = dev_get_by_index(rtmsg->rtmsg_ifindex);
818 if (!dev)
819 goto out;
820 idev = in6_dev_get(dev);
821 if (!idev)
822 goto out;
823 }
824
825 if (rtmsg->rtmsg_metric == 0)
826 rtmsg->rtmsg_metric = IP6_RT_PRIO_USER;
827
828 rt = ip6_dst_alloc();
829
830 if (rt == NULL) {
831 err = -ENOMEM;
832 goto out;
833 }
834
835 rt->u.dst.obsolete = -1;
836 rt->rt6i_expires = jiffies + clock_t_to_jiffies(rtmsg->rtmsg_info);
837 if (nlh && (r = NLMSG_DATA(nlh))) {
838 rt->rt6i_protocol = r->rtm_protocol;
839 } else {
840 rt->rt6i_protocol = RTPROT_BOOT;
841 }
842
843 addr_type = ipv6_addr_type(&rtmsg->rtmsg_dst);
844
845 if (addr_type & IPV6_ADDR_MULTICAST)
846 rt->u.dst.input = ip6_mc_input;
847 else
848 rt->u.dst.input = ip6_forward;
849
850 rt->u.dst.output = ip6_output;
851
852 ipv6_addr_prefix(&rt->rt6i_dst.addr,
853 &rtmsg->rtmsg_dst, rtmsg->rtmsg_dst_len);
854 rt->rt6i_dst.plen = rtmsg->rtmsg_dst_len;
855 if (rt->rt6i_dst.plen == 128)
856 rt->u.dst.flags = DST_HOST;
857
858 #ifdef CONFIG_IPV6_SUBTREES
859 ipv6_addr_prefix(&rt->rt6i_src.addr,
860 &rtmsg->rtmsg_src, rtmsg->rtmsg_src_len);
861 rt->rt6i_src.plen = rtmsg->rtmsg_src_len;
862 #endif
863
864 rt->rt6i_metric = rtmsg->rtmsg_metric;
865
866 /* We cannot add true routes via loopback here,
867 they would result in kernel looping; promote them to reject routes
868 */
869 if ((rtmsg->rtmsg_flags&RTF_REJECT) ||
870 (dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK))) {
871 /* hold loopback dev/idev if we haven't done so. */
872 if (dev != &loopback_dev) {
873 if (dev) {
874 dev_put(dev);
875 in6_dev_put(idev);
876 }
877 dev = &loopback_dev;
878 dev_hold(dev);
879 idev = in6_dev_get(dev);
880 if (!idev) {
881 err = -ENODEV;
882 goto out;
883 }
884 }
885 rt->u.dst.output = ip6_pkt_discard_out;
886 rt->u.dst.input = ip6_pkt_discard;
887 rt->u.dst.error = -ENETUNREACH;
888 rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
889 goto install_route;
890 }
891
892 if (rtmsg->rtmsg_flags & RTF_GATEWAY) {
893 struct in6_addr *gw_addr;
894 int gwa_type;
895
896 gw_addr = &rtmsg->rtmsg_gateway;
897 ipv6_addr_copy(&rt->rt6i_gateway, &rtmsg->rtmsg_gateway);
898 gwa_type = ipv6_addr_type(gw_addr);
899
900 if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
901 struct rt6_info *grt;
902
903 /* IPv6 strictly inhibits using not link-local
904 addresses as nexthop address.
905 Otherwise, router will not able to send redirects.
906 It is very good, but in some (rare!) circumstances
907 (SIT, PtP, NBMA NOARP links) it is handy to allow
908 some exceptions. --ANK
909 */
910 err = -EINVAL;
911 if (!(gwa_type&IPV6_ADDR_UNICAST))
912 goto out;
913
914 grt = rt6_lookup(gw_addr, NULL, rtmsg->rtmsg_ifindex, 1);
915
916 err = -EHOSTUNREACH;
917 if (grt == NULL)
918 goto out;
919 if (dev) {
920 if (dev != grt->rt6i_dev) {
921 dst_release(&grt->u.dst);
922 goto out;
923 }
924 } else {
925 dev = grt->rt6i_dev;
926 idev = grt->rt6i_idev;
927 dev_hold(dev);
928 in6_dev_hold(grt->rt6i_idev);
929 }
930 if (!(grt->rt6i_flags&RTF_GATEWAY))
931 err = 0;
932 dst_release(&grt->u.dst);
933
934 if (err)
935 goto out;
936 }
937 err = -EINVAL;
938 if (dev == NULL || (dev->flags&IFF_LOOPBACK))
939 goto out;
940 }
941
942 err = -ENODEV;
943 if (dev == NULL)
944 goto out;
945
946 if (rtmsg->rtmsg_flags & (RTF_GATEWAY|RTF_NONEXTHOP)) {
947 rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);
948 if (IS_ERR(rt->rt6i_nexthop)) {
949 err = PTR_ERR(rt->rt6i_nexthop);
950 rt->rt6i_nexthop = NULL;
951 goto out;
952 }
953 }
954
955 rt->rt6i_flags = rtmsg->rtmsg_flags;
956
957 install_route:
958 if (rta && rta[RTA_METRICS-1]) {
959 int attrlen = RTA_PAYLOAD(rta[RTA_METRICS-1]);
960 struct rtattr *attr = RTA_DATA(rta[RTA_METRICS-1]);
961
962 while (RTA_OK(attr, attrlen)) {
963 unsigned flavor = attr->rta_type;
964 if (flavor) {
965 if (flavor > RTAX_MAX) {
966 err = -EINVAL;
967 goto out;
968 }
969 rt->u.dst.metrics[flavor-1] =
970 *(u32 *)RTA_DATA(attr);
971 }
972 attr = RTA_NEXT(attr, attrlen);
973 }
974 }
975
976 if (rt->u.dst.metrics[RTAX_HOPLIMIT-1] == 0)
977 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
978 if (!rt->u.dst.metrics[RTAX_MTU-1])
979 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(dev);
980 if (!rt->u.dst.metrics[RTAX_ADVMSS-1])
981 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
982 rt->u.dst.dev = dev;
983 rt->rt6i_idev = idev;
984 return ip6_ins_rt(rt, nlh, _rtattr, req);
985
986 out:
987 if (dev)
988 dev_put(dev);
989 if (idev)
990 in6_dev_put(idev);
991 if (rt)
992 dst_free((struct dst_entry *) rt);
993 return err;
994 }
995
996 int ip6_del_rt(struct rt6_info *rt, struct nlmsghdr *nlh, void *_rtattr, struct netlink_skb_parms *req)
997 {
998 int err;
999
1000 write_lock_bh(&rt6_lock);
1001
1002 rt6_reset_dflt_pointer(NULL);
1003
1004 err = fib6_del(rt, nlh, _rtattr, req);
1005 dst_release(&rt->u.dst);
1006
1007 write_unlock_bh(&rt6_lock);
1008
1009 return err;
1010 }
1011
1012 static int ip6_route_del(struct in6_rtmsg *rtmsg, struct nlmsghdr *nlh, void *_rtattr, struct netlink_skb_parms *req)
1013 {
1014 struct fib6_node *fn;
1015 struct rt6_info *rt;
1016 int err = -ESRCH;
1017
1018 read_lock_bh(&rt6_lock);
1019
1020 fn = fib6_locate(&ip6_routing_table,
1021 &rtmsg->rtmsg_dst, rtmsg->rtmsg_dst_len,
1022 &rtmsg->rtmsg_src, rtmsg->rtmsg_src_len);
1023
1024 if (fn) {
1025 for (rt = fn->leaf; rt; rt = rt->u.next) {
1026 if (rtmsg->rtmsg_ifindex &&
1027 (rt->rt6i_dev == NULL ||
1028 rt->rt6i_dev->ifindex != rtmsg->rtmsg_ifindex))
1029 continue;
1030 if (rtmsg->rtmsg_flags&RTF_GATEWAY &&
1031 !ipv6_addr_equal(&rtmsg->rtmsg_gateway, &rt->rt6i_gateway))
1032 continue;
1033 if (rtmsg->rtmsg_metric &&
1034 rtmsg->rtmsg_metric != rt->rt6i_metric)
1035 continue;
1036 dst_hold(&rt->u.dst);
1037 read_unlock_bh(&rt6_lock);
1038
1039 return ip6_del_rt(rt, nlh, _rtattr, req);
1040 }
1041 }
1042 read_unlock_bh(&rt6_lock);
1043
1044 return err;
1045 }
1046
1047 /*
1048 * Handle redirects
1049 */
1050 void rt6_redirect(struct in6_addr *dest, struct in6_addr *saddr,
1051 struct neighbour *neigh, u8 *lladdr, int on_link)
1052 {
1053 struct rt6_info *rt, *nrt;
1054
1055 /* Locate old route to this destination. */
1056 rt = rt6_lookup(dest, NULL, neigh->dev->ifindex, 1);
1057
1058 if (rt == NULL)
1059 return;
1060
1061 if (neigh->dev != rt->rt6i_dev)
1062 goto out;
1063
1064 /*
1065 * Current route is on-link; redirect is always invalid.
1066 *
1067 * Seems, previous statement is not true. It could
1068 * be node, which looks for us as on-link (f.e. proxy ndisc)
1069 * But then router serving it might decide, that we should
1070 * know truth 8)8) --ANK (980726).
1071 */
1072 if (!(rt->rt6i_flags&RTF_GATEWAY))
1073 goto out;
1074
1075 /*
1076 * RFC 2461 specifies that redirects should only be
1077 * accepted if they come from the nexthop to the target.
1078 * Due to the way default routers are chosen, this notion
1079 * is a bit fuzzy and one might need to check all default
1080 * routers.
1081 */
1082 if (!ipv6_addr_equal(saddr, &rt->rt6i_gateway)) {
1083 if (rt->rt6i_flags & RTF_DEFAULT) {
1084 struct rt6_info *rt1;
1085
1086 read_lock(&rt6_lock);
1087 for (rt1 = ip6_routing_table.leaf; rt1; rt1 = rt1->u.next) {
1088 if (ipv6_addr_equal(saddr, &rt1->rt6i_gateway)) {
1089 dst_hold(&rt1->u.dst);
1090 dst_release(&rt->u.dst);
1091 read_unlock(&rt6_lock);
1092 rt = rt1;
1093 goto source_ok;
1094 }
1095 }
1096 read_unlock(&rt6_lock);
1097 }
1098 if (net_ratelimit())
1099 printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
1100 "for redirect target\n");
1101 goto out;
1102 }
1103
1104 source_ok:
1105
1106 /*
1107 * We have finally decided to accept it.
1108 */
1109
1110 neigh_update(neigh, lladdr, NUD_STALE,
1111 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1112 NEIGH_UPDATE_F_OVERRIDE|
1113 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1114 NEIGH_UPDATE_F_ISROUTER))
1115 );
1116
1117 /*
1118 * Redirect received -> path was valid.
1119 * Look, redirects are sent only in response to data packets,
1120 * so that this nexthop apparently is reachable. --ANK
1121 */
1122 dst_confirm(&rt->u.dst);
1123
1124 /* Duplicate redirect: silently ignore. */
1125 if (neigh == rt->u.dst.neighbour)
1126 goto out;
1127
1128 nrt = ip6_rt_copy(rt);
1129 if (nrt == NULL)
1130 goto out;
1131
1132 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1133 if (on_link)
1134 nrt->rt6i_flags &= ~RTF_GATEWAY;
1135
1136 ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
1137 nrt->rt6i_dst.plen = 128;
1138 nrt->u.dst.flags |= DST_HOST;
1139
1140 ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
1141 nrt->rt6i_nexthop = neigh_clone(neigh);
1142 /* Reset pmtu, it may be better */
1143 nrt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(neigh->dev);
1144 nrt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&nrt->u.dst));
1145
1146 if (ip6_ins_rt(nrt, NULL, NULL, NULL))
1147 goto out;
1148
1149 if (rt->rt6i_flags&RTF_CACHE) {
1150 ip6_del_rt(rt, NULL, NULL, NULL);
1151 return;
1152 }
1153
1154 out:
1155 dst_release(&rt->u.dst);
1156 return;
1157 }
1158
1159 /*
1160 * Handle ICMP "packet too big" messages
1161 * i.e. Path MTU discovery
1162 */
1163
1164 void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
1165 struct net_device *dev, u32 pmtu)
1166 {
1167 struct rt6_info *rt, *nrt;
1168 int allfrag = 0;
1169
1170 rt = rt6_lookup(daddr, saddr, dev->ifindex, 0);
1171 if (rt == NULL)
1172 return;
1173
1174 if (pmtu >= dst_mtu(&rt->u.dst))
1175 goto out;
1176
1177 if (pmtu < IPV6_MIN_MTU) {
1178 /*
1179 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
1180 * MTU (1280) and a fragment header should always be included
1181 * after a node receiving Too Big message reporting PMTU is
1182 * less than the IPv6 Minimum Link MTU.
1183 */
1184 pmtu = IPV6_MIN_MTU;
1185 allfrag = 1;
1186 }
1187
1188 /* New mtu received -> path was valid.
1189 They are sent only in response to data packets,
1190 so that this nexthop apparently is reachable. --ANK
1191 */
1192 dst_confirm(&rt->u.dst);
1193
1194 /* Host route. If it is static, it would be better
1195 not to override it, but add new one, so that
1196 when cache entry will expire old pmtu
1197 would return automatically.
1198 */
1199 if (rt->rt6i_flags & RTF_CACHE) {
1200 rt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1201 if (allfrag)
1202 rt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1203 dst_set_expires(&rt->u.dst, ip6_rt_mtu_expires);
1204 rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
1205 goto out;
1206 }
1207
1208 /* Network route.
1209 Two cases are possible:
1210 1. It is connected route. Action: COW
1211 2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1212 */
1213 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP)) {
1214 nrt = rt6_cow(rt, daddr, saddr, NULL);
1215 if (!nrt->u.dst.error) {
1216 nrt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1217 if (allfrag)
1218 nrt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1219 /* According to RFC 1981, detecting PMTU increase shouldn't be
1220 happened within 5 mins, the recommended timer is 10 mins.
1221 Here this route expiration time is set to ip6_rt_mtu_expires
1222 which is 10 mins. After 10 mins the decreased pmtu is expired
1223 and detecting PMTU increase will be automatically happened.
1224 */
1225 dst_set_expires(&nrt->u.dst, ip6_rt_mtu_expires);
1226 nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
1227 }
1228 dst_release(&nrt->u.dst);
1229 } else {
1230 nrt = ip6_rt_copy(rt);
1231 if (nrt == NULL)
1232 goto out;
1233 ipv6_addr_copy(&nrt->rt6i_dst.addr, daddr);
1234 nrt->rt6i_dst.plen = 128;
1235 nrt->u.dst.flags |= DST_HOST;
1236 nrt->rt6i_nexthop = neigh_clone(rt->rt6i_nexthop);
1237 dst_set_expires(&nrt->u.dst, ip6_rt_mtu_expires);
1238 nrt->rt6i_flags |= RTF_DYNAMIC|RTF_CACHE|RTF_EXPIRES;
1239 nrt->u.dst.metrics[RTAX_MTU-1] = pmtu;
1240 if (allfrag)
1241 nrt->u.dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1242 ip6_ins_rt(nrt, NULL, NULL, NULL);
1243 }
1244
1245 out:
1246 dst_release(&rt->u.dst);
1247 }
1248
1249 /*
1250 * Misc support functions
1251 */
1252
1253 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
1254 {
1255 struct rt6_info *rt = ip6_dst_alloc();
1256
1257 if (rt) {
1258 rt->u.dst.input = ort->u.dst.input;
1259 rt->u.dst.output = ort->u.dst.output;
1260
1261 memcpy(rt->u.dst.metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
1262 rt->u.dst.dev = ort->u.dst.dev;
1263 if (rt->u.dst.dev)
1264 dev_hold(rt->u.dst.dev);
1265 rt->rt6i_idev = ort->rt6i_idev;
1266 if (rt->rt6i_idev)
1267 in6_dev_hold(rt->rt6i_idev);
1268 rt->u.dst.lastuse = jiffies;
1269 rt->rt6i_expires = 0;
1270
1271 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
1272 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
1273 rt->rt6i_metric = 0;
1274
1275 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1276 #ifdef CONFIG_IPV6_SUBTREES
1277 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1278 #endif
1279 }
1280 return rt;
1281 }
1282
1283 struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
1284 {
1285 struct rt6_info *rt;
1286 struct fib6_node *fn;
1287
1288 fn = &ip6_routing_table;
1289
1290 write_lock_bh(&rt6_lock);
1291 for (rt = fn->leaf; rt; rt=rt->u.next) {
1292 if (dev == rt->rt6i_dev &&
1293 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1294 break;
1295 }
1296 if (rt)
1297 dst_hold(&rt->u.dst);
1298 write_unlock_bh(&rt6_lock);
1299 return rt;
1300 }
1301
1302 struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
1303 struct net_device *dev)
1304 {
1305 struct in6_rtmsg rtmsg;
1306
1307 memset(&rtmsg, 0, sizeof(struct in6_rtmsg));
1308 rtmsg.rtmsg_type = RTMSG_NEWROUTE;
1309 ipv6_addr_copy(&rtmsg.rtmsg_gateway, gwaddr);
1310 rtmsg.rtmsg_metric = 1024;
1311 rtmsg.rtmsg_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT | RTF_UP | RTF_EXPIRES;
1312
1313 rtmsg.rtmsg_ifindex = dev->ifindex;
1314
1315 ip6_route_add(&rtmsg, NULL, NULL, NULL);
1316 return rt6_get_dflt_router(gwaddr, dev);
1317 }
1318
1319 void rt6_purge_dflt_routers(void)
1320 {
1321 struct rt6_info *rt;
1322
1323 restart:
1324 read_lock_bh(&rt6_lock);
1325 for (rt = ip6_routing_table.leaf; rt; rt = rt->u.next) {
1326 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1327 dst_hold(&rt->u.dst);
1328
1329 rt6_reset_dflt_pointer(NULL);
1330
1331 read_unlock_bh(&rt6_lock);
1332
1333 ip6_del_rt(rt, NULL, NULL, NULL);
1334
1335 goto restart;
1336 }
1337 }
1338 read_unlock_bh(&rt6_lock);
1339 }
1340
1341 int ipv6_route_ioctl(unsigned int cmd, void __user *arg)
1342 {
1343 struct in6_rtmsg rtmsg;
1344 int err;
1345
1346 switch(cmd) {
1347 case SIOCADDRT: /* Add a route */
1348 case SIOCDELRT: /* Delete a route */
1349 if (!capable(CAP_NET_ADMIN))
1350 return -EPERM;
1351 err = copy_from_user(&rtmsg, arg,
1352 sizeof(struct in6_rtmsg));
1353 if (err)
1354 return -EFAULT;
1355
1356 rtnl_lock();
1357 switch (cmd) {
1358 case SIOCADDRT:
1359 err = ip6_route_add(&rtmsg, NULL, NULL, NULL);
1360 break;
1361 case SIOCDELRT:
1362 err = ip6_route_del(&rtmsg, NULL, NULL, NULL);
1363 break;
1364 default:
1365 err = -EINVAL;
1366 }
1367 rtnl_unlock();
1368
1369 return err;
1370 };
1371
1372 return -EINVAL;
1373 }
1374
1375 /*
1376 * Drop the packet on the floor
1377 */
1378
1379 static int ip6_pkt_discard(struct sk_buff *skb)
1380 {
1381 IP6_INC_STATS(IPSTATS_MIB_OUTNOROUTES);
1382 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_NOROUTE, 0, skb->dev);
1383 kfree_skb(skb);
1384 return 0;
1385 }
1386
1387 static int ip6_pkt_discard_out(struct sk_buff *skb)
1388 {
1389 skb->dev = skb->dst->dev;
1390 return ip6_pkt_discard(skb);
1391 }
1392
1393 /*
1394 * Allocate a dst for local (unicast / anycast) address.
1395 */
1396
1397 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
1398 const struct in6_addr *addr,
1399 int anycast)
1400 {
1401 struct rt6_info *rt = ip6_dst_alloc();
1402
1403 if (rt == NULL)
1404 return ERR_PTR(-ENOMEM);
1405
1406 dev_hold(&loopback_dev);
1407 in6_dev_hold(idev);
1408
1409 rt->u.dst.flags = DST_HOST;
1410 rt->u.dst.input = ip6_input;
1411 rt->u.dst.output = ip6_output;
1412 rt->rt6i_dev = &loopback_dev;
1413 rt->rt6i_idev = idev;
1414 rt->u.dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
1415 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dst_mtu(&rt->u.dst));
1416 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = -1;
1417 rt->u.dst.obsolete = -1;
1418
1419 rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
1420 if (anycast)
1421 rt->rt6i_flags |= RTF_ANYCAST;
1422 else
1423 rt->rt6i_flags |= RTF_LOCAL;
1424 rt->rt6i_nexthop = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
1425 if (rt->rt6i_nexthop == NULL) {
1426 dst_free((struct dst_entry *) rt);
1427 return ERR_PTR(-ENOMEM);
1428 }
1429
1430 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1431 rt->rt6i_dst.plen = 128;
1432
1433 atomic_set(&rt->u.dst.__refcnt, 1);
1434
1435 return rt;
1436 }
1437
1438 static int fib6_ifdown(struct rt6_info *rt, void *arg)
1439 {
1440 if (((void*)rt->rt6i_dev == arg || arg == NULL) &&
1441 rt != &ip6_null_entry) {
1442 RT6_TRACE("deleted by ifdown %p\n", rt);
1443 return -1;
1444 }
1445 return 0;
1446 }
1447
1448 void rt6_ifdown(struct net_device *dev)
1449 {
1450 write_lock_bh(&rt6_lock);
1451 fib6_clean_tree(&ip6_routing_table, fib6_ifdown, 0, dev);
1452 write_unlock_bh(&rt6_lock);
1453 }
1454
1455 struct rt6_mtu_change_arg
1456 {
1457 struct net_device *dev;
1458 unsigned mtu;
1459 };
1460
1461 static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
1462 {
1463 struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
1464 struct inet6_dev *idev;
1465
1466 /* In IPv6 pmtu discovery is not optional,
1467 so that RTAX_MTU lock cannot disable it.
1468 We still use this lock to block changes
1469 caused by addrconf/ndisc.
1470 */
1471
1472 idev = __in6_dev_get(arg->dev);
1473 if (idev == NULL)
1474 return 0;
1475
1476 /* For administrative MTU increase, there is no way to discover
1477 IPv6 PMTU increase, so PMTU increase should be updated here.
1478 Since RFC 1981 doesn't include administrative MTU increase
1479 update PMTU increase is a MUST. (i.e. jumbo frame)
1480 */
1481 /*
1482 If new MTU is less than route PMTU, this new MTU will be the
1483 lowest MTU in the path, update the route PMTU to reflect PMTU
1484 decreases; if new MTU is greater than route PMTU, and the
1485 old MTU is the lowest MTU in the path, update the route PMTU
1486 to reflect the increase. In this case if the other nodes' MTU
1487 also have the lowest MTU, TOO BIG MESSAGE will be lead to
1488 PMTU discouvery.
1489 */
1490 if (rt->rt6i_dev == arg->dev &&
1491 !dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
1492 (dst_mtu(&rt->u.dst) > arg->mtu ||
1493 (dst_mtu(&rt->u.dst) < arg->mtu &&
1494 dst_mtu(&rt->u.dst) == idev->cnf.mtu6)))
1495 rt->u.dst.metrics[RTAX_MTU-1] = arg->mtu;
1496 rt->u.dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(arg->mtu);
1497 return 0;
1498 }
1499
1500 void rt6_mtu_change(struct net_device *dev, unsigned mtu)
1501 {
1502 struct rt6_mtu_change_arg arg;
1503
1504 arg.dev = dev;
1505 arg.mtu = mtu;
1506 read_lock_bh(&rt6_lock);
1507 fib6_clean_tree(&ip6_routing_table, rt6_mtu_change_route, 0, &arg);
1508 read_unlock_bh(&rt6_lock);
1509 }
1510
1511 static int inet6_rtm_to_rtmsg(struct rtmsg *r, struct rtattr **rta,
1512 struct in6_rtmsg *rtmsg)
1513 {
1514 memset(rtmsg, 0, sizeof(*rtmsg));
1515
1516 rtmsg->rtmsg_dst_len = r->rtm_dst_len;
1517 rtmsg->rtmsg_src_len = r->rtm_src_len;
1518 rtmsg->rtmsg_flags = RTF_UP;
1519 if (r->rtm_type == RTN_UNREACHABLE)
1520 rtmsg->rtmsg_flags |= RTF_REJECT;
1521
1522 if (rta[RTA_GATEWAY-1]) {
1523 if (rta[RTA_GATEWAY-1]->rta_len != RTA_LENGTH(16))
1524 return -EINVAL;
1525 memcpy(&rtmsg->rtmsg_gateway, RTA_DATA(rta[RTA_GATEWAY-1]), 16);
1526 rtmsg->rtmsg_flags |= RTF_GATEWAY;
1527 }
1528 if (rta[RTA_DST-1]) {
1529 if (RTA_PAYLOAD(rta[RTA_DST-1]) < ((r->rtm_dst_len+7)>>3))
1530 return -EINVAL;
1531 memcpy(&rtmsg->rtmsg_dst, RTA_DATA(rta[RTA_DST-1]), ((r->rtm_dst_len+7)>>3));
1532 }
1533 if (rta[RTA_SRC-1]) {
1534 if (RTA_PAYLOAD(rta[RTA_SRC-1]) < ((r->rtm_src_len+7)>>3))
1535 return -EINVAL;
1536 memcpy(&rtmsg->rtmsg_src, RTA_DATA(rta[RTA_SRC-1]), ((r->rtm_src_len+7)>>3));
1537 }
1538 if (rta[RTA_OIF-1]) {
1539 if (rta[RTA_OIF-1]->rta_len != RTA_LENGTH(sizeof(int)))
1540 return -EINVAL;
1541 memcpy(&rtmsg->rtmsg_ifindex, RTA_DATA(rta[RTA_OIF-1]), sizeof(int));
1542 }
1543 if (rta[RTA_PRIORITY-1]) {
1544 if (rta[RTA_PRIORITY-1]->rta_len != RTA_LENGTH(4))
1545 return -EINVAL;
1546 memcpy(&rtmsg->rtmsg_metric, RTA_DATA(rta[RTA_PRIORITY-1]), 4);
1547 }
1548 return 0;
1549 }
1550
1551 int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
1552 {
1553 struct rtmsg *r = NLMSG_DATA(nlh);
1554 struct in6_rtmsg rtmsg;
1555
1556 if (inet6_rtm_to_rtmsg(r, arg, &rtmsg))
1557 return -EINVAL;
1558 return ip6_route_del(&rtmsg, nlh, arg, &NETLINK_CB(skb));
1559 }
1560
1561 int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
1562 {
1563 struct rtmsg *r = NLMSG_DATA(nlh);
1564 struct in6_rtmsg rtmsg;
1565
1566 if (inet6_rtm_to_rtmsg(r, arg, &rtmsg))
1567 return -EINVAL;
1568 return ip6_route_add(&rtmsg, nlh, arg, &NETLINK_CB(skb));
1569 }
1570
1571 struct rt6_rtnl_dump_arg
1572 {
1573 struct sk_buff *skb;
1574 struct netlink_callback *cb;
1575 };
1576
1577 static int rt6_fill_node(struct sk_buff *skb, struct rt6_info *rt,
1578 struct in6_addr *dst, struct in6_addr *src,
1579 int iif, int type, u32 pid, u32 seq,
1580 int prefix, unsigned int flags)
1581 {
1582 struct rtmsg *rtm;
1583 struct nlmsghdr *nlh;
1584 unsigned char *b = skb->tail;
1585 struct rta_cacheinfo ci;
1586
1587 if (prefix) { /* user wants prefix routes only */
1588 if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
1589 /* success since this is not a prefix route */
1590 return 1;
1591 }
1592 }
1593
1594 nlh = NLMSG_NEW(skb, pid, seq, type, sizeof(*rtm), flags);
1595 rtm = NLMSG_DATA(nlh);
1596 rtm->rtm_family = AF_INET6;
1597 rtm->rtm_dst_len = rt->rt6i_dst.plen;
1598 rtm->rtm_src_len = rt->rt6i_src.plen;
1599 rtm->rtm_tos = 0;
1600 rtm->rtm_table = RT_TABLE_MAIN;
1601 if (rt->rt6i_flags&RTF_REJECT)
1602 rtm->rtm_type = RTN_UNREACHABLE;
1603 else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))
1604 rtm->rtm_type = RTN_LOCAL;
1605 else
1606 rtm->rtm_type = RTN_UNICAST;
1607 rtm->rtm_flags = 0;
1608 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
1609 rtm->rtm_protocol = rt->rt6i_protocol;
1610 if (rt->rt6i_flags&RTF_DYNAMIC)
1611 rtm->rtm_protocol = RTPROT_REDIRECT;
1612 else if (rt->rt6i_flags & RTF_ADDRCONF)
1613 rtm->rtm_protocol = RTPROT_KERNEL;
1614 else if (rt->rt6i_flags&RTF_DEFAULT)
1615 rtm->rtm_protocol = RTPROT_RA;
1616
1617 if (rt->rt6i_flags&RTF_CACHE)
1618 rtm->rtm_flags |= RTM_F_CLONED;
1619
1620 if (dst) {
1621 RTA_PUT(skb, RTA_DST, 16, dst);
1622 rtm->rtm_dst_len = 128;
1623 } else if (rtm->rtm_dst_len)
1624 RTA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);
1625 #ifdef CONFIG_IPV6_SUBTREES
1626 if (src) {
1627 RTA_PUT(skb, RTA_SRC, 16, src);
1628 rtm->rtm_src_len = 128;
1629 } else if (rtm->rtm_src_len)
1630 RTA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);
1631 #endif
1632 if (iif)
1633 RTA_PUT(skb, RTA_IIF, 4, &iif);
1634 else if (dst) {
1635 struct in6_addr saddr_buf;
1636 if (ipv6_get_saddr(&rt->u.dst, dst, &saddr_buf) == 0)
1637 RTA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);
1638 }
1639 if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
1640 goto rtattr_failure;
1641 if (rt->u.dst.neighbour)
1642 RTA_PUT(skb, RTA_GATEWAY, 16, &rt->u.dst.neighbour->primary_key);
1643 if (rt->u.dst.dev)
1644 RTA_PUT(skb, RTA_OIF, sizeof(int), &rt->rt6i_dev->ifindex);
1645 RTA_PUT(skb, RTA_PRIORITY, 4, &rt->rt6i_metric);
1646 ci.rta_lastuse = jiffies_to_clock_t(jiffies - rt->u.dst.lastuse);
1647 if (rt->rt6i_expires)
1648 ci.rta_expires = jiffies_to_clock_t(rt->rt6i_expires - jiffies);
1649 else
1650 ci.rta_expires = 0;
1651 ci.rta_used = rt->u.dst.__use;
1652 ci.rta_clntref = atomic_read(&rt->u.dst.__refcnt);
1653 ci.rta_error = rt->u.dst.error;
1654 ci.rta_id = 0;
1655 ci.rta_ts = 0;
1656 ci.rta_tsage = 0;
1657 RTA_PUT(skb, RTA_CACHEINFO, sizeof(ci), &ci);
1658 nlh->nlmsg_len = skb->tail - b;
1659 return skb->len;
1660
1661 nlmsg_failure:
1662 rtattr_failure:
1663 skb_trim(skb, b - skb->data);
1664 return -1;
1665 }
1666
1667 static int rt6_dump_route(struct rt6_info *rt, void *p_arg)
1668 {
1669 struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
1670 int prefix;
1671
1672 if (arg->cb->nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(struct rtmsg))) {
1673 struct rtmsg *rtm = NLMSG_DATA(arg->cb->nlh);
1674 prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
1675 } else
1676 prefix = 0;
1677
1678 return rt6_fill_node(arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
1679 NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
1680 prefix, NLM_F_MULTI);
1681 }
1682
1683 static int fib6_dump_node(struct fib6_walker_t *w)
1684 {
1685 int res;
1686 struct rt6_info *rt;
1687
1688 for (rt = w->leaf; rt; rt = rt->u.next) {
1689 res = rt6_dump_route(rt, w->args);
1690 if (res < 0) {
1691 /* Frame is full, suspend walking */
1692 w->leaf = rt;
1693 return 1;
1694 }
1695 BUG_TRAP(res!=0);
1696 }
1697 w->leaf = NULL;
1698 return 0;
1699 }
1700
1701 static void fib6_dump_end(struct netlink_callback *cb)
1702 {
1703 struct fib6_walker_t *w = (void*)cb->args[0];
1704
1705 if (w) {
1706 cb->args[0] = 0;
1707 fib6_walker_unlink(w);
1708 kfree(w);
1709 }
1710 cb->done = (void*)cb->args[1];
1711 cb->args[1] = 0;
1712 }
1713
1714 static int fib6_dump_done(struct netlink_callback *cb)
1715 {
1716 fib6_dump_end(cb);
1717 return cb->done ? cb->done(cb) : 0;
1718 }
1719
1720 int inet6_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
1721 {
1722 struct rt6_rtnl_dump_arg arg;
1723 struct fib6_walker_t *w;
1724 int res;
1725
1726 arg.skb = skb;
1727 arg.cb = cb;
1728
1729 w = (void*)cb->args[0];
1730 if (w == NULL) {
1731 /* New dump:
1732 *
1733 * 1. hook callback destructor.
1734 */
1735 cb->args[1] = (long)cb->done;
1736 cb->done = fib6_dump_done;
1737
1738 /*
1739 * 2. allocate and initialize walker.
1740 */
1741 w = kmalloc(sizeof(*w), GFP_ATOMIC);
1742 if (w == NULL)
1743 return -ENOMEM;
1744 RT6_TRACE("dump<%p", w);
1745 memset(w, 0, sizeof(*w));
1746 w->root = &ip6_routing_table;
1747 w->func = fib6_dump_node;
1748 w->args = &arg;
1749 cb->args[0] = (long)w;
1750 read_lock_bh(&rt6_lock);
1751 res = fib6_walk(w);
1752 read_unlock_bh(&rt6_lock);
1753 } else {
1754 w->args = &arg;
1755 read_lock_bh(&rt6_lock);
1756 res = fib6_walk_continue(w);
1757 read_unlock_bh(&rt6_lock);
1758 }
1759 #if RT6_DEBUG >= 3
1760 if (res <= 0 && skb->len == 0)
1761 RT6_TRACE("%p>dump end\n", w);
1762 #endif
1763 res = res < 0 ? res : skb->len;
1764 /* res < 0 is an error. (really, impossible)
1765 res == 0 means that dump is complete, but skb still can contain data.
1766 res > 0 dump is not complete, but frame is full.
1767 */
1768 /* Destroy walker, if dump of this table is complete. */
1769 if (res <= 0)
1770 fib6_dump_end(cb);
1771 return res;
1772 }
1773
1774 int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
1775 {
1776 struct rtattr **rta = arg;
1777 int iif = 0;
1778 int err = -ENOBUFS;
1779 struct sk_buff *skb;
1780 struct flowi fl;
1781 struct rt6_info *rt;
1782
1783 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
1784 if (skb == NULL)
1785 goto out;
1786
1787 /* Reserve room for dummy headers, this skb can pass
1788 through good chunk of routing engine.
1789 */
1790 skb->mac.raw = skb->data;
1791 skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
1792
1793 memset(&fl, 0, sizeof(fl));
1794 if (rta[RTA_SRC-1])
1795 ipv6_addr_copy(&fl.fl6_src,
1796 (struct in6_addr*)RTA_DATA(rta[RTA_SRC-1]));
1797 if (rta[RTA_DST-1])
1798 ipv6_addr_copy(&fl.fl6_dst,
1799 (struct in6_addr*)RTA_DATA(rta[RTA_DST-1]));
1800
1801 if (rta[RTA_IIF-1])
1802 memcpy(&iif, RTA_DATA(rta[RTA_IIF-1]), sizeof(int));
1803
1804 if (iif) {
1805 struct net_device *dev;
1806 dev = __dev_get_by_index(iif);
1807 if (!dev) {
1808 err = -ENODEV;
1809 goto out_free;
1810 }
1811 }
1812
1813 fl.oif = 0;
1814 if (rta[RTA_OIF-1])
1815 memcpy(&fl.oif, RTA_DATA(rta[RTA_OIF-1]), sizeof(int));
1816
1817 rt = (struct rt6_info*)ip6_route_output(NULL, &fl);
1818
1819 skb->dst = &rt->u.dst;
1820
1821 NETLINK_CB(skb).dst_pid = NETLINK_CB(in_skb).pid;
1822 err = rt6_fill_node(skb, rt,
1823 &fl.fl6_dst, &fl.fl6_src,
1824 iif,
1825 RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
1826 nlh->nlmsg_seq, 0, 0);
1827 if (err < 0) {
1828 err = -EMSGSIZE;
1829 goto out_free;
1830 }
1831
1832 err = netlink_unicast(rtnl, skb, NETLINK_CB(in_skb).pid, MSG_DONTWAIT);
1833 if (err > 0)
1834 err = 0;
1835 out:
1836 return err;
1837 out_free:
1838 kfree_skb(skb);
1839 goto out;
1840 }
1841
1842 void inet6_rt_notify(int event, struct rt6_info *rt, struct nlmsghdr *nlh,
1843 struct netlink_skb_parms *req)
1844 {
1845 struct sk_buff *skb;
1846 int size = NLMSG_SPACE(sizeof(struct rtmsg)+256);
1847 u32 pid = current->pid;
1848 u32 seq = 0;
1849
1850 if (req)
1851 pid = req->pid;
1852 if (nlh)
1853 seq = nlh->nlmsg_seq;
1854
1855 skb = alloc_skb(size, gfp_any());
1856 if (!skb) {
1857 netlink_set_err(rtnl, 0, RTNLGRP_IPV6_ROUTE, ENOBUFS);
1858 return;
1859 }
1860 if (rt6_fill_node(skb, rt, NULL, NULL, 0, event, pid, seq, 0, 0) < 0) {
1861 kfree_skb(skb);
1862 netlink_set_err(rtnl, 0, RTNLGRP_IPV6_ROUTE, EINVAL);
1863 return;
1864 }
1865 NETLINK_CB(skb).dst_group = RTNLGRP_IPV6_ROUTE;
1866 netlink_broadcast(rtnl, skb, 0, RTNLGRP_IPV6_ROUTE, gfp_any());
1867 }
1868
1869 /*
1870 * /proc
1871 */
1872
1873 #ifdef CONFIG_PROC_FS
1874
1875 #define RT6_INFO_LEN (32 + 4 + 32 + 4 + 32 + 40 + 5 + 1)
1876
1877 struct rt6_proc_arg
1878 {
1879 char *buffer;
1880 int offset;
1881 int length;
1882 int skip;
1883 int len;
1884 };
1885
1886 static int rt6_info_route(struct rt6_info *rt, void *p_arg)
1887 {
1888 struct rt6_proc_arg *arg = (struct rt6_proc_arg *) p_arg;
1889 int i;
1890
1891 if (arg->skip < arg->offset / RT6_INFO_LEN) {
1892 arg->skip++;
1893 return 0;
1894 }
1895
1896 if (arg->len >= arg->length)
1897 return 0;
1898
1899 for (i=0; i<16; i++) {
1900 sprintf(arg->buffer + arg->len, "%02x",
1901 rt->rt6i_dst.addr.s6_addr[i]);
1902 arg->len += 2;
1903 }
1904 arg->len += sprintf(arg->buffer + arg->len, " %02x ",
1905 rt->rt6i_dst.plen);
1906
1907 #ifdef CONFIG_IPV6_SUBTREES
1908 for (i=0; i<16; i++) {
1909 sprintf(arg->buffer + arg->len, "%02x",
1910 rt->rt6i_src.addr.s6_addr[i]);
1911 arg->len += 2;
1912 }
1913 arg->len += sprintf(arg->buffer + arg->len, " %02x ",
1914 rt->rt6i_src.plen);
1915 #else
1916 sprintf(arg->buffer + arg->len,
1917 "00000000000000000000000000000000 00 ");
1918 arg->len += 36;
1919 #endif
1920
1921 if (rt->rt6i_nexthop) {
1922 for (i=0; i<16; i++) {
1923 sprintf(arg->buffer + arg->len, "%02x",
1924 rt->rt6i_nexthop->primary_key[i]);
1925 arg->len += 2;
1926 }
1927 } else {
1928 sprintf(arg->buffer + arg->len,
1929 "00000000000000000000000000000000");
1930 arg->len += 32;
1931 }
1932 arg->len += sprintf(arg->buffer + arg->len,
1933 " %08x %08x %08x %08x %8s\n",
1934 rt->rt6i_metric, atomic_read(&rt->u.dst.__refcnt),
1935 rt->u.dst.__use, rt->rt6i_flags,
1936 rt->rt6i_dev ? rt->rt6i_dev->name : "");
1937 return 0;
1938 }
1939
1940 static int rt6_proc_info(char *buffer, char **start, off_t offset, int length)
1941 {
1942 struct rt6_proc_arg arg;
1943 arg.buffer = buffer;
1944 arg.offset = offset;
1945 arg.length = length;
1946 arg.skip = 0;
1947 arg.len = 0;
1948
1949 read_lock_bh(&rt6_lock);
1950 fib6_clean_tree(&ip6_routing_table, rt6_info_route, 0, &arg);
1951 read_unlock_bh(&rt6_lock);
1952
1953 *start = buffer;
1954 if (offset)
1955 *start += offset % RT6_INFO_LEN;
1956
1957 arg.len -= offset % RT6_INFO_LEN;
1958
1959 if (arg.len > length)
1960 arg.len = length;
1961 if (arg.len < 0)
1962 arg.len = 0;
1963
1964 return arg.len;
1965 }
1966
1967 static int rt6_stats_seq_show(struct seq_file *seq, void *v)
1968 {
1969 seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
1970 rt6_stats.fib_nodes, rt6_stats.fib_route_nodes,
1971 rt6_stats.fib_rt_alloc, rt6_stats.fib_rt_entries,
1972 rt6_stats.fib_rt_cache,
1973 atomic_read(&ip6_dst_ops.entries),
1974 rt6_stats.fib_discarded_routes);
1975
1976 return 0;
1977 }
1978
1979 static int rt6_stats_seq_open(struct inode *inode, struct file *file)
1980 {
1981 return single_open(file, rt6_stats_seq_show, NULL);
1982 }
1983
1984 static struct file_operations rt6_stats_seq_fops = {
1985 .owner = THIS_MODULE,
1986 .open = rt6_stats_seq_open,
1987 .read = seq_read,
1988 .llseek = seq_lseek,
1989 .release = single_release,
1990 };
1991 #endif /* CONFIG_PROC_FS */
1992
1993 #ifdef CONFIG_SYSCTL
1994
1995 static int flush_delay;
1996
1997 static
1998 int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write, struct file * filp,
1999 void __user *buffer, size_t *lenp, loff_t *ppos)
2000 {
2001 if (write) {
2002 proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
2003 fib6_run_gc(flush_delay <= 0 ? ~0UL : (unsigned long)flush_delay);
2004 return 0;
2005 } else
2006 return -EINVAL;
2007 }
2008
2009 ctl_table ipv6_route_table[] = {
2010 {
2011 .ctl_name = NET_IPV6_ROUTE_FLUSH,
2012 .procname = "flush",
2013 .data = &flush_delay,
2014 .maxlen = sizeof(int),
2015 .mode = 0200,
2016 .proc_handler = &ipv6_sysctl_rtcache_flush
2017 },
2018 {
2019 .ctl_name = NET_IPV6_ROUTE_GC_THRESH,
2020 .procname = "gc_thresh",
2021 .data = &ip6_dst_ops.gc_thresh,
2022 .maxlen = sizeof(int),
2023 .mode = 0644,
2024 .proc_handler = &proc_dointvec,
2025 },
2026 {
2027 .ctl_name = NET_IPV6_ROUTE_MAX_SIZE,
2028 .procname = "max_size",
2029 .data = &ip6_rt_max_size,
2030 .maxlen = sizeof(int),
2031 .mode = 0644,
2032 .proc_handler = &proc_dointvec,
2033 },
2034 {
2035 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL,
2036 .procname = "gc_min_interval",
2037 .data = &ip6_rt_gc_min_interval,
2038 .maxlen = sizeof(int),
2039 .mode = 0644,
2040 .proc_handler = &proc_dointvec_jiffies,
2041 .strategy = &sysctl_jiffies,
2042 },
2043 {
2044 .ctl_name = NET_IPV6_ROUTE_GC_TIMEOUT,
2045 .procname = "gc_timeout",
2046 .data = &ip6_rt_gc_timeout,
2047 .maxlen = sizeof(int),
2048 .mode = 0644,
2049 .proc_handler = &proc_dointvec_jiffies,
2050 .strategy = &sysctl_jiffies,
2051 },
2052 {
2053 .ctl_name = NET_IPV6_ROUTE_GC_INTERVAL,
2054 .procname = "gc_interval",
2055 .data = &ip6_rt_gc_interval,
2056 .maxlen = sizeof(int),
2057 .mode = 0644,
2058 .proc_handler = &proc_dointvec_jiffies,
2059 .strategy = &sysctl_jiffies,
2060 },
2061 {
2062 .ctl_name = NET_IPV6_ROUTE_GC_ELASTICITY,
2063 .procname = "gc_elasticity",
2064 .data = &ip6_rt_gc_elasticity,
2065 .maxlen = sizeof(int),
2066 .mode = 0644,
2067 .proc_handler = &proc_dointvec_jiffies,
2068 .strategy = &sysctl_jiffies,
2069 },
2070 {
2071 .ctl_name = NET_IPV6_ROUTE_MTU_EXPIRES,
2072 .procname = "mtu_expires",
2073 .data = &ip6_rt_mtu_expires,
2074 .maxlen = sizeof(int),
2075 .mode = 0644,
2076 .proc_handler = &proc_dointvec_jiffies,
2077 .strategy = &sysctl_jiffies,
2078 },
2079 {
2080 .ctl_name = NET_IPV6_ROUTE_MIN_ADVMSS,
2081 .procname = "min_adv_mss",
2082 .data = &ip6_rt_min_advmss,
2083 .maxlen = sizeof(int),
2084 .mode = 0644,
2085 .proc_handler = &proc_dointvec_jiffies,
2086 .strategy = &sysctl_jiffies,
2087 },
2088 {
2089 .ctl_name = NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS,
2090 .procname = "gc_min_interval_ms",
2091 .data = &ip6_rt_gc_min_interval,
2092 .maxlen = sizeof(int),
2093 .mode = 0644,
2094 .proc_handler = &proc_dointvec_ms_jiffies,
2095 .strategy = &sysctl_ms_jiffies,
2096 },
2097 { .ctl_name = 0 }
2098 };
2099
2100 #endif
2101
2102 void __init ip6_route_init(void)
2103 {
2104 struct proc_dir_entry *p;
2105
2106 ip6_dst_ops.kmem_cachep = kmem_cache_create("ip6_dst_cache",
2107 sizeof(struct rt6_info),
2108 0, SLAB_HWCACHE_ALIGN,
2109 NULL, NULL);
2110 if (!ip6_dst_ops.kmem_cachep)
2111 panic("cannot create ip6_dst_cache");
2112
2113 fib6_init();
2114 #ifdef CONFIG_PROC_FS
2115 p = proc_net_create("ipv6_route", 0, rt6_proc_info);
2116 if (p)
2117 p->owner = THIS_MODULE;
2118
2119 proc_net_fops_create("rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
2120 #endif
2121 #ifdef CONFIG_XFRM
2122 xfrm6_init();
2123 #endif
2124 }
2125
2126 void ip6_route_cleanup(void)
2127 {
2128 #ifdef CONFIG_PROC_FS
2129 proc_net_remove("ipv6_route");
2130 proc_net_remove("rt6_stats");
2131 #endif
2132 #ifdef CONFIG_XFRM
2133 xfrm6_fini();
2134 #endif
2135 rt6_ifdown(NULL);
2136 fib6_gc_cleanup();
2137 kmem_cache_destroy(ip6_dst_ops.kmem_cachep);
2138 }
x86 "subsystem" repository