?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
NFS: Prevent memory allocation failure in nfsacl_encode()
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / net / ipv6 / route.c
blob373bd0416f69f9ad7e4645eebb574a3ec4eb4127
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 unsigned int ip6_default_mtu(const struct dst_entry *dst);
81 static struct dst_entry *ip6_negative_advice(struct dst_entry *);
82 static void ip6_dst_destroy(struct dst_entry *);
83 static void ip6_dst_ifdown(struct dst_entry *,
84 struct net_device *dev, int how);
85 static int ip6_dst_gc(struct dst_ops *ops);
86
87 static int ip6_pkt_discard(struct sk_buff *skb);
88 static int ip6_pkt_discard_out(struct sk_buff *skb);
89 static void ip6_link_failure(struct sk_buff *skb);
90 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
91
92 #ifdef CONFIG_IPV6_ROUTE_INFO
93 static struct rt6_info *rt6_add_route_info(struct net *net,
94 struct in6_addr *prefix, int prefixlen,
95 struct in6_addr *gwaddr, int ifindex,
96 unsigned pref);
97 static struct rt6_info *rt6_get_route_info(struct net *net,
98 struct in6_addr *prefix, int prefixlen,
99 struct in6_addr *gwaddr, int ifindex);
100 #endif
101
102 static struct dst_ops ip6_dst_ops_template = {
103 .family = AF_INET6,
104 .protocol = cpu_to_be16(ETH_P_IPV6),
105 .gc = ip6_dst_gc,
106 .gc_thresh = 1024,
107 .check = ip6_dst_check,
108 .default_advmss = ip6_default_advmss,
109 .default_mtu = ip6_default_mtu,
110 .destroy = ip6_dst_destroy,
111 .ifdown = ip6_dst_ifdown,
112 .negative_advice = ip6_negative_advice,
113 .link_failure = ip6_link_failure,
114 .update_pmtu = ip6_rt_update_pmtu,
115 .local_out = __ip6_local_out,
116 };
117
118 static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu)
119 {
120 }
121
122 static struct dst_ops ip6_dst_blackhole_ops = {
123 .family = AF_INET6,
124 .protocol = cpu_to_be16(ETH_P_IPV6),
125 .destroy = ip6_dst_destroy,
126 .check = ip6_dst_check,
127 .update_pmtu = ip6_rt_blackhole_update_pmtu,
128 };
129
130 static struct rt6_info ip6_null_entry_template = {
131 .dst = {
132 .__refcnt = ATOMIC_INIT(1),
133 .__use = 1,
134 .obsolete = -1,
135 .error = -ENETUNREACH,
136 .input = ip6_pkt_discard,
137 .output = ip6_pkt_discard_out,
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 .dst = {
152 .__refcnt = ATOMIC_INIT(1),
153 .__use = 1,
154 .obsolete = -1,
155 .error = -EACCES,
156 .input = ip6_pkt_prohibit,
157 .output = ip6_pkt_prohibit_out,
158 },
159 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
160 .rt6i_protocol = RTPROT_KERNEL,
161 .rt6i_metric = ~(u32) 0,
162 .rt6i_ref = ATOMIC_INIT(1),
163 };
164
165 static struct rt6_info ip6_blk_hole_entry_template = {
166 .dst = {
167 .__refcnt = ATOMIC_INIT(1),
168 .__use = 1,
169 .obsolete = -1,
170 .error = -EINVAL,
171 .input = dst_discard,
172 .output = dst_discard,
173 },
174 .rt6i_flags = (RTF_REJECT | RTF_NONEXTHOP),
175 .rt6i_protocol = RTPROT_KERNEL,
176 .rt6i_metric = ~(u32) 0,
177 .rt6i_ref = ATOMIC_INIT(1),
178 };
179
180 #endif
181
182 /* allocate dst with ip6_dst_ops */
183 static inline struct rt6_info *ip6_dst_alloc(struct dst_ops *ops)
184 {
185 return (struct rt6_info *)dst_alloc(ops);
186 }
187
188 static void ip6_dst_destroy(struct dst_entry *dst)
189 {
190 struct rt6_info *rt = (struct rt6_info *)dst;
191 struct inet6_dev *idev = rt->rt6i_idev;
192 struct inet_peer *peer = rt->rt6i_peer;
193
194 if (idev != NULL) {
195 rt->rt6i_idev = NULL;
196 in6_dev_put(idev);
197 }
198 if (peer) {
199 BUG_ON(!(rt->rt6i_flags & RTF_CACHE));
200 rt->rt6i_peer = NULL;
201 inet_putpeer(peer);
202 }
203 }
204
205 void rt6_bind_peer(struct rt6_info *rt, int create)
206 {
207 struct inet_peer *peer;
208
209 if (WARN_ON(!(rt->rt6i_flags & RTF_CACHE)))
210 return;
211
212 peer = inet_getpeer_v6(&rt->rt6i_dst.addr, create);
213 if (peer && cmpxchg(&rt->rt6i_peer, NULL, peer) != NULL)
214 inet_putpeer(peer);
215 }
216
217 static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
218 int how)
219 {
220 struct rt6_info *rt = (struct rt6_info *)dst;
221 struct inet6_dev *idev = rt->rt6i_idev;
222 struct net_device *loopback_dev =
223 dev_net(dev)->loopback_dev;
224
225 if (dev != loopback_dev && idev != NULL && idev->dev == dev) {
226 struct inet6_dev *loopback_idev =
227 in6_dev_get(loopback_dev);
228 if (loopback_idev != NULL) {
229 rt->rt6i_idev = loopback_idev;
230 in6_dev_put(idev);
231 }
232 }
233 }
234
235 static __inline__ int rt6_check_expired(const struct rt6_info *rt)
236 {
237 return (rt->rt6i_flags & RTF_EXPIRES) &&
238 time_after(jiffies, rt->rt6i_expires);
239 }
240
241 static inline int rt6_need_strict(struct in6_addr *daddr)
242 {
243 return ipv6_addr_type(daddr) &
244 (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK);
245 }
246
247 /*
248 * Route lookup. Any table->tb6_lock is implied.
249 */
250
251 static inline struct rt6_info *rt6_device_match(struct net *net,
252 struct rt6_info *rt,
253 struct in6_addr *saddr,
254 int oif,
255 int flags)
256 {
257 struct rt6_info *local = NULL;
258 struct rt6_info *sprt;
259
260 if (!oif && ipv6_addr_any(saddr))
261 goto out;
262
263 for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
264 struct net_device *dev = sprt->rt6i_dev;
265
266 if (oif) {
267 if (dev->ifindex == oif)
268 return sprt;
269 if (dev->flags & IFF_LOOPBACK) {
270 if (sprt->rt6i_idev == NULL ||
271 sprt->rt6i_idev->dev->ifindex != oif) {
272 if (flags & RT6_LOOKUP_F_IFACE && oif)
273 continue;
274 if (local && (!oif ||
275 local->rt6i_idev->dev->ifindex == oif))
276 continue;
277 }
278 local = sprt;
279 }
280 } else {
281 if (ipv6_chk_addr(net, saddr, dev,
282 flags & RT6_LOOKUP_F_IFACE))
283 return sprt;
284 }
285 }
286
287 if (oif) {
288 if (local)
289 return local;
290
291 if (flags & RT6_LOOKUP_F_IFACE)
292 return net->ipv6.ip6_null_entry;
293 }
294 out:
295 return rt;
296 }
297
298 #ifdef CONFIG_IPV6_ROUTER_PREF
299 static void rt6_probe(struct rt6_info *rt)
300 {
301 struct neighbour *neigh = rt ? rt->rt6i_nexthop : NULL;
302 /*
303 * Okay, this does not seem to be appropriate
304 * for now, however, we need to check if it
305 * is really so; aka Router Reachability Probing.
306 *
307 * Router Reachability Probe MUST be rate-limited
308 * to no more than one per minute.
309 */
310 if (!neigh || (neigh->nud_state & NUD_VALID))
311 return;
312 read_lock_bh(&neigh->lock);
313 if (!(neigh->nud_state & NUD_VALID) &&
314 time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
315 struct in6_addr mcaddr;
316 struct in6_addr *target;
317
318 neigh->updated = jiffies;
319 read_unlock_bh(&neigh->lock);
320
321 target = (struct in6_addr *)&neigh->primary_key;
322 addrconf_addr_solict_mult(target, &mcaddr);
323 ndisc_send_ns(rt->rt6i_dev, NULL, target, &mcaddr, NULL);
324 } else
325 read_unlock_bh(&neigh->lock);
326 }
327 #else
328 static inline void rt6_probe(struct rt6_info *rt)
329 {
330 }
331 #endif
332
333 /*
334 * Default Router Selection (RFC 2461 6.3.6)
335 */
336 static inline int rt6_check_dev(struct rt6_info *rt, int oif)
337 {
338 struct net_device *dev = rt->rt6i_dev;
339 if (!oif || dev->ifindex == oif)
340 return 2;
341 if ((dev->flags & IFF_LOOPBACK) &&
342 rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
343 return 1;
344 return 0;
345 }
346
347 static inline int rt6_check_neigh(struct rt6_info *rt)
348 {
349 struct neighbour *neigh = rt->rt6i_nexthop;
350 int m;
351 if (rt->rt6i_flags & RTF_NONEXTHOP ||
352 !(rt->rt6i_flags & RTF_GATEWAY))
353 m = 1;
354 else if (neigh) {
355 read_lock_bh(&neigh->lock);
356 if (neigh->nud_state & NUD_VALID)
357 m = 2;
358 #ifdef CONFIG_IPV6_ROUTER_PREF
359 else if (neigh->nud_state & NUD_FAILED)
360 m = 0;
361 #endif
362 else
363 m = 1;
364 read_unlock_bh(&neigh->lock);
365 } else
366 m = 0;
367 return m;
368 }
369
370 static int rt6_score_route(struct rt6_info *rt, int oif,
371 int strict)
372 {
373 int m, n;
374
375 m = rt6_check_dev(rt, oif);
376 if (!m && (strict & RT6_LOOKUP_F_IFACE))
377 return -1;
378 #ifdef CONFIG_IPV6_ROUTER_PREF
379 m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
380 #endif
381 n = rt6_check_neigh(rt);
382 if (!n && (strict & RT6_LOOKUP_F_REACHABLE))
383 return -1;
384 return m;
385 }
386
387 static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
388 int *mpri, struct rt6_info *match)
389 {
390 int m;
391
392 if (rt6_check_expired(rt))
393 goto out;
394
395 m = rt6_score_route(rt, oif, strict);
396 if (m < 0)
397 goto out;
398
399 if (m > *mpri) {
400 if (strict & RT6_LOOKUP_F_REACHABLE)
401 rt6_probe(match);
402 *mpri = m;
403 match = rt;
404 } else if (strict & RT6_LOOKUP_F_REACHABLE) {
405 rt6_probe(rt);
406 }
407
408 out:
409 return match;
410 }
411
412 static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
413 struct rt6_info *rr_head,
414 u32 metric, int oif, int strict)
415 {
416 struct rt6_info *rt, *match;
417 int mpri = -1;
418
419 match = NULL;
420 for (rt = rr_head; rt && rt->rt6i_metric == metric;
421 rt = rt->dst.rt6_next)
422 match = find_match(rt, oif, strict, &mpri, match);
423 for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
424 rt = rt->dst.rt6_next)
425 match = find_match(rt, oif, strict, &mpri, match);
426
427 return match;
428 }
429
430 static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
431 {
432 struct rt6_info *match, *rt0;
433 struct net *net;
434
435 RT6_TRACE("%s(fn->leaf=%p, oif=%d)\n",
436 __func__, fn->leaf, oif);
437
438 rt0 = fn->rr_ptr;
439 if (!rt0)
440 fn->rr_ptr = rt0 = fn->leaf;
441
442 match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict);
443
444 if (!match &&
445 (strict & RT6_LOOKUP_F_REACHABLE)) {
446 struct rt6_info *next = rt0->dst.rt6_next;
447
448 /* no entries matched; do round-robin */
449 if (!next || next->rt6i_metric != rt0->rt6i_metric)
450 next = fn->leaf;
451
452 if (next != rt0)
453 fn->rr_ptr = next;
454 }
455
456 RT6_TRACE("%s() => %p\n",
457 __func__, match);
458
459 net = dev_net(rt0->rt6i_dev);
460 return match ? match : net->ipv6.ip6_null_entry;
461 }
462
463 #ifdef CONFIG_IPV6_ROUTE_INFO
464 int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
465 struct in6_addr *gwaddr)
466 {
467 struct net *net = dev_net(dev);
468 struct route_info *rinfo = (struct route_info *) opt;
469 struct in6_addr prefix_buf, *prefix;
470 unsigned int pref;
471 unsigned long lifetime;
472 struct rt6_info *rt;
473
474 if (len < sizeof(struct route_info)) {
475 return -EINVAL;
476 }
477
478 /* Sanity check for prefix_len and length */
479 if (rinfo->length > 3) {
480 return -EINVAL;
481 } else if (rinfo->prefix_len > 128) {
482 return -EINVAL;
483 } else if (rinfo->prefix_len > 64) {
484 if (rinfo->length < 2) {
485 return -EINVAL;
486 }
487 } else if (rinfo->prefix_len > 0) {
488 if (rinfo->length < 1) {
489 return -EINVAL;
490 }
491 }
492
493 pref = rinfo->route_pref;
494 if (pref == ICMPV6_ROUTER_PREF_INVALID)
495 return -EINVAL;
496
497 lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
498
499 if (rinfo->length == 3)
500 prefix = (struct in6_addr *)rinfo->prefix;
501 else {
502 /* this function is safe */
503 ipv6_addr_prefix(&prefix_buf,
504 (struct in6_addr *)rinfo->prefix,
505 rinfo->prefix_len);
506 prefix = &prefix_buf;
507 }
508
509 rt = rt6_get_route_info(net, prefix, rinfo->prefix_len, gwaddr,
510 dev->ifindex);
511
512 if (rt && !lifetime) {
513 ip6_del_rt(rt);
514 rt = NULL;
515 }
516
517 if (!rt && lifetime)
518 rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
519 pref);
520 else if (rt)
521 rt->rt6i_flags = RTF_ROUTEINFO |
522 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
523
524 if (rt) {
525 if (!addrconf_finite_timeout(lifetime)) {
526 rt->rt6i_flags &= ~RTF_EXPIRES;
527 } else {
528 rt->rt6i_expires = jiffies + HZ * lifetime;
529 rt->rt6i_flags |= RTF_EXPIRES;
530 }
531 dst_release(&rt->dst);
532 }
533 return 0;
534 }
535 #endif
536
537 #define BACKTRACK(__net, saddr) \
538 do { \
539 if (rt == __net->ipv6.ip6_null_entry) { \
540 struct fib6_node *pn; \
541 while (1) { \
542 if (fn->fn_flags & RTN_TL_ROOT) \
543 goto out; \
544 pn = fn->parent; \
545 if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
546 fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
547 else \
548 fn = pn; \
549 if (fn->fn_flags & RTN_RTINFO) \
550 goto restart; \
551 } \
552 } \
553 } while(0)
554
555 static struct rt6_info *ip6_pol_route_lookup(struct net *net,
556 struct fib6_table *table,
557 struct flowi *fl, int flags)
558 {
559 struct fib6_node *fn;
560 struct rt6_info *rt;
561
562 read_lock_bh(&table->tb6_lock);
563 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
564 restart:
565 rt = fn->leaf;
566 rt = rt6_device_match(net, rt, &fl->fl6_src, fl->oif, flags);
567 BACKTRACK(net, &fl->fl6_src);
568 out:
569 dst_use(&rt->dst, jiffies);
570 read_unlock_bh(&table->tb6_lock);
571 return rt;
572
573 }
574
575 struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
576 const struct in6_addr *saddr, int oif, int strict)
577 {
578 struct flowi fl = {
579 .oif = oif,
580 .fl6_dst = *daddr,
581 };
582 struct dst_entry *dst;
583 int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
584
585 if (saddr) {
586 memcpy(&fl.fl6_src, saddr, sizeof(*saddr));
587 flags |= RT6_LOOKUP_F_HAS_SADDR;
588 }
589
590 dst = fib6_rule_lookup(net, &fl, flags, ip6_pol_route_lookup);
591 if (dst->error == 0)
592 return (struct rt6_info *) dst;
593
594 dst_release(dst);
595
596 return NULL;
597 }
598
599 EXPORT_SYMBOL(rt6_lookup);
600
601 /* ip6_ins_rt is called with FREE table->tb6_lock.
602 It takes new route entry, the addition fails by any reason the
603 route is freed. In any case, if caller does not hold it, it may
604 be destroyed.
605 */
606
607 static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
608 {
609 int err;
610 struct fib6_table *table;
611
612 table = rt->rt6i_table;
613 write_lock_bh(&table->tb6_lock);
614 err = fib6_add(&table->tb6_root, rt, info);
615 write_unlock_bh(&table->tb6_lock);
616
617 return err;
618 }
619
620 int ip6_ins_rt(struct rt6_info *rt)
621 {
622 struct nl_info info = {
623 .nl_net = dev_net(rt->rt6i_dev),
624 };
625 return __ip6_ins_rt(rt, &info);
626 }
627
628 static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,
629 struct in6_addr *saddr)
630 {
631 struct rt6_info *rt;
632
633 /*
634 * Clone the route.
635 */
636
637 rt = ip6_rt_copy(ort);
638
639 if (rt) {
640 struct neighbour *neigh;
641 int attempts = !in_softirq();
642
643 if (!(rt->rt6i_flags&RTF_GATEWAY)) {
644 if (rt->rt6i_dst.plen != 128 &&
645 ipv6_addr_equal(&rt->rt6i_dst.addr, daddr))
646 rt->rt6i_flags |= RTF_ANYCAST;
647 ipv6_addr_copy(&rt->rt6i_gateway, daddr);
648 }
649
650 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
651 rt->rt6i_dst.plen = 128;
652 rt->rt6i_flags |= RTF_CACHE;
653 rt->dst.flags |= DST_HOST;
654
655 #ifdef CONFIG_IPV6_SUBTREES
656 if (rt->rt6i_src.plen && saddr) {
657 ipv6_addr_copy(&rt->rt6i_src.addr, saddr);
658 rt->rt6i_src.plen = 128;
659 }
660 #endif
661
662 retry:
663 neigh = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
664 if (IS_ERR(neigh)) {
665 struct net *net = dev_net(rt->rt6i_dev);
666 int saved_rt_min_interval =
667 net->ipv6.sysctl.ip6_rt_gc_min_interval;
668 int saved_rt_elasticity =
669 net->ipv6.sysctl.ip6_rt_gc_elasticity;
670
671 if (attempts-- > 0) {
672 net->ipv6.sysctl.ip6_rt_gc_elasticity = 1;
673 net->ipv6.sysctl.ip6_rt_gc_min_interval = 0;
674
675 ip6_dst_gc(&net->ipv6.ip6_dst_ops);
676
677 net->ipv6.sysctl.ip6_rt_gc_elasticity =
678 saved_rt_elasticity;
679 net->ipv6.sysctl.ip6_rt_gc_min_interval =
680 saved_rt_min_interval;
681 goto retry;
682 }
683
684 if (net_ratelimit())
685 printk(KERN_WARNING
686 "ipv6: Neighbour table overflow.\n");
687 dst_free(&rt->dst);
688 return NULL;
689 }
690 rt->rt6i_nexthop = neigh;
691
692 }
693
694 return rt;
695 }
696
697 static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)
698 {
699 struct rt6_info *rt = ip6_rt_copy(ort);
700 if (rt) {
701 ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
702 rt->rt6i_dst.plen = 128;
703 rt->rt6i_flags |= RTF_CACHE;
704 rt->dst.flags |= DST_HOST;
705 rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);
706 }
707 return rt;
708 }
709
710 static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
711 struct flowi *fl, int flags)
712 {
713 struct fib6_node *fn;
714 struct rt6_info *rt, *nrt;
715 int strict = 0;
716 int attempts = 3;
717 int err;
718 int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
719
720 strict |= flags & RT6_LOOKUP_F_IFACE;
721
722 relookup:
723 read_lock_bh(&table->tb6_lock);
724
725 restart_2:
726 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
727
728 restart:
729 rt = rt6_select(fn, oif, strict | reachable);
730
731 BACKTRACK(net, &fl->fl6_src);
732 if (rt == net->ipv6.ip6_null_entry ||
733 rt->rt6i_flags & RTF_CACHE)
734 goto out;
735
736 dst_hold(&rt->dst);
737 read_unlock_bh(&table->tb6_lock);
738
739 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
740 nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
741 else {
742 #if CLONE_OFFLINK_ROUTE
743 nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
744 #else
745 goto out2;
746 #endif
747 }
748
749 dst_release(&rt->dst);
750 rt = nrt ? : net->ipv6.ip6_null_entry;
751
752 dst_hold(&rt->dst);
753 if (nrt) {
754 err = ip6_ins_rt(nrt);
755 if (!err)
756 goto out2;
757 }
758
759 if (--attempts <= 0)
760 goto out2;
761
762 /*
763 * Race condition! In the gap, when table->tb6_lock was
764 * released someone could insert this route. Relookup.
765 */
766 dst_release(&rt->dst);
767 goto relookup;
768
769 out:
770 if (reachable) {
771 reachable = 0;
772 goto restart_2;
773 }
774 dst_hold(&rt->dst);
775 read_unlock_bh(&table->tb6_lock);
776 out2:
777 rt->dst.lastuse = jiffies;
778 rt->dst.__use++;
779
780 return rt;
781 }
782
783 static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
784 struct flowi *fl, int flags)
785 {
786 return ip6_pol_route(net, table, fl->iif, fl, flags);
787 }
788
789 void ip6_route_input(struct sk_buff *skb)
790 {
791 struct ipv6hdr *iph = ipv6_hdr(skb);
792 struct net *net = dev_net(skb->dev);
793 int flags = RT6_LOOKUP_F_HAS_SADDR;
794 struct flowi fl = {
795 .iif = skb->dev->ifindex,
796 .fl6_dst = iph->daddr,
797 .fl6_src = iph->saddr,
798 .fl6_flowlabel = (* (__be32 *) iph)&IPV6_FLOWINFO_MASK,
799 .mark = skb->mark,
800 .proto = iph->nexthdr,
801 };
802
803 if (rt6_need_strict(&iph->daddr) && skb->dev->type != ARPHRD_PIMREG)
804 flags |= RT6_LOOKUP_F_IFACE;
805
806 skb_dst_set(skb, fib6_rule_lookup(net, &fl, flags, ip6_pol_route_input));
807 }
808
809 static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
810 struct flowi *fl, int flags)
811 {
812 return ip6_pol_route(net, table, fl->oif, fl, flags);
813 }
814
815 struct dst_entry * ip6_route_output(struct net *net, struct sock *sk,
816 struct flowi *fl)
817 {
818 int flags = 0;
819
820 if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl->fl6_dst))
821 flags |= RT6_LOOKUP_F_IFACE;
822
823 if (!ipv6_addr_any(&fl->fl6_src))
824 flags |= RT6_LOOKUP_F_HAS_SADDR;
825 else if (sk)
826 flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
827
828 return fib6_rule_lookup(net, fl, flags, ip6_pol_route_output);
829 }
830
831 EXPORT_SYMBOL(ip6_route_output);
832
833 int ip6_dst_blackhole(struct sock *sk, struct dst_entry **dstp, struct flowi *fl)
834 {
835 struct rt6_info *ort = (struct rt6_info *) *dstp;
836 struct rt6_info *rt = (struct rt6_info *)
837 dst_alloc(&ip6_dst_blackhole_ops);
838 struct dst_entry *new = NULL;
839
840 if (rt) {
841 new = &rt->dst;
842
843 atomic_set(&new->__refcnt, 1);
844 new->__use = 1;
845 new->input = dst_discard;
846 new->output = dst_discard;
847
848 dst_copy_metrics(new, &ort->dst);
849 new->dev = ort->dst.dev;
850 if (new->dev)
851 dev_hold(new->dev);
852 rt->rt6i_idev = ort->rt6i_idev;
853 if (rt->rt6i_idev)
854 in6_dev_hold(rt->rt6i_idev);
855 rt->rt6i_expires = 0;
856
857 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
858 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
859 rt->rt6i_metric = 0;
860
861 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
862 #ifdef CONFIG_IPV6_SUBTREES
863 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
864 #endif
865
866 dst_free(new);
867 }
868
869 dst_release(*dstp);
870 *dstp = new;
871 return new ? 0 : -ENOMEM;
872 }
873 EXPORT_SYMBOL_GPL(ip6_dst_blackhole);
874
875 /*
876 * Destination cache support functions
877 */
878
879 static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
880 {
881 struct rt6_info *rt;
882
883 rt = (struct rt6_info *) dst;
884
885 if (rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
886 return dst;
887
888 return NULL;
889 }
890
891 static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
892 {
893 struct rt6_info *rt = (struct rt6_info *) dst;
894
895 if (rt) {
896 if (rt->rt6i_flags & RTF_CACHE) {
897 if (rt6_check_expired(rt)) {
898 ip6_del_rt(rt);
899 dst = NULL;
900 }
901 } else {
902 dst_release(dst);
903 dst = NULL;
904 }
905 }
906 return dst;
907 }
908
909 static void ip6_link_failure(struct sk_buff *skb)
910 {
911 struct rt6_info *rt;
912
913 icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
914
915 rt = (struct rt6_info *) skb_dst(skb);
916 if (rt) {
917 if (rt->rt6i_flags&RTF_CACHE) {
918 dst_set_expires(&rt->dst, 0);
919 rt->rt6i_flags |= RTF_EXPIRES;
920 } else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
921 rt->rt6i_node->fn_sernum = -1;
922 }
923 }
924
925 static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
926 {
927 struct rt6_info *rt6 = (struct rt6_info*)dst;
928
929 if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
930 rt6->rt6i_flags |= RTF_MODIFIED;
931 if (mtu < IPV6_MIN_MTU) {
932 u32 features = dst_metric(dst, RTAX_FEATURES);
933 mtu = IPV6_MIN_MTU;
934 features |= RTAX_FEATURE_ALLFRAG;
935 dst_metric_set(dst, RTAX_FEATURES, features);
936 }
937 dst_metric_set(dst, RTAX_MTU, mtu);
938 call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);
939 }
940 }
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 unsigned int ip6_default_mtu(const struct dst_entry *dst)
965 {
966 unsigned int mtu = IPV6_MIN_MTU;
967 struct inet6_dev *idev;
968
969 rcu_read_lock();
970 idev = __in6_dev_get(dst->dev);
971 if (idev)
972 mtu = idev->cnf.mtu6;
973 rcu_read_unlock();
974
975 return mtu;
976 }
977
978 static struct dst_entry *icmp6_dst_gc_list;
979 static DEFINE_SPINLOCK(icmp6_dst_lock);
980
981 struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
982 struct neighbour *neigh,
983 const struct in6_addr *addr)
984 {
985 struct rt6_info *rt;
986 struct inet6_dev *idev = in6_dev_get(dev);
987 struct net *net = dev_net(dev);
988
989 if (unlikely(idev == NULL))
990 return NULL;
991
992 rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
993 if (unlikely(rt == NULL)) {
994 in6_dev_put(idev);
995 goto out;
996 }
997
998 dev_hold(dev);
999 if (neigh)
1000 neigh_hold(neigh);
1001 else {
1002 neigh = ndisc_get_neigh(dev, addr);
1003 if (IS_ERR(neigh))
1004 neigh = NULL;
1005 }
1006
1007 rt->rt6i_dev = dev;
1008 rt->rt6i_idev = idev;
1009 rt->rt6i_nexthop = neigh;
1010 atomic_set(&rt->dst.__refcnt, 1);
1011 dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 255);
1012 rt->dst.output = ip6_output;
1013
1014 #if 0 /* there's no chance to use these for ndisc */
1015 rt->dst.flags = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST
1016 ? DST_HOST
1017 : 0;
1018 ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
1019 rt->rt6i_dst.plen = 128;
1020 #endif
1021
1022 spin_lock_bh(&icmp6_dst_lock);
1023 rt->dst.next = icmp6_dst_gc_list;
1024 icmp6_dst_gc_list = &rt->dst;
1025 spin_unlock_bh(&icmp6_dst_lock);
1026
1027 fib6_force_start_gc(net);
1028
1029 out:
1030 return &rt->dst;
1031 }
1032
1033 int icmp6_dst_gc(void)
1034 {
1035 struct dst_entry *dst, *next, **pprev;
1036 int more = 0;
1037
1038 next = NULL;
1039
1040 spin_lock_bh(&icmp6_dst_lock);
1041 pprev = &icmp6_dst_gc_list;
1042
1043 while ((dst = *pprev) != NULL) {
1044 if (!atomic_read(&dst->__refcnt)) {
1045 *pprev = dst->next;
1046 dst_free(dst);
1047 } else {
1048 pprev = &dst->next;
1049 ++more;
1050 }
1051 }
1052
1053 spin_unlock_bh(&icmp6_dst_lock);
1054
1055 return more;
1056 }
1057
1058 static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
1059 void *arg)
1060 {
1061 struct dst_entry *dst, **pprev;
1062
1063 spin_lock_bh(&icmp6_dst_lock);
1064 pprev = &icmp6_dst_gc_list;
1065 while ((dst = *pprev) != NULL) {
1066 struct rt6_info *rt = (struct rt6_info *) dst;
1067 if (func(rt, arg)) {
1068 *pprev = dst->next;
1069 dst_free(dst);
1070 } else {
1071 pprev = &dst->next;
1072 }
1073 }
1074 spin_unlock_bh(&icmp6_dst_lock);
1075 }
1076
1077 static int ip6_dst_gc(struct dst_ops *ops)
1078 {
1079 unsigned long now = jiffies;
1080 struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
1081 int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
1082 int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
1083 int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
1084 int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
1085 unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
1086 int entries;
1087
1088 entries = dst_entries_get_fast(ops);
1089 if (time_after(rt_last_gc + rt_min_interval, now) &&
1090 entries <= rt_max_size)
1091 goto out;
1092
1093 net->ipv6.ip6_rt_gc_expire++;
1094 fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net);
1095 net->ipv6.ip6_rt_last_gc = now;
1096 entries = dst_entries_get_slow(ops);
1097 if (entries < ops->gc_thresh)
1098 net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
1099 out:
1100 net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
1101 return entries > rt_max_size;
1102 }
1103
1104 /* Clean host part of a prefix. Not necessary in radix tree,
1105 but results in cleaner routing tables.
1106
1107 Remove it only when all the things will work!
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 rt->dst.dev = dev;
1319 rt->rt6i_idev = idev;
1320 rt->rt6i_table = table;
1321
1322 cfg->fc_nlinfo.nl_net = dev_net(dev);
1323
1324 return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
1325
1326 out:
1327 if (dev)
1328 dev_put(dev);
1329 if (idev)
1330 in6_dev_put(idev);
1331 if (rt)
1332 dst_free(&rt->dst);
1333 return err;
1334 }
1335
1336 static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
1337 {
1338 int err;
1339 struct fib6_table *table;
1340 struct net *net = dev_net(rt->rt6i_dev);
1341
1342 if (rt == net->ipv6.ip6_null_entry)
1343 return -ENOENT;
1344
1345 table = rt->rt6i_table;
1346 write_lock_bh(&table->tb6_lock);
1347
1348 err = fib6_del(rt, info);
1349 dst_release(&rt->dst);
1350
1351 write_unlock_bh(&table->tb6_lock);
1352
1353 return err;
1354 }
1355
1356 int ip6_del_rt(struct rt6_info *rt)
1357 {
1358 struct nl_info info = {
1359 .nl_net = dev_net(rt->rt6i_dev),
1360 };
1361 return __ip6_del_rt(rt, &info);
1362 }
1363
1364 static int ip6_route_del(struct fib6_config *cfg)
1365 {
1366 struct fib6_table *table;
1367 struct fib6_node *fn;
1368 struct rt6_info *rt;
1369 int err = -ESRCH;
1370
1371 table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
1372 if (table == NULL)
1373 return err;
1374
1375 read_lock_bh(&table->tb6_lock);
1376
1377 fn = fib6_locate(&table->tb6_root,
1378 &cfg->fc_dst, cfg->fc_dst_len,
1379 &cfg->fc_src, cfg->fc_src_len);
1380
1381 if (fn) {
1382 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1383 if (cfg->fc_ifindex &&
1384 (rt->rt6i_dev == NULL ||
1385 rt->rt6i_dev->ifindex != cfg->fc_ifindex))
1386 continue;
1387 if (cfg->fc_flags & RTF_GATEWAY &&
1388 !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
1389 continue;
1390 if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
1391 continue;
1392 dst_hold(&rt->dst);
1393 read_unlock_bh(&table->tb6_lock);
1394
1395 return __ip6_del_rt(rt, &cfg->fc_nlinfo);
1396 }
1397 }
1398 read_unlock_bh(&table->tb6_lock);
1399
1400 return err;
1401 }
1402
1403 /*
1404 * Handle redirects
1405 */
1406 struct ip6rd_flowi {
1407 struct flowi fl;
1408 struct in6_addr gateway;
1409 };
1410
1411 static struct rt6_info *__ip6_route_redirect(struct net *net,
1412 struct fib6_table *table,
1413 struct flowi *fl,
1414 int flags)
1415 {
1416 struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl;
1417 struct rt6_info *rt;
1418 struct fib6_node *fn;
1419
1420 /*
1421 * Get the "current" route for this destination and
1422 * check if the redirect has come from approriate router.
1423 *
1424 * RFC 2461 specifies that redirects should only be
1425 * accepted if they come from the nexthop to the target.
1426 * Due to the way the routes are chosen, this notion
1427 * is a bit fuzzy and one might need to check all possible
1428 * routes.
1429 */
1430
1431 read_lock_bh(&table->tb6_lock);
1432 fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
1433 restart:
1434 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1435 /*
1436 * Current route is on-link; redirect is always invalid.
1437 *
1438 * Seems, previous statement is not true. It could
1439 * be node, which looks for us as on-link (f.e. proxy ndisc)
1440 * But then router serving it might decide, that we should
1441 * know truth 8)8) --ANK (980726).
1442 */
1443 if (rt6_check_expired(rt))
1444 continue;
1445 if (!(rt->rt6i_flags & RTF_GATEWAY))
1446 continue;
1447 if (fl->oif != rt->rt6i_dev->ifindex)
1448 continue;
1449 if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1450 continue;
1451 break;
1452 }
1453
1454 if (!rt)
1455 rt = net->ipv6.ip6_null_entry;
1456 BACKTRACK(net, &fl->fl6_src);
1457 out:
1458 dst_hold(&rt->dst);
1459
1460 read_unlock_bh(&table->tb6_lock);
1461
1462 return rt;
1463 };
1464
1465 static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,
1466 struct in6_addr *src,
1467 struct in6_addr *gateway,
1468 struct net_device *dev)
1469 {
1470 int flags = RT6_LOOKUP_F_HAS_SADDR;
1471 struct net *net = dev_net(dev);
1472 struct ip6rd_flowi rdfl = {
1473 .fl = {
1474 .oif = dev->ifindex,
1475 .fl6_dst = *dest,
1476 .fl6_src = *src,
1477 },
1478 };
1479
1480 ipv6_addr_copy(&rdfl.gateway, gateway);
1481
1482 if (rt6_need_strict(dest))
1483 flags |= RT6_LOOKUP_F_IFACE;
1484
1485 return (struct rt6_info *)fib6_rule_lookup(net, (struct flowi *)&rdfl,
1486 flags, __ip6_route_redirect);
1487 }
1488
1489 void rt6_redirect(struct in6_addr *dest, struct in6_addr *src,
1490 struct in6_addr *saddr,
1491 struct neighbour *neigh, u8 *lladdr, int on_link)
1492 {
1493 struct rt6_info *rt, *nrt = NULL;
1494 struct netevent_redirect netevent;
1495 struct net *net = dev_net(neigh->dev);
1496
1497 rt = ip6_route_redirect(dest, src, saddr, neigh->dev);
1498
1499 if (rt == net->ipv6.ip6_null_entry) {
1500 if (net_ratelimit())
1501 printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
1502 "for redirect target\n");
1503 goto out;
1504 }
1505
1506 /*
1507 * We have finally decided to accept it.
1508 */
1509
1510 neigh_update(neigh, lladdr, NUD_STALE,
1511 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1512 NEIGH_UPDATE_F_OVERRIDE|
1513 (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1514 NEIGH_UPDATE_F_ISROUTER))
1515 );
1516
1517 /*
1518 * Redirect received -> path was valid.
1519 * Look, redirects are sent only in response to data packets,
1520 * so that this nexthop apparently is reachable. --ANK
1521 */
1522 dst_confirm(&rt->dst);
1523
1524 /* Duplicate redirect: silently ignore. */
1525 if (neigh == rt->dst.neighbour)
1526 goto out;
1527
1528 nrt = ip6_rt_copy(rt);
1529 if (nrt == NULL)
1530 goto out;
1531
1532 nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
1533 if (on_link)
1534 nrt->rt6i_flags &= ~RTF_GATEWAY;
1535
1536 ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
1537 nrt->rt6i_dst.plen = 128;
1538 nrt->dst.flags |= DST_HOST;
1539
1540 ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
1541 nrt->rt6i_nexthop = neigh_clone(neigh);
1542
1543 if (ip6_ins_rt(nrt))
1544 goto out;
1545
1546 netevent.old = &rt->dst;
1547 netevent.new = &nrt->dst;
1548 call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
1549
1550 if (rt->rt6i_flags&RTF_CACHE) {
1551 ip6_del_rt(rt);
1552 return;
1553 }
1554
1555 out:
1556 dst_release(&rt->dst);
1557 }
1558
1559 /*
1560 * Handle ICMP "packet too big" messages
1561 * i.e. Path MTU discovery
1562 */
1563
1564 static void rt6_do_pmtu_disc(struct in6_addr *daddr, struct in6_addr *saddr,
1565 struct net *net, u32 pmtu, int ifindex)
1566 {
1567 struct rt6_info *rt, *nrt;
1568 int allfrag = 0;
1569 again:
1570 rt = rt6_lookup(net, daddr, saddr, ifindex, 0);
1571 if (rt == NULL)
1572 return;
1573
1574 if (rt6_check_expired(rt)) {
1575 ip6_del_rt(rt);
1576 goto again;
1577 }
1578
1579 if (pmtu >= dst_mtu(&rt->dst))
1580 goto out;
1581
1582 if (pmtu < IPV6_MIN_MTU) {
1583 /*
1584 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
1585 * MTU (1280) and a fragment header should always be included
1586 * after a node receiving Too Big message reporting PMTU is
1587 * less than the IPv6 Minimum Link MTU.
1588 */
1589 pmtu = IPV6_MIN_MTU;
1590 allfrag = 1;
1591 }
1592
1593 /* New mtu received -> path was valid.
1594 They are sent only in response to data packets,
1595 so that this nexthop apparently is reachable. --ANK
1596 */
1597 dst_confirm(&rt->dst);
1598
1599 /* Host route. If it is static, it would be better
1600 not to override it, but add new one, so that
1601 when cache entry will expire old pmtu
1602 would return automatically.
1603 */
1604 if (rt->rt6i_flags & RTF_CACHE) {
1605 dst_metric_set(&rt->dst, RTAX_MTU, pmtu);
1606 if (allfrag) {
1607 u32 features = dst_metric(&rt->dst, RTAX_FEATURES);
1608 features |= RTAX_FEATURE_ALLFRAG;
1609 dst_metric_set(&rt->dst, RTAX_FEATURES, features);
1610 }
1611 dst_set_expires(&rt->dst, net->ipv6.sysctl.ip6_rt_mtu_expires);
1612 rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
1613 goto out;
1614 }
1615
1616 /* Network route.
1617 Two cases are possible:
1618 1. It is connected route. Action: COW
1619 2. It is gatewayed route or NONEXTHOP route. Action: clone it.
1620 */
1621 if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
1622 nrt = rt6_alloc_cow(rt, daddr, saddr);
1623 else
1624 nrt = rt6_alloc_clone(rt, daddr);
1625
1626 if (nrt) {
1627 dst_metric_set(&nrt->dst, RTAX_MTU, pmtu);
1628 if (allfrag) {
1629 u32 features = dst_metric(&nrt->dst, RTAX_FEATURES);
1630 features |= RTAX_FEATURE_ALLFRAG;
1631 dst_metric_set(&nrt->dst, RTAX_FEATURES, features);
1632 }
1633
1634 /* According to RFC 1981, detecting PMTU increase shouldn't be
1635 * happened within 5 mins, the recommended timer is 10 mins.
1636 * Here this route expiration time is set to ip6_rt_mtu_expires
1637 * which is 10 mins. After 10 mins the decreased pmtu is expired
1638 * and detecting PMTU increase will be automatically happened.
1639 */
1640 dst_set_expires(&nrt->dst, net->ipv6.sysctl.ip6_rt_mtu_expires);
1641 nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
1642
1643 ip6_ins_rt(nrt);
1644 }
1645 out:
1646 dst_release(&rt->dst);
1647 }
1648
1649 void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
1650 struct net_device *dev, u32 pmtu)
1651 {
1652 struct net *net = dev_net(dev);
1653
1654 /*
1655 * RFC 1981 states that a node "MUST reduce the size of the packets it
1656 * is sending along the path" that caused the Packet Too Big message.
1657 * Since it's not possible in the general case to determine which
1658 * interface was used to send the original packet, we update the MTU
1659 * on the interface that will be used to send future packets. We also
1660 * update the MTU on the interface that received the Packet Too Big in
1661 * case the original packet was forced out that interface with
1662 * SO_BINDTODEVICE or similar. This is the next best thing to the
1663 * correct behaviour, which would be to update the MTU on all
1664 * interfaces.
1665 */
1666 rt6_do_pmtu_disc(daddr, saddr, net, pmtu, 0);
1667 rt6_do_pmtu_disc(daddr, saddr, net, pmtu, dev->ifindex);
1668 }
1669
1670 /*
1671 * Misc support functions
1672 */
1673
1674 static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
1675 {
1676 struct net *net = dev_net(ort->rt6i_dev);
1677 struct rt6_info *rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
1678
1679 if (rt) {
1680 rt->dst.input = ort->dst.input;
1681 rt->dst.output = ort->dst.output;
1682
1683 dst_copy_metrics(&rt->dst, &ort->dst);
1684 rt->dst.error = ort->dst.error;
1685 rt->dst.dev = ort->dst.dev;
1686 if (rt->dst.dev)
1687 dev_hold(rt->dst.dev);
1688 rt->rt6i_idev = ort->rt6i_idev;
1689 if (rt->rt6i_idev)
1690 in6_dev_hold(rt->rt6i_idev);
1691 rt->dst.lastuse = jiffies;
1692 rt->rt6i_expires = 0;
1693
1694 ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
1695 rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
1696 rt->rt6i_metric = 0;
1697
1698 memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
1699 #ifdef CONFIG_IPV6_SUBTREES
1700 memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
1701 #endif
1702 rt->rt6i_table = ort->rt6i_table;
1703 }
1704 return rt;
1705 }
1706
1707 #ifdef CONFIG_IPV6_ROUTE_INFO
1708 static struct rt6_info *rt6_get_route_info(struct net *net,
1709 struct in6_addr *prefix, int prefixlen,
1710 struct in6_addr *gwaddr, int ifindex)
1711 {
1712 struct fib6_node *fn;
1713 struct rt6_info *rt = NULL;
1714 struct fib6_table *table;
1715
1716 table = fib6_get_table(net, RT6_TABLE_INFO);
1717 if (table == NULL)
1718 return NULL;
1719
1720 write_lock_bh(&table->tb6_lock);
1721 fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
1722 if (!fn)
1723 goto out;
1724
1725 for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
1726 if (rt->rt6i_dev->ifindex != ifindex)
1727 continue;
1728 if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
1729 continue;
1730 if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
1731 continue;
1732 dst_hold(&rt->dst);
1733 break;
1734 }
1735 out:
1736 write_unlock_bh(&table->tb6_lock);
1737 return rt;
1738 }
1739
1740 static struct rt6_info *rt6_add_route_info(struct net *net,
1741 struct in6_addr *prefix, int prefixlen,
1742 struct in6_addr *gwaddr, int ifindex,
1743 unsigned pref)
1744 {
1745 struct fib6_config cfg = {
1746 .fc_table = RT6_TABLE_INFO,
1747 .fc_metric = IP6_RT_PRIO_USER,
1748 .fc_ifindex = ifindex,
1749 .fc_dst_len = prefixlen,
1750 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
1751 RTF_UP | RTF_PREF(pref),
1752 .fc_nlinfo.pid = 0,
1753 .fc_nlinfo.nlh = NULL,
1754 .fc_nlinfo.nl_net = net,
1755 };
1756
1757 ipv6_addr_copy(&cfg.fc_dst, prefix);
1758 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1759
1760 /* We should treat it as a default route if prefix length is 0. */
1761 if (!prefixlen)
1762 cfg.fc_flags |= RTF_DEFAULT;
1763
1764 ip6_route_add(&cfg);
1765
1766 return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
1767 }
1768 #endif
1769
1770 struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
1771 {
1772 struct rt6_info *rt;
1773 struct fib6_table *table;
1774
1775 table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
1776 if (table == NULL)
1777 return NULL;
1778
1779 write_lock_bh(&table->tb6_lock);
1780 for (rt = table->tb6_root.leaf; rt; rt=rt->dst.rt6_next) {
1781 if (dev == rt->rt6i_dev &&
1782 ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
1783 ipv6_addr_equal(&rt->rt6i_gateway, addr))
1784 break;
1785 }
1786 if (rt)
1787 dst_hold(&rt->dst);
1788 write_unlock_bh(&table->tb6_lock);
1789 return rt;
1790 }
1791
1792 struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
1793 struct net_device *dev,
1794 unsigned int pref)
1795 {
1796 struct fib6_config cfg = {
1797 .fc_table = RT6_TABLE_DFLT,
1798 .fc_metric = IP6_RT_PRIO_USER,
1799 .fc_ifindex = dev->ifindex,
1800 .fc_flags = RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
1801 RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
1802 .fc_nlinfo.pid = 0,
1803 .fc_nlinfo.nlh = NULL,
1804 .fc_nlinfo.nl_net = dev_net(dev),
1805 };
1806
1807 ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
1808
1809 ip6_route_add(&cfg);
1810
1811 return rt6_get_dflt_router(gwaddr, dev);
1812 }
1813
1814 void rt6_purge_dflt_routers(struct net *net)
1815 {
1816 struct rt6_info *rt;
1817 struct fib6_table *table;
1818
1819 /* NOTE: Keep consistent with rt6_get_dflt_router */
1820 table = fib6_get_table(net, RT6_TABLE_DFLT);
1821 if (table == NULL)
1822 return;
1823
1824 restart:
1825 read_lock_bh(&table->tb6_lock);
1826 for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
1827 if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1828 dst_hold(&rt->dst);
1829 read_unlock_bh(&table->tb6_lock);
1830 ip6_del_rt(rt);
1831 goto restart;
1832 }
1833 }
1834 read_unlock_bh(&table->tb6_lock);
1835 }
1836
1837 static void rtmsg_to_fib6_config(struct net *net,
1838 struct in6_rtmsg *rtmsg,
1839 struct fib6_config *cfg)
1840 {
1841 memset(cfg, 0, sizeof(*cfg));
1842
1843 cfg->fc_table = RT6_TABLE_MAIN;
1844 cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
1845 cfg->fc_metric = rtmsg->rtmsg_metric;
1846 cfg->fc_expires = rtmsg->rtmsg_info;
1847 cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
1848 cfg->fc_src_len = rtmsg->rtmsg_src_len;
1849 cfg->fc_flags = rtmsg->rtmsg_flags;
1850
1851 cfg->fc_nlinfo.nl_net = net;
1852
1853 ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst);
1854 ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src);
1855 ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway);
1856 }
1857
1858 int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1859 {
1860 struct fib6_config cfg;
1861 struct in6_rtmsg rtmsg;
1862 int err;
1863
1864 switch(cmd) {
1865 case SIOCADDRT: /* Add a route */
1866 case SIOCDELRT: /* Delete a route */
1867 if (!capable(CAP_NET_ADMIN))
1868 return -EPERM;
1869 err = copy_from_user(&rtmsg, arg,
1870 sizeof(struct in6_rtmsg));
1871 if (err)
1872 return -EFAULT;
1873
1874 rtmsg_to_fib6_config(net, &rtmsg, &cfg);
1875
1876 rtnl_lock();
1877 switch (cmd) {
1878 case SIOCADDRT:
1879 err = ip6_route_add(&cfg);
1880 break;
1881 case SIOCDELRT:
1882 err = ip6_route_del(&cfg);
1883 break;
1884 default:
1885 err = -EINVAL;
1886 }
1887 rtnl_unlock();
1888
1889 return err;
1890 }
1891
1892 return -EINVAL;
1893 }
1894
1895 /*
1896 * Drop the packet on the floor
1897 */
1898
1899 static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
1900 {
1901 int type;
1902 struct dst_entry *dst = skb_dst(skb);
1903 switch (ipstats_mib_noroutes) {
1904 case IPSTATS_MIB_INNOROUTES:
1905 type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
1906 if (type == IPV6_ADDR_ANY) {
1907 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
1908 IPSTATS_MIB_INADDRERRORS);
1909 break;
1910 }
1911 /* FALLTHROUGH */
1912 case IPSTATS_MIB_OUTNOROUTES:
1913 IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
1914 ipstats_mib_noroutes);
1915 break;
1916 }
1917 icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
1918 kfree_skb(skb);
1919 return 0;
1920 }
1921
1922 static int ip6_pkt_discard(struct sk_buff *skb)
1923 {
1924 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
1925 }
1926
1927 static int ip6_pkt_discard_out(struct sk_buff *skb)
1928 {
1929 skb->dev = skb_dst(skb)->dev;
1930 return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
1931 }
1932
1933 #ifdef CONFIG_IPV6_MULTIPLE_TABLES
1934
1935 static int ip6_pkt_prohibit(struct sk_buff *skb)
1936 {
1937 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
1938 }
1939
1940 static int ip6_pkt_prohibit_out(struct sk_buff *skb)
1941 {
1942 skb->dev = skb_dst(skb)->dev;
1943 return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
1944 }
1945
1946 #endif
1947
1948 /*
1949 * Allocate a dst for local (unicast / anycast) address.
1950 */
1951
1952 struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
1953 const struct in6_addr *addr,
1954 int anycast)
1955 {
1956 struct net *net = dev_net(idev->dev);
1957 struct rt6_info *rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
1958 struct neighbour *neigh;
1959
1960 if (rt == NULL) {
1961 if (net_ratelimit())
1962 pr_warning("IPv6: Maximum number of routes reached,"
1963 " consider increasing route/max_size.\n");
1964 return ERR_PTR(-ENOMEM);
1965 }
1966
1967 dev_hold(net->loopback_dev);
1968 in6_dev_hold(idev);
1969
1970 rt->dst.flags = DST_HOST;
1971 rt->dst.input = ip6_input;
1972 rt->dst.output = ip6_output;
1973 rt->rt6i_dev = net->loopback_dev;
1974 rt->rt6i_idev = idev;
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 const struct arg_dev_net *adn = arg;
2013 const struct net_device *dev = adn->dev;
2014
2015 if ((rt->rt6i_dev == dev || dev == NULL) &&
2016 rt != adn->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