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