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