xref: /openbmc/linux/net/ipv6/route.c (revision c68f24cc354050415c5ea543cd19ea5424463a2f)
11da177e4SLinus Torvalds /*
21da177e4SLinus Torvalds  *	Linux INET6 implementation
31da177e4SLinus Torvalds  *	FIB front-end.
41da177e4SLinus Torvalds  *
51da177e4SLinus Torvalds  *	Authors:
61da177e4SLinus Torvalds  *	Pedro Roque		<roque@di.fc.ul.pt>
71da177e4SLinus Torvalds  *
81da177e4SLinus Torvalds  *	This program is free software; you can redistribute it and/or
91da177e4SLinus Torvalds  *      modify it under the terms of the GNU General Public License
101da177e4SLinus Torvalds  *      as published by the Free Software Foundation; either version
111da177e4SLinus Torvalds  *      2 of the License, or (at your option) any later version.
121da177e4SLinus Torvalds  */
131da177e4SLinus Torvalds 
141da177e4SLinus Torvalds /*	Changes:
151da177e4SLinus Torvalds  *
161da177e4SLinus Torvalds  *	YOSHIFUJI Hideaki @USAGI
171da177e4SLinus Torvalds  *		reworked default router selection.
181da177e4SLinus Torvalds  *		- respect outgoing interface
191da177e4SLinus Torvalds  *		- select from (probably) reachable routers (i.e.
201da177e4SLinus Torvalds  *		routers in REACHABLE, STALE, DELAY or PROBE states).
211da177e4SLinus Torvalds  *		- always select the same router if it is (probably)
221da177e4SLinus Torvalds  *		reachable.  otherwise, round-robin the list.
23c0bece9fSYOSHIFUJI Hideaki  *	Ville Nuorvala
24c0bece9fSYOSHIFUJI Hideaki  *		Fixed routing subtrees.
251da177e4SLinus Torvalds  */
261da177e4SLinus Torvalds 
274fc268d2SRandy Dunlap #include <linux/capability.h>
281da177e4SLinus Torvalds #include <linux/errno.h>
291da177e4SLinus Torvalds #include <linux/types.h>
301da177e4SLinus Torvalds #include <linux/times.h>
311da177e4SLinus Torvalds #include <linux/socket.h>
321da177e4SLinus Torvalds #include <linux/sockios.h>
331da177e4SLinus Torvalds #include <linux/net.h>
341da177e4SLinus Torvalds #include <linux/route.h>
351da177e4SLinus Torvalds #include <linux/netdevice.h>
361da177e4SLinus Torvalds #include <linux/in6.h>
377bc570c8SYOSHIFUJI Hideaki #include <linux/mroute6.h>
381da177e4SLinus Torvalds #include <linux/init.h>
391da177e4SLinus Torvalds #include <linux/if_arp.h>
401da177e4SLinus Torvalds #include <linux/proc_fs.h>
411da177e4SLinus Torvalds #include <linux/seq_file.h>
425b7c931dSDaniel Lezcano #include <linux/nsproxy.h>
435a0e3ad6STejun Heo #include <linux/slab.h>
44457c4cbcSEric W. Biederman #include <net/net_namespace.h>
451da177e4SLinus Torvalds #include <net/snmp.h>
461da177e4SLinus Torvalds #include <net/ipv6.h>
471da177e4SLinus Torvalds #include <net/ip6_fib.h>
481da177e4SLinus Torvalds #include <net/ip6_route.h>
491da177e4SLinus Torvalds #include <net/ndisc.h>
501da177e4SLinus Torvalds #include <net/addrconf.h>
511da177e4SLinus Torvalds #include <net/tcp.h>
521da177e4SLinus Torvalds #include <linux/rtnetlink.h>
531da177e4SLinus Torvalds #include <net/dst.h>
541da177e4SLinus Torvalds #include <net/xfrm.h>
558d71740cSTom Tucker #include <net/netevent.h>
5621713ebcSThomas Graf #include <net/netlink.h>
571da177e4SLinus Torvalds 
581da177e4SLinus Torvalds #include <asm/uaccess.h>
591da177e4SLinus Torvalds 
601da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL
611da177e4SLinus Torvalds #include <linux/sysctl.h>
621da177e4SLinus Torvalds #endif
631da177e4SLinus Torvalds 
641da177e4SLinus Torvalds /* Set to 3 to get tracing. */
651da177e4SLinus Torvalds #define RT6_DEBUG 2
661da177e4SLinus Torvalds 
671da177e4SLinus Torvalds #if RT6_DEBUG >= 3
681da177e4SLinus Torvalds #define RDBG(x) printk x
691da177e4SLinus Torvalds #define RT6_TRACE(x...) printk(KERN_DEBUG x)
701da177e4SLinus Torvalds #else
711da177e4SLinus Torvalds #define RDBG(x)
721da177e4SLinus Torvalds #define RT6_TRACE(x...) do { ; } while (0)
731da177e4SLinus Torvalds #endif
741da177e4SLinus Torvalds 
75519fbd87SYOSHIFUJI Hideaki #define CLONE_OFFLINK_ROUTE 0
761da177e4SLinus Torvalds 
771da177e4SLinus Torvalds static struct rt6_info * ip6_rt_copy(struct rt6_info *ort);
781da177e4SLinus Torvalds static struct dst_entry	*ip6_dst_check(struct dst_entry *dst, u32 cookie);
791da177e4SLinus Torvalds static struct dst_entry *ip6_negative_advice(struct dst_entry *);
801da177e4SLinus Torvalds static void		ip6_dst_destroy(struct dst_entry *);
811da177e4SLinus Torvalds static void		ip6_dst_ifdown(struct dst_entry *,
821da177e4SLinus Torvalds 				       struct net_device *dev, int how);
83569d3645SDaniel Lezcano static int		 ip6_dst_gc(struct dst_ops *ops);
841da177e4SLinus Torvalds 
851da177e4SLinus Torvalds static int		ip6_pkt_discard(struct sk_buff *skb);
861da177e4SLinus Torvalds static int		ip6_pkt_discard_out(struct sk_buff *skb);
871da177e4SLinus Torvalds static void		ip6_link_failure(struct sk_buff *skb);
881da177e4SLinus Torvalds static void		ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
891da177e4SLinus Torvalds 
9070ceb4f5SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_ROUTE_INFO
91efa2cea0SDaniel Lezcano static struct rt6_info *rt6_add_route_info(struct net *net,
92efa2cea0SDaniel Lezcano 					   struct in6_addr *prefix, int prefixlen,
9370ceb4f5SYOSHIFUJI Hideaki 					   struct in6_addr *gwaddr, int ifindex,
9470ceb4f5SYOSHIFUJI Hideaki 					   unsigned pref);
95efa2cea0SDaniel Lezcano static struct rt6_info *rt6_get_route_info(struct net *net,
96efa2cea0SDaniel Lezcano 					   struct in6_addr *prefix, int prefixlen,
9770ceb4f5SYOSHIFUJI Hideaki 					   struct in6_addr *gwaddr, int ifindex);
9870ceb4f5SYOSHIFUJI Hideaki #endif
9970ceb4f5SYOSHIFUJI Hideaki 
1009a7ec3a9SDaniel Lezcano static struct dst_ops ip6_dst_ops_template = {
1011da177e4SLinus Torvalds 	.family			=	AF_INET6,
10209640e63SHarvey Harrison 	.protocol		=	cpu_to_be16(ETH_P_IPV6),
1031da177e4SLinus Torvalds 	.gc			=	ip6_dst_gc,
1041da177e4SLinus Torvalds 	.gc_thresh		=	1024,
1051da177e4SLinus Torvalds 	.check			=	ip6_dst_check,
1061da177e4SLinus Torvalds 	.destroy		=	ip6_dst_destroy,
1071da177e4SLinus Torvalds 	.ifdown			=	ip6_dst_ifdown,
1081da177e4SLinus Torvalds 	.negative_advice	=	ip6_negative_advice,
1091da177e4SLinus Torvalds 	.link_failure		=	ip6_link_failure,
1101da177e4SLinus Torvalds 	.update_pmtu		=	ip6_rt_update_pmtu,
1111ac06e03SHerbert Xu 	.local_out		=	__ip6_local_out,
112e2422970SEric Dumazet 	.entries		=	ATOMIC_INIT(0),
1131da177e4SLinus Torvalds };
1141da177e4SLinus Torvalds 
11514e50e57SDavid S. Miller static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu)
11614e50e57SDavid S. Miller {
11714e50e57SDavid S. Miller }
11814e50e57SDavid S. Miller 
11914e50e57SDavid S. Miller static struct dst_ops ip6_dst_blackhole_ops = {
12014e50e57SDavid S. Miller 	.family			=	AF_INET6,
12109640e63SHarvey Harrison 	.protocol		=	cpu_to_be16(ETH_P_IPV6),
12214e50e57SDavid S. Miller 	.destroy		=	ip6_dst_destroy,
12314e50e57SDavid S. Miller 	.check			=	ip6_dst_check,
12414e50e57SDavid S. Miller 	.update_pmtu		=	ip6_rt_blackhole_update_pmtu,
125e2422970SEric Dumazet 	.entries		=	ATOMIC_INIT(0),
12614e50e57SDavid S. Miller };
12714e50e57SDavid S. Miller 
128bdb3289fSDaniel Lezcano static struct rt6_info ip6_null_entry_template = {
1291da177e4SLinus Torvalds 	.dst = {
1301da177e4SLinus Torvalds 		.__refcnt	= ATOMIC_INIT(1),
1311da177e4SLinus Torvalds 		.__use		= 1,
1321da177e4SLinus Torvalds 		.obsolete	= -1,
1331da177e4SLinus Torvalds 		.error		= -ENETUNREACH,
1341da177e4SLinus Torvalds 		.metrics	= { [RTAX_HOPLIMIT - 1] = 255, },
1351da177e4SLinus Torvalds 		.input		= ip6_pkt_discard,
1361da177e4SLinus Torvalds 		.output		= ip6_pkt_discard_out,
1371da177e4SLinus Torvalds 	},
1381da177e4SLinus Torvalds 	.rt6i_flags	= (RTF_REJECT | RTF_NONEXTHOP),
1394f724279SJean-Mickael Guerin 	.rt6i_protocol  = RTPROT_KERNEL,
1401da177e4SLinus Torvalds 	.rt6i_metric	= ~(u32) 0,
1411da177e4SLinus Torvalds 	.rt6i_ref	= ATOMIC_INIT(1),
1421da177e4SLinus Torvalds };
1431da177e4SLinus Torvalds 
144101367c2SThomas Graf #ifdef CONFIG_IPV6_MULTIPLE_TABLES
145101367c2SThomas Graf 
1466723ab54SDavid S. Miller static int ip6_pkt_prohibit(struct sk_buff *skb);
1476723ab54SDavid S. Miller static int ip6_pkt_prohibit_out(struct sk_buff *skb);
1486723ab54SDavid S. Miller 
149280a34c8SAdrian Bunk static struct rt6_info ip6_prohibit_entry_template = {
150101367c2SThomas Graf 	.dst = {
151101367c2SThomas Graf 		.__refcnt	= ATOMIC_INIT(1),
152101367c2SThomas Graf 		.__use		= 1,
153101367c2SThomas Graf 		.obsolete	= -1,
154101367c2SThomas Graf 		.error		= -EACCES,
155101367c2SThomas Graf 		.metrics	= { [RTAX_HOPLIMIT - 1] = 255, },
1569ce8ade0SThomas Graf 		.input		= ip6_pkt_prohibit,
1579ce8ade0SThomas Graf 		.output		= ip6_pkt_prohibit_out,
158101367c2SThomas Graf 	},
159101367c2SThomas Graf 	.rt6i_flags	= (RTF_REJECT | RTF_NONEXTHOP),
1604f724279SJean-Mickael Guerin 	.rt6i_protocol  = RTPROT_KERNEL,
161101367c2SThomas Graf 	.rt6i_metric	= ~(u32) 0,
162101367c2SThomas Graf 	.rt6i_ref	= ATOMIC_INIT(1),
163101367c2SThomas Graf };
164101367c2SThomas Graf 
165bdb3289fSDaniel Lezcano static struct rt6_info ip6_blk_hole_entry_template = {
166101367c2SThomas Graf 	.dst = {
167101367c2SThomas Graf 		.__refcnt	= ATOMIC_INIT(1),
168101367c2SThomas Graf 		.__use		= 1,
169101367c2SThomas Graf 		.obsolete	= -1,
170101367c2SThomas Graf 		.error		= -EINVAL,
171101367c2SThomas Graf 		.metrics	= { [RTAX_HOPLIMIT - 1] = 255, },
172352e512cSHerbert Xu 		.input		= dst_discard,
173352e512cSHerbert Xu 		.output		= dst_discard,
174101367c2SThomas Graf 	},
175101367c2SThomas Graf 	.rt6i_flags	= (RTF_REJECT | RTF_NONEXTHOP),
1764f724279SJean-Mickael Guerin 	.rt6i_protocol  = RTPROT_KERNEL,
177101367c2SThomas Graf 	.rt6i_metric	= ~(u32) 0,
178101367c2SThomas Graf 	.rt6i_ref	= ATOMIC_INIT(1),
179101367c2SThomas Graf };
180101367c2SThomas Graf 
181101367c2SThomas Graf #endif
182101367c2SThomas Graf 
1831da177e4SLinus Torvalds /* allocate dst with ip6_dst_ops */
184f2fc6a54SBenjamin Thery static inline struct rt6_info *ip6_dst_alloc(struct dst_ops *ops)
1851da177e4SLinus Torvalds {
186f2fc6a54SBenjamin Thery 	return (struct rt6_info *)dst_alloc(ops);
1871da177e4SLinus Torvalds }
1881da177e4SLinus Torvalds 
1891da177e4SLinus Torvalds static void ip6_dst_destroy(struct dst_entry *dst)
1901da177e4SLinus Torvalds {
1911da177e4SLinus Torvalds 	struct rt6_info *rt = (struct rt6_info *)dst;
1921da177e4SLinus Torvalds 	struct inet6_dev *idev = rt->rt6i_idev;
1931da177e4SLinus Torvalds 
1941da177e4SLinus Torvalds 	if (idev != NULL) {
1951da177e4SLinus Torvalds 		rt->rt6i_idev = NULL;
1961da177e4SLinus Torvalds 		in6_dev_put(idev);
1971da177e4SLinus Torvalds 	}
1981da177e4SLinus Torvalds }
1991da177e4SLinus Torvalds 
2001da177e4SLinus Torvalds static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
2011da177e4SLinus Torvalds 			   int how)
2021da177e4SLinus Torvalds {
2031da177e4SLinus Torvalds 	struct rt6_info *rt = (struct rt6_info *)dst;
2041da177e4SLinus Torvalds 	struct inet6_dev *idev = rt->rt6i_idev;
2055a3e55d6SDenis V. Lunev 	struct net_device *loopback_dev =
206c346dca1SYOSHIFUJI Hideaki 		dev_net(dev)->loopback_dev;
2071da177e4SLinus Torvalds 
2085a3e55d6SDenis V. Lunev 	if (dev != loopback_dev && idev != NULL && idev->dev == dev) {
2095a3e55d6SDenis V. Lunev 		struct inet6_dev *loopback_idev =
2105a3e55d6SDenis V. Lunev 			in6_dev_get(loopback_dev);
2111da177e4SLinus Torvalds 		if (loopback_idev != NULL) {
2121da177e4SLinus Torvalds 			rt->rt6i_idev = loopback_idev;
2131da177e4SLinus Torvalds 			in6_dev_put(idev);
2141da177e4SLinus Torvalds 		}
2151da177e4SLinus Torvalds 	}
2161da177e4SLinus Torvalds }
2171da177e4SLinus Torvalds 
2181da177e4SLinus Torvalds static __inline__ int rt6_check_expired(const struct rt6_info *rt)
2191da177e4SLinus Torvalds {
2201da177e4SLinus Torvalds 	return (rt->rt6i_flags & RTF_EXPIRES &&
2211da177e4SLinus Torvalds 		time_after(jiffies, rt->rt6i_expires));
2221da177e4SLinus Torvalds }
2231da177e4SLinus Torvalds 
224c71099acSThomas Graf static inline int rt6_need_strict(struct in6_addr *daddr)
225c71099acSThomas Graf {
226c71099acSThomas Graf 	return (ipv6_addr_type(daddr) &
2275ce83afaSYOSHIFUJI Hideaki 		(IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK));
228c71099acSThomas Graf }
229c71099acSThomas Graf 
2301da177e4SLinus Torvalds /*
231c71099acSThomas Graf  *	Route lookup. Any table->tb6_lock is implied.
2321da177e4SLinus Torvalds  */
2331da177e4SLinus Torvalds 
2348ed67789SDaniel Lezcano static inline struct rt6_info *rt6_device_match(struct net *net,
2358ed67789SDaniel Lezcano 						    struct rt6_info *rt,
236dd3abc4eSYOSHIFUJI Hideaki 						    struct in6_addr *saddr,
2371da177e4SLinus Torvalds 						    int oif,
238d420895eSYOSHIFUJI Hideaki 						    int flags)
2391da177e4SLinus Torvalds {
2401da177e4SLinus Torvalds 	struct rt6_info *local = NULL;
2411da177e4SLinus Torvalds 	struct rt6_info *sprt;
2421da177e4SLinus Torvalds 
243dd3abc4eSYOSHIFUJI Hideaki 	if (!oif && ipv6_addr_any(saddr))
244dd3abc4eSYOSHIFUJI Hideaki 		goto out;
245dd3abc4eSYOSHIFUJI Hideaki 
246d8d1f30bSChangli Gao 	for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {
2471da177e4SLinus Torvalds 		struct net_device *dev = sprt->rt6i_dev;
248dd3abc4eSYOSHIFUJI Hideaki 
249dd3abc4eSYOSHIFUJI Hideaki 		if (oif) {
2501da177e4SLinus Torvalds 			if (dev->ifindex == oif)
2511da177e4SLinus Torvalds 				return sprt;
2521da177e4SLinus Torvalds 			if (dev->flags & IFF_LOOPBACK) {
2531da177e4SLinus Torvalds 				if (sprt->rt6i_idev == NULL ||
2541da177e4SLinus Torvalds 				    sprt->rt6i_idev->dev->ifindex != oif) {
255d420895eSYOSHIFUJI Hideaki 					if (flags & RT6_LOOKUP_F_IFACE && oif)
2561da177e4SLinus Torvalds 						continue;
2571da177e4SLinus Torvalds 					if (local && (!oif ||
2581da177e4SLinus Torvalds 						      local->rt6i_idev->dev->ifindex == oif))
2591da177e4SLinus Torvalds 						continue;
2601da177e4SLinus Torvalds 				}
2611da177e4SLinus Torvalds 				local = sprt;
2621da177e4SLinus Torvalds 			}
263dd3abc4eSYOSHIFUJI Hideaki 		} else {
264dd3abc4eSYOSHIFUJI Hideaki 			if (ipv6_chk_addr(net, saddr, dev,
265dd3abc4eSYOSHIFUJI Hideaki 					  flags & RT6_LOOKUP_F_IFACE))
266dd3abc4eSYOSHIFUJI Hideaki 				return sprt;
267dd3abc4eSYOSHIFUJI Hideaki 		}
2681da177e4SLinus Torvalds 	}
2691da177e4SLinus Torvalds 
270dd3abc4eSYOSHIFUJI Hideaki 	if (oif) {
2711da177e4SLinus Torvalds 		if (local)
2721da177e4SLinus Torvalds 			return local;
2731da177e4SLinus Torvalds 
274d420895eSYOSHIFUJI Hideaki 		if (flags & RT6_LOOKUP_F_IFACE)
2758ed67789SDaniel Lezcano 			return net->ipv6.ip6_null_entry;
2761da177e4SLinus Torvalds 	}
277dd3abc4eSYOSHIFUJI Hideaki out:
2781da177e4SLinus Torvalds 	return rt;
2791da177e4SLinus Torvalds }
2801da177e4SLinus Torvalds 
28127097255SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_ROUTER_PREF
28227097255SYOSHIFUJI Hideaki static void rt6_probe(struct rt6_info *rt)
28327097255SYOSHIFUJI Hideaki {
28427097255SYOSHIFUJI Hideaki 	struct neighbour *neigh = rt ? rt->rt6i_nexthop : NULL;
28527097255SYOSHIFUJI Hideaki 	/*
28627097255SYOSHIFUJI Hideaki 	 * Okay, this does not seem to be appropriate
28727097255SYOSHIFUJI Hideaki 	 * for now, however, we need to check if it
28827097255SYOSHIFUJI Hideaki 	 * is really so; aka Router Reachability Probing.
28927097255SYOSHIFUJI Hideaki 	 *
29027097255SYOSHIFUJI Hideaki 	 * Router Reachability Probe MUST be rate-limited
29127097255SYOSHIFUJI Hideaki 	 * to no more than one per minute.
29227097255SYOSHIFUJI Hideaki 	 */
29327097255SYOSHIFUJI Hideaki 	if (!neigh || (neigh->nud_state & NUD_VALID))
29427097255SYOSHIFUJI Hideaki 		return;
29527097255SYOSHIFUJI Hideaki 	read_lock_bh(&neigh->lock);
29627097255SYOSHIFUJI Hideaki 	if (!(neigh->nud_state & NUD_VALID) &&
29752e16356SYOSHIFUJI Hideaki 	    time_after(jiffies, neigh->updated + rt->rt6i_idev->cnf.rtr_probe_interval)) {
29827097255SYOSHIFUJI Hideaki 		struct in6_addr mcaddr;
29927097255SYOSHIFUJI Hideaki 		struct in6_addr *target;
30027097255SYOSHIFUJI Hideaki 
30127097255SYOSHIFUJI Hideaki 		neigh->updated = jiffies;
30227097255SYOSHIFUJI Hideaki 		read_unlock_bh(&neigh->lock);
30327097255SYOSHIFUJI Hideaki 
30427097255SYOSHIFUJI Hideaki 		target = (struct in6_addr *)&neigh->primary_key;
30527097255SYOSHIFUJI Hideaki 		addrconf_addr_solict_mult(target, &mcaddr);
30627097255SYOSHIFUJI Hideaki 		ndisc_send_ns(rt->rt6i_dev, NULL, target, &mcaddr, NULL);
30727097255SYOSHIFUJI Hideaki 	} else
30827097255SYOSHIFUJI Hideaki 		read_unlock_bh(&neigh->lock);
30927097255SYOSHIFUJI Hideaki }
31027097255SYOSHIFUJI Hideaki #else
31127097255SYOSHIFUJI Hideaki static inline void rt6_probe(struct rt6_info *rt)
31227097255SYOSHIFUJI Hideaki {
31327097255SYOSHIFUJI Hideaki }
31427097255SYOSHIFUJI Hideaki #endif
31527097255SYOSHIFUJI Hideaki 
3161da177e4SLinus Torvalds /*
317554cfb7eSYOSHIFUJI Hideaki  * Default Router Selection (RFC 2461 6.3.6)
3181da177e4SLinus Torvalds  */
319b6f99a21SDave Jones static inline int rt6_check_dev(struct rt6_info *rt, int oif)
3201da177e4SLinus Torvalds {
321554cfb7eSYOSHIFUJI Hideaki 	struct net_device *dev = rt->rt6i_dev;
322161980f4SDavid S. Miller 	if (!oif || dev->ifindex == oif)
323554cfb7eSYOSHIFUJI Hideaki 		return 2;
324161980f4SDavid S. Miller 	if ((dev->flags & IFF_LOOPBACK) &&
325161980f4SDavid S. Miller 	    rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
326161980f4SDavid S. Miller 		return 1;
327554cfb7eSYOSHIFUJI Hideaki 	return 0;
3281da177e4SLinus Torvalds }
3291da177e4SLinus Torvalds 
330b6f99a21SDave Jones static inline int rt6_check_neigh(struct rt6_info *rt)
3311da177e4SLinus Torvalds {
332554cfb7eSYOSHIFUJI Hideaki 	struct neighbour *neigh = rt->rt6i_nexthop;
333398bcbebSYOSHIFUJI Hideaki 	int m;
3344d0c5911SYOSHIFUJI Hideaki 	if (rt->rt6i_flags & RTF_NONEXTHOP ||
3354d0c5911SYOSHIFUJI Hideaki 	    !(rt->rt6i_flags & RTF_GATEWAY))
3364d0c5911SYOSHIFUJI Hideaki 		m = 1;
3374d0c5911SYOSHIFUJI Hideaki 	else if (neigh) {
3381da177e4SLinus Torvalds 		read_lock_bh(&neigh->lock);
339554cfb7eSYOSHIFUJI Hideaki 		if (neigh->nud_state & NUD_VALID)
3404d0c5911SYOSHIFUJI Hideaki 			m = 2;
341398bcbebSYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_ROUTER_PREF
342398bcbebSYOSHIFUJI Hideaki 		else if (neigh->nud_state & NUD_FAILED)
343398bcbebSYOSHIFUJI Hideaki 			m = 0;
344398bcbebSYOSHIFUJI Hideaki #endif
345398bcbebSYOSHIFUJI Hideaki 		else
346ea73ee23SYOSHIFUJI Hideaki 			m = 1;
3471da177e4SLinus Torvalds 		read_unlock_bh(&neigh->lock);
348398bcbebSYOSHIFUJI Hideaki 	} else
349398bcbebSYOSHIFUJI Hideaki 		m = 0;
350554cfb7eSYOSHIFUJI Hideaki 	return m;
3511da177e4SLinus Torvalds }
3521da177e4SLinus Torvalds 
353554cfb7eSYOSHIFUJI Hideaki static int rt6_score_route(struct rt6_info *rt, int oif,
354554cfb7eSYOSHIFUJI Hideaki 			   int strict)
355554cfb7eSYOSHIFUJI Hideaki {
3564d0c5911SYOSHIFUJI Hideaki 	int m, n;
3574d0c5911SYOSHIFUJI Hideaki 
3584d0c5911SYOSHIFUJI Hideaki 	m = rt6_check_dev(rt, oif);
35977d16f45SYOSHIFUJI Hideaki 	if (!m && (strict & RT6_LOOKUP_F_IFACE))
360554cfb7eSYOSHIFUJI Hideaki 		return -1;
361ebacaaa0SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_ROUTER_PREF
362ebacaaa0SYOSHIFUJI Hideaki 	m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
363ebacaaa0SYOSHIFUJI Hideaki #endif
3644d0c5911SYOSHIFUJI Hideaki 	n = rt6_check_neigh(rt);
365557e92efSYOSHIFUJI Hideaki 	if (!n && (strict & RT6_LOOKUP_F_REACHABLE))
366554cfb7eSYOSHIFUJI Hideaki 		return -1;
367554cfb7eSYOSHIFUJI Hideaki 	return m;
368554cfb7eSYOSHIFUJI Hideaki }
369554cfb7eSYOSHIFUJI Hideaki 
370f11e6659SDavid S. Miller static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,
371f11e6659SDavid S. Miller 				   int *mpri, struct rt6_info *match)
372554cfb7eSYOSHIFUJI Hideaki {
373554cfb7eSYOSHIFUJI Hideaki 	int m;
374554cfb7eSYOSHIFUJI Hideaki 
375554cfb7eSYOSHIFUJI Hideaki 	if (rt6_check_expired(rt))
376f11e6659SDavid S. Miller 		goto out;
377554cfb7eSYOSHIFUJI Hideaki 
378554cfb7eSYOSHIFUJI Hideaki 	m = rt6_score_route(rt, oif, strict);
379554cfb7eSYOSHIFUJI Hideaki 	if (m < 0)
380f11e6659SDavid S. Miller 		goto out;
381554cfb7eSYOSHIFUJI Hideaki 
382f11e6659SDavid S. Miller 	if (m > *mpri) {
383ea659e07SYOSHIFUJI Hideaki 		if (strict & RT6_LOOKUP_F_REACHABLE)
38427097255SYOSHIFUJI Hideaki 			rt6_probe(match);
385f11e6659SDavid S. Miller 		*mpri = m;
386554cfb7eSYOSHIFUJI Hideaki 		match = rt;
387ea659e07SYOSHIFUJI Hideaki 	} else if (strict & RT6_LOOKUP_F_REACHABLE) {
38827097255SYOSHIFUJI Hideaki 		rt6_probe(rt);
3891da177e4SLinus Torvalds 	}
390f11e6659SDavid S. Miller 
391f11e6659SDavid S. Miller out:
392f11e6659SDavid S. Miller 	return match;
3931da177e4SLinus Torvalds }
3941da177e4SLinus Torvalds 
395f11e6659SDavid S. Miller static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
396f11e6659SDavid S. Miller 				     struct rt6_info *rr_head,
397f11e6659SDavid S. Miller 				     u32 metric, int oif, int strict)
398f11e6659SDavid S. Miller {
399f11e6659SDavid S. Miller 	struct rt6_info *rt, *match;
400f11e6659SDavid S. Miller 	int mpri = -1;
401f11e6659SDavid S. Miller 
402f11e6659SDavid S. Miller 	match = NULL;
403f11e6659SDavid S. Miller 	for (rt = rr_head; rt && rt->rt6i_metric == metric;
404d8d1f30bSChangli Gao 	     rt = rt->dst.rt6_next)
405f11e6659SDavid S. Miller 		match = find_match(rt, oif, strict, &mpri, match);
406f11e6659SDavid S. Miller 	for (rt = fn->leaf; rt && rt != rr_head && rt->rt6i_metric == metric;
407d8d1f30bSChangli Gao 	     rt = rt->dst.rt6_next)
408f11e6659SDavid S. Miller 		match = find_match(rt, oif, strict, &mpri, match);
409f11e6659SDavid S. Miller 
410f11e6659SDavid S. Miller 	return match;
411f11e6659SDavid S. Miller }
412f11e6659SDavid S. Miller 
413f11e6659SDavid S. Miller static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
414f11e6659SDavid S. Miller {
415f11e6659SDavid S. Miller 	struct rt6_info *match, *rt0;
4168ed67789SDaniel Lezcano 	struct net *net;
417f11e6659SDavid S. Miller 
418f11e6659SDavid S. Miller 	RT6_TRACE("%s(fn->leaf=%p, oif=%d)\n",
4190dc47877SHarvey Harrison 		  __func__, fn->leaf, oif);
420f11e6659SDavid S. Miller 
421f11e6659SDavid S. Miller 	rt0 = fn->rr_ptr;
422f11e6659SDavid S. Miller 	if (!rt0)
423f11e6659SDavid S. Miller 		fn->rr_ptr = rt0 = fn->leaf;
424f11e6659SDavid S. Miller 
425f11e6659SDavid S. Miller 	match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict);
426f11e6659SDavid S. Miller 
427554cfb7eSYOSHIFUJI Hideaki 	if (!match &&
428f11e6659SDavid S. Miller 	    (strict & RT6_LOOKUP_F_REACHABLE)) {
429d8d1f30bSChangli Gao 		struct rt6_info *next = rt0->dst.rt6_next;
430f11e6659SDavid S. Miller 
431554cfb7eSYOSHIFUJI Hideaki 		/* no entries matched; do round-robin */
432f11e6659SDavid S. Miller 		if (!next || next->rt6i_metric != rt0->rt6i_metric)
433f11e6659SDavid S. Miller 			next = fn->leaf;
434f11e6659SDavid S. Miller 
435f11e6659SDavid S. Miller 		if (next != rt0)
436f11e6659SDavid S. Miller 			fn->rr_ptr = next;
437554cfb7eSYOSHIFUJI Hideaki 	}
438554cfb7eSYOSHIFUJI Hideaki 
439f11e6659SDavid S. Miller 	RT6_TRACE("%s() => %p\n",
4400dc47877SHarvey Harrison 		  __func__, match);
441554cfb7eSYOSHIFUJI Hideaki 
442c346dca1SYOSHIFUJI Hideaki 	net = dev_net(rt0->rt6i_dev);
4438ed67789SDaniel Lezcano 	return (match ? match : net->ipv6.ip6_null_entry);
4441da177e4SLinus Torvalds }
4451da177e4SLinus Torvalds 
44670ceb4f5SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_ROUTE_INFO
44770ceb4f5SYOSHIFUJI Hideaki int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
44870ceb4f5SYOSHIFUJI Hideaki 		  struct in6_addr *gwaddr)
44970ceb4f5SYOSHIFUJI Hideaki {
450c346dca1SYOSHIFUJI Hideaki 	struct net *net = dev_net(dev);
45170ceb4f5SYOSHIFUJI Hideaki 	struct route_info *rinfo = (struct route_info *) opt;
45270ceb4f5SYOSHIFUJI Hideaki 	struct in6_addr prefix_buf, *prefix;
45370ceb4f5SYOSHIFUJI Hideaki 	unsigned int pref;
4544bed72e4SYOSHIFUJI Hideaki 	unsigned long lifetime;
45570ceb4f5SYOSHIFUJI Hideaki 	struct rt6_info *rt;
45670ceb4f5SYOSHIFUJI Hideaki 
45770ceb4f5SYOSHIFUJI Hideaki 	if (len < sizeof(struct route_info)) {
45870ceb4f5SYOSHIFUJI Hideaki 		return -EINVAL;
45970ceb4f5SYOSHIFUJI Hideaki 	}
46070ceb4f5SYOSHIFUJI Hideaki 
46170ceb4f5SYOSHIFUJI Hideaki 	/* Sanity check for prefix_len and length */
46270ceb4f5SYOSHIFUJI Hideaki 	if (rinfo->length > 3) {
46370ceb4f5SYOSHIFUJI Hideaki 		return -EINVAL;
46470ceb4f5SYOSHIFUJI Hideaki 	} else if (rinfo->prefix_len > 128) {
46570ceb4f5SYOSHIFUJI Hideaki 		return -EINVAL;
46670ceb4f5SYOSHIFUJI Hideaki 	} else if (rinfo->prefix_len > 64) {
46770ceb4f5SYOSHIFUJI Hideaki 		if (rinfo->length < 2) {
46870ceb4f5SYOSHIFUJI Hideaki 			return -EINVAL;
46970ceb4f5SYOSHIFUJI Hideaki 		}
47070ceb4f5SYOSHIFUJI Hideaki 	} else if (rinfo->prefix_len > 0) {
47170ceb4f5SYOSHIFUJI Hideaki 		if (rinfo->length < 1) {
47270ceb4f5SYOSHIFUJI Hideaki 			return -EINVAL;
47370ceb4f5SYOSHIFUJI Hideaki 		}
47470ceb4f5SYOSHIFUJI Hideaki 	}
47570ceb4f5SYOSHIFUJI Hideaki 
47670ceb4f5SYOSHIFUJI Hideaki 	pref = rinfo->route_pref;
47770ceb4f5SYOSHIFUJI Hideaki 	if (pref == ICMPV6_ROUTER_PREF_INVALID)
4783933fc95SJens Rosenboom 		return -EINVAL;
47970ceb4f5SYOSHIFUJI Hideaki 
4804bed72e4SYOSHIFUJI Hideaki 	lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
48170ceb4f5SYOSHIFUJI Hideaki 
48270ceb4f5SYOSHIFUJI Hideaki 	if (rinfo->length == 3)
48370ceb4f5SYOSHIFUJI Hideaki 		prefix = (struct in6_addr *)rinfo->prefix;
48470ceb4f5SYOSHIFUJI Hideaki 	else {
48570ceb4f5SYOSHIFUJI Hideaki 		/* this function is safe */
48670ceb4f5SYOSHIFUJI Hideaki 		ipv6_addr_prefix(&prefix_buf,
48770ceb4f5SYOSHIFUJI Hideaki 				 (struct in6_addr *)rinfo->prefix,
48870ceb4f5SYOSHIFUJI Hideaki 				 rinfo->prefix_len);
48970ceb4f5SYOSHIFUJI Hideaki 		prefix = &prefix_buf;
49070ceb4f5SYOSHIFUJI Hideaki 	}
49170ceb4f5SYOSHIFUJI Hideaki 
492efa2cea0SDaniel Lezcano 	rt = rt6_get_route_info(net, prefix, rinfo->prefix_len, gwaddr,
493efa2cea0SDaniel Lezcano 				dev->ifindex);
49470ceb4f5SYOSHIFUJI Hideaki 
49570ceb4f5SYOSHIFUJI Hideaki 	if (rt && !lifetime) {
496e0a1ad73SThomas Graf 		ip6_del_rt(rt);
49770ceb4f5SYOSHIFUJI Hideaki 		rt = NULL;
49870ceb4f5SYOSHIFUJI Hideaki 	}
49970ceb4f5SYOSHIFUJI Hideaki 
50070ceb4f5SYOSHIFUJI Hideaki 	if (!rt && lifetime)
501efa2cea0SDaniel Lezcano 		rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr, dev->ifindex,
50270ceb4f5SYOSHIFUJI Hideaki 					pref);
50370ceb4f5SYOSHIFUJI Hideaki 	else if (rt)
50470ceb4f5SYOSHIFUJI Hideaki 		rt->rt6i_flags = RTF_ROUTEINFO |
50570ceb4f5SYOSHIFUJI Hideaki 				 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
50670ceb4f5SYOSHIFUJI Hideaki 
50770ceb4f5SYOSHIFUJI Hideaki 	if (rt) {
5084bed72e4SYOSHIFUJI Hideaki 		if (!addrconf_finite_timeout(lifetime)) {
50970ceb4f5SYOSHIFUJI Hideaki 			rt->rt6i_flags &= ~RTF_EXPIRES;
51070ceb4f5SYOSHIFUJI Hideaki 		} else {
51170ceb4f5SYOSHIFUJI Hideaki 			rt->rt6i_expires = jiffies + HZ * lifetime;
51270ceb4f5SYOSHIFUJI Hideaki 			rt->rt6i_flags |= RTF_EXPIRES;
51370ceb4f5SYOSHIFUJI Hideaki 		}
514d8d1f30bSChangli Gao 		dst_release(&rt->dst);
51570ceb4f5SYOSHIFUJI Hideaki 	}
51670ceb4f5SYOSHIFUJI Hideaki 	return 0;
51770ceb4f5SYOSHIFUJI Hideaki }
51870ceb4f5SYOSHIFUJI Hideaki #endif
51970ceb4f5SYOSHIFUJI Hideaki 
5208ed67789SDaniel Lezcano #define BACKTRACK(__net, saddr)			\
521982f56f3SYOSHIFUJI Hideaki do { \
5228ed67789SDaniel Lezcano 	if (rt == __net->ipv6.ip6_null_entry) {	\
523982f56f3SYOSHIFUJI Hideaki 		struct fib6_node *pn; \
524e0eda7bbSVille Nuorvala 		while (1) { \
525982f56f3SYOSHIFUJI Hideaki 			if (fn->fn_flags & RTN_TL_ROOT) \
526c71099acSThomas Graf 				goto out; \
527982f56f3SYOSHIFUJI Hideaki 			pn = fn->parent; \
528982f56f3SYOSHIFUJI Hideaki 			if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn) \
5298bce65b9SKim Nordlund 				fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr); \
530982f56f3SYOSHIFUJI Hideaki 			else \
531982f56f3SYOSHIFUJI Hideaki 				fn = pn; \
532c71099acSThomas Graf 			if (fn->fn_flags & RTN_RTINFO) \
533c71099acSThomas Graf 				goto restart; \
534c71099acSThomas Graf 		} \
535982f56f3SYOSHIFUJI Hideaki 	} \
536982f56f3SYOSHIFUJI Hideaki } while(0)
537c71099acSThomas Graf 
5388ed67789SDaniel Lezcano static struct rt6_info *ip6_pol_route_lookup(struct net *net,
5398ed67789SDaniel Lezcano 					     struct fib6_table *table,
540c71099acSThomas Graf 					     struct flowi *fl, int flags)
5411da177e4SLinus Torvalds {
5421da177e4SLinus Torvalds 	struct fib6_node *fn;
5431da177e4SLinus Torvalds 	struct rt6_info *rt;
5441da177e4SLinus Torvalds 
545c71099acSThomas Graf 	read_lock_bh(&table->tb6_lock);
546c71099acSThomas Graf 	fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
547c71099acSThomas Graf restart:
548c71099acSThomas Graf 	rt = fn->leaf;
549dd3abc4eSYOSHIFUJI Hideaki 	rt = rt6_device_match(net, rt, &fl->fl6_src, fl->oif, flags);
5508ed67789SDaniel Lezcano 	BACKTRACK(net, &fl->fl6_src);
551c71099acSThomas Graf out:
552d8d1f30bSChangli Gao 	dst_use(&rt->dst, jiffies);
553c71099acSThomas Graf 	read_unlock_bh(&table->tb6_lock);
5541da177e4SLinus Torvalds 	return rt;
555c71099acSThomas Graf 
556c71099acSThomas Graf }
557c71099acSThomas Graf 
5589acd9f3aSYOSHIFUJI Hideaki struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
5599acd9f3aSYOSHIFUJI Hideaki 			    const struct in6_addr *saddr, int oif, int strict)
560c71099acSThomas Graf {
561c71099acSThomas Graf 	struct flowi fl = {
562c71099acSThomas Graf 		.oif = oif,
563c71099acSThomas Graf 		.nl_u = {
564c71099acSThomas Graf 			.ip6_u = {
565c71099acSThomas Graf 				.daddr = *daddr,
566c71099acSThomas Graf 			},
567c71099acSThomas Graf 		},
568c71099acSThomas Graf 	};
569c71099acSThomas Graf 	struct dst_entry *dst;
57077d16f45SYOSHIFUJI Hideaki 	int flags = strict ? RT6_LOOKUP_F_IFACE : 0;
571c71099acSThomas Graf 
572adaa70bbSThomas Graf 	if (saddr) {
573adaa70bbSThomas Graf 		memcpy(&fl.fl6_src, saddr, sizeof(*saddr));
574adaa70bbSThomas Graf 		flags |= RT6_LOOKUP_F_HAS_SADDR;
575adaa70bbSThomas Graf 	}
576adaa70bbSThomas Graf 
577606a2b48SDaniel Lezcano 	dst = fib6_rule_lookup(net, &fl, flags, ip6_pol_route_lookup);
578c71099acSThomas Graf 	if (dst->error == 0)
579c71099acSThomas Graf 		return (struct rt6_info *) dst;
580c71099acSThomas Graf 
581c71099acSThomas Graf 	dst_release(dst);
582c71099acSThomas Graf 
5831da177e4SLinus Torvalds 	return NULL;
5841da177e4SLinus Torvalds }
5851da177e4SLinus Torvalds 
5867159039aSYOSHIFUJI Hideaki EXPORT_SYMBOL(rt6_lookup);
5877159039aSYOSHIFUJI Hideaki 
588c71099acSThomas Graf /* ip6_ins_rt is called with FREE table->tb6_lock.
5891da177e4SLinus Torvalds    It takes new route entry, the addition fails by any reason the
5901da177e4SLinus Torvalds    route is freed. In any case, if caller does not hold it, it may
5911da177e4SLinus Torvalds    be destroyed.
5921da177e4SLinus Torvalds  */
5931da177e4SLinus Torvalds 
59486872cb5SThomas Graf static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info)
5951da177e4SLinus Torvalds {
5961da177e4SLinus Torvalds 	int err;
597c71099acSThomas Graf 	struct fib6_table *table;
5981da177e4SLinus Torvalds 
599c71099acSThomas Graf 	table = rt->rt6i_table;
600c71099acSThomas Graf 	write_lock_bh(&table->tb6_lock);
60186872cb5SThomas Graf 	err = fib6_add(&table->tb6_root, rt, info);
602c71099acSThomas Graf 	write_unlock_bh(&table->tb6_lock);
6031da177e4SLinus Torvalds 
6041da177e4SLinus Torvalds 	return err;
6051da177e4SLinus Torvalds }
6061da177e4SLinus Torvalds 
60740e22e8fSThomas Graf int ip6_ins_rt(struct rt6_info *rt)
60840e22e8fSThomas Graf {
6094d1169c1SDenis V. Lunev 	struct nl_info info = {
610c346dca1SYOSHIFUJI Hideaki 		.nl_net = dev_net(rt->rt6i_dev),
6114d1169c1SDenis V. Lunev 	};
612528c4cebSDenis V. Lunev 	return __ip6_ins_rt(rt, &info);
61340e22e8fSThomas Graf }
61440e22e8fSThomas Graf 
61595a9a5baSYOSHIFUJI Hideaki static struct rt6_info *rt6_alloc_cow(struct rt6_info *ort, struct in6_addr *daddr,
61695a9a5baSYOSHIFUJI Hideaki 				      struct in6_addr *saddr)
6171da177e4SLinus Torvalds {
6181da177e4SLinus Torvalds 	struct rt6_info *rt;
6191da177e4SLinus Torvalds 
6201da177e4SLinus Torvalds 	/*
6211da177e4SLinus Torvalds 	 *	Clone the route.
6221da177e4SLinus Torvalds 	 */
6231da177e4SLinus Torvalds 
6241da177e4SLinus Torvalds 	rt = ip6_rt_copy(ort);
6251da177e4SLinus Torvalds 
6261da177e4SLinus Torvalds 	if (rt) {
62714deae41SDavid S. Miller 		struct neighbour *neigh;
62814deae41SDavid S. Miller 		int attempts = !in_softirq();
62914deae41SDavid S. Miller 
63058c4fb86SYOSHIFUJI Hideaki 		if (!(rt->rt6i_flags&RTF_GATEWAY)) {
63158c4fb86SYOSHIFUJI Hideaki 			if (rt->rt6i_dst.plen != 128 &&
63258c4fb86SYOSHIFUJI Hideaki 			    ipv6_addr_equal(&rt->rt6i_dst.addr, daddr))
63358c4fb86SYOSHIFUJI Hideaki 				rt->rt6i_flags |= RTF_ANYCAST;
6341da177e4SLinus Torvalds 			ipv6_addr_copy(&rt->rt6i_gateway, daddr);
63558c4fb86SYOSHIFUJI Hideaki 		}
6361da177e4SLinus Torvalds 
63758c4fb86SYOSHIFUJI Hideaki 		ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
6381da177e4SLinus Torvalds 		rt->rt6i_dst.plen = 128;
6391da177e4SLinus Torvalds 		rt->rt6i_flags |= RTF_CACHE;
640d8d1f30bSChangli Gao 		rt->dst.flags |= DST_HOST;
6411da177e4SLinus Torvalds 
6421da177e4SLinus Torvalds #ifdef CONFIG_IPV6_SUBTREES
6431da177e4SLinus Torvalds 		if (rt->rt6i_src.plen && saddr) {
6441da177e4SLinus Torvalds 			ipv6_addr_copy(&rt->rt6i_src.addr, saddr);
6451da177e4SLinus Torvalds 			rt->rt6i_src.plen = 128;
6461da177e4SLinus Torvalds 		}
6471da177e4SLinus Torvalds #endif
6481da177e4SLinus Torvalds 
64914deae41SDavid S. Miller 	retry:
65014deae41SDavid S. Miller 		neigh = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
65114deae41SDavid S. Miller 		if (IS_ERR(neigh)) {
65214deae41SDavid S. Miller 			struct net *net = dev_net(rt->rt6i_dev);
65314deae41SDavid S. Miller 			int saved_rt_min_interval =
65414deae41SDavid S. Miller 				net->ipv6.sysctl.ip6_rt_gc_min_interval;
65514deae41SDavid S. Miller 			int saved_rt_elasticity =
65614deae41SDavid S. Miller 				net->ipv6.sysctl.ip6_rt_gc_elasticity;
65714deae41SDavid S. Miller 
65814deae41SDavid S. Miller 			if (attempts-- > 0) {
65914deae41SDavid S. Miller 				net->ipv6.sysctl.ip6_rt_gc_elasticity = 1;
66014deae41SDavid S. Miller 				net->ipv6.sysctl.ip6_rt_gc_min_interval = 0;
66114deae41SDavid S. Miller 
66286393e52SAlexey Dobriyan 				ip6_dst_gc(&net->ipv6.ip6_dst_ops);
66314deae41SDavid S. Miller 
66414deae41SDavid S. Miller 				net->ipv6.sysctl.ip6_rt_gc_elasticity =
66514deae41SDavid S. Miller 					saved_rt_elasticity;
66614deae41SDavid S. Miller 				net->ipv6.sysctl.ip6_rt_gc_min_interval =
66714deae41SDavid S. Miller 					saved_rt_min_interval;
66814deae41SDavid S. Miller 				goto retry;
66914deae41SDavid S. Miller 			}
67014deae41SDavid S. Miller 
67114deae41SDavid S. Miller 			if (net_ratelimit())
67214deae41SDavid S. Miller 				printk(KERN_WARNING
67314deae41SDavid S. Miller 				       "Neighbour table overflow.\n");
674d8d1f30bSChangli Gao 			dst_free(&rt->dst);
67514deae41SDavid S. Miller 			return NULL;
67614deae41SDavid S. Miller 		}
67714deae41SDavid S. Miller 		rt->rt6i_nexthop = neigh;
6781da177e4SLinus Torvalds 
67995a9a5baSYOSHIFUJI Hideaki 	}
6801da177e4SLinus Torvalds 
6811da177e4SLinus Torvalds 	return rt;
6821da177e4SLinus Torvalds }
68395a9a5baSYOSHIFUJI Hideaki 
684299d9939SYOSHIFUJI Hideaki static struct rt6_info *rt6_alloc_clone(struct rt6_info *ort, struct in6_addr *daddr)
685299d9939SYOSHIFUJI Hideaki {
686299d9939SYOSHIFUJI Hideaki 	struct rt6_info *rt = ip6_rt_copy(ort);
687299d9939SYOSHIFUJI Hideaki 	if (rt) {
688299d9939SYOSHIFUJI Hideaki 		ipv6_addr_copy(&rt->rt6i_dst.addr, daddr);
689299d9939SYOSHIFUJI Hideaki 		rt->rt6i_dst.plen = 128;
690299d9939SYOSHIFUJI Hideaki 		rt->rt6i_flags |= RTF_CACHE;
691d8d1f30bSChangli Gao 		rt->dst.flags |= DST_HOST;
692299d9939SYOSHIFUJI Hideaki 		rt->rt6i_nexthop = neigh_clone(ort->rt6i_nexthop);
693299d9939SYOSHIFUJI Hideaki 	}
694299d9939SYOSHIFUJI Hideaki 	return rt;
695299d9939SYOSHIFUJI Hideaki }
696299d9939SYOSHIFUJI Hideaki 
6978ed67789SDaniel Lezcano static struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table, int oif,
6988ce11e6aSAdrian Bunk 				      struct flowi *fl, int flags)
6991da177e4SLinus Torvalds {
7001da177e4SLinus Torvalds 	struct fib6_node *fn;
701519fbd87SYOSHIFUJI Hideaki 	struct rt6_info *rt, *nrt;
702c71099acSThomas Graf 	int strict = 0;
7031da177e4SLinus Torvalds 	int attempts = 3;
704519fbd87SYOSHIFUJI Hideaki 	int err;
70553b7997fSYOSHIFUJI Hideaki 	int reachable = net->ipv6.devconf_all->forwarding ? 0 : RT6_LOOKUP_F_REACHABLE;
7061da177e4SLinus Torvalds 
70777d16f45SYOSHIFUJI Hideaki 	strict |= flags & RT6_LOOKUP_F_IFACE;
7081da177e4SLinus Torvalds 
7091da177e4SLinus Torvalds relookup:
710c71099acSThomas Graf 	read_lock_bh(&table->tb6_lock);
7111da177e4SLinus Torvalds 
7128238dd06SYOSHIFUJI Hideaki restart_2:
713c71099acSThomas Graf 	fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
7141da177e4SLinus Torvalds 
7151da177e4SLinus Torvalds restart:
7164acad72dSPavel Emelyanov 	rt = rt6_select(fn, oif, strict | reachable);
7178ed67789SDaniel Lezcano 
7188ed67789SDaniel Lezcano 	BACKTRACK(net, &fl->fl6_src);
7198ed67789SDaniel Lezcano 	if (rt == net->ipv6.ip6_null_entry ||
7208238dd06SYOSHIFUJI Hideaki 	    rt->rt6i_flags & RTF_CACHE)
7211da177e4SLinus Torvalds 		goto out;
7221da177e4SLinus Torvalds 
723d8d1f30bSChangli Gao 	dst_hold(&rt->dst);
724c71099acSThomas Graf 	read_unlock_bh(&table->tb6_lock);
7251da177e4SLinus Torvalds 
726519fbd87SYOSHIFUJI Hideaki 	if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
727e40cf353SYOSHIFUJI Hideaki 		nrt = rt6_alloc_cow(rt, &fl->fl6_dst, &fl->fl6_src);
728519fbd87SYOSHIFUJI Hideaki 	else {
729519fbd87SYOSHIFUJI Hideaki #if CLONE_OFFLINK_ROUTE
730519fbd87SYOSHIFUJI Hideaki 		nrt = rt6_alloc_clone(rt, &fl->fl6_dst);
731519fbd87SYOSHIFUJI Hideaki #else
732519fbd87SYOSHIFUJI Hideaki 		goto out2;
733519fbd87SYOSHIFUJI Hideaki #endif
734519fbd87SYOSHIFUJI Hideaki 	}
7351da177e4SLinus Torvalds 
736d8d1f30bSChangli Gao 	dst_release(&rt->dst);
7378ed67789SDaniel Lezcano 	rt = nrt ? : net->ipv6.ip6_null_entry;
7381da177e4SLinus Torvalds 
739d8d1f30bSChangli Gao 	dst_hold(&rt->dst);
740e40cf353SYOSHIFUJI Hideaki 	if (nrt) {
74140e22e8fSThomas Graf 		err = ip6_ins_rt(nrt);
742e40cf353SYOSHIFUJI Hideaki 		if (!err)
743e40cf353SYOSHIFUJI Hideaki 			goto out2;
744e40cf353SYOSHIFUJI Hideaki 	}
745e40cf353SYOSHIFUJI Hideaki 
746e40cf353SYOSHIFUJI Hideaki 	if (--attempts <= 0)
7471da177e4SLinus Torvalds 		goto out2;
7481da177e4SLinus Torvalds 
749519fbd87SYOSHIFUJI Hideaki 	/*
750c71099acSThomas Graf 	 * Race condition! In the gap, when table->tb6_lock was
751519fbd87SYOSHIFUJI Hideaki 	 * released someone could insert this route.  Relookup.
7521da177e4SLinus Torvalds 	 */
753d8d1f30bSChangli Gao 	dst_release(&rt->dst);
7541da177e4SLinus Torvalds 	goto relookup;
755e40cf353SYOSHIFUJI Hideaki 
756519fbd87SYOSHIFUJI Hideaki out:
7578238dd06SYOSHIFUJI Hideaki 	if (reachable) {
7588238dd06SYOSHIFUJI Hideaki 		reachable = 0;
7598238dd06SYOSHIFUJI Hideaki 		goto restart_2;
7608238dd06SYOSHIFUJI Hideaki 	}
761d8d1f30bSChangli Gao 	dst_hold(&rt->dst);
762c71099acSThomas Graf 	read_unlock_bh(&table->tb6_lock);
7631da177e4SLinus Torvalds out2:
764d8d1f30bSChangli Gao 	rt->dst.lastuse = jiffies;
765d8d1f30bSChangli Gao 	rt->dst.__use++;
766c71099acSThomas Graf 
767c71099acSThomas Graf 	return rt;
768c71099acSThomas Graf }
769c71099acSThomas Graf 
7708ed67789SDaniel Lezcano static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,
7714acad72dSPavel Emelyanov 					    struct flowi *fl, int flags)
7724acad72dSPavel Emelyanov {
7738ed67789SDaniel Lezcano 	return ip6_pol_route(net, table, fl->iif, fl, flags);
7744acad72dSPavel Emelyanov }
7754acad72dSPavel Emelyanov 
776c71099acSThomas Graf void ip6_route_input(struct sk_buff *skb)
777c71099acSThomas Graf {
7780660e03fSArnaldo Carvalho de Melo 	struct ipv6hdr *iph = ipv6_hdr(skb);
779c346dca1SYOSHIFUJI Hideaki 	struct net *net = dev_net(skb->dev);
780adaa70bbSThomas Graf 	int flags = RT6_LOOKUP_F_HAS_SADDR;
781c71099acSThomas Graf 	struct flowi fl = {
782c71099acSThomas Graf 		.iif = skb->dev->ifindex,
783c71099acSThomas Graf 		.nl_u = {
784c71099acSThomas Graf 			.ip6_u = {
785c71099acSThomas Graf 				.daddr = iph->daddr,
786c71099acSThomas Graf 				.saddr = iph->saddr,
78790bcaf7bSAl Viro 				.flowlabel = (* (__be32 *) iph)&IPV6_FLOWINFO_MASK,
788c71099acSThomas Graf 			},
789c71099acSThomas Graf 		},
79047dcf0cbSThomas Graf 		.mark = skb->mark,
791c71099acSThomas Graf 		.proto = iph->nexthdr,
792c71099acSThomas Graf 	};
793adaa70bbSThomas Graf 
7941d6e55f1SThomas Goff 	if (rt6_need_strict(&iph->daddr) && skb->dev->type != ARPHRD_PIMREG)
795adaa70bbSThomas Graf 		flags |= RT6_LOOKUP_F_IFACE;
796c71099acSThomas Graf 
797adf30907SEric Dumazet 	skb_dst_set(skb, fib6_rule_lookup(net, &fl, flags, ip6_pol_route_input));
798c71099acSThomas Graf }
799c71099acSThomas Graf 
8008ed67789SDaniel Lezcano static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,
801c71099acSThomas Graf 					     struct flowi *fl, int flags)
802c71099acSThomas Graf {
8038ed67789SDaniel Lezcano 	return ip6_pol_route(net, table, fl->oif, fl, flags);
804c71099acSThomas Graf }
805c71099acSThomas Graf 
8064591db4fSDaniel Lezcano struct dst_entry * ip6_route_output(struct net *net, struct sock *sk,
8074591db4fSDaniel Lezcano 				    struct flowi *fl)
808c71099acSThomas Graf {
809c71099acSThomas Graf 	int flags = 0;
810c71099acSThomas Graf 
8116057fd78SBrian Haley 	if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl->fl6_dst))
81277d16f45SYOSHIFUJI Hideaki 		flags |= RT6_LOOKUP_F_IFACE;
813c71099acSThomas Graf 
814adaa70bbSThomas Graf 	if (!ipv6_addr_any(&fl->fl6_src))
815adaa70bbSThomas Graf 		flags |= RT6_LOOKUP_F_HAS_SADDR;
8160c9a2ac1SYOSHIFUJI Hideaki / 吉藤英明 	else if (sk)
8170c9a2ac1SYOSHIFUJI Hideaki / 吉藤英明 		flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);
818adaa70bbSThomas Graf 
8194591db4fSDaniel Lezcano 	return fib6_rule_lookup(net, fl, flags, ip6_pol_route_output);
8201da177e4SLinus Torvalds }
8211da177e4SLinus Torvalds 
8227159039aSYOSHIFUJI Hideaki EXPORT_SYMBOL(ip6_route_output);
8231da177e4SLinus Torvalds 
82414e50e57SDavid S. Miller int ip6_dst_blackhole(struct sock *sk, struct dst_entry **dstp, struct flowi *fl)
82514e50e57SDavid S. Miller {
82614e50e57SDavid S. Miller 	struct rt6_info *ort = (struct rt6_info *) *dstp;
82714e50e57SDavid S. Miller 	struct rt6_info *rt = (struct rt6_info *)
82814e50e57SDavid S. Miller 		dst_alloc(&ip6_dst_blackhole_ops);
82914e50e57SDavid S. Miller 	struct dst_entry *new = NULL;
83014e50e57SDavid S. Miller 
83114e50e57SDavid S. Miller 	if (rt) {
832d8d1f30bSChangli Gao 		new = &rt->dst;
83314e50e57SDavid S. Miller 
83414e50e57SDavid S. Miller 		atomic_set(&new->__refcnt, 1);
83514e50e57SDavid S. Miller 		new->__use = 1;
836352e512cSHerbert Xu 		new->input = dst_discard;
837352e512cSHerbert Xu 		new->output = dst_discard;
83814e50e57SDavid S. Miller 
839d8d1f30bSChangli Gao 		memcpy(new->metrics, ort->dst.metrics, RTAX_MAX*sizeof(u32));
840d8d1f30bSChangli Gao 		new->dev = ort->dst.dev;
84114e50e57SDavid S. Miller 		if (new->dev)
84214e50e57SDavid S. Miller 			dev_hold(new->dev);
84314e50e57SDavid S. Miller 		rt->rt6i_idev = ort->rt6i_idev;
84414e50e57SDavid S. Miller 		if (rt->rt6i_idev)
84514e50e57SDavid S. Miller 			in6_dev_hold(rt->rt6i_idev);
84614e50e57SDavid S. Miller 		rt->rt6i_expires = 0;
84714e50e57SDavid S. Miller 
84814e50e57SDavid S. Miller 		ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
84914e50e57SDavid S. Miller 		rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
85014e50e57SDavid S. Miller 		rt->rt6i_metric = 0;
85114e50e57SDavid S. Miller 
85214e50e57SDavid S. Miller 		memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
85314e50e57SDavid S. Miller #ifdef CONFIG_IPV6_SUBTREES
85414e50e57SDavid S. Miller 		memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
85514e50e57SDavid S. Miller #endif
85614e50e57SDavid S. Miller 
85714e50e57SDavid S. Miller 		dst_free(new);
85814e50e57SDavid S. Miller 	}
85914e50e57SDavid S. Miller 
86014e50e57SDavid S. Miller 	dst_release(*dstp);
86114e50e57SDavid S. Miller 	*dstp = new;
86214e50e57SDavid S. Miller 	return (new ? 0 : -ENOMEM);
86314e50e57SDavid S. Miller }
86414e50e57SDavid S. Miller EXPORT_SYMBOL_GPL(ip6_dst_blackhole);
86514e50e57SDavid S. Miller 
8661da177e4SLinus Torvalds /*
8671da177e4SLinus Torvalds  *	Destination cache support functions
8681da177e4SLinus Torvalds  */
8691da177e4SLinus Torvalds 
8701da177e4SLinus Torvalds static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
8711da177e4SLinus Torvalds {
8721da177e4SLinus Torvalds 	struct rt6_info *rt;
8731da177e4SLinus Torvalds 
8741da177e4SLinus Torvalds 	rt = (struct rt6_info *) dst;
8751da177e4SLinus Torvalds 
87610414444SHerbert Xu 	if (rt->rt6i_node && (rt->rt6i_node->fn_sernum == cookie))
8771da177e4SLinus Torvalds 		return dst;
8781da177e4SLinus Torvalds 
8791da177e4SLinus Torvalds 	return NULL;
8801da177e4SLinus Torvalds }
8811da177e4SLinus Torvalds 
8821da177e4SLinus Torvalds static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
8831da177e4SLinus Torvalds {
8841da177e4SLinus Torvalds 	struct rt6_info *rt = (struct rt6_info *) dst;
8851da177e4SLinus Torvalds 
8861da177e4SLinus Torvalds 	if (rt) {
88754c1a859SYOSHIFUJI Hideaki / 吉藤英明 		if (rt->rt6i_flags & RTF_CACHE) {
88854c1a859SYOSHIFUJI Hideaki / 吉藤英明 			if (rt6_check_expired(rt)) {
889e0a1ad73SThomas Graf 				ip6_del_rt(rt);
89054c1a859SYOSHIFUJI Hideaki / 吉藤英明 				dst = NULL;
8911da177e4SLinus Torvalds 			}
89254c1a859SYOSHIFUJI Hideaki / 吉藤英明 		} else {
89354c1a859SYOSHIFUJI Hideaki / 吉藤英明 			dst_release(dst);
89454c1a859SYOSHIFUJI Hideaki / 吉藤英明 			dst = NULL;
89554c1a859SYOSHIFUJI Hideaki / 吉藤英明 		}
89654c1a859SYOSHIFUJI Hideaki / 吉藤英明 	}
89754c1a859SYOSHIFUJI Hideaki / 吉藤英明 	return dst;
8981da177e4SLinus Torvalds }
8991da177e4SLinus Torvalds 
9001da177e4SLinus Torvalds static void ip6_link_failure(struct sk_buff *skb)
9011da177e4SLinus Torvalds {
9021da177e4SLinus Torvalds 	struct rt6_info *rt;
9031da177e4SLinus Torvalds 
9043ffe533cSAlexey Dobriyan 	icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);
9051da177e4SLinus Torvalds 
906adf30907SEric Dumazet 	rt = (struct rt6_info *) skb_dst(skb);
9071da177e4SLinus Torvalds 	if (rt) {
9081da177e4SLinus Torvalds 		if (rt->rt6i_flags&RTF_CACHE) {
909d8d1f30bSChangli Gao 			dst_set_expires(&rt->dst, 0);
9101da177e4SLinus Torvalds 			rt->rt6i_flags |= RTF_EXPIRES;
9111da177e4SLinus Torvalds 		} else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT))
9121da177e4SLinus Torvalds 			rt->rt6i_node->fn_sernum = -1;
9131da177e4SLinus Torvalds 	}
9141da177e4SLinus Torvalds }
9151da177e4SLinus Torvalds 
9161da177e4SLinus Torvalds static void ip6_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
9171da177e4SLinus Torvalds {
9181da177e4SLinus Torvalds 	struct rt6_info *rt6 = (struct rt6_info*)dst;
9191da177e4SLinus Torvalds 
9201da177e4SLinus Torvalds 	if (mtu < dst_mtu(dst) && rt6->rt6i_dst.plen == 128) {
9211da177e4SLinus Torvalds 		rt6->rt6i_flags |= RTF_MODIFIED;
9221da177e4SLinus Torvalds 		if (mtu < IPV6_MIN_MTU) {
9231da177e4SLinus Torvalds 			mtu = IPV6_MIN_MTU;
9241da177e4SLinus Torvalds 			dst->metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
9251da177e4SLinus Torvalds 		}
9261da177e4SLinus Torvalds 		dst->metrics[RTAX_MTU-1] = mtu;
9278d71740cSTom Tucker 		call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);
9281da177e4SLinus Torvalds 	}
9291da177e4SLinus Torvalds }
9301da177e4SLinus Torvalds 
9311da177e4SLinus Torvalds static int ipv6_get_mtu(struct net_device *dev);
9321da177e4SLinus Torvalds 
9335578689aSDaniel Lezcano static inline unsigned int ipv6_advmss(struct net *net, unsigned int mtu)
9341da177e4SLinus Torvalds {
9351da177e4SLinus Torvalds 	mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
9361da177e4SLinus Torvalds 
9375578689aSDaniel Lezcano 	if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
9385578689aSDaniel Lezcano 		mtu = net->ipv6.sysctl.ip6_rt_min_advmss;
9391da177e4SLinus Torvalds 
9401da177e4SLinus Torvalds 	/*
9411da177e4SLinus Torvalds 	 * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
9421da177e4SLinus Torvalds 	 * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
9431da177e4SLinus Torvalds 	 * IPV6_MAXPLEN is also valid and means: "any MSS,
9441da177e4SLinus Torvalds 	 * rely only on pmtu discovery"
9451da177e4SLinus Torvalds 	 */
9461da177e4SLinus Torvalds 	if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
9471da177e4SLinus Torvalds 		mtu = IPV6_MAXPLEN;
9481da177e4SLinus Torvalds 	return mtu;
9491da177e4SLinus Torvalds }
9501da177e4SLinus Torvalds 
9513b00944cSYOSHIFUJI Hideaki static struct dst_entry *icmp6_dst_gc_list;
9523b00944cSYOSHIFUJI Hideaki static DEFINE_SPINLOCK(icmp6_dst_lock);
9535d0bbeebSThomas Graf 
9543b00944cSYOSHIFUJI Hideaki struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
9551da177e4SLinus Torvalds 				  struct neighbour *neigh,
9569acd9f3aSYOSHIFUJI Hideaki 				  const struct in6_addr *addr)
9571da177e4SLinus Torvalds {
9581da177e4SLinus Torvalds 	struct rt6_info *rt;
9591da177e4SLinus Torvalds 	struct inet6_dev *idev = in6_dev_get(dev);
960c346dca1SYOSHIFUJI Hideaki 	struct net *net = dev_net(dev);
9611da177e4SLinus Torvalds 
9621da177e4SLinus Torvalds 	if (unlikely(idev == NULL))
9631da177e4SLinus Torvalds 		return NULL;
9641da177e4SLinus Torvalds 
96586393e52SAlexey Dobriyan 	rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
9661da177e4SLinus Torvalds 	if (unlikely(rt == NULL)) {
9671da177e4SLinus Torvalds 		in6_dev_put(idev);
9681da177e4SLinus Torvalds 		goto out;
9691da177e4SLinus Torvalds 	}
9701da177e4SLinus Torvalds 
9711da177e4SLinus Torvalds 	dev_hold(dev);
9721da177e4SLinus Torvalds 	if (neigh)
9731da177e4SLinus Torvalds 		neigh_hold(neigh);
97414deae41SDavid S. Miller 	else {
9751da177e4SLinus Torvalds 		neigh = ndisc_get_neigh(dev, addr);
97614deae41SDavid S. Miller 		if (IS_ERR(neigh))
97714deae41SDavid S. Miller 			neigh = NULL;
97814deae41SDavid S. Miller 	}
9791da177e4SLinus Torvalds 
9801da177e4SLinus Torvalds 	rt->rt6i_dev	  = dev;
9811da177e4SLinus Torvalds 	rt->rt6i_idev     = idev;
9821da177e4SLinus Torvalds 	rt->rt6i_nexthop  = neigh;
983d8d1f30bSChangli Gao 	atomic_set(&rt->dst.__refcnt, 1);
984d8d1f30bSChangli Gao 	rt->dst.metrics[RTAX_HOPLIMIT-1] = 255;
985d8d1f30bSChangli Gao 	rt->dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
986d8d1f30bSChangli Gao 	rt->dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(net, dst_mtu(&rt->dst));
987d8d1f30bSChangli Gao 	rt->dst.output  = ip6_output;
9881da177e4SLinus Torvalds 
9891da177e4SLinus Torvalds #if 0	/* there's no chance to use these for ndisc */
990d8d1f30bSChangli Gao 	rt->dst.flags   = ipv6_addr_type(addr) & IPV6_ADDR_UNICAST
9911da177e4SLinus Torvalds 				? DST_HOST
9921da177e4SLinus Torvalds 				: 0;
9931da177e4SLinus Torvalds 	ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
9941da177e4SLinus Torvalds 	rt->rt6i_dst.plen = 128;
9951da177e4SLinus Torvalds #endif
9961da177e4SLinus Torvalds 
9973b00944cSYOSHIFUJI Hideaki 	spin_lock_bh(&icmp6_dst_lock);
998d8d1f30bSChangli Gao 	rt->dst.next = icmp6_dst_gc_list;
999d8d1f30bSChangli Gao 	icmp6_dst_gc_list = &rt->dst;
10003b00944cSYOSHIFUJI Hideaki 	spin_unlock_bh(&icmp6_dst_lock);
10011da177e4SLinus Torvalds 
10025578689aSDaniel Lezcano 	fib6_force_start_gc(net);
10031da177e4SLinus Torvalds 
10041da177e4SLinus Torvalds out:
1005d8d1f30bSChangli Gao 	return &rt->dst;
10061da177e4SLinus Torvalds }
10071da177e4SLinus Torvalds 
10083d0f24a7SStephen Hemminger int icmp6_dst_gc(void)
10091da177e4SLinus Torvalds {
10101da177e4SLinus Torvalds 	struct dst_entry *dst, *next, **pprev;
10113d0f24a7SStephen Hemminger 	int more = 0;
10121da177e4SLinus Torvalds 
10131da177e4SLinus Torvalds 	next = NULL;
10145d0bbeebSThomas Graf 
10153b00944cSYOSHIFUJI Hideaki 	spin_lock_bh(&icmp6_dst_lock);
10163b00944cSYOSHIFUJI Hideaki 	pprev = &icmp6_dst_gc_list;
10175d0bbeebSThomas Graf 
10181da177e4SLinus Torvalds 	while ((dst = *pprev) != NULL) {
10191da177e4SLinus Torvalds 		if (!atomic_read(&dst->__refcnt)) {
10201da177e4SLinus Torvalds 			*pprev = dst->next;
10211da177e4SLinus Torvalds 			dst_free(dst);
10221da177e4SLinus Torvalds 		} else {
10231da177e4SLinus Torvalds 			pprev = &dst->next;
10243d0f24a7SStephen Hemminger 			++more;
10251da177e4SLinus Torvalds 		}
10261da177e4SLinus Torvalds 	}
10271da177e4SLinus Torvalds 
10283b00944cSYOSHIFUJI Hideaki 	spin_unlock_bh(&icmp6_dst_lock);
10295d0bbeebSThomas Graf 
10303d0f24a7SStephen Hemminger 	return more;
10311da177e4SLinus Torvalds }
10321da177e4SLinus Torvalds 
10331e493d19SDavid S. Miller static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
10341e493d19SDavid S. Miller 			    void *arg)
10351e493d19SDavid S. Miller {
10361e493d19SDavid S. Miller 	struct dst_entry *dst, **pprev;
10371e493d19SDavid S. Miller 
10381e493d19SDavid S. Miller 	spin_lock_bh(&icmp6_dst_lock);
10391e493d19SDavid S. Miller 	pprev = &icmp6_dst_gc_list;
10401e493d19SDavid S. Miller 	while ((dst = *pprev) != NULL) {
10411e493d19SDavid S. Miller 		struct rt6_info *rt = (struct rt6_info *) dst;
10421e493d19SDavid S. Miller 		if (func(rt, arg)) {
10431e493d19SDavid S. Miller 			*pprev = dst->next;
10441e493d19SDavid S. Miller 			dst_free(dst);
10451e493d19SDavid S. Miller 		} else {
10461e493d19SDavid S. Miller 			pprev = &dst->next;
10471e493d19SDavid S. Miller 		}
10481e493d19SDavid S. Miller 	}
10491e493d19SDavid S. Miller 	spin_unlock_bh(&icmp6_dst_lock);
10501e493d19SDavid S. Miller }
10511e493d19SDavid S. Miller 
1052569d3645SDaniel Lezcano static int ip6_dst_gc(struct dst_ops *ops)
10531da177e4SLinus Torvalds {
10541da177e4SLinus Torvalds 	unsigned long now = jiffies;
105586393e52SAlexey Dobriyan 	struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
10567019b78eSDaniel Lezcano 	int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
10577019b78eSDaniel Lezcano 	int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
10587019b78eSDaniel Lezcano 	int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
10597019b78eSDaniel Lezcano 	int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
10607019b78eSDaniel Lezcano 	unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
10611da177e4SLinus Torvalds 
10627019b78eSDaniel Lezcano 	if (time_after(rt_last_gc + rt_min_interval, now) &&
10637019b78eSDaniel Lezcano 	    atomic_read(&ops->entries) <= rt_max_size)
10641da177e4SLinus Torvalds 		goto out;
10651da177e4SLinus Torvalds 
10666891a346SBenjamin Thery 	net->ipv6.ip6_rt_gc_expire++;
10676891a346SBenjamin Thery 	fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net);
10686891a346SBenjamin Thery 	net->ipv6.ip6_rt_last_gc = now;
10697019b78eSDaniel Lezcano 	if (atomic_read(&ops->entries) < ops->gc_thresh)
10707019b78eSDaniel Lezcano 		net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
10711da177e4SLinus Torvalds out:
10727019b78eSDaniel Lezcano 	net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
10737019b78eSDaniel Lezcano 	return (atomic_read(&ops->entries) > rt_max_size);
10741da177e4SLinus Torvalds }
10751da177e4SLinus Torvalds 
10761da177e4SLinus Torvalds /* Clean host part of a prefix. Not necessary in radix tree,
10771da177e4SLinus Torvalds    but results in cleaner routing tables.
10781da177e4SLinus Torvalds 
10791da177e4SLinus Torvalds    Remove it only when all the things will work!
10801da177e4SLinus Torvalds  */
10811da177e4SLinus Torvalds 
10821da177e4SLinus Torvalds static int ipv6_get_mtu(struct net_device *dev)
10831da177e4SLinus Torvalds {
10841da177e4SLinus Torvalds 	int mtu = IPV6_MIN_MTU;
10851da177e4SLinus Torvalds 	struct inet6_dev *idev;
10861da177e4SLinus Torvalds 
1087*c68f24ccSEric Dumazet 	rcu_read_lock();
1088*c68f24ccSEric Dumazet 	idev = __in6_dev_get(dev);
1089*c68f24ccSEric Dumazet 	if (idev)
10901da177e4SLinus Torvalds 		mtu = idev->cnf.mtu6;
1091*c68f24ccSEric Dumazet 	rcu_read_unlock();
10921da177e4SLinus Torvalds 	return mtu;
10931da177e4SLinus Torvalds }
10941da177e4SLinus Torvalds 
10956b75d090SYOSHIFUJI Hideaki int ip6_dst_hoplimit(struct dst_entry *dst)
10961da177e4SLinus Torvalds {
10976b75d090SYOSHIFUJI Hideaki 	int hoplimit = dst_metric(dst, RTAX_HOPLIMIT);
10986b75d090SYOSHIFUJI Hideaki 	if (hoplimit < 0) {
10996b75d090SYOSHIFUJI Hideaki 		struct net_device *dev = dst->dev;
1100*c68f24ccSEric Dumazet 		struct inet6_dev *idev;
1101*c68f24ccSEric Dumazet 
1102*c68f24ccSEric Dumazet 		rcu_read_lock();
1103*c68f24ccSEric Dumazet 		idev = __in6_dev_get(dev);
1104*c68f24ccSEric Dumazet 		if (idev)
11051da177e4SLinus Torvalds 			hoplimit = idev->cnf.hop_limit;
1106*c68f24ccSEric Dumazet 		else
110753b7997fSYOSHIFUJI Hideaki 			hoplimit = dev_net(dev)->ipv6.devconf_all->hop_limit;
1108*c68f24ccSEric Dumazet 		rcu_read_unlock();
11091da177e4SLinus Torvalds 	}
11101da177e4SLinus Torvalds 	return hoplimit;
11111da177e4SLinus Torvalds }
11121da177e4SLinus Torvalds 
11131da177e4SLinus Torvalds /*
11141da177e4SLinus Torvalds  *
11151da177e4SLinus Torvalds  */
11161da177e4SLinus Torvalds 
111786872cb5SThomas Graf int ip6_route_add(struct fib6_config *cfg)
11181da177e4SLinus Torvalds {
11191da177e4SLinus Torvalds 	int err;
11205578689aSDaniel Lezcano 	struct net *net = cfg->fc_nlinfo.nl_net;
11211da177e4SLinus Torvalds 	struct rt6_info *rt = NULL;
11221da177e4SLinus Torvalds 	struct net_device *dev = NULL;
11231da177e4SLinus Torvalds 	struct inet6_dev *idev = NULL;
1124c71099acSThomas Graf 	struct fib6_table *table;
11251da177e4SLinus Torvalds 	int addr_type;
11261da177e4SLinus Torvalds 
112786872cb5SThomas Graf 	if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
11281da177e4SLinus Torvalds 		return -EINVAL;
11291da177e4SLinus Torvalds #ifndef CONFIG_IPV6_SUBTREES
113086872cb5SThomas Graf 	if (cfg->fc_src_len)
11311da177e4SLinus Torvalds 		return -EINVAL;
11321da177e4SLinus Torvalds #endif
113386872cb5SThomas Graf 	if (cfg->fc_ifindex) {
11341da177e4SLinus Torvalds 		err = -ENODEV;
11355578689aSDaniel Lezcano 		dev = dev_get_by_index(net, cfg->fc_ifindex);
11361da177e4SLinus Torvalds 		if (!dev)
11371da177e4SLinus Torvalds 			goto out;
11381da177e4SLinus Torvalds 		idev = in6_dev_get(dev);
11391da177e4SLinus Torvalds 		if (!idev)
11401da177e4SLinus Torvalds 			goto out;
11411da177e4SLinus Torvalds 	}
11421da177e4SLinus Torvalds 
114386872cb5SThomas Graf 	if (cfg->fc_metric == 0)
114486872cb5SThomas Graf 		cfg->fc_metric = IP6_RT_PRIO_USER;
11451da177e4SLinus Torvalds 
11465578689aSDaniel Lezcano 	table = fib6_new_table(net, cfg->fc_table);
1147c71099acSThomas Graf 	if (table == NULL) {
1148c71099acSThomas Graf 		err = -ENOBUFS;
1149c71099acSThomas Graf 		goto out;
1150c71099acSThomas Graf 	}
1151c71099acSThomas Graf 
115286393e52SAlexey Dobriyan 	rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
11531da177e4SLinus Torvalds 
11541da177e4SLinus Torvalds 	if (rt == NULL) {
11551da177e4SLinus Torvalds 		err = -ENOMEM;
11561da177e4SLinus Torvalds 		goto out;
11571da177e4SLinus Torvalds 	}
11581da177e4SLinus Torvalds 
1159d8d1f30bSChangli Gao 	rt->dst.obsolete = -1;
11606f704992SYOSHIFUJI Hideaki 	rt->rt6i_expires = (cfg->fc_flags & RTF_EXPIRES) ?
11616f704992SYOSHIFUJI Hideaki 				jiffies + clock_t_to_jiffies(cfg->fc_expires) :
11626f704992SYOSHIFUJI Hideaki 				0;
11631da177e4SLinus Torvalds 
116486872cb5SThomas Graf 	if (cfg->fc_protocol == RTPROT_UNSPEC)
116586872cb5SThomas Graf 		cfg->fc_protocol = RTPROT_BOOT;
116686872cb5SThomas Graf 	rt->rt6i_protocol = cfg->fc_protocol;
116786872cb5SThomas Graf 
116886872cb5SThomas Graf 	addr_type = ipv6_addr_type(&cfg->fc_dst);
11691da177e4SLinus Torvalds 
11701da177e4SLinus Torvalds 	if (addr_type & IPV6_ADDR_MULTICAST)
1171d8d1f30bSChangli Gao 		rt->dst.input = ip6_mc_input;
11721da177e4SLinus Torvalds 	else
1173d8d1f30bSChangli Gao 		rt->dst.input = ip6_forward;
11741da177e4SLinus Torvalds 
1175d8d1f30bSChangli Gao 	rt->dst.output = ip6_output;
11761da177e4SLinus Torvalds 
117786872cb5SThomas Graf 	ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
117886872cb5SThomas Graf 	rt->rt6i_dst.plen = cfg->fc_dst_len;
11791da177e4SLinus Torvalds 	if (rt->rt6i_dst.plen == 128)
1180d8d1f30bSChangli Gao 	       rt->dst.flags = DST_HOST;
11811da177e4SLinus Torvalds 
11821da177e4SLinus Torvalds #ifdef CONFIG_IPV6_SUBTREES
118386872cb5SThomas Graf 	ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
118486872cb5SThomas Graf 	rt->rt6i_src.plen = cfg->fc_src_len;
11851da177e4SLinus Torvalds #endif
11861da177e4SLinus Torvalds 
118786872cb5SThomas Graf 	rt->rt6i_metric = cfg->fc_metric;
11881da177e4SLinus Torvalds 
11891da177e4SLinus Torvalds 	/* We cannot add true routes via loopback here,
11901da177e4SLinus Torvalds 	   they would result in kernel looping; promote them to reject routes
11911da177e4SLinus Torvalds 	 */
119286872cb5SThomas Graf 	if ((cfg->fc_flags & RTF_REJECT) ||
11931da177e4SLinus Torvalds 	    (dev && (dev->flags&IFF_LOOPBACK) && !(addr_type&IPV6_ADDR_LOOPBACK))) {
11941da177e4SLinus Torvalds 		/* hold loopback dev/idev if we haven't done so. */
11955578689aSDaniel Lezcano 		if (dev != net->loopback_dev) {
11961da177e4SLinus Torvalds 			if (dev) {
11971da177e4SLinus Torvalds 				dev_put(dev);
11981da177e4SLinus Torvalds 				in6_dev_put(idev);
11991da177e4SLinus Torvalds 			}
12005578689aSDaniel Lezcano 			dev = net->loopback_dev;
12011da177e4SLinus Torvalds 			dev_hold(dev);
12021da177e4SLinus Torvalds 			idev = in6_dev_get(dev);
12031da177e4SLinus Torvalds 			if (!idev) {
12041da177e4SLinus Torvalds 				err = -ENODEV;
12051da177e4SLinus Torvalds 				goto out;
12061da177e4SLinus Torvalds 			}
12071da177e4SLinus Torvalds 		}
1208d8d1f30bSChangli Gao 		rt->dst.output = ip6_pkt_discard_out;
1209d8d1f30bSChangli Gao 		rt->dst.input = ip6_pkt_discard;
1210d8d1f30bSChangli Gao 		rt->dst.error = -ENETUNREACH;
12111da177e4SLinus Torvalds 		rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
12121da177e4SLinus Torvalds 		goto install_route;
12131da177e4SLinus Torvalds 	}
12141da177e4SLinus Torvalds 
121586872cb5SThomas Graf 	if (cfg->fc_flags & RTF_GATEWAY) {
12161da177e4SLinus Torvalds 		struct in6_addr *gw_addr;
12171da177e4SLinus Torvalds 		int gwa_type;
12181da177e4SLinus Torvalds 
121986872cb5SThomas Graf 		gw_addr = &cfg->fc_gateway;
122086872cb5SThomas Graf 		ipv6_addr_copy(&rt->rt6i_gateway, gw_addr);
12211da177e4SLinus Torvalds 		gwa_type = ipv6_addr_type(gw_addr);
12221da177e4SLinus Torvalds 
12231da177e4SLinus Torvalds 		if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
12241da177e4SLinus Torvalds 			struct rt6_info *grt;
12251da177e4SLinus Torvalds 
12261da177e4SLinus Torvalds 			/* IPv6 strictly inhibits using not link-local
12271da177e4SLinus Torvalds 			   addresses as nexthop address.
12281da177e4SLinus Torvalds 			   Otherwise, router will not able to send redirects.
12291da177e4SLinus Torvalds 			   It is very good, but in some (rare!) circumstances
12301da177e4SLinus Torvalds 			   (SIT, PtP, NBMA NOARP links) it is handy to allow
12311da177e4SLinus Torvalds 			   some exceptions. --ANK
12321da177e4SLinus Torvalds 			 */
12331da177e4SLinus Torvalds 			err = -EINVAL;
12341da177e4SLinus Torvalds 			if (!(gwa_type&IPV6_ADDR_UNICAST))
12351da177e4SLinus Torvalds 				goto out;
12361da177e4SLinus Torvalds 
12375578689aSDaniel Lezcano 			grt = rt6_lookup(net, gw_addr, NULL, cfg->fc_ifindex, 1);
12381da177e4SLinus Torvalds 
12391da177e4SLinus Torvalds 			err = -EHOSTUNREACH;
12401da177e4SLinus Torvalds 			if (grt == NULL)
12411da177e4SLinus Torvalds 				goto out;
12421da177e4SLinus Torvalds 			if (dev) {
12431da177e4SLinus Torvalds 				if (dev != grt->rt6i_dev) {
1244d8d1f30bSChangli Gao 					dst_release(&grt->dst);
12451da177e4SLinus Torvalds 					goto out;
12461da177e4SLinus Torvalds 				}
12471da177e4SLinus Torvalds 			} else {
12481da177e4SLinus Torvalds 				dev = grt->rt6i_dev;
12491da177e4SLinus Torvalds 				idev = grt->rt6i_idev;
12501da177e4SLinus Torvalds 				dev_hold(dev);
12511da177e4SLinus Torvalds 				in6_dev_hold(grt->rt6i_idev);
12521da177e4SLinus Torvalds 			}
12531da177e4SLinus Torvalds 			if (!(grt->rt6i_flags&RTF_GATEWAY))
12541da177e4SLinus Torvalds 				err = 0;
1255d8d1f30bSChangli Gao 			dst_release(&grt->dst);
12561da177e4SLinus Torvalds 
12571da177e4SLinus Torvalds 			if (err)
12581da177e4SLinus Torvalds 				goto out;
12591da177e4SLinus Torvalds 		}
12601da177e4SLinus Torvalds 		err = -EINVAL;
12611da177e4SLinus Torvalds 		if (dev == NULL || (dev->flags&IFF_LOOPBACK))
12621da177e4SLinus Torvalds 			goto out;
12631da177e4SLinus Torvalds 	}
12641da177e4SLinus Torvalds 
12651da177e4SLinus Torvalds 	err = -ENODEV;
12661da177e4SLinus Torvalds 	if (dev == NULL)
12671da177e4SLinus Torvalds 		goto out;
12681da177e4SLinus Torvalds 
126986872cb5SThomas Graf 	if (cfg->fc_flags & (RTF_GATEWAY | RTF_NONEXTHOP)) {
12701da177e4SLinus Torvalds 		rt->rt6i_nexthop = __neigh_lookup_errno(&nd_tbl, &rt->rt6i_gateway, dev);
12711da177e4SLinus Torvalds 		if (IS_ERR(rt->rt6i_nexthop)) {
12721da177e4SLinus Torvalds 			err = PTR_ERR(rt->rt6i_nexthop);
12731da177e4SLinus Torvalds 			rt->rt6i_nexthop = NULL;
12741da177e4SLinus Torvalds 			goto out;
12751da177e4SLinus Torvalds 		}
12761da177e4SLinus Torvalds 	}
12771da177e4SLinus Torvalds 
127886872cb5SThomas Graf 	rt->rt6i_flags = cfg->fc_flags;
12791da177e4SLinus Torvalds 
12801da177e4SLinus Torvalds install_route:
128186872cb5SThomas Graf 	if (cfg->fc_mx) {
128286872cb5SThomas Graf 		struct nlattr *nla;
128386872cb5SThomas Graf 		int remaining;
12841da177e4SLinus Torvalds 
128586872cb5SThomas Graf 		nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
12868f4c1f9bSThomas Graf 			int type = nla_type(nla);
128786872cb5SThomas Graf 
128886872cb5SThomas Graf 			if (type) {
128986872cb5SThomas Graf 				if (type > RTAX_MAX) {
12901da177e4SLinus Torvalds 					err = -EINVAL;
12911da177e4SLinus Torvalds 					goto out;
12921da177e4SLinus Torvalds 				}
129386872cb5SThomas Graf 
1294d8d1f30bSChangli Gao 				rt->dst.metrics[type - 1] = nla_get_u32(nla);
12951da177e4SLinus Torvalds 			}
12961da177e4SLinus Torvalds 		}
12971da177e4SLinus Torvalds 	}
12981da177e4SLinus Torvalds 
1299d8d1f30bSChangli Gao 	if (dst_metric(&rt->dst, RTAX_HOPLIMIT) == 0)
1300d8d1f30bSChangli Gao 		rt->dst.metrics[RTAX_HOPLIMIT-1] = -1;
1301d8d1f30bSChangli Gao 	if (!dst_mtu(&rt->dst))
1302d8d1f30bSChangli Gao 		rt->dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(dev);
1303d8d1f30bSChangli Gao 	if (!dst_metric(&rt->dst, RTAX_ADVMSS))
1304d8d1f30bSChangli Gao 		rt->dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(net, dst_mtu(&rt->dst));
1305d8d1f30bSChangli Gao 	rt->dst.dev = dev;
13061da177e4SLinus Torvalds 	rt->rt6i_idev = idev;
1307c71099acSThomas Graf 	rt->rt6i_table = table;
130863152fc0SDaniel Lezcano 
1309c346dca1SYOSHIFUJI Hideaki 	cfg->fc_nlinfo.nl_net = dev_net(dev);
131063152fc0SDaniel Lezcano 
131186872cb5SThomas Graf 	return __ip6_ins_rt(rt, &cfg->fc_nlinfo);
13121da177e4SLinus Torvalds 
13131da177e4SLinus Torvalds out:
13141da177e4SLinus Torvalds 	if (dev)
13151da177e4SLinus Torvalds 		dev_put(dev);
13161da177e4SLinus Torvalds 	if (idev)
13171da177e4SLinus Torvalds 		in6_dev_put(idev);
13181da177e4SLinus Torvalds 	if (rt)
1319d8d1f30bSChangli Gao 		dst_free(&rt->dst);
13201da177e4SLinus Torvalds 	return err;
13211da177e4SLinus Torvalds }
13221da177e4SLinus Torvalds 
132386872cb5SThomas Graf static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
13241da177e4SLinus Torvalds {
13251da177e4SLinus Torvalds 	int err;
1326c71099acSThomas Graf 	struct fib6_table *table;
1327c346dca1SYOSHIFUJI Hideaki 	struct net *net = dev_net(rt->rt6i_dev);
13281da177e4SLinus Torvalds 
13298ed67789SDaniel Lezcano 	if (rt == net->ipv6.ip6_null_entry)
13306c813a72SPatrick McHardy 		return -ENOENT;
13316c813a72SPatrick McHardy 
1332c71099acSThomas Graf 	table = rt->rt6i_table;
1333c71099acSThomas Graf 	write_lock_bh(&table->tb6_lock);
13341da177e4SLinus Torvalds 
133586872cb5SThomas Graf 	err = fib6_del(rt, info);
1336d8d1f30bSChangli Gao 	dst_release(&rt->dst);
13371da177e4SLinus Torvalds 
1338c71099acSThomas Graf 	write_unlock_bh(&table->tb6_lock);
13391da177e4SLinus Torvalds 
13401da177e4SLinus Torvalds 	return err;
13411da177e4SLinus Torvalds }
13421da177e4SLinus Torvalds 
1343e0a1ad73SThomas Graf int ip6_del_rt(struct rt6_info *rt)
1344e0a1ad73SThomas Graf {
13454d1169c1SDenis V. Lunev 	struct nl_info info = {
1346c346dca1SYOSHIFUJI Hideaki 		.nl_net = dev_net(rt->rt6i_dev),
13474d1169c1SDenis V. Lunev 	};
1348528c4cebSDenis V. Lunev 	return __ip6_del_rt(rt, &info);
1349e0a1ad73SThomas Graf }
1350e0a1ad73SThomas Graf 
135186872cb5SThomas Graf static int ip6_route_del(struct fib6_config *cfg)
13521da177e4SLinus Torvalds {
1353c71099acSThomas Graf 	struct fib6_table *table;
13541da177e4SLinus Torvalds 	struct fib6_node *fn;
13551da177e4SLinus Torvalds 	struct rt6_info *rt;
13561da177e4SLinus Torvalds 	int err = -ESRCH;
13571da177e4SLinus Torvalds 
13585578689aSDaniel Lezcano 	table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
1359c71099acSThomas Graf 	if (table == NULL)
1360c71099acSThomas Graf 		return err;
13611da177e4SLinus Torvalds 
1362c71099acSThomas Graf 	read_lock_bh(&table->tb6_lock);
1363c71099acSThomas Graf 
1364c71099acSThomas Graf 	fn = fib6_locate(&table->tb6_root,
136586872cb5SThomas Graf 			 &cfg->fc_dst, cfg->fc_dst_len,
136686872cb5SThomas Graf 			 &cfg->fc_src, cfg->fc_src_len);
13671da177e4SLinus Torvalds 
13681da177e4SLinus Torvalds 	if (fn) {
1369d8d1f30bSChangli Gao 		for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
137086872cb5SThomas Graf 			if (cfg->fc_ifindex &&
13711da177e4SLinus Torvalds 			    (rt->rt6i_dev == NULL ||
137286872cb5SThomas Graf 			     rt->rt6i_dev->ifindex != cfg->fc_ifindex))
13731da177e4SLinus Torvalds 				continue;
137486872cb5SThomas Graf 			if (cfg->fc_flags & RTF_GATEWAY &&
137586872cb5SThomas Graf 			    !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
13761da177e4SLinus Torvalds 				continue;
137786872cb5SThomas Graf 			if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
13781da177e4SLinus Torvalds 				continue;
1379d8d1f30bSChangli Gao 			dst_hold(&rt->dst);
1380c71099acSThomas Graf 			read_unlock_bh(&table->tb6_lock);
13811da177e4SLinus Torvalds 
138286872cb5SThomas Graf 			return __ip6_del_rt(rt, &cfg->fc_nlinfo);
13831da177e4SLinus Torvalds 		}
13841da177e4SLinus Torvalds 	}
1385c71099acSThomas Graf 	read_unlock_bh(&table->tb6_lock);
13861da177e4SLinus Torvalds 
13871da177e4SLinus Torvalds 	return err;
13881da177e4SLinus Torvalds }
13891da177e4SLinus Torvalds 
13901da177e4SLinus Torvalds /*
13911da177e4SLinus Torvalds  *	Handle redirects
13921da177e4SLinus Torvalds  */
1393a6279458SYOSHIFUJI Hideaki struct ip6rd_flowi {
1394a6279458SYOSHIFUJI Hideaki 	struct flowi fl;
1395a6279458SYOSHIFUJI Hideaki 	struct in6_addr gateway;
1396a6279458SYOSHIFUJI Hideaki };
13971da177e4SLinus Torvalds 
13988ed67789SDaniel Lezcano static struct rt6_info *__ip6_route_redirect(struct net *net,
13998ed67789SDaniel Lezcano 					     struct fib6_table *table,
1400a6279458SYOSHIFUJI Hideaki 					     struct flowi *fl,
1401a6279458SYOSHIFUJI Hideaki 					     int flags)
1402a6279458SYOSHIFUJI Hideaki {
1403a6279458SYOSHIFUJI Hideaki 	struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl;
1404a6279458SYOSHIFUJI Hideaki 	struct rt6_info *rt;
1405a6279458SYOSHIFUJI Hideaki 	struct fib6_node *fn;
1406c71099acSThomas Graf 
1407e843b9e1SYOSHIFUJI Hideaki 	/*
1408e843b9e1SYOSHIFUJI Hideaki 	 * Get the "current" route for this destination and
1409e843b9e1SYOSHIFUJI Hideaki 	 * check if the redirect has come from approriate router.
1410e843b9e1SYOSHIFUJI Hideaki 	 *
1411e843b9e1SYOSHIFUJI Hideaki 	 * RFC 2461 specifies that redirects should only be
1412e843b9e1SYOSHIFUJI Hideaki 	 * accepted if they come from the nexthop to the target.
1413e843b9e1SYOSHIFUJI Hideaki 	 * Due to the way the routes are chosen, this notion
1414e843b9e1SYOSHIFUJI Hideaki 	 * is a bit fuzzy and one might need to check all possible
1415e843b9e1SYOSHIFUJI Hideaki 	 * routes.
1416e843b9e1SYOSHIFUJI Hideaki 	 */
14171da177e4SLinus Torvalds 
1418c71099acSThomas Graf 	read_lock_bh(&table->tb6_lock);
1419a6279458SYOSHIFUJI Hideaki 	fn = fib6_lookup(&table->tb6_root, &fl->fl6_dst, &fl->fl6_src);
1420e843b9e1SYOSHIFUJI Hideaki restart:
1421d8d1f30bSChangli Gao 	for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
14221da177e4SLinus Torvalds 		/*
14231da177e4SLinus Torvalds 		 * Current route is on-link; redirect is always invalid.
14241da177e4SLinus Torvalds 		 *
14251da177e4SLinus Torvalds 		 * Seems, previous statement is not true. It could
14261da177e4SLinus Torvalds 		 * be node, which looks for us as on-link (f.e. proxy ndisc)
14271da177e4SLinus Torvalds 		 * But then router serving it might decide, that we should
14281da177e4SLinus Torvalds 		 * know truth 8)8) --ANK (980726).
14291da177e4SLinus Torvalds 		 */
1430e843b9e1SYOSHIFUJI Hideaki 		if (rt6_check_expired(rt))
1431e843b9e1SYOSHIFUJI Hideaki 			continue;
14321da177e4SLinus Torvalds 		if (!(rt->rt6i_flags & RTF_GATEWAY))
1433e843b9e1SYOSHIFUJI Hideaki 			continue;
1434a6279458SYOSHIFUJI Hideaki 		if (fl->oif != rt->rt6i_dev->ifindex)
1435e843b9e1SYOSHIFUJI Hideaki 			continue;
1436a6279458SYOSHIFUJI Hideaki 		if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
1437e843b9e1SYOSHIFUJI Hideaki 			continue;
1438e843b9e1SYOSHIFUJI Hideaki 		break;
1439e843b9e1SYOSHIFUJI Hideaki 	}
1440a6279458SYOSHIFUJI Hideaki 
1441cb15d9c2SYOSHIFUJI Hideaki 	if (!rt)
14428ed67789SDaniel Lezcano 		rt = net->ipv6.ip6_null_entry;
14438ed67789SDaniel Lezcano 	BACKTRACK(net, &fl->fl6_src);
1444cb15d9c2SYOSHIFUJI Hideaki out:
1445d8d1f30bSChangli Gao 	dst_hold(&rt->dst);
1446a6279458SYOSHIFUJI Hideaki 
1447c71099acSThomas Graf 	read_unlock_bh(&table->tb6_lock);
14481da177e4SLinus Torvalds 
1449a6279458SYOSHIFUJI Hideaki 	return rt;
1450a6279458SYOSHIFUJI Hideaki };
1451a6279458SYOSHIFUJI Hideaki 
1452a6279458SYOSHIFUJI Hideaki static struct rt6_info *ip6_route_redirect(struct in6_addr *dest,
1453a6279458SYOSHIFUJI Hideaki 					   struct in6_addr *src,
1454a6279458SYOSHIFUJI Hideaki 					   struct in6_addr *gateway,
1455a6279458SYOSHIFUJI Hideaki 					   struct net_device *dev)
1456a6279458SYOSHIFUJI Hideaki {
1457adaa70bbSThomas Graf 	int flags = RT6_LOOKUP_F_HAS_SADDR;
1458c346dca1SYOSHIFUJI Hideaki 	struct net *net = dev_net(dev);
1459a6279458SYOSHIFUJI Hideaki 	struct ip6rd_flowi rdfl = {
1460a6279458SYOSHIFUJI Hideaki 		.fl = {
1461a6279458SYOSHIFUJI Hideaki 			.oif = dev->ifindex,
1462a6279458SYOSHIFUJI Hideaki 			.nl_u = {
1463a6279458SYOSHIFUJI Hideaki 				.ip6_u = {
1464a6279458SYOSHIFUJI Hideaki 					.daddr = *dest,
1465a6279458SYOSHIFUJI Hideaki 					.saddr = *src,
1466a6279458SYOSHIFUJI Hideaki 				},
1467a6279458SYOSHIFUJI Hideaki 			},
1468a6279458SYOSHIFUJI Hideaki 		},
1469a6279458SYOSHIFUJI Hideaki 	};
1470adaa70bbSThomas Graf 
147186c36ce4SBrian Haley 	ipv6_addr_copy(&rdfl.gateway, gateway);
147286c36ce4SBrian Haley 
1473adaa70bbSThomas Graf 	if (rt6_need_strict(dest))
1474adaa70bbSThomas Graf 		flags |= RT6_LOOKUP_F_IFACE;
1475a6279458SYOSHIFUJI Hideaki 
14765578689aSDaniel Lezcano 	return (struct rt6_info *)fib6_rule_lookup(net, (struct flowi *)&rdfl,
147758f09b78SDaniel Lezcano 						   flags, __ip6_route_redirect);
1478a6279458SYOSHIFUJI Hideaki }
1479a6279458SYOSHIFUJI Hideaki 
1480a6279458SYOSHIFUJI Hideaki void rt6_redirect(struct in6_addr *dest, struct in6_addr *src,
1481a6279458SYOSHIFUJI Hideaki 		  struct in6_addr *saddr,
1482a6279458SYOSHIFUJI Hideaki 		  struct neighbour *neigh, u8 *lladdr, int on_link)
1483a6279458SYOSHIFUJI Hideaki {
1484a6279458SYOSHIFUJI Hideaki 	struct rt6_info *rt, *nrt = NULL;
1485a6279458SYOSHIFUJI Hideaki 	struct netevent_redirect netevent;
1486c346dca1SYOSHIFUJI Hideaki 	struct net *net = dev_net(neigh->dev);
1487a6279458SYOSHIFUJI Hideaki 
1488a6279458SYOSHIFUJI Hideaki 	rt = ip6_route_redirect(dest, src, saddr, neigh->dev);
1489a6279458SYOSHIFUJI Hideaki 
14908ed67789SDaniel Lezcano 	if (rt == net->ipv6.ip6_null_entry) {
14911da177e4SLinus Torvalds 		if (net_ratelimit())
14921da177e4SLinus Torvalds 			printk(KERN_DEBUG "rt6_redirect: source isn't a valid nexthop "
14931da177e4SLinus Torvalds 			       "for redirect target\n");
1494a6279458SYOSHIFUJI Hideaki 		goto out;
14951da177e4SLinus Torvalds 	}
14961da177e4SLinus Torvalds 
14971da177e4SLinus Torvalds 	/*
14981da177e4SLinus Torvalds 	 *	We have finally decided to accept it.
14991da177e4SLinus Torvalds 	 */
15001da177e4SLinus Torvalds 
15011da177e4SLinus Torvalds 	neigh_update(neigh, lladdr, NUD_STALE,
15021da177e4SLinus Torvalds 		     NEIGH_UPDATE_F_WEAK_OVERRIDE|
15031da177e4SLinus Torvalds 		     NEIGH_UPDATE_F_OVERRIDE|
15041da177e4SLinus Torvalds 		     (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
15051da177e4SLinus Torvalds 				     NEIGH_UPDATE_F_ISROUTER))
15061da177e4SLinus Torvalds 		     );
15071da177e4SLinus Torvalds 
15081da177e4SLinus Torvalds 	/*
15091da177e4SLinus Torvalds 	 * Redirect received -> path was valid.
15101da177e4SLinus Torvalds 	 * Look, redirects are sent only in response to data packets,
15111da177e4SLinus Torvalds 	 * so that this nexthop apparently is reachable. --ANK
15121da177e4SLinus Torvalds 	 */
1513d8d1f30bSChangli Gao 	dst_confirm(&rt->dst);
15141da177e4SLinus Torvalds 
15151da177e4SLinus Torvalds 	/* Duplicate redirect: silently ignore. */
1516d8d1f30bSChangli Gao 	if (neigh == rt->dst.neighbour)
15171da177e4SLinus Torvalds 		goto out;
15181da177e4SLinus Torvalds 
15191da177e4SLinus Torvalds 	nrt = ip6_rt_copy(rt);
15201da177e4SLinus Torvalds 	if (nrt == NULL)
15211da177e4SLinus Torvalds 		goto out;
15221da177e4SLinus Torvalds 
15231da177e4SLinus Torvalds 	nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
15241da177e4SLinus Torvalds 	if (on_link)
15251da177e4SLinus Torvalds 		nrt->rt6i_flags &= ~RTF_GATEWAY;
15261da177e4SLinus Torvalds 
15271da177e4SLinus Torvalds 	ipv6_addr_copy(&nrt->rt6i_dst.addr, dest);
15281da177e4SLinus Torvalds 	nrt->rt6i_dst.plen = 128;
1529d8d1f30bSChangli Gao 	nrt->dst.flags |= DST_HOST;
15301da177e4SLinus Torvalds 
15311da177e4SLinus Torvalds 	ipv6_addr_copy(&nrt->rt6i_gateway, (struct in6_addr*)neigh->primary_key);
15321da177e4SLinus Torvalds 	nrt->rt6i_nexthop = neigh_clone(neigh);
15331da177e4SLinus Torvalds 	/* Reset pmtu, it may be better */
1534d8d1f30bSChangli Gao 	nrt->dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(neigh->dev);
1535d8d1f30bSChangli Gao 	nrt->dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(dev_net(neigh->dev),
1536d8d1f30bSChangli Gao 							dst_mtu(&nrt->dst));
15371da177e4SLinus Torvalds 
153840e22e8fSThomas Graf 	if (ip6_ins_rt(nrt))
15391da177e4SLinus Torvalds 		goto out;
15401da177e4SLinus Torvalds 
1541d8d1f30bSChangli Gao 	netevent.old = &rt->dst;
1542d8d1f30bSChangli Gao 	netevent.new = &nrt->dst;
15438d71740cSTom Tucker 	call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);
15448d71740cSTom Tucker 
15451da177e4SLinus Torvalds 	if (rt->rt6i_flags&RTF_CACHE) {
1546e0a1ad73SThomas Graf 		ip6_del_rt(rt);
15471da177e4SLinus Torvalds 		return;
15481da177e4SLinus Torvalds 	}
15491da177e4SLinus Torvalds 
15501da177e4SLinus Torvalds out:
1551d8d1f30bSChangli Gao 	dst_release(&rt->dst);
15521da177e4SLinus Torvalds }
15531da177e4SLinus Torvalds 
15541da177e4SLinus Torvalds /*
15551da177e4SLinus Torvalds  *	Handle ICMP "packet too big" messages
15561da177e4SLinus Torvalds  *	i.e. Path MTU discovery
15571da177e4SLinus Torvalds  */
15581da177e4SLinus Torvalds 
15591da177e4SLinus Torvalds void rt6_pmtu_discovery(struct in6_addr *daddr, struct in6_addr *saddr,
15601da177e4SLinus Torvalds 			struct net_device *dev, u32 pmtu)
15611da177e4SLinus Torvalds {
15621da177e4SLinus Torvalds 	struct rt6_info *rt, *nrt;
1563c346dca1SYOSHIFUJI Hideaki 	struct net *net = dev_net(dev);
15641da177e4SLinus Torvalds 	int allfrag = 0;
15651da177e4SLinus Torvalds 
15665578689aSDaniel Lezcano 	rt = rt6_lookup(net, daddr, saddr, dev->ifindex, 0);
15671da177e4SLinus Torvalds 	if (rt == NULL)
15681da177e4SLinus Torvalds 		return;
15691da177e4SLinus Torvalds 
1570d8d1f30bSChangli Gao 	if (pmtu >= dst_mtu(&rt->dst))
15711da177e4SLinus Torvalds 		goto out;
15721da177e4SLinus Torvalds 
15731da177e4SLinus Torvalds 	if (pmtu < IPV6_MIN_MTU) {
15741da177e4SLinus Torvalds 		/*
15751da177e4SLinus Torvalds 		 * According to RFC2460, PMTU is set to the IPv6 Minimum Link
15761da177e4SLinus Torvalds 		 * MTU (1280) and a fragment header should always be included
15771da177e4SLinus Torvalds 		 * after a node receiving Too Big message reporting PMTU is
15781da177e4SLinus Torvalds 		 * less than the IPv6 Minimum Link MTU.
15791da177e4SLinus Torvalds 		 */
15801da177e4SLinus Torvalds 		pmtu = IPV6_MIN_MTU;
15811da177e4SLinus Torvalds 		allfrag = 1;
15821da177e4SLinus Torvalds 	}
15831da177e4SLinus Torvalds 
15841da177e4SLinus Torvalds 	/* New mtu received -> path was valid.
15851da177e4SLinus Torvalds 	   They are sent only in response to data packets,
15861da177e4SLinus Torvalds 	   so that this nexthop apparently is reachable. --ANK
15871da177e4SLinus Torvalds 	 */
1588d8d1f30bSChangli Gao 	dst_confirm(&rt->dst);
15891da177e4SLinus Torvalds 
15901da177e4SLinus Torvalds 	/* Host route. If it is static, it would be better
15911da177e4SLinus Torvalds 	   not to override it, but add new one, so that
15921da177e4SLinus Torvalds 	   when cache entry will expire old pmtu
15931da177e4SLinus Torvalds 	   would return automatically.
15941da177e4SLinus Torvalds 	 */
15951da177e4SLinus Torvalds 	if (rt->rt6i_flags & RTF_CACHE) {
1596d8d1f30bSChangli Gao 		rt->dst.metrics[RTAX_MTU-1] = pmtu;
15971da177e4SLinus Torvalds 		if (allfrag)
1598d8d1f30bSChangli Gao 			rt->dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1599d8d1f30bSChangli Gao 		dst_set_expires(&rt->dst, net->ipv6.sysctl.ip6_rt_mtu_expires);
16001da177e4SLinus Torvalds 		rt->rt6i_flags |= RTF_MODIFIED|RTF_EXPIRES;
16011da177e4SLinus Torvalds 		goto out;
16021da177e4SLinus Torvalds 	}
16031da177e4SLinus Torvalds 
16041da177e4SLinus Torvalds 	/* Network route.
16051da177e4SLinus Torvalds 	   Two cases are possible:
16061da177e4SLinus Torvalds 	   1. It is connected route. Action: COW
16071da177e4SLinus Torvalds 	   2. It is gatewayed route or NONEXTHOP route. Action: clone it.
16081da177e4SLinus Torvalds 	 */
1609d5315b50SYOSHIFUJI Hideaki 	if (!rt->rt6i_nexthop && !(rt->rt6i_flags & RTF_NONEXTHOP))
1610a1e78363SYOSHIFUJI Hideaki 		nrt = rt6_alloc_cow(rt, daddr, saddr);
1611d5315b50SYOSHIFUJI Hideaki 	else
1612d5315b50SYOSHIFUJI Hideaki 		nrt = rt6_alloc_clone(rt, daddr);
1613a1e78363SYOSHIFUJI Hideaki 
1614d5315b50SYOSHIFUJI Hideaki 	if (nrt) {
1615d8d1f30bSChangli Gao 		nrt->dst.metrics[RTAX_MTU-1] = pmtu;
16161da177e4SLinus Torvalds 		if (allfrag)
1617d8d1f30bSChangli Gao 			nrt->dst.metrics[RTAX_FEATURES-1] |= RTAX_FEATURE_ALLFRAG;
1618a1e78363SYOSHIFUJI Hideaki 
16191da177e4SLinus Torvalds 		/* According to RFC 1981, detecting PMTU increase shouldn't be
1620a1e78363SYOSHIFUJI Hideaki 		 * happened within 5 mins, the recommended timer is 10 mins.
1621a1e78363SYOSHIFUJI Hideaki 		 * Here this route expiration time is set to ip6_rt_mtu_expires
1622a1e78363SYOSHIFUJI Hideaki 		 * which is 10 mins. After 10 mins the decreased pmtu is expired
1623a1e78363SYOSHIFUJI Hideaki 		 * and detecting PMTU increase will be automatically happened.
16241da177e4SLinus Torvalds 		 */
1625d8d1f30bSChangli Gao 		dst_set_expires(&nrt->dst, net->ipv6.sysctl.ip6_rt_mtu_expires);
16261da177e4SLinus Torvalds 		nrt->rt6i_flags |= RTF_DYNAMIC|RTF_EXPIRES;
1627a1e78363SYOSHIFUJI Hideaki 
162840e22e8fSThomas Graf 		ip6_ins_rt(nrt);
16291da177e4SLinus Torvalds 	}
16301da177e4SLinus Torvalds out:
1631d8d1f30bSChangli Gao 	dst_release(&rt->dst);
16321da177e4SLinus Torvalds }
16331da177e4SLinus Torvalds 
16341da177e4SLinus Torvalds /*
16351da177e4SLinus Torvalds  *	Misc support functions
16361da177e4SLinus Torvalds  */
16371da177e4SLinus Torvalds 
16381da177e4SLinus Torvalds static struct rt6_info * ip6_rt_copy(struct rt6_info *ort)
16391da177e4SLinus Torvalds {
1640c346dca1SYOSHIFUJI Hideaki 	struct net *net = dev_net(ort->rt6i_dev);
164186393e52SAlexey Dobriyan 	struct rt6_info *rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
16421da177e4SLinus Torvalds 
16431da177e4SLinus Torvalds 	if (rt) {
1644d8d1f30bSChangli Gao 		rt->dst.input = ort->dst.input;
1645d8d1f30bSChangli Gao 		rt->dst.output = ort->dst.output;
16461da177e4SLinus Torvalds 
1647d8d1f30bSChangli Gao 		memcpy(rt->dst.metrics, ort->dst.metrics, RTAX_MAX*sizeof(u32));
1648d8d1f30bSChangli Gao 		rt->dst.error = ort->dst.error;
1649d8d1f30bSChangli Gao 		rt->dst.dev = ort->dst.dev;
1650d8d1f30bSChangli Gao 		if (rt->dst.dev)
1651d8d1f30bSChangli Gao 			dev_hold(rt->dst.dev);
16521da177e4SLinus Torvalds 		rt->rt6i_idev = ort->rt6i_idev;
16531da177e4SLinus Torvalds 		if (rt->rt6i_idev)
16541da177e4SLinus Torvalds 			in6_dev_hold(rt->rt6i_idev);
1655d8d1f30bSChangli Gao 		rt->dst.lastuse = jiffies;
16561da177e4SLinus Torvalds 		rt->rt6i_expires = 0;
16571da177e4SLinus Torvalds 
16581da177e4SLinus Torvalds 		ipv6_addr_copy(&rt->rt6i_gateway, &ort->rt6i_gateway);
16591da177e4SLinus Torvalds 		rt->rt6i_flags = ort->rt6i_flags & ~RTF_EXPIRES;
16601da177e4SLinus Torvalds 		rt->rt6i_metric = 0;
16611da177e4SLinus Torvalds 
16621da177e4SLinus Torvalds 		memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
16631da177e4SLinus Torvalds #ifdef CONFIG_IPV6_SUBTREES
16641da177e4SLinus Torvalds 		memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
16651da177e4SLinus Torvalds #endif
1666c71099acSThomas Graf 		rt->rt6i_table = ort->rt6i_table;
16671da177e4SLinus Torvalds 	}
16681da177e4SLinus Torvalds 	return rt;
16691da177e4SLinus Torvalds }
16701da177e4SLinus Torvalds 
167170ceb4f5SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_ROUTE_INFO
1672efa2cea0SDaniel Lezcano static struct rt6_info *rt6_get_route_info(struct net *net,
1673efa2cea0SDaniel Lezcano 					   struct in6_addr *prefix, int prefixlen,
167470ceb4f5SYOSHIFUJI Hideaki 					   struct in6_addr *gwaddr, int ifindex)
167570ceb4f5SYOSHIFUJI Hideaki {
167670ceb4f5SYOSHIFUJI Hideaki 	struct fib6_node *fn;
167770ceb4f5SYOSHIFUJI Hideaki 	struct rt6_info *rt = NULL;
1678c71099acSThomas Graf 	struct fib6_table *table;
167970ceb4f5SYOSHIFUJI Hideaki 
1680efa2cea0SDaniel Lezcano 	table = fib6_get_table(net, RT6_TABLE_INFO);
1681c71099acSThomas Graf 	if (table == NULL)
1682c71099acSThomas Graf 		return NULL;
1683c71099acSThomas Graf 
1684c71099acSThomas Graf 	write_lock_bh(&table->tb6_lock);
1685c71099acSThomas Graf 	fn = fib6_locate(&table->tb6_root, prefix ,prefixlen, NULL, 0);
168670ceb4f5SYOSHIFUJI Hideaki 	if (!fn)
168770ceb4f5SYOSHIFUJI Hideaki 		goto out;
168870ceb4f5SYOSHIFUJI Hideaki 
1689d8d1f30bSChangli Gao 	for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
169070ceb4f5SYOSHIFUJI Hideaki 		if (rt->rt6i_dev->ifindex != ifindex)
169170ceb4f5SYOSHIFUJI Hideaki 			continue;
169270ceb4f5SYOSHIFUJI Hideaki 		if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
169370ceb4f5SYOSHIFUJI Hideaki 			continue;
169470ceb4f5SYOSHIFUJI Hideaki 		if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
169570ceb4f5SYOSHIFUJI Hideaki 			continue;
1696d8d1f30bSChangli Gao 		dst_hold(&rt->dst);
169770ceb4f5SYOSHIFUJI Hideaki 		break;
169870ceb4f5SYOSHIFUJI Hideaki 	}
169970ceb4f5SYOSHIFUJI Hideaki out:
1700c71099acSThomas Graf 	write_unlock_bh(&table->tb6_lock);
170170ceb4f5SYOSHIFUJI Hideaki 	return rt;
170270ceb4f5SYOSHIFUJI Hideaki }
170370ceb4f5SYOSHIFUJI Hideaki 
1704efa2cea0SDaniel Lezcano static struct rt6_info *rt6_add_route_info(struct net *net,
1705efa2cea0SDaniel Lezcano 					   struct in6_addr *prefix, int prefixlen,
170670ceb4f5SYOSHIFUJI Hideaki 					   struct in6_addr *gwaddr, int ifindex,
170770ceb4f5SYOSHIFUJI Hideaki 					   unsigned pref)
170870ceb4f5SYOSHIFUJI Hideaki {
170986872cb5SThomas Graf 	struct fib6_config cfg = {
171086872cb5SThomas Graf 		.fc_table	= RT6_TABLE_INFO,
1711238fc7eaSRami Rosen 		.fc_metric	= IP6_RT_PRIO_USER,
171286872cb5SThomas Graf 		.fc_ifindex	= ifindex,
171386872cb5SThomas Graf 		.fc_dst_len	= prefixlen,
171486872cb5SThomas Graf 		.fc_flags	= RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
171586872cb5SThomas Graf 				  RTF_UP | RTF_PREF(pref),
1716efa2cea0SDaniel Lezcano 		.fc_nlinfo.pid = 0,
1717efa2cea0SDaniel Lezcano 		.fc_nlinfo.nlh = NULL,
1718efa2cea0SDaniel Lezcano 		.fc_nlinfo.nl_net = net,
171986872cb5SThomas Graf 	};
172070ceb4f5SYOSHIFUJI Hideaki 
172186872cb5SThomas Graf 	ipv6_addr_copy(&cfg.fc_dst, prefix);
172286872cb5SThomas Graf 	ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
172386872cb5SThomas Graf 
1724e317da96SYOSHIFUJI Hideaki 	/* We should treat it as a default route if prefix length is 0. */
1725e317da96SYOSHIFUJI Hideaki 	if (!prefixlen)
172686872cb5SThomas Graf 		cfg.fc_flags |= RTF_DEFAULT;
172770ceb4f5SYOSHIFUJI Hideaki 
172886872cb5SThomas Graf 	ip6_route_add(&cfg);
172970ceb4f5SYOSHIFUJI Hideaki 
1730efa2cea0SDaniel Lezcano 	return rt6_get_route_info(net, prefix, prefixlen, gwaddr, ifindex);
173170ceb4f5SYOSHIFUJI Hideaki }
173270ceb4f5SYOSHIFUJI Hideaki #endif
173370ceb4f5SYOSHIFUJI Hideaki 
17341da177e4SLinus Torvalds struct rt6_info *rt6_get_dflt_router(struct in6_addr *addr, struct net_device *dev)
17351da177e4SLinus Torvalds {
17361da177e4SLinus Torvalds 	struct rt6_info *rt;
1737c71099acSThomas Graf 	struct fib6_table *table;
17381da177e4SLinus Torvalds 
1739c346dca1SYOSHIFUJI Hideaki 	table = fib6_get_table(dev_net(dev), RT6_TABLE_DFLT);
1740c71099acSThomas Graf 	if (table == NULL)
1741c71099acSThomas Graf 		return NULL;
17421da177e4SLinus Torvalds 
1743c71099acSThomas Graf 	write_lock_bh(&table->tb6_lock);
1744d8d1f30bSChangli Gao 	for (rt = table->tb6_root.leaf; rt; rt=rt->dst.rt6_next) {
17451da177e4SLinus Torvalds 		if (dev == rt->rt6i_dev &&
1746045927ffSYOSHIFUJI Hideaki 		    ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
17471da177e4SLinus Torvalds 		    ipv6_addr_equal(&rt->rt6i_gateway, addr))
17481da177e4SLinus Torvalds 			break;
17491da177e4SLinus Torvalds 	}
17501da177e4SLinus Torvalds 	if (rt)
1751d8d1f30bSChangli Gao 		dst_hold(&rt->dst);
1752c71099acSThomas Graf 	write_unlock_bh(&table->tb6_lock);
17531da177e4SLinus Torvalds 	return rt;
17541da177e4SLinus Torvalds }
17551da177e4SLinus Torvalds 
17561da177e4SLinus Torvalds struct rt6_info *rt6_add_dflt_router(struct in6_addr *gwaddr,
1757ebacaaa0SYOSHIFUJI Hideaki 				     struct net_device *dev,
1758ebacaaa0SYOSHIFUJI Hideaki 				     unsigned int pref)
17591da177e4SLinus Torvalds {
176086872cb5SThomas Graf 	struct fib6_config cfg = {
176186872cb5SThomas Graf 		.fc_table	= RT6_TABLE_DFLT,
1762238fc7eaSRami Rosen 		.fc_metric	= IP6_RT_PRIO_USER,
176386872cb5SThomas Graf 		.fc_ifindex	= dev->ifindex,
176486872cb5SThomas Graf 		.fc_flags	= RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
176586872cb5SThomas Graf 				  RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
17665578689aSDaniel Lezcano 		.fc_nlinfo.pid = 0,
17675578689aSDaniel Lezcano 		.fc_nlinfo.nlh = NULL,
1768c346dca1SYOSHIFUJI Hideaki 		.fc_nlinfo.nl_net = dev_net(dev),
176986872cb5SThomas Graf 	};
17701da177e4SLinus Torvalds 
177186872cb5SThomas Graf 	ipv6_addr_copy(&cfg.fc_gateway, gwaddr);
17721da177e4SLinus Torvalds 
177386872cb5SThomas Graf 	ip6_route_add(&cfg);
17741da177e4SLinus Torvalds 
17751da177e4SLinus Torvalds 	return rt6_get_dflt_router(gwaddr, dev);
17761da177e4SLinus Torvalds }
17771da177e4SLinus Torvalds 
17787b4da532SDaniel Lezcano void rt6_purge_dflt_routers(struct net *net)
17791da177e4SLinus Torvalds {
17801da177e4SLinus Torvalds 	struct rt6_info *rt;
1781c71099acSThomas Graf 	struct fib6_table *table;
1782c71099acSThomas Graf 
1783c71099acSThomas Graf 	/* NOTE: Keep consistent with rt6_get_dflt_router */
17847b4da532SDaniel Lezcano 	table = fib6_get_table(net, RT6_TABLE_DFLT);
1785c71099acSThomas Graf 	if (table == NULL)
1786c71099acSThomas Graf 		return;
17871da177e4SLinus Torvalds 
17881da177e4SLinus Torvalds restart:
1789c71099acSThomas Graf 	read_lock_bh(&table->tb6_lock);
1790d8d1f30bSChangli Gao 	for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
17911da177e4SLinus Torvalds 		if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF)) {
1792d8d1f30bSChangli Gao 			dst_hold(&rt->dst);
1793c71099acSThomas Graf 			read_unlock_bh(&table->tb6_lock);
1794e0a1ad73SThomas Graf 			ip6_del_rt(rt);
17951da177e4SLinus Torvalds 			goto restart;
17961da177e4SLinus Torvalds 		}
17971da177e4SLinus Torvalds 	}
1798c71099acSThomas Graf 	read_unlock_bh(&table->tb6_lock);
17991da177e4SLinus Torvalds }
18001da177e4SLinus Torvalds 
18015578689aSDaniel Lezcano static void rtmsg_to_fib6_config(struct net *net,
18025578689aSDaniel Lezcano 				 struct in6_rtmsg *rtmsg,
180386872cb5SThomas Graf 				 struct fib6_config *cfg)
180486872cb5SThomas Graf {
180586872cb5SThomas Graf 	memset(cfg, 0, sizeof(*cfg));
180686872cb5SThomas Graf 
180786872cb5SThomas Graf 	cfg->fc_table = RT6_TABLE_MAIN;
180886872cb5SThomas Graf 	cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
180986872cb5SThomas Graf 	cfg->fc_metric = rtmsg->rtmsg_metric;
181086872cb5SThomas Graf 	cfg->fc_expires = rtmsg->rtmsg_info;
181186872cb5SThomas Graf 	cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
181286872cb5SThomas Graf 	cfg->fc_src_len = rtmsg->rtmsg_src_len;
181386872cb5SThomas Graf 	cfg->fc_flags = rtmsg->rtmsg_flags;
181486872cb5SThomas Graf 
18155578689aSDaniel Lezcano 	cfg->fc_nlinfo.nl_net = net;
1816f1243c2dSBenjamin Thery 
181786872cb5SThomas Graf 	ipv6_addr_copy(&cfg->fc_dst, &rtmsg->rtmsg_dst);
181886872cb5SThomas Graf 	ipv6_addr_copy(&cfg->fc_src, &rtmsg->rtmsg_src);
181986872cb5SThomas Graf 	ipv6_addr_copy(&cfg->fc_gateway, &rtmsg->rtmsg_gateway);
182086872cb5SThomas Graf }
182186872cb5SThomas Graf 
18225578689aSDaniel Lezcano int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
18231da177e4SLinus Torvalds {
182486872cb5SThomas Graf 	struct fib6_config cfg;
18251da177e4SLinus Torvalds 	struct in6_rtmsg rtmsg;
18261da177e4SLinus Torvalds 	int err;
18271da177e4SLinus Torvalds 
18281da177e4SLinus Torvalds 	switch(cmd) {
18291da177e4SLinus Torvalds 	case SIOCADDRT:		/* Add a route */
18301da177e4SLinus Torvalds 	case SIOCDELRT:		/* Delete a route */
18311da177e4SLinus Torvalds 		if (!capable(CAP_NET_ADMIN))
18321da177e4SLinus Torvalds 			return -EPERM;
18331da177e4SLinus Torvalds 		err = copy_from_user(&rtmsg, arg,
18341da177e4SLinus Torvalds 				     sizeof(struct in6_rtmsg));
18351da177e4SLinus Torvalds 		if (err)
18361da177e4SLinus Torvalds 			return -EFAULT;
18371da177e4SLinus Torvalds 
18385578689aSDaniel Lezcano 		rtmsg_to_fib6_config(net, &rtmsg, &cfg);
183986872cb5SThomas Graf 
18401da177e4SLinus Torvalds 		rtnl_lock();
18411da177e4SLinus Torvalds 		switch (cmd) {
18421da177e4SLinus Torvalds 		case SIOCADDRT:
184386872cb5SThomas Graf 			err = ip6_route_add(&cfg);
18441da177e4SLinus Torvalds 			break;
18451da177e4SLinus Torvalds 		case SIOCDELRT:
184686872cb5SThomas Graf 			err = ip6_route_del(&cfg);
18471da177e4SLinus Torvalds 			break;
18481da177e4SLinus Torvalds 		default:
18491da177e4SLinus Torvalds 			err = -EINVAL;
18501da177e4SLinus Torvalds 		}
18511da177e4SLinus Torvalds 		rtnl_unlock();
18521da177e4SLinus Torvalds 
18531da177e4SLinus Torvalds 		return err;
18543ff50b79SStephen Hemminger 	}
18551da177e4SLinus Torvalds 
18561da177e4SLinus Torvalds 	return -EINVAL;
18571da177e4SLinus Torvalds }
18581da177e4SLinus Torvalds 
18591da177e4SLinus Torvalds /*
18601da177e4SLinus Torvalds  *	Drop the packet on the floor
18611da177e4SLinus Torvalds  */
18621da177e4SLinus Torvalds 
1863d5fdd6baSBrian Haley static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
18641da177e4SLinus Torvalds {
1865612f09e8SYOSHIFUJI Hideaki 	int type;
1866adf30907SEric Dumazet 	struct dst_entry *dst = skb_dst(skb);
1867612f09e8SYOSHIFUJI Hideaki 	switch (ipstats_mib_noroutes) {
1868612f09e8SYOSHIFUJI Hideaki 	case IPSTATS_MIB_INNOROUTES:
18690660e03fSArnaldo Carvalho de Melo 		type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
187045bb0060SUlrich Weber 		if (type == IPV6_ADDR_ANY) {
18713bd653c8SDenis V. Lunev 			IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
18723bd653c8SDenis V. Lunev 				      IPSTATS_MIB_INADDRERRORS);
1873612f09e8SYOSHIFUJI Hideaki 			break;
1874612f09e8SYOSHIFUJI Hideaki 		}
1875612f09e8SYOSHIFUJI Hideaki 		/* FALLTHROUGH */
1876612f09e8SYOSHIFUJI Hideaki 	case IPSTATS_MIB_OUTNOROUTES:
18773bd653c8SDenis V. Lunev 		IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
18783bd653c8SDenis V. Lunev 			      ipstats_mib_noroutes);
1879612f09e8SYOSHIFUJI Hideaki 		break;
1880612f09e8SYOSHIFUJI Hideaki 	}
18813ffe533cSAlexey Dobriyan 	icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
18821da177e4SLinus Torvalds 	kfree_skb(skb);
18831da177e4SLinus Torvalds 	return 0;
18841da177e4SLinus Torvalds }
18851da177e4SLinus Torvalds 
18869ce8ade0SThomas Graf static int ip6_pkt_discard(struct sk_buff *skb)
18879ce8ade0SThomas Graf {
1888612f09e8SYOSHIFUJI Hideaki 	return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
18899ce8ade0SThomas Graf }
18909ce8ade0SThomas Graf 
189120380731SArnaldo Carvalho de Melo static int ip6_pkt_discard_out(struct sk_buff *skb)
18921da177e4SLinus Torvalds {
1893adf30907SEric Dumazet 	skb->dev = skb_dst(skb)->dev;
1894612f09e8SYOSHIFUJI Hideaki 	return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
18951da177e4SLinus Torvalds }
18961da177e4SLinus Torvalds 
18976723ab54SDavid S. Miller #ifdef CONFIG_IPV6_MULTIPLE_TABLES
18986723ab54SDavid S. Miller 
18999ce8ade0SThomas Graf static int ip6_pkt_prohibit(struct sk_buff *skb)
19009ce8ade0SThomas Graf {
1901612f09e8SYOSHIFUJI Hideaki 	return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
19029ce8ade0SThomas Graf }
19039ce8ade0SThomas Graf 
19049ce8ade0SThomas Graf static int ip6_pkt_prohibit_out(struct sk_buff *skb)
19059ce8ade0SThomas Graf {
1906adf30907SEric Dumazet 	skb->dev = skb_dst(skb)->dev;
1907612f09e8SYOSHIFUJI Hideaki 	return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
19089ce8ade0SThomas Graf }
19099ce8ade0SThomas Graf 
19106723ab54SDavid S. Miller #endif
19116723ab54SDavid S. Miller 
19121da177e4SLinus Torvalds /*
19131da177e4SLinus Torvalds  *	Allocate a dst for local (unicast / anycast) address.
19141da177e4SLinus Torvalds  */
19151da177e4SLinus Torvalds 
19161da177e4SLinus Torvalds struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
19171da177e4SLinus Torvalds 				    const struct in6_addr *addr,
19181da177e4SLinus Torvalds 				    int anycast)
19191da177e4SLinus Torvalds {
1920c346dca1SYOSHIFUJI Hideaki 	struct net *net = dev_net(idev->dev);
192186393e52SAlexey Dobriyan 	struct rt6_info *rt = ip6_dst_alloc(&net->ipv6.ip6_dst_ops);
192214deae41SDavid S. Miller 	struct neighbour *neigh;
19231da177e4SLinus Torvalds 
19241da177e4SLinus Torvalds 	if (rt == NULL)
19251da177e4SLinus Torvalds 		return ERR_PTR(-ENOMEM);
19261da177e4SLinus Torvalds 
19275578689aSDaniel Lezcano 	dev_hold(net->loopback_dev);
19281da177e4SLinus Torvalds 	in6_dev_hold(idev);
19291da177e4SLinus Torvalds 
1930d8d1f30bSChangli Gao 	rt->dst.flags = DST_HOST;
1931d8d1f30bSChangli Gao 	rt->dst.input = ip6_input;
1932d8d1f30bSChangli Gao 	rt->dst.output = ip6_output;
19335578689aSDaniel Lezcano 	rt->rt6i_dev = net->loopback_dev;
19341da177e4SLinus Torvalds 	rt->rt6i_idev = idev;
1935d8d1f30bSChangli Gao 	rt->dst.metrics[RTAX_MTU-1] = ipv6_get_mtu(rt->rt6i_dev);
1936d8d1f30bSChangli Gao 	rt->dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(net, dst_mtu(&rt->dst));
1937d8d1f30bSChangli Gao 	rt->dst.metrics[RTAX_HOPLIMIT-1] = -1;
1938d8d1f30bSChangli Gao 	rt->dst.obsolete = -1;
19391da177e4SLinus Torvalds 
19401da177e4SLinus Torvalds 	rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
194158c4fb86SYOSHIFUJI Hideaki 	if (anycast)
194258c4fb86SYOSHIFUJI Hideaki 		rt->rt6i_flags |= RTF_ANYCAST;
194358c4fb86SYOSHIFUJI Hideaki 	else
19441da177e4SLinus Torvalds 		rt->rt6i_flags |= RTF_LOCAL;
194514deae41SDavid S. Miller 	neigh = ndisc_get_neigh(rt->rt6i_dev, &rt->rt6i_gateway);
194614deae41SDavid S. Miller 	if (IS_ERR(neigh)) {
1947d8d1f30bSChangli Gao 		dst_free(&rt->dst);
194814deae41SDavid S. Miller 
194914deae41SDavid S. Miller 		/* We are casting this because that is the return
195014deae41SDavid S. Miller 		 * value type.  But an errno encoded pointer is the
195114deae41SDavid S. Miller 		 * same regardless of the underlying pointer type,
195214deae41SDavid S. Miller 		 * and that's what we are returning.  So this is OK.
195314deae41SDavid S. Miller 		 */
195414deae41SDavid S. Miller 		return (struct rt6_info *) neigh;
19551da177e4SLinus Torvalds 	}
195614deae41SDavid S. Miller 	rt->rt6i_nexthop = neigh;
19571da177e4SLinus Torvalds 
19581da177e4SLinus Torvalds 	ipv6_addr_copy(&rt->rt6i_dst.addr, addr);
19591da177e4SLinus Torvalds 	rt->rt6i_dst.plen = 128;
19605578689aSDaniel Lezcano 	rt->rt6i_table = fib6_get_table(net, RT6_TABLE_LOCAL);
19611da177e4SLinus Torvalds 
1962d8d1f30bSChangli Gao 	atomic_set(&rt->dst.__refcnt, 1);
19631da177e4SLinus Torvalds 
19641da177e4SLinus Torvalds 	return rt;
19651da177e4SLinus Torvalds }
19661da177e4SLinus Torvalds 
19678ed67789SDaniel Lezcano struct arg_dev_net {
19688ed67789SDaniel Lezcano 	struct net_device *dev;
19698ed67789SDaniel Lezcano 	struct net *net;
19708ed67789SDaniel Lezcano };
19718ed67789SDaniel Lezcano 
19721da177e4SLinus Torvalds static int fib6_ifdown(struct rt6_info *rt, void *arg)
19731da177e4SLinus Torvalds {
19748ed67789SDaniel Lezcano 	struct net_device *dev = ((struct arg_dev_net *)arg)->dev;
19758ed67789SDaniel Lezcano 	struct net *net = ((struct arg_dev_net *)arg)->net;
19768ed67789SDaniel Lezcano 
19778ed67789SDaniel Lezcano 	if (((void *)rt->rt6i_dev == dev || dev == NULL) &&
19788ed67789SDaniel Lezcano 	    rt != net->ipv6.ip6_null_entry) {
19791da177e4SLinus Torvalds 		RT6_TRACE("deleted by ifdown %p\n", rt);
19801da177e4SLinus Torvalds 		return -1;
19811da177e4SLinus Torvalds 	}
19821da177e4SLinus Torvalds 	return 0;
19831da177e4SLinus Torvalds }
19841da177e4SLinus Torvalds 
1985f3db4851SDaniel Lezcano void rt6_ifdown(struct net *net, struct net_device *dev)
19861da177e4SLinus Torvalds {
19878ed67789SDaniel Lezcano 	struct arg_dev_net adn = {
19888ed67789SDaniel Lezcano 		.dev = dev,
19898ed67789SDaniel Lezcano 		.net = net,
19908ed67789SDaniel Lezcano 	};
19918ed67789SDaniel Lezcano 
19928ed67789SDaniel Lezcano 	fib6_clean_all(net, fib6_ifdown, 0, &adn);
19931e493d19SDavid S. Miller 	icmp6_clean_all(fib6_ifdown, &adn);
19941da177e4SLinus Torvalds }
19951da177e4SLinus Torvalds 
19961da177e4SLinus Torvalds struct rt6_mtu_change_arg
19971da177e4SLinus Torvalds {
19981da177e4SLinus Torvalds 	struct net_device *dev;
19991da177e4SLinus Torvalds 	unsigned mtu;
20001da177e4SLinus Torvalds };
20011da177e4SLinus Torvalds 
20021da177e4SLinus Torvalds static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
20031da177e4SLinus Torvalds {
20041da177e4SLinus Torvalds 	struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
20051da177e4SLinus Torvalds 	struct inet6_dev *idev;
2006c346dca1SYOSHIFUJI Hideaki 	struct net *net = dev_net(arg->dev);
20071da177e4SLinus Torvalds 
20081da177e4SLinus Torvalds 	/* In IPv6 pmtu discovery is not optional,
20091da177e4SLinus Torvalds 	   so that RTAX_MTU lock cannot disable it.
20101da177e4SLinus Torvalds 	   We still use this lock to block changes
20111da177e4SLinus Torvalds 	   caused by addrconf/ndisc.
20121da177e4SLinus Torvalds 	*/
20131da177e4SLinus Torvalds 
20141da177e4SLinus Torvalds 	idev = __in6_dev_get(arg->dev);
20151da177e4SLinus Torvalds 	if (idev == NULL)
20161da177e4SLinus Torvalds 		return 0;
20171da177e4SLinus Torvalds 
20181da177e4SLinus Torvalds 	/* For administrative MTU increase, there is no way to discover
20191da177e4SLinus Torvalds 	   IPv6 PMTU increase, so PMTU increase should be updated here.
20201da177e4SLinus Torvalds 	   Since RFC 1981 doesn't include administrative MTU increase
20211da177e4SLinus Torvalds 	   update PMTU increase is a MUST. (i.e. jumbo frame)
20221da177e4SLinus Torvalds 	 */
20231da177e4SLinus Torvalds 	/*
20241da177e4SLinus Torvalds 	   If new MTU is less than route PMTU, this new MTU will be the
20251da177e4SLinus Torvalds 	   lowest MTU in the path, update the route PMTU to reflect PMTU
20261da177e4SLinus Torvalds 	   decreases; if new MTU is greater than route PMTU, and the
20271da177e4SLinus Torvalds 	   old MTU is the lowest MTU in the path, update the route PMTU
20281da177e4SLinus Torvalds 	   to reflect the increase. In this case if the other nodes' MTU
20291da177e4SLinus Torvalds 	   also have the lowest MTU, TOO BIG MESSAGE will be lead to
20301da177e4SLinus Torvalds 	   PMTU discouvery.
20311da177e4SLinus Torvalds 	 */
20321da177e4SLinus Torvalds 	if (rt->rt6i_dev == arg->dev &&
2033d8d1f30bSChangli Gao 	    !dst_metric_locked(&rt->dst, RTAX_MTU) &&
2034d8d1f30bSChangli Gao 	    (dst_mtu(&rt->dst) >= arg->mtu ||
2035d8d1f30bSChangli Gao 	     (dst_mtu(&rt->dst) < arg->mtu &&
2036d8d1f30bSChangli Gao 	      dst_mtu(&rt->dst) == idev->cnf.mtu6))) {
2037d8d1f30bSChangli Gao 		rt->dst.metrics[RTAX_MTU-1] = arg->mtu;
2038d8d1f30bSChangli Gao 		rt->dst.metrics[RTAX_ADVMSS-1] = ipv6_advmss(net, arg->mtu);
2039566cfd8fSSimon Arlott 	}
20401da177e4SLinus Torvalds 	return 0;
20411da177e4SLinus Torvalds }
20421da177e4SLinus Torvalds 
20431da177e4SLinus Torvalds void rt6_mtu_change(struct net_device *dev, unsigned mtu)
20441da177e4SLinus Torvalds {
2045c71099acSThomas Graf 	struct rt6_mtu_change_arg arg = {
2046c71099acSThomas Graf 		.dev = dev,
2047c71099acSThomas Graf 		.mtu = mtu,
2048c71099acSThomas Graf 	};
20491da177e4SLinus Torvalds 
2050c346dca1SYOSHIFUJI Hideaki 	fib6_clean_all(dev_net(dev), rt6_mtu_change_route, 0, &arg);
20511da177e4SLinus Torvalds }
20521da177e4SLinus Torvalds 
2053ef7c79edSPatrick McHardy static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
20545176f91eSThomas Graf 	[RTA_GATEWAY]           = { .len = sizeof(struct in6_addr) },
205586872cb5SThomas Graf 	[RTA_OIF]               = { .type = NLA_U32 },
2056ab364a6fSThomas Graf 	[RTA_IIF]		= { .type = NLA_U32 },
205786872cb5SThomas Graf 	[RTA_PRIORITY]          = { .type = NLA_U32 },
205886872cb5SThomas Graf 	[RTA_METRICS]           = { .type = NLA_NESTED },
205986872cb5SThomas Graf };
206086872cb5SThomas Graf 
206186872cb5SThomas Graf static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
206286872cb5SThomas Graf 			      struct fib6_config *cfg)
20631da177e4SLinus Torvalds {
206486872cb5SThomas Graf 	struct rtmsg *rtm;
206586872cb5SThomas Graf 	struct nlattr *tb[RTA_MAX+1];
206686872cb5SThomas Graf 	int err;
20671da177e4SLinus Torvalds 
206886872cb5SThomas Graf 	err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
206986872cb5SThomas Graf 	if (err < 0)
207086872cb5SThomas Graf 		goto errout;
20711da177e4SLinus Torvalds 
207286872cb5SThomas Graf 	err = -EINVAL;
207386872cb5SThomas Graf 	rtm = nlmsg_data(nlh);
207486872cb5SThomas Graf 	memset(cfg, 0, sizeof(*cfg));
207586872cb5SThomas Graf 
207686872cb5SThomas Graf 	cfg->fc_table = rtm->rtm_table;
207786872cb5SThomas Graf 	cfg->fc_dst_len = rtm->rtm_dst_len;
207886872cb5SThomas Graf 	cfg->fc_src_len = rtm->rtm_src_len;
207986872cb5SThomas Graf 	cfg->fc_flags = RTF_UP;
208086872cb5SThomas Graf 	cfg->fc_protocol = rtm->rtm_protocol;
208186872cb5SThomas Graf 
208286872cb5SThomas Graf 	if (rtm->rtm_type == RTN_UNREACHABLE)
208386872cb5SThomas Graf 		cfg->fc_flags |= RTF_REJECT;
208486872cb5SThomas Graf 
208586872cb5SThomas Graf 	cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
208686872cb5SThomas Graf 	cfg->fc_nlinfo.nlh = nlh;
20873b1e0a65SYOSHIFUJI Hideaki 	cfg->fc_nlinfo.nl_net = sock_net(skb->sk);
208886872cb5SThomas Graf 
208986872cb5SThomas Graf 	if (tb[RTA_GATEWAY]) {
209086872cb5SThomas Graf 		nla_memcpy(&cfg->fc_gateway, tb[RTA_GATEWAY], 16);
209186872cb5SThomas Graf 		cfg->fc_flags |= RTF_GATEWAY;
20921da177e4SLinus Torvalds 	}
209386872cb5SThomas Graf 
209486872cb5SThomas Graf 	if (tb[RTA_DST]) {
209586872cb5SThomas Graf 		int plen = (rtm->rtm_dst_len + 7) >> 3;
209686872cb5SThomas Graf 
209786872cb5SThomas Graf 		if (nla_len(tb[RTA_DST]) < plen)
209886872cb5SThomas Graf 			goto errout;
209986872cb5SThomas Graf 
210086872cb5SThomas Graf 		nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
21011da177e4SLinus Torvalds 	}
210286872cb5SThomas Graf 
210386872cb5SThomas Graf 	if (tb[RTA_SRC]) {
210486872cb5SThomas Graf 		int plen = (rtm->rtm_src_len + 7) >> 3;
210586872cb5SThomas Graf 
210686872cb5SThomas Graf 		if (nla_len(tb[RTA_SRC]) < plen)
210786872cb5SThomas Graf 			goto errout;
210886872cb5SThomas Graf 
210986872cb5SThomas Graf 		nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
21101da177e4SLinus Torvalds 	}
211186872cb5SThomas Graf 
211286872cb5SThomas Graf 	if (tb[RTA_OIF])
211386872cb5SThomas Graf 		cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);
211486872cb5SThomas Graf 
211586872cb5SThomas Graf 	if (tb[RTA_PRIORITY])
211686872cb5SThomas Graf 		cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);
211786872cb5SThomas Graf 
211886872cb5SThomas Graf 	if (tb[RTA_METRICS]) {
211986872cb5SThomas Graf 		cfg->fc_mx = nla_data(tb[RTA_METRICS]);
212086872cb5SThomas Graf 		cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
21211da177e4SLinus Torvalds 	}
212286872cb5SThomas Graf 
212386872cb5SThomas Graf 	if (tb[RTA_TABLE])
212486872cb5SThomas Graf 		cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);
212586872cb5SThomas Graf 
212686872cb5SThomas Graf 	err = 0;
212786872cb5SThomas Graf errout:
212886872cb5SThomas Graf 	return err;
21291da177e4SLinus Torvalds }
21301da177e4SLinus Torvalds 
2131c127ea2cSThomas Graf static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
21321da177e4SLinus Torvalds {
213386872cb5SThomas Graf 	struct fib6_config cfg;
213486872cb5SThomas Graf 	int err;
21351da177e4SLinus Torvalds 
213686872cb5SThomas Graf 	err = rtm_to_fib6_config(skb, nlh, &cfg);
213786872cb5SThomas Graf 	if (err < 0)
213886872cb5SThomas Graf 		return err;
213986872cb5SThomas Graf 
214086872cb5SThomas Graf 	return ip6_route_del(&cfg);
21411da177e4SLinus Torvalds }
21421da177e4SLinus Torvalds 
2143c127ea2cSThomas Graf static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
21441da177e4SLinus Torvalds {
214586872cb5SThomas Graf 	struct fib6_config cfg;
214686872cb5SThomas Graf 	int err;
21471da177e4SLinus Torvalds 
214886872cb5SThomas Graf 	err = rtm_to_fib6_config(skb, nlh, &cfg);
214986872cb5SThomas Graf 	if (err < 0)
215086872cb5SThomas Graf 		return err;
215186872cb5SThomas Graf 
215286872cb5SThomas Graf 	return ip6_route_add(&cfg);
21531da177e4SLinus Torvalds }
21541da177e4SLinus Torvalds 
2155339bf98fSThomas Graf static inline size_t rt6_nlmsg_size(void)
2156339bf98fSThomas Graf {
2157339bf98fSThomas Graf 	return NLMSG_ALIGN(sizeof(struct rtmsg))
2158339bf98fSThomas Graf 	       + nla_total_size(16) /* RTA_SRC */
2159339bf98fSThomas Graf 	       + nla_total_size(16) /* RTA_DST */
2160339bf98fSThomas Graf 	       + nla_total_size(16) /* RTA_GATEWAY */
2161339bf98fSThomas Graf 	       + nla_total_size(16) /* RTA_PREFSRC */
2162339bf98fSThomas Graf 	       + nla_total_size(4) /* RTA_TABLE */
2163339bf98fSThomas Graf 	       + nla_total_size(4) /* RTA_IIF */
2164339bf98fSThomas Graf 	       + nla_total_size(4) /* RTA_OIF */
2165339bf98fSThomas Graf 	       + nla_total_size(4) /* RTA_PRIORITY */
21666a2b9ce0SNoriaki TAKAMIYA 	       + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
2167339bf98fSThomas Graf 	       + nla_total_size(sizeof(struct rta_cacheinfo));
2168339bf98fSThomas Graf }
2169339bf98fSThomas Graf 
2170191cd582SBrian Haley static int rt6_fill_node(struct net *net,
2171191cd582SBrian Haley 			 struct sk_buff *skb, struct rt6_info *rt,
21720d51aa80SJamal Hadi Salim 			 struct in6_addr *dst, struct in6_addr *src,
21730d51aa80SJamal Hadi Salim 			 int iif, int type, u32 pid, u32 seq,
21747bc570c8SYOSHIFUJI Hideaki 			 int prefix, int nowait, unsigned int flags)
21751da177e4SLinus Torvalds {
21761da177e4SLinus Torvalds 	struct rtmsg *rtm;
21771da177e4SLinus Torvalds 	struct nlmsghdr *nlh;
2178e3703b3dSThomas Graf 	long expires;
21799e762a4aSPatrick McHardy 	u32 table;
21801da177e4SLinus Torvalds 
21811da177e4SLinus Torvalds 	if (prefix) {	/* user wants prefix routes only */
21821da177e4SLinus Torvalds 		if (!(rt->rt6i_flags & RTF_PREFIX_RT)) {
21831da177e4SLinus Torvalds 			/* success since this is not a prefix route */
21841da177e4SLinus Torvalds 			return 1;
21851da177e4SLinus Torvalds 		}
21861da177e4SLinus Torvalds 	}
21871da177e4SLinus Torvalds 
21882d7202bfSThomas Graf 	nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtm), flags);
21892d7202bfSThomas Graf 	if (nlh == NULL)
219026932566SPatrick McHardy 		return -EMSGSIZE;
21912d7202bfSThomas Graf 
21922d7202bfSThomas Graf 	rtm = nlmsg_data(nlh);
21931da177e4SLinus Torvalds 	rtm->rtm_family = AF_INET6;
21941da177e4SLinus Torvalds 	rtm->rtm_dst_len = rt->rt6i_dst.plen;
21951da177e4SLinus Torvalds 	rtm->rtm_src_len = rt->rt6i_src.plen;
21961da177e4SLinus Torvalds 	rtm->rtm_tos = 0;
2197c71099acSThomas Graf 	if (rt->rt6i_table)
21989e762a4aSPatrick McHardy 		table = rt->rt6i_table->tb6_id;
2199c71099acSThomas Graf 	else
22009e762a4aSPatrick McHardy 		table = RT6_TABLE_UNSPEC;
22019e762a4aSPatrick McHardy 	rtm->rtm_table = table;
22022d7202bfSThomas Graf 	NLA_PUT_U32(skb, RTA_TABLE, table);
22031da177e4SLinus Torvalds 	if (rt->rt6i_flags&RTF_REJECT)
22041da177e4SLinus Torvalds 		rtm->rtm_type = RTN_UNREACHABLE;
22051da177e4SLinus Torvalds 	else if (rt->rt6i_dev && (rt->rt6i_dev->flags&IFF_LOOPBACK))
22061da177e4SLinus Torvalds 		rtm->rtm_type = RTN_LOCAL;
22071da177e4SLinus Torvalds 	else
22081da177e4SLinus Torvalds 		rtm->rtm_type = RTN_UNICAST;
22091da177e4SLinus Torvalds 	rtm->rtm_flags = 0;
22101da177e4SLinus Torvalds 	rtm->rtm_scope = RT_SCOPE_UNIVERSE;
22111da177e4SLinus Torvalds 	rtm->rtm_protocol = rt->rt6i_protocol;
22121da177e4SLinus Torvalds 	if (rt->rt6i_flags&RTF_DYNAMIC)
22131da177e4SLinus Torvalds 		rtm->rtm_protocol = RTPROT_REDIRECT;
22141da177e4SLinus Torvalds 	else if (rt->rt6i_flags & RTF_ADDRCONF)
22151da177e4SLinus Torvalds 		rtm->rtm_protocol = RTPROT_KERNEL;
22161da177e4SLinus Torvalds 	else if (rt->rt6i_flags&RTF_DEFAULT)
22171da177e4SLinus Torvalds 		rtm->rtm_protocol = RTPROT_RA;
22181da177e4SLinus Torvalds 
22191da177e4SLinus Torvalds 	if (rt->rt6i_flags&RTF_CACHE)
22201da177e4SLinus Torvalds 		rtm->rtm_flags |= RTM_F_CLONED;
22211da177e4SLinus Torvalds 
22221da177e4SLinus Torvalds 	if (dst) {
22232d7202bfSThomas Graf 		NLA_PUT(skb, RTA_DST, 16, dst);
22241da177e4SLinus Torvalds 		rtm->rtm_dst_len = 128;
22251da177e4SLinus Torvalds 	} else if (rtm->rtm_dst_len)
22262d7202bfSThomas Graf 		NLA_PUT(skb, RTA_DST, 16, &rt->rt6i_dst.addr);
22271da177e4SLinus Torvalds #ifdef CONFIG_IPV6_SUBTREES
22281da177e4SLinus Torvalds 	if (src) {
22292d7202bfSThomas Graf 		NLA_PUT(skb, RTA_SRC, 16, src);
22301da177e4SLinus Torvalds 		rtm->rtm_src_len = 128;
22311da177e4SLinus Torvalds 	} else if (rtm->rtm_src_len)
22322d7202bfSThomas Graf 		NLA_PUT(skb, RTA_SRC, 16, &rt->rt6i_src.addr);
22331da177e4SLinus Torvalds #endif
22347bc570c8SYOSHIFUJI Hideaki 	if (iif) {
22357bc570c8SYOSHIFUJI Hideaki #ifdef CONFIG_IPV6_MROUTE
22367bc570c8SYOSHIFUJI Hideaki 		if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
22378229efdaSBenjamin Thery 			int err = ip6mr_get_route(net, skb, rtm, nowait);
22387bc570c8SYOSHIFUJI Hideaki 			if (err <= 0) {
22397bc570c8SYOSHIFUJI Hideaki 				if (!nowait) {
22407bc570c8SYOSHIFUJI Hideaki 					if (err == 0)
22417bc570c8SYOSHIFUJI Hideaki 						return 0;
22427bc570c8SYOSHIFUJI Hideaki 					goto nla_put_failure;
22437bc570c8SYOSHIFUJI Hideaki 				} else {
22447bc570c8SYOSHIFUJI Hideaki 					if (err == -EMSGSIZE)
22457bc570c8SYOSHIFUJI Hideaki 						goto nla_put_failure;
22467bc570c8SYOSHIFUJI Hideaki 				}
22477bc570c8SYOSHIFUJI Hideaki 			}
22487bc570c8SYOSHIFUJI Hideaki 		} else
22497bc570c8SYOSHIFUJI Hideaki #endif
22502d7202bfSThomas Graf 			NLA_PUT_U32(skb, RTA_IIF, iif);
22517bc570c8SYOSHIFUJI Hideaki 	} else if (dst) {
2252d8d1f30bSChangli Gao 		struct inet6_dev *idev = ip6_dst_idev(&rt->dst);
22531da177e4SLinus Torvalds 		struct in6_addr saddr_buf;
2254191cd582SBrian Haley 		if (ipv6_dev_get_saddr(net, idev ? idev->dev : NULL,
22557cbca67cSYOSHIFUJI Hideaki 				       dst, 0, &saddr_buf) == 0)
22562d7202bfSThomas Graf 			NLA_PUT(skb, RTA_PREFSRC, 16, &saddr_buf);
22571da177e4SLinus Torvalds 	}
22582d7202bfSThomas Graf 
2259d8d1f30bSChangli Gao 	if (rtnetlink_put_metrics(skb, rt->dst.metrics) < 0)
22602d7202bfSThomas Graf 		goto nla_put_failure;
22612d7202bfSThomas Graf 
2262d8d1f30bSChangli Gao 	if (rt->dst.neighbour)
2263d8d1f30bSChangli Gao 		NLA_PUT(skb, RTA_GATEWAY, 16, &rt->dst.neighbour->primary_key);
22642d7202bfSThomas Graf 
2265d8d1f30bSChangli Gao 	if (rt->dst.dev)
22662d7202bfSThomas Graf 		NLA_PUT_U32(skb, RTA_OIF, rt->rt6i_dev->ifindex);
22672d7202bfSThomas Graf 
22682d7202bfSThomas Graf 	NLA_PUT_U32(skb, RTA_PRIORITY, rt->rt6i_metric);
2269e3703b3dSThomas Graf 
227036e3deaeSYOSHIFUJI Hideaki 	if (!(rt->rt6i_flags & RTF_EXPIRES))
227136e3deaeSYOSHIFUJI Hideaki 		expires = 0;
227236e3deaeSYOSHIFUJI Hideaki 	else if (rt->rt6i_expires - jiffies < INT_MAX)
227336e3deaeSYOSHIFUJI Hideaki 		expires = rt->rt6i_expires - jiffies;
227436e3deaeSYOSHIFUJI Hideaki 	else
227536e3deaeSYOSHIFUJI Hideaki 		expires = INT_MAX;
227669cdf8f9SYOSHIFUJI Hideaki 
2277d8d1f30bSChangli Gao 	if (rtnl_put_cacheinfo(skb, &rt->dst, 0, 0, 0,
2278d8d1f30bSChangli Gao 			       expires, rt->dst.error) < 0)
2279e3703b3dSThomas Graf 		goto nla_put_failure;
22801da177e4SLinus Torvalds 
22812d7202bfSThomas Graf 	return nlmsg_end(skb, nlh);
22822d7202bfSThomas Graf 
22832d7202bfSThomas Graf nla_put_failure:
228426932566SPatrick McHardy 	nlmsg_cancel(skb, nlh);
228526932566SPatrick McHardy 	return -EMSGSIZE;
22861da177e4SLinus Torvalds }
22871da177e4SLinus Torvalds 
22881b43af54SPatrick McHardy int rt6_dump_route(struct rt6_info *rt, void *p_arg)
22891da177e4SLinus Torvalds {
22901da177e4SLinus Torvalds 	struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
22911da177e4SLinus Torvalds 	int prefix;
22921da177e4SLinus Torvalds 
22932d7202bfSThomas Graf 	if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
22942d7202bfSThomas Graf 		struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);
22951da177e4SLinus Torvalds 		prefix = (rtm->rtm_flags & RTM_F_PREFIX) != 0;
22961da177e4SLinus Torvalds 	} else
22971da177e4SLinus Torvalds 		prefix = 0;
22981da177e4SLinus Torvalds 
2299191cd582SBrian Haley 	return rt6_fill_node(arg->net,
2300191cd582SBrian Haley 		     arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
23011da177e4SLinus Torvalds 		     NETLINK_CB(arg->cb->skb).pid, arg->cb->nlh->nlmsg_seq,
23027bc570c8SYOSHIFUJI Hideaki 		     prefix, 0, NLM_F_MULTI);
23031da177e4SLinus Torvalds }
23041da177e4SLinus Torvalds 
2305c127ea2cSThomas Graf static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
23061da177e4SLinus Torvalds {
23073b1e0a65SYOSHIFUJI Hideaki 	struct net *net = sock_net(in_skb->sk);
2308ab364a6fSThomas Graf 	struct nlattr *tb[RTA_MAX+1];
23091da177e4SLinus Torvalds 	struct rt6_info *rt;
2310ab364a6fSThomas Graf 	struct sk_buff *skb;
2311ab364a6fSThomas Graf 	struct rtmsg *rtm;
2312ab364a6fSThomas Graf 	struct flowi fl;
2313ab364a6fSThomas Graf 	int err, iif = 0;
2314ab364a6fSThomas Graf 
2315ab364a6fSThomas Graf 	err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
2316ab364a6fSThomas Graf 	if (err < 0)
2317ab364a6fSThomas Graf 		goto errout;
2318ab364a6fSThomas Graf 
2319ab364a6fSThomas Graf 	err = -EINVAL;
2320ab364a6fSThomas Graf 	memset(&fl, 0, sizeof(fl));
2321ab364a6fSThomas Graf 
2322ab364a6fSThomas Graf 	if (tb[RTA_SRC]) {
2323ab364a6fSThomas Graf 		if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
2324ab364a6fSThomas Graf 			goto errout;
2325ab364a6fSThomas Graf 
2326ab364a6fSThomas Graf 		ipv6_addr_copy(&fl.fl6_src, nla_data(tb[RTA_SRC]));
2327ab364a6fSThomas Graf 	}
2328ab364a6fSThomas Graf 
2329ab364a6fSThomas Graf 	if (tb[RTA_DST]) {
2330ab364a6fSThomas Graf 		if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
2331ab364a6fSThomas Graf 			goto errout;
2332ab364a6fSThomas Graf 
2333ab364a6fSThomas Graf 		ipv6_addr_copy(&fl.fl6_dst, nla_data(tb[RTA_DST]));
2334ab364a6fSThomas Graf 	}
2335ab364a6fSThomas Graf 
2336ab364a6fSThomas Graf 	if (tb[RTA_IIF])
2337ab364a6fSThomas Graf 		iif = nla_get_u32(tb[RTA_IIF]);
2338ab364a6fSThomas Graf 
2339ab364a6fSThomas Graf 	if (tb[RTA_OIF])
2340ab364a6fSThomas Graf 		fl.oif = nla_get_u32(tb[RTA_OIF]);
2341ab364a6fSThomas Graf 
2342ab364a6fSThomas Graf 	if (iif) {
2343ab364a6fSThomas Graf 		struct net_device *dev;
23445578689aSDaniel Lezcano 		dev = __dev_get_by_index(net, iif);
2345ab364a6fSThomas Graf 		if (!dev) {
2346ab364a6fSThomas Graf 			err = -ENODEV;
2347ab364a6fSThomas Graf 			goto errout;
2348ab364a6fSThomas Graf 		}
2349ab364a6fSThomas Graf 	}
23501da177e4SLinus Torvalds 
23511da177e4SLinus Torvalds 	skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2352ab364a6fSThomas Graf 	if (skb == NULL) {
2353ab364a6fSThomas Graf 		err = -ENOBUFS;
2354ab364a6fSThomas Graf 		goto errout;
2355ab364a6fSThomas Graf 	}
23561da177e4SLinus Torvalds 
23571da177e4SLinus Torvalds 	/* Reserve room for dummy headers, this skb can pass
23581da177e4SLinus Torvalds 	   through good chunk of routing engine.
23591da177e4SLinus Torvalds 	 */
2360459a98edSArnaldo Carvalho de Melo 	skb_reset_mac_header(skb);
23611da177e4SLinus Torvalds 	skb_reserve(skb, MAX_HEADER + sizeof(struct ipv6hdr));
23621da177e4SLinus Torvalds 
23638a3edd80SDaniel Lezcano 	rt = (struct rt6_info*) ip6_route_output(net, NULL, &fl);
2364d8d1f30bSChangli Gao 	skb_dst_set(skb, &rt->dst);
23651da177e4SLinus Torvalds 
2366191cd582SBrian Haley 	err = rt6_fill_node(net, skb, rt, &fl.fl6_dst, &fl.fl6_src, iif,
23671da177e4SLinus Torvalds 			    RTM_NEWROUTE, NETLINK_CB(in_skb).pid,
23687bc570c8SYOSHIFUJI Hideaki 			    nlh->nlmsg_seq, 0, 0, 0);
23691da177e4SLinus Torvalds 	if (err < 0) {
2370ab364a6fSThomas Graf 		kfree_skb(skb);
2371ab364a6fSThomas Graf 		goto errout;
23721da177e4SLinus Torvalds 	}
23731da177e4SLinus Torvalds 
23745578689aSDaniel Lezcano 	err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).pid);
2375ab364a6fSThomas Graf errout:
23761da177e4SLinus Torvalds 	return err;
23771da177e4SLinus Torvalds }
23781da177e4SLinus Torvalds 
237986872cb5SThomas Graf void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info)
23801da177e4SLinus Torvalds {
23811da177e4SLinus Torvalds 	struct sk_buff *skb;
23825578689aSDaniel Lezcano 	struct net *net = info->nl_net;
2383528c4cebSDenis V. Lunev 	u32 seq;
2384528c4cebSDenis V. Lunev 	int err;
23850d51aa80SJamal Hadi Salim 
2386528c4cebSDenis V. Lunev 	err = -ENOBUFS;
2387528c4cebSDenis V. Lunev 	seq = info->nlh != NULL ? info->nlh->nlmsg_seq : 0;
238886872cb5SThomas Graf 
2389339bf98fSThomas Graf 	skb = nlmsg_new(rt6_nlmsg_size(), gfp_any());
239021713ebcSThomas Graf 	if (skb == NULL)
239121713ebcSThomas Graf 		goto errout;
23921da177e4SLinus Torvalds 
2393191cd582SBrian Haley 	err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
23947bc570c8SYOSHIFUJI Hideaki 				event, info->pid, seq, 0, 0, 0);
239526932566SPatrick McHardy 	if (err < 0) {
239626932566SPatrick McHardy 		/* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
239726932566SPatrick McHardy 		WARN_ON(err == -EMSGSIZE);
239826932566SPatrick McHardy 		kfree_skb(skb);
239926932566SPatrick McHardy 		goto errout;
240026932566SPatrick McHardy 	}
24011ce85fe4SPablo Neira Ayuso 	rtnl_notify(skb, net, info->pid, RTNLGRP_IPV6_ROUTE,
24025578689aSDaniel Lezcano 		    info->nlh, gfp_any());
24031ce85fe4SPablo Neira Ayuso 	return;
240421713ebcSThomas Graf errout:
240521713ebcSThomas Graf 	if (err < 0)
24065578689aSDaniel Lezcano 		rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
24071da177e4SLinus Torvalds }
24081da177e4SLinus Torvalds 
24098ed67789SDaniel Lezcano static int ip6_route_dev_notify(struct notifier_block *this,
24108ed67789SDaniel Lezcano 				unsigned long event, void *data)
24118ed67789SDaniel Lezcano {
24128ed67789SDaniel Lezcano 	struct net_device *dev = (struct net_device *)data;
2413c346dca1SYOSHIFUJI Hideaki 	struct net *net = dev_net(dev);
24148ed67789SDaniel Lezcano 
24158ed67789SDaniel Lezcano 	if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
2416d8d1f30bSChangli Gao 		net->ipv6.ip6_null_entry->dst.dev = dev;
24178ed67789SDaniel Lezcano 		net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
24188ed67789SDaniel Lezcano #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2419d8d1f30bSChangli Gao 		net->ipv6.ip6_prohibit_entry->dst.dev = dev;
24208ed67789SDaniel Lezcano 		net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
2421d8d1f30bSChangli Gao 		net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
24228ed67789SDaniel Lezcano 		net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
24238ed67789SDaniel Lezcano #endif
24248ed67789SDaniel Lezcano 	}
24258ed67789SDaniel Lezcano 
24268ed67789SDaniel Lezcano 	return NOTIFY_OK;
24278ed67789SDaniel Lezcano }
24288ed67789SDaniel Lezcano 
24291da177e4SLinus Torvalds /*
24301da177e4SLinus Torvalds  *	/proc
24311da177e4SLinus Torvalds  */
24321da177e4SLinus Torvalds 
24331da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS
24341da177e4SLinus Torvalds 
24351da177e4SLinus Torvalds #define RT6_INFO_LEN (32 + 4 + 32 + 4 + 32 + 40 + 5 + 1)
24361da177e4SLinus Torvalds 
24371da177e4SLinus Torvalds struct rt6_proc_arg
24381da177e4SLinus Torvalds {
24391da177e4SLinus Torvalds 	char *buffer;
24401da177e4SLinus Torvalds 	int offset;
24411da177e4SLinus Torvalds 	int length;
24421da177e4SLinus Torvalds 	int skip;
24431da177e4SLinus Torvalds 	int len;
24441da177e4SLinus Torvalds };
24451da177e4SLinus Torvalds 
24461da177e4SLinus Torvalds static int rt6_info_route(struct rt6_info *rt, void *p_arg)
24471da177e4SLinus Torvalds {
244833120b30SAlexey Dobriyan 	struct seq_file *m = p_arg;
24491da177e4SLinus Torvalds 
24504b7a4274SHarvey Harrison 	seq_printf(m, "%pi6 %02x ", &rt->rt6i_dst.addr, rt->rt6i_dst.plen);
24511da177e4SLinus Torvalds 
24521da177e4SLinus Torvalds #ifdef CONFIG_IPV6_SUBTREES
24534b7a4274SHarvey Harrison 	seq_printf(m, "%pi6 %02x ", &rt->rt6i_src.addr, rt->rt6i_src.plen);
24541da177e4SLinus Torvalds #else
245533120b30SAlexey Dobriyan 	seq_puts(m, "00000000000000000000000000000000 00 ");
24561da177e4SLinus Torvalds #endif
24571da177e4SLinus Torvalds 
24581da177e4SLinus Torvalds 	if (rt->rt6i_nexthop) {
24594b7a4274SHarvey Harrison 		seq_printf(m, "%pi6", rt->rt6i_nexthop->primary_key);
24601da177e4SLinus Torvalds 	} else {
246133120b30SAlexey Dobriyan 		seq_puts(m, "00000000000000000000000000000000");
24621da177e4SLinus Torvalds 	}
246333120b30SAlexey Dobriyan 	seq_printf(m, " %08x %08x %08x %08x %8s\n",
2464d8d1f30bSChangli Gao 		   rt->rt6i_metric, atomic_read(&rt->dst.__refcnt),
2465d8d1f30bSChangli Gao 		   rt->dst.__use, rt->rt6i_flags,
24661da177e4SLinus Torvalds 		   rt->rt6i_dev ? rt->rt6i_dev->name : "");
24671da177e4SLinus Torvalds 	return 0;
24681da177e4SLinus Torvalds }
24691da177e4SLinus Torvalds 
247033120b30SAlexey Dobriyan static int ipv6_route_show(struct seq_file *m, void *v)
24711da177e4SLinus Torvalds {
2472f3db4851SDaniel Lezcano 	struct net *net = (struct net *)m->private;
2473f3db4851SDaniel Lezcano 	fib6_clean_all(net, rt6_info_route, 0, m);
247433120b30SAlexey Dobriyan 	return 0;
24751da177e4SLinus Torvalds }
24761da177e4SLinus Torvalds 
247733120b30SAlexey Dobriyan static int ipv6_route_open(struct inode *inode, struct file *file)
247833120b30SAlexey Dobriyan {
2479de05c557SPavel Emelyanov 	return single_open_net(inode, file, ipv6_route_show);
2480f3db4851SDaniel Lezcano }
2481f3db4851SDaniel Lezcano 
248233120b30SAlexey Dobriyan static const struct file_operations ipv6_route_proc_fops = {
248333120b30SAlexey Dobriyan 	.owner		= THIS_MODULE,
248433120b30SAlexey Dobriyan 	.open		= ipv6_route_open,
248533120b30SAlexey Dobriyan 	.read		= seq_read,
248633120b30SAlexey Dobriyan 	.llseek		= seq_lseek,
2487b6fcbdb4SPavel Emelyanov 	.release	= single_release_net,
248833120b30SAlexey Dobriyan };
248933120b30SAlexey Dobriyan 
24901da177e4SLinus Torvalds static int rt6_stats_seq_show(struct seq_file *seq, void *v)
24911da177e4SLinus Torvalds {
249269ddb805SDaniel Lezcano 	struct net *net = (struct net *)seq->private;
24931da177e4SLinus Torvalds 	seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
249469ddb805SDaniel Lezcano 		   net->ipv6.rt6_stats->fib_nodes,
249569ddb805SDaniel Lezcano 		   net->ipv6.rt6_stats->fib_route_nodes,
249669ddb805SDaniel Lezcano 		   net->ipv6.rt6_stats->fib_rt_alloc,
249769ddb805SDaniel Lezcano 		   net->ipv6.rt6_stats->fib_rt_entries,
249869ddb805SDaniel Lezcano 		   net->ipv6.rt6_stats->fib_rt_cache,
249986393e52SAlexey Dobriyan 		   atomic_read(&net->ipv6.ip6_dst_ops.entries),
250069ddb805SDaniel Lezcano 		   net->ipv6.rt6_stats->fib_discarded_routes);
25011da177e4SLinus Torvalds 
25021da177e4SLinus Torvalds 	return 0;
25031da177e4SLinus Torvalds }
25041da177e4SLinus Torvalds 
25051da177e4SLinus Torvalds static int rt6_stats_seq_open(struct inode *inode, struct file *file)
25061da177e4SLinus Torvalds {
2507de05c557SPavel Emelyanov 	return single_open_net(inode, file, rt6_stats_seq_show);
250869ddb805SDaniel Lezcano }
250969ddb805SDaniel Lezcano 
25109a32144eSArjan van de Ven static const struct file_operations rt6_stats_seq_fops = {
25111da177e4SLinus Torvalds 	.owner	 = THIS_MODULE,
25121da177e4SLinus Torvalds 	.open	 = rt6_stats_seq_open,
25131da177e4SLinus Torvalds 	.read	 = seq_read,
25141da177e4SLinus Torvalds 	.llseek	 = seq_lseek,
2515b6fcbdb4SPavel Emelyanov 	.release = single_release_net,
25161da177e4SLinus Torvalds };
25171da177e4SLinus Torvalds #endif	/* CONFIG_PROC_FS */
25181da177e4SLinus Torvalds 
25191da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL
25201da177e4SLinus Torvalds 
25211da177e4SLinus Torvalds static
25228d65af78SAlexey Dobriyan int ipv6_sysctl_rtcache_flush(ctl_table *ctl, int write,
25231da177e4SLinus Torvalds 			      void __user *buffer, size_t *lenp, loff_t *ppos)
25241da177e4SLinus Torvalds {
25255b7c931dSDaniel Lezcano 	struct net *net = current->nsproxy->net_ns;
25265b7c931dSDaniel Lezcano 	int delay = net->ipv6.sysctl.flush_delay;
25271da177e4SLinus Torvalds 	if (write) {
25288d65af78SAlexey Dobriyan 		proc_dointvec(ctl, write, buffer, lenp, ppos);
25295b7c931dSDaniel Lezcano 		fib6_run_gc(delay <= 0 ? ~0UL : (unsigned long)delay, net);
25301da177e4SLinus Torvalds 		return 0;
25311da177e4SLinus Torvalds 	} else
25321da177e4SLinus Torvalds 		return -EINVAL;
25331da177e4SLinus Torvalds }
25341da177e4SLinus Torvalds 
2535760f2d01SDaniel Lezcano ctl_table ipv6_route_table_template[] = {
25361da177e4SLinus Torvalds 	{
25371da177e4SLinus Torvalds 		.procname	=	"flush",
25384990509fSDaniel Lezcano 		.data		=	&init_net.ipv6.sysctl.flush_delay,
25391da177e4SLinus Torvalds 		.maxlen		=	sizeof(int),
254089c8b3a1SDave Jones 		.mode		=	0200,
25416d9f239aSAlexey Dobriyan 		.proc_handler	=	ipv6_sysctl_rtcache_flush
25421da177e4SLinus Torvalds 	},
25431da177e4SLinus Torvalds 	{
25441da177e4SLinus Torvalds 		.procname	=	"gc_thresh",
25459a7ec3a9SDaniel Lezcano 		.data		=	&ip6_dst_ops_template.gc_thresh,
25461da177e4SLinus Torvalds 		.maxlen		=	sizeof(int),
25471da177e4SLinus Torvalds 		.mode		=	0644,
25486d9f239aSAlexey Dobriyan 		.proc_handler	=	proc_dointvec,
25491da177e4SLinus Torvalds 	},
25501da177e4SLinus Torvalds 	{
25511da177e4SLinus Torvalds 		.procname	=	"max_size",
25524990509fSDaniel Lezcano 		.data		=	&init_net.ipv6.sysctl.ip6_rt_max_size,
25531da177e4SLinus Torvalds 		.maxlen		=	sizeof(int),
25541da177e4SLinus Torvalds 		.mode		=	0644,
25556d9f239aSAlexey Dobriyan 		.proc_handler	=	proc_dointvec,
25561da177e4SLinus Torvalds 	},
25571da177e4SLinus Torvalds 	{
25581da177e4SLinus Torvalds 		.procname	=	"gc_min_interval",
25594990509fSDaniel Lezcano 		.data		=	&init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
25601da177e4SLinus Torvalds 		.maxlen		=	sizeof(int),
25611da177e4SLinus Torvalds 		.mode		=	0644,
25626d9f239aSAlexey Dobriyan 		.proc_handler	=	proc_dointvec_jiffies,
25631da177e4SLinus Torvalds 	},
25641da177e4SLinus Torvalds 	{
25651da177e4SLinus Torvalds 		.procname	=	"gc_timeout",
25664990509fSDaniel Lezcano 		.data		=	&init_net.ipv6.sysctl.ip6_rt_gc_timeout,
25671da177e4SLinus Torvalds 		.maxlen		=	sizeof(int),
25681da177e4SLinus Torvalds 		.mode		=	0644,
25696d9f239aSAlexey Dobriyan 		.proc_handler	=	proc_dointvec_jiffies,
25701da177e4SLinus Torvalds 	},
25711da177e4SLinus Torvalds 	{
25721da177e4SLinus Torvalds 		.procname	=	"gc_interval",
25734990509fSDaniel Lezcano 		.data		=	&init_net.ipv6.sysctl.ip6_rt_gc_interval,
25741da177e4SLinus Torvalds 		.maxlen		=	sizeof(int),
25751da177e4SLinus Torvalds 		.mode		=	0644,
25766d9f239aSAlexey Dobriyan 		.proc_handler	=	proc_dointvec_jiffies,
25771da177e4SLinus Torvalds 	},
25781da177e4SLinus Torvalds 	{
25791da177e4SLinus Torvalds 		.procname	=	"gc_elasticity",
25804990509fSDaniel Lezcano 		.data		=	&init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
25811da177e4SLinus Torvalds 		.maxlen		=	sizeof(int),
25821da177e4SLinus Torvalds 		.mode		=	0644,
25836d9f239aSAlexey Dobriyan 		.proc_handler	=	proc_dointvec_jiffies,
25841da177e4SLinus Torvalds 	},
25851da177e4SLinus Torvalds 	{
25861da177e4SLinus Torvalds 		.procname	=	"mtu_expires",
25874990509fSDaniel Lezcano 		.data		=	&init_net.ipv6.sysctl.ip6_rt_mtu_expires,
25881da177e4SLinus Torvalds 		.maxlen		=	sizeof(int),
25891da177e4SLinus Torvalds 		.mode		=	0644,
25906d9f239aSAlexey Dobriyan 		.proc_handler	=	proc_dointvec_jiffies,
25911da177e4SLinus Torvalds 	},
25921da177e4SLinus Torvalds 	{
25931da177e4SLinus Torvalds 		.procname	=	"min_adv_mss",
25944990509fSDaniel Lezcano 		.data		=	&init_net.ipv6.sysctl.ip6_rt_min_advmss,
25951da177e4SLinus Torvalds 		.maxlen		=	sizeof(int),
25961da177e4SLinus Torvalds 		.mode		=	0644,
25976d9f239aSAlexey Dobriyan 		.proc_handler	=	proc_dointvec_jiffies,
25981da177e4SLinus Torvalds 	},
25991da177e4SLinus Torvalds 	{
26001da177e4SLinus Torvalds 		.procname	=	"gc_min_interval_ms",
26014990509fSDaniel Lezcano 		.data		=	&init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
26021da177e4SLinus Torvalds 		.maxlen		=	sizeof(int),
26031da177e4SLinus Torvalds 		.mode		=	0644,
26046d9f239aSAlexey Dobriyan 		.proc_handler	=	proc_dointvec_ms_jiffies,
26051da177e4SLinus Torvalds 	},
2606f8572d8fSEric W. Biederman 	{ }
26071da177e4SLinus Torvalds };
26081da177e4SLinus Torvalds 
26092c8c1e72SAlexey Dobriyan struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
2610760f2d01SDaniel Lezcano {
2611760f2d01SDaniel Lezcano 	struct ctl_table *table;
2612760f2d01SDaniel Lezcano 
2613760f2d01SDaniel Lezcano 	table = kmemdup(ipv6_route_table_template,
2614760f2d01SDaniel Lezcano 			sizeof(ipv6_route_table_template),
2615760f2d01SDaniel Lezcano 			GFP_KERNEL);
26165ee09105SYOSHIFUJI Hideaki 
26175ee09105SYOSHIFUJI Hideaki 	if (table) {
26185ee09105SYOSHIFUJI Hideaki 		table[0].data = &net->ipv6.sysctl.flush_delay;
261986393e52SAlexey Dobriyan 		table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
26205ee09105SYOSHIFUJI Hideaki 		table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
26215ee09105SYOSHIFUJI Hideaki 		table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
26225ee09105SYOSHIFUJI Hideaki 		table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
26235ee09105SYOSHIFUJI Hideaki 		table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
26245ee09105SYOSHIFUJI Hideaki 		table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
26255ee09105SYOSHIFUJI Hideaki 		table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
26265ee09105SYOSHIFUJI Hideaki 		table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
26279c69fabeSAlexey Dobriyan 		table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
26285ee09105SYOSHIFUJI Hideaki 	}
26295ee09105SYOSHIFUJI Hideaki 
2630760f2d01SDaniel Lezcano 	return table;
2631760f2d01SDaniel Lezcano }
26321da177e4SLinus Torvalds #endif
26331da177e4SLinus Torvalds 
26342c8c1e72SAlexey Dobriyan static int __net_init ip6_route_net_init(struct net *net)
2635cdb18761SDaniel Lezcano {
2636633d424bSPavel Emelyanov 	int ret = -ENOMEM;
26378ed67789SDaniel Lezcano 
263886393e52SAlexey Dobriyan 	memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
263986393e52SAlexey Dobriyan 	       sizeof(net->ipv6.ip6_dst_ops));
2640f2fc6a54SBenjamin Thery 
26418ed67789SDaniel Lezcano 	net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
26428ed67789SDaniel Lezcano 					   sizeof(*net->ipv6.ip6_null_entry),
26438ed67789SDaniel Lezcano 					   GFP_KERNEL);
26448ed67789SDaniel Lezcano 	if (!net->ipv6.ip6_null_entry)
2645f2fc6a54SBenjamin Thery 		goto out_ip6_dst_ops;
2646d8d1f30bSChangli Gao 	net->ipv6.ip6_null_entry->dst.path =
26478ed67789SDaniel Lezcano 		(struct dst_entry *)net->ipv6.ip6_null_entry;
2648d8d1f30bSChangli Gao 	net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
26498ed67789SDaniel Lezcano 
26508ed67789SDaniel Lezcano #ifdef CONFIG_IPV6_MULTIPLE_TABLES
26518ed67789SDaniel Lezcano 	net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
26528ed67789SDaniel Lezcano 					       sizeof(*net->ipv6.ip6_prohibit_entry),
26538ed67789SDaniel Lezcano 					       GFP_KERNEL);
265468fffc67SPeter Zijlstra 	if (!net->ipv6.ip6_prohibit_entry)
265568fffc67SPeter Zijlstra 		goto out_ip6_null_entry;
2656d8d1f30bSChangli Gao 	net->ipv6.ip6_prohibit_entry->dst.path =
26578ed67789SDaniel Lezcano 		(struct dst_entry *)net->ipv6.ip6_prohibit_entry;
2658d8d1f30bSChangli Gao 	net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
26598ed67789SDaniel Lezcano 
26608ed67789SDaniel Lezcano 	net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
26618ed67789SDaniel Lezcano 					       sizeof(*net->ipv6.ip6_blk_hole_entry),
26628ed67789SDaniel Lezcano 					       GFP_KERNEL);
266368fffc67SPeter Zijlstra 	if (!net->ipv6.ip6_blk_hole_entry)
266468fffc67SPeter Zijlstra 		goto out_ip6_prohibit_entry;
2665d8d1f30bSChangli Gao 	net->ipv6.ip6_blk_hole_entry->dst.path =
26668ed67789SDaniel Lezcano 		(struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
2667d8d1f30bSChangli Gao 	net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
26688ed67789SDaniel Lezcano #endif
26698ed67789SDaniel Lezcano 
2670b339a47cSPeter Zijlstra 	net->ipv6.sysctl.flush_delay = 0;
2671b339a47cSPeter Zijlstra 	net->ipv6.sysctl.ip6_rt_max_size = 4096;
2672b339a47cSPeter Zijlstra 	net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
2673b339a47cSPeter Zijlstra 	net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
2674b339a47cSPeter Zijlstra 	net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
2675b339a47cSPeter Zijlstra 	net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
2676b339a47cSPeter Zijlstra 	net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
2677b339a47cSPeter Zijlstra 	net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;
2678b339a47cSPeter Zijlstra 
2679cdb18761SDaniel Lezcano #ifdef CONFIG_PROC_FS
2680cdb18761SDaniel Lezcano 	proc_net_fops_create(net, "ipv6_route", 0, &ipv6_route_proc_fops);
2681cdb18761SDaniel Lezcano 	proc_net_fops_create(net, "rt6_stats", S_IRUGO, &rt6_stats_seq_fops);
2682cdb18761SDaniel Lezcano #endif
26836891a346SBenjamin Thery 	net->ipv6.ip6_rt_gc_expire = 30*HZ;
26846891a346SBenjamin Thery 
26858ed67789SDaniel Lezcano 	ret = 0;
26868ed67789SDaniel Lezcano out:
26878ed67789SDaniel Lezcano 	return ret;
2688f2fc6a54SBenjamin Thery 
268968fffc67SPeter Zijlstra #ifdef CONFIG_IPV6_MULTIPLE_TABLES
269068fffc67SPeter Zijlstra out_ip6_prohibit_entry:
269168fffc67SPeter Zijlstra 	kfree(net->ipv6.ip6_prohibit_entry);
269268fffc67SPeter Zijlstra out_ip6_null_entry:
269368fffc67SPeter Zijlstra 	kfree(net->ipv6.ip6_null_entry);
269468fffc67SPeter Zijlstra #endif
2695f2fc6a54SBenjamin Thery out_ip6_dst_ops:
2696f2fc6a54SBenjamin Thery 	goto out;
2697cdb18761SDaniel Lezcano }
2698cdb18761SDaniel Lezcano 
26992c8c1e72SAlexey Dobriyan static void __net_exit ip6_route_net_exit(struct net *net)
2700cdb18761SDaniel Lezcano {
2701cdb18761SDaniel Lezcano #ifdef CONFIG_PROC_FS
2702cdb18761SDaniel Lezcano 	proc_net_remove(net, "ipv6_route");
2703cdb18761SDaniel Lezcano 	proc_net_remove(net, "rt6_stats");
2704cdb18761SDaniel Lezcano #endif
27058ed67789SDaniel Lezcano 	kfree(net->ipv6.ip6_null_entry);
27068ed67789SDaniel Lezcano #ifdef CONFIG_IPV6_MULTIPLE_TABLES
27078ed67789SDaniel Lezcano 	kfree(net->ipv6.ip6_prohibit_entry);
27088ed67789SDaniel Lezcano 	kfree(net->ipv6.ip6_blk_hole_entry);
27098ed67789SDaniel Lezcano #endif
2710cdb18761SDaniel Lezcano }
2711cdb18761SDaniel Lezcano 
2712cdb18761SDaniel Lezcano static struct pernet_operations ip6_route_net_ops = {
2713cdb18761SDaniel Lezcano 	.init = ip6_route_net_init,
2714cdb18761SDaniel Lezcano 	.exit = ip6_route_net_exit,
2715cdb18761SDaniel Lezcano };
2716cdb18761SDaniel Lezcano 
27178ed67789SDaniel Lezcano static struct notifier_block ip6_route_dev_notifier = {
27188ed67789SDaniel Lezcano 	.notifier_call = ip6_route_dev_notify,
27198ed67789SDaniel Lezcano 	.priority = 0,
27208ed67789SDaniel Lezcano };
27218ed67789SDaniel Lezcano 
2722433d49c3SDaniel Lezcano int __init ip6_route_init(void)
27231da177e4SLinus Torvalds {
2724433d49c3SDaniel Lezcano 	int ret;
2725433d49c3SDaniel Lezcano 
27269a7ec3a9SDaniel Lezcano 	ret = -ENOMEM;
27279a7ec3a9SDaniel Lezcano 	ip6_dst_ops_template.kmem_cachep =
27289a7ec3a9SDaniel Lezcano 		kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
27299a7ec3a9SDaniel Lezcano 				  SLAB_HWCACHE_ALIGN, NULL);
27309a7ec3a9SDaniel Lezcano 	if (!ip6_dst_ops_template.kmem_cachep)
2731c19a28e1SFernando Carrijo 		goto out;
273214e50e57SDavid S. Miller 
27338ed67789SDaniel Lezcano 	ret = register_pernet_subsys(&ip6_route_net_ops);
27348ed67789SDaniel Lezcano 	if (ret)
2735bdb3289fSDaniel Lezcano 		goto out_kmem_cache;
2736bdb3289fSDaniel Lezcano 
27375dc121e9SArnaud Ebalard 	ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;
27385dc121e9SArnaud Ebalard 
27398ed67789SDaniel Lezcano 	/* Registering of the loopback is done before this portion of code,
27408ed67789SDaniel Lezcano 	 * the loopback reference in rt6_info will not be taken, do it
27418ed67789SDaniel Lezcano 	 * manually for init_net */
2742d8d1f30bSChangli Gao 	init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
27438ed67789SDaniel Lezcano 	init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
2744bdb3289fSDaniel Lezcano   #ifdef CONFIG_IPV6_MULTIPLE_TABLES
2745d8d1f30bSChangli Gao 	init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
27468ed67789SDaniel Lezcano 	init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
2747d8d1f30bSChangli Gao 	init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
27488ed67789SDaniel Lezcano 	init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
2749bdb3289fSDaniel Lezcano   #endif
2750433d49c3SDaniel Lezcano 	ret = fib6_init();
2751433d49c3SDaniel Lezcano 	if (ret)
27528ed67789SDaniel Lezcano 		goto out_register_subsys;
2753433d49c3SDaniel Lezcano 
2754433d49c3SDaniel Lezcano 	ret = xfrm6_init();
2755433d49c3SDaniel Lezcano 	if (ret)
2756cdb18761SDaniel Lezcano 		goto out_fib6_init;
2757c35b7e72SDaniel Lezcano 
2758433d49c3SDaniel Lezcano 	ret = fib6_rules_init();
2759433d49c3SDaniel Lezcano 	if (ret)
2760433d49c3SDaniel Lezcano 		goto xfrm6_init;
27617e5449c2SDaniel Lezcano 
2762433d49c3SDaniel Lezcano 	ret = -ENOBUFS;
2763433d49c3SDaniel Lezcano 	if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL) ||
2764433d49c3SDaniel Lezcano 	    __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL) ||
2765433d49c3SDaniel Lezcano 	    __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL))
2766433d49c3SDaniel Lezcano 		goto fib6_rules_init;
2767433d49c3SDaniel Lezcano 
27688ed67789SDaniel Lezcano 	ret = register_netdevice_notifier(&ip6_route_dev_notifier);
2769cdb18761SDaniel Lezcano 	if (ret)
2770cdb18761SDaniel Lezcano 		goto fib6_rules_init;
27718ed67789SDaniel Lezcano 
2772433d49c3SDaniel Lezcano out:
2773433d49c3SDaniel Lezcano 	return ret;
2774433d49c3SDaniel Lezcano 
2775433d49c3SDaniel Lezcano fib6_rules_init:
2776433d49c3SDaniel Lezcano 	fib6_rules_cleanup();
2777433d49c3SDaniel Lezcano xfrm6_init:
2778433d49c3SDaniel Lezcano 	xfrm6_fini();
2779433d49c3SDaniel Lezcano out_fib6_init:
2780433d49c3SDaniel Lezcano 	fib6_gc_cleanup();
27818ed67789SDaniel Lezcano out_register_subsys:
27828ed67789SDaniel Lezcano 	unregister_pernet_subsys(&ip6_route_net_ops);
2783433d49c3SDaniel Lezcano out_kmem_cache:
2784f2fc6a54SBenjamin Thery 	kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
2785433d49c3SDaniel Lezcano 	goto out;
27861da177e4SLinus Torvalds }
27871da177e4SLinus Torvalds 
27881da177e4SLinus Torvalds void ip6_route_cleanup(void)
27891da177e4SLinus Torvalds {
27908ed67789SDaniel Lezcano 	unregister_netdevice_notifier(&ip6_route_dev_notifier);
2791101367c2SThomas Graf 	fib6_rules_cleanup();
27921da177e4SLinus Torvalds 	xfrm6_fini();
27931da177e4SLinus Torvalds 	fib6_gc_cleanup();
27948ed67789SDaniel Lezcano 	unregister_pernet_subsys(&ip6_route_net_ops);
2795f2fc6a54SBenjamin Thery 	kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
27961da177e4SLinus Torvalds }
2797