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