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