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