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