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