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