/*
   *	Linux INET6 implementation
   *	FIB front-end.
   *
   *	Authors:

   *	Pedro Roque		<roque@di.fc.ul.pt>

   *

   *	This program is free software; you can redistribute it and/or
   *      modify it under the terms of the GNU General Public License
   *      as published by the Free Software Foundation; either version
   *      2 of the License, or (at your option) any later version.
   */
  
  /*	Changes:
   *
   *	YOSHIFUJI Hideaki @USAGI
   *		reworked default router selection.
   *		- respect outgoing interface
   *		- select from (probably) reachable routers (i.e.
   *		routers in REACHABLE, STALE, DELAY or PROBE states).
   *		- always select the same router if it is (probably)
   *		reachable.  otherwise, round-robin the list.

   *	Ville Nuorvala
   *		Fixed routing subtrees.

   */

  #define pr_fmt(fmt) "IPv6: " fmt

  #include <linux/capability.h>

  #include <linux/errno.h>

  #include <linux/export.h>

  #include <linux/types.h>
  #include <linux/times.h>
  #include <linux/socket.h>
  #include <linux/sockios.h>
  #include <linux/net.h>
  #include <linux/route.h>
  #include <linux/netdevice.h>
  #include <linux/in6.h>

  #include <linux/mroute6.h>

  #include <linux/init.h>

  #include <linux/if_arp.h>

  #include <linux/proc_fs.h>
  #include <linux/seq_file.h>

  #include <linux/nsproxy.h>

  #include <linux/slab.h>

  #include <net/net_namespace.h>

  #include <net/snmp.h>
  #include <net/ipv6.h>
  #include <net/ip6_fib.h>
  #include <net/ip6_route.h>
  #include <net/ndisc.h>
  #include <net/addrconf.h>
  #include <net/tcp.h>
  #include <linux/rtnetlink.h>
  #include <net/dst.h>

  #include <net/dst_metadata.h>

  #include <net/xfrm.h>

  #include <net/netevent.h>

  #include <net/netlink.h>

  #include <net/nexthop.h>

  #include <net/lwtunnel.h>

  #include <net/ip_tunnels.h>

  #include <net/l3mdev.h>

  #include <trace/events/fib6.h>

  #include <linux/uaccess.h>

  
  #ifdef CONFIG_SYSCTL
  #include <linux/sysctl.h>
  #endif

  enum rt6_nud_state {

  	RT6_NUD_FAIL_HARD = -3,
  	RT6_NUD_FAIL_PROBE = -2,
  	RT6_NUD_FAIL_DO_RR = -1,

  	RT6_NUD_SUCCEED = 1
  };

  static void ip6_rt_copy_init(struct rt6_info *rt, struct rt6_info *ort);

  static struct dst_entry	*ip6_dst_check(struct dst_entry *dst, u32 cookie);

  static unsigned int	 ip6_default_advmss(const struct dst_entry *dst);

  static unsigned int	 ip6_mtu(const struct dst_entry *dst);

  static struct dst_entry *ip6_negative_advice(struct dst_entry *);
  static void		ip6_dst_destroy(struct dst_entry *);
  static void		ip6_dst_ifdown(struct dst_entry *,
  				       struct net_device *dev, int how);

  static int		 ip6_dst_gc(struct dst_ops *ops);

  
  static int		ip6_pkt_discard(struct sk_buff *skb);

  static int		ip6_pkt_discard_out(struct net *net, struct sock *sk, struct sk_buff *skb);

  static int		ip6_pkt_prohibit(struct sk_buff *skb);

  static int		ip6_pkt_prohibit_out(struct net *net, struct sock *sk, struct sk_buff *skb);

  static void		ip6_link_failure(struct sk_buff *skb);

  static void		ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
  					   struct sk_buff *skb, u32 mtu);
  static void		rt6_do_redirect(struct dst_entry *dst, struct sock *sk,
  					struct sk_buff *skb);

  static void		rt6_dst_from_metrics_check(struct rt6_info *rt);

  static int rt6_score_route(struct rt6_info *rt, int oif, int strict);

  static size_t rt6_nlmsg_size(struct rt6_info *rt);
  static int rt6_fill_node(struct net *net,
  			 struct sk_buff *skb, struct rt6_info *rt,
  			 struct in6_addr *dst, struct in6_addr *src,
  			 int iif, int type, u32 portid, u32 seq,
  			 unsigned int flags);

  #ifdef CONFIG_IPV6_ROUTE_INFO

  static struct rt6_info *rt6_add_route_info(struct net *net,

  					   const struct in6_addr *prefix, int prefixlen,

  					   const struct in6_addr *gwaddr,
  					   struct net_device *dev,

  					   unsigned int pref);

  static struct rt6_info *rt6_get_route_info(struct net *net,

  					   const struct in6_addr *prefix, int prefixlen,

  					   const struct in6_addr *gwaddr,
  					   struct net_device *dev);

  #endif

  struct uncached_list {
  	spinlock_t		lock;
  	struct list_head	head;
  };
  
  static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt6_uncached_list);
  
  static void rt6_uncached_list_add(struct rt6_info *rt)
  {
  	struct uncached_list *ul = raw_cpu_ptr(&rt6_uncached_list);

  	rt->rt6i_uncached_list = ul;
  
  	spin_lock_bh(&ul->lock);
  	list_add_tail(&rt->rt6i_uncached, &ul->head);
  	spin_unlock_bh(&ul->lock);
  }
  
  static void rt6_uncached_list_del(struct rt6_info *rt)
  {
  	if (!list_empty(&rt->rt6i_uncached)) {
  		struct uncached_list *ul = rt->rt6i_uncached_list;
  
  		spin_lock_bh(&ul->lock);
  		list_del(&rt->rt6i_uncached);
  		spin_unlock_bh(&ul->lock);
  	}
  }
  
  static void rt6_uncached_list_flush_dev(struct net *net, struct net_device *dev)
  {
  	struct net_device *loopback_dev = net->loopback_dev;
  	int cpu;

  	if (dev == loopback_dev)
  		return;

  	for_each_possible_cpu(cpu) {
  		struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
  		struct rt6_info *rt;
  
  		spin_lock_bh(&ul->lock);
  		list_for_each_entry(rt, &ul->head, rt6i_uncached) {
  			struct inet6_dev *rt_idev = rt->rt6i_idev;
  			struct net_device *rt_dev = rt->dst.dev;

  			if (rt_idev->dev == dev) {

  				rt->rt6i_idev = in6_dev_get(loopback_dev);
  				in6_dev_put(rt_idev);
  			}

  			if (rt_dev == dev) {

  				rt->dst.dev = loopback_dev;
  				dev_hold(rt->dst.dev);
  				dev_put(rt_dev);
  			}
  		}
  		spin_unlock_bh(&ul->lock);
  	}
  }

  static u32 *rt6_pcpu_cow_metrics(struct rt6_info *rt)
  {
  	return dst_metrics_write_ptr(rt->dst.from);
  }

  static u32 *ipv6_cow_metrics(struct dst_entry *dst, unsigned long old)
  {

  	struct rt6_info *rt = (struct rt6_info *)dst;

  	if (rt->rt6i_flags & RTF_PCPU)
  		return rt6_pcpu_cow_metrics(rt);
  	else if (rt->rt6i_flags & RTF_CACHE)

  		return NULL;
  	else

  		return dst_cow_metrics_generic(dst, old);

  }

  static inline const void *choose_neigh_daddr(struct rt6_info *rt,
  					     struct sk_buff *skb,
  					     const void *daddr)

  {
  	struct in6_addr *p = &rt->rt6i_gateway;

  	if (!ipv6_addr_any(p))

  		return (const void *) p;

  	else if (skb)
  		return &ipv6_hdr(skb)->daddr;

  	return daddr;
  }

  static struct neighbour *ip6_neigh_lookup(const struct dst_entry *dst,
  					  struct sk_buff *skb,
  					  const void *daddr)

  {

  	struct rt6_info *rt = (struct rt6_info *) dst;
  	struct neighbour *n;

  	daddr = choose_neigh_daddr(rt, skb, daddr);

  	n = __ipv6_neigh_lookup(dst->dev, daddr);

  	if (n)
  		return n;
  	return neigh_create(&nd_tbl, daddr, dst->dev);
  }

  static void ip6_confirm_neigh(const struct dst_entry *dst, const void *daddr)
  {
  	struct net_device *dev = dst->dev;
  	struct rt6_info *rt = (struct rt6_info *)dst;
  
  	daddr = choose_neigh_daddr(rt, NULL, daddr);
  	if (!daddr)
  		return;
  	if (dev->flags & (IFF_NOARP | IFF_LOOPBACK))
  		return;
  	if (ipv6_addr_is_multicast((const struct in6_addr *)daddr))
  		return;
  	__ipv6_confirm_neigh(dev, daddr);
  }

  static struct dst_ops ip6_dst_ops_template = {

  	.family			=	AF_INET6,

  	.gc			=	ip6_dst_gc,
  	.gc_thresh		=	1024,
  	.check			=	ip6_dst_check,

  	.default_advmss		=	ip6_default_advmss,

  	.mtu			=	ip6_mtu,

  	.cow_metrics		=	ipv6_cow_metrics,

  	.destroy		=	ip6_dst_destroy,
  	.ifdown			=	ip6_dst_ifdown,
  	.negative_advice	=	ip6_negative_advice,
  	.link_failure		=	ip6_link_failure,
  	.update_pmtu		=	ip6_rt_update_pmtu,

  	.redirect		=	rt6_do_redirect,

  	.local_out		=	__ip6_local_out,

  	.neigh_lookup		=	ip6_neigh_lookup,

  	.confirm_neigh		=	ip6_confirm_neigh,

  };

  static unsigned int ip6_blackhole_mtu(const struct dst_entry *dst)

  {

  	unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
  
  	return mtu ? : dst->dev->mtu;

  }

  static void ip6_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
  					 struct sk_buff *skb, u32 mtu)

  {
  }

  static void ip6_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
  				      struct sk_buff *skb)

  {
  }

  static struct dst_ops ip6_dst_blackhole_ops = {
  	.family			=	AF_INET6,

  	.destroy		=	ip6_dst_destroy,
  	.check			=	ip6_dst_check,

  	.mtu			=	ip6_blackhole_mtu,

  	.default_advmss		=	ip6_default_advmss,

  	.update_pmtu		=	ip6_rt_blackhole_update_pmtu,

  	.redirect		=	ip6_rt_blackhole_redirect,

  	.cow_metrics		=	dst_cow_metrics_generic,

  	.neigh_lookup		=	ip6_neigh_lookup,

  };

  static const u32 ip6_template_metrics[RTAX_MAX] = {

  	[RTAX_HOPLIMIT - 1] = 0,

  };

  static const struct rt6_info ip6_null_entry_template = {

  	.dst = {
  		.__refcnt	= ATOMIC_INIT(1),
  		.__use		= 1,

  		.obsolete	= DST_OBSOLETE_FORCE_CHK,

  		.error		= -ENETUNREACH,

  		.input		= ip6_pkt_discard,
  		.output		= ip6_pkt_discard_out,

  	},
  	.rt6i_flags	= (RTF_REJECT | RTF_NONEXTHOP),

  	.rt6i_protocol  = RTPROT_KERNEL,

  	.rt6i_metric	= ~(u32) 0,
  	.rt6i_ref	= ATOMIC_INIT(1),
  };

  #ifdef CONFIG_IPV6_MULTIPLE_TABLES

  static const struct rt6_info ip6_prohibit_entry_template = {

  	.dst = {
  		.__refcnt	= ATOMIC_INIT(1),
  		.__use		= 1,

  		.obsolete	= DST_OBSOLETE_FORCE_CHK,

  		.error		= -EACCES,

  		.input		= ip6_pkt_prohibit,
  		.output		= ip6_pkt_prohibit_out,

  	},
  	.rt6i_flags	= (RTF_REJECT | RTF_NONEXTHOP),

  	.rt6i_protocol  = RTPROT_KERNEL,

  	.rt6i_metric	= ~(u32) 0,
  	.rt6i_ref	= ATOMIC_INIT(1),
  };

  static const struct rt6_info ip6_blk_hole_entry_template = {

  	.dst = {
  		.__refcnt	= ATOMIC_INIT(1),
  		.__use		= 1,

  		.obsolete	= DST_OBSOLETE_FORCE_CHK,

  		.error		= -EINVAL,

  		.input		= dst_discard,

  		.output		= dst_discard_out,

  	},
  	.rt6i_flags	= (RTF_REJECT | RTF_NONEXTHOP),

  	.rt6i_protocol  = RTPROT_KERNEL,

  	.rt6i_metric	= ~(u32) 0,
  	.rt6i_ref	= ATOMIC_INIT(1),
  };
  
  #endif

  static void rt6_info_init(struct rt6_info *rt)
  {
  	struct dst_entry *dst = &rt->dst;
  
  	memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
  	INIT_LIST_HEAD(&rt->rt6i_siblings);
  	INIT_LIST_HEAD(&rt->rt6i_uncached);
  }

  /* allocate dst with ip6_dst_ops */

  static struct rt6_info *__ip6_dst_alloc(struct net *net,
  					struct net_device *dev,

  					int flags)

  {

  	struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,

  					1, DST_OBSOLETE_FORCE_CHK, flags);

  	if (rt)
  		rt6_info_init(rt);

  	return rt;

  }

  struct rt6_info *ip6_dst_alloc(struct net *net,
  			       struct net_device *dev,
  			       int flags)

  {

  	struct rt6_info *rt = __ip6_dst_alloc(net, dev, flags);

  
  	if (rt) {
  		rt->rt6i_pcpu = alloc_percpu_gfp(struct rt6_info *, GFP_ATOMIC);
  		if (rt->rt6i_pcpu) {
  			int cpu;
  
  			for_each_possible_cpu(cpu) {
  				struct rt6_info **p;
  
  				p = per_cpu_ptr(rt->rt6i_pcpu, cpu);
  				/* no one shares rt */
  				*p =  NULL;
  			}
  		} else {

  			dst_release_immediate(&rt->dst);

  			return NULL;
  		}
  	}
  
  	return rt;
  }

  EXPORT_SYMBOL(ip6_dst_alloc);

  static void ip6_dst_destroy(struct dst_entry *dst)
  {
  	struct rt6_info *rt = (struct rt6_info *)dst;

  	struct dst_entry *from = dst->from;

  	struct inet6_dev *idev;

  	dst_destroy_metrics_generic(dst);

  	free_percpu(rt->rt6i_pcpu);

  	rt6_uncached_list_del(rt);
  
  	idev = rt->rt6i_idev;

  	if (idev) {

  		rt->rt6i_idev = NULL;
  		in6_dev_put(idev);

  	}

  	dst->from = NULL;
  	dst_release(from);

  }

  static void ip6_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
  			   int how)
  {
  	struct rt6_info *rt = (struct rt6_info *)dst;
  	struct inet6_dev *idev = rt->rt6i_idev;

  	struct net_device *loopback_dev =

  		dev_net(dev)->loopback_dev;

  	if (idev && idev->dev != loopback_dev) {
  		struct inet6_dev *loopback_idev = in6_dev_get(loopback_dev);
  		if (loopback_idev) {
  			rt->rt6i_idev = loopback_idev;
  			in6_dev_put(idev);

  		}

  	}
  }

  static bool __rt6_check_expired(const struct rt6_info *rt)
  {
  	if (rt->rt6i_flags & RTF_EXPIRES)
  		return time_after(jiffies, rt->dst.expires);
  	else
  		return false;
  }

  static bool rt6_check_expired(const struct rt6_info *rt)

  {

  	if (rt->rt6i_flags & RTF_EXPIRES) {
  		if (time_after(jiffies, rt->dst.expires))

  			return true;

  	} else if (rt->dst.from) {

  		return rt->dst.obsolete != DST_OBSOLETE_FORCE_CHK ||
  		       rt6_check_expired((struct rt6_info *)rt->dst.from);

  	}

  	return false;

  }

  static struct rt6_info *rt6_multipath_select(struct rt6_info *match,

  					     struct flowi6 *fl6, int oif,
  					     int strict)

  {
  	struct rt6_info *sibling, *next_sibling;
  	int route_choosen;

  	/* We might have already computed the hash for ICMPv6 errors. In such
  	 * case it will always be non-zero. Otherwise now is the time to do it.
  	 */
  	if (!fl6->mp_hash)
  		fl6->mp_hash = rt6_multipath_hash(fl6, NULL);
  
  	route_choosen = fl6->mp_hash % (match->rt6i_nsiblings + 1);

  	/* Don't change the route, if route_choosen == 0
  	 * (siblings does not include ourself)
  	 */
  	if (route_choosen)
  		list_for_each_entry_safe(sibling, next_sibling,
  				&match->rt6i_siblings, rt6i_siblings) {
  			route_choosen--;
  			if (route_choosen == 0) {

  				if (rt6_score_route(sibling, oif, strict) < 0)
  					break;

  				match = sibling;
  				break;
  			}
  		}
  	return match;
  }

  /*

   *	Route lookup. Any table->tb6_lock is implied.

   */

  static inline struct rt6_info *rt6_device_match(struct net *net,
  						    struct rt6_info *rt,

  						    const struct in6_addr *saddr,

  						    int oif,

  						    int flags)

  {
  	struct rt6_info *local = NULL;
  	struct rt6_info *sprt;

  	if (!oif && ipv6_addr_any(saddr))
  		goto out;

  	for (sprt = rt; sprt; sprt = sprt->dst.rt6_next) {

  		struct net_device *dev = sprt->dst.dev;

  
  		if (oif) {

  			if (dev->ifindex == oif)
  				return sprt;
  			if (dev->flags & IFF_LOOPBACK) {

  				if (!sprt->rt6i_idev ||

  				    sprt->rt6i_idev->dev->ifindex != oif) {

  					if (flags & RT6_LOOKUP_F_IFACE)

  						continue;

  					if (local &&
  					    local->rt6i_idev->dev->ifindex == oif)

  						continue;
  				}
  				local = sprt;
  			}

  		} else {
  			if (ipv6_chk_addr(net, saddr, dev,
  					  flags & RT6_LOOKUP_F_IFACE))
  				return sprt;

  		}

  	}

  	if (oif) {

  		if (local)
  			return local;

  		if (flags & RT6_LOOKUP_F_IFACE)

  			return net->ipv6.ip6_null_entry;

  	}

  out:

  	return rt;
  }

  #ifdef CONFIG_IPV6_ROUTER_PREF

  struct __rt6_probe_work {
  	struct work_struct work;
  	struct in6_addr target;
  	struct net_device *dev;
  };
  
  static void rt6_probe_deferred(struct work_struct *w)
  {
  	struct in6_addr mcaddr;
  	struct __rt6_probe_work *work =
  		container_of(w, struct __rt6_probe_work, work);
  
  	addrconf_addr_solict_mult(&work->target, &mcaddr);

  	ndisc_send_ns(work->dev, &work->target, &mcaddr, NULL, 0);

  	dev_put(work->dev);

  	kfree(work);

  }

  static void rt6_probe(struct rt6_info *rt)
  {

  	struct __rt6_probe_work *work;

  	struct neighbour *neigh;

  	/*
  	 * Okay, this does not seem to be appropriate
  	 * for now, however, we need to check if it
  	 * is really so; aka Router Reachability Probing.
  	 *
  	 * Router Reachability Probe MUST be rate-limited
  	 * to no more than one per minute.
  	 */

  	if (!rt || !(rt->rt6i_flags & RTF_GATEWAY))

  		return;

  	rcu_read_lock_bh();
  	neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
  	if (neigh) {

  		if (neigh->nud_state & NUD_VALID)
  			goto out;

  		work = NULL;

  		write_lock(&neigh->lock);

  		if (!(neigh->nud_state & NUD_VALID) &&
  		    time_after(jiffies,
  			       neigh->updated +
  			       rt->rt6i_idev->cnf.rtr_probe_interval)) {
  			work = kmalloc(sizeof(*work), GFP_ATOMIC);
  			if (work)
  				__neigh_set_probe_once(neigh);

  		}

  		write_unlock(&neigh->lock);

  	} else {
  		work = kmalloc(sizeof(*work), GFP_ATOMIC);

  	}

  
  	if (work) {
  		INIT_WORK(&work->work, rt6_probe_deferred);
  		work->target = rt->rt6i_gateway;
  		dev_hold(rt->dst.dev);
  		work->dev = rt->dst.dev;
  		schedule_work(&work->work);
  	}

  out:

  	rcu_read_unlock_bh();

  }
  #else
  static inline void rt6_probe(struct rt6_info *rt)
  {

  }
  #endif

  /*

   * Default Router Selection (RFC 2461 6.3.6)

   */

  static inline int rt6_check_dev(struct rt6_info *rt, int oif)

  {

  	struct net_device *dev = rt->dst.dev;

  	if (!oif || dev->ifindex == oif)

  		return 2;

  	if ((dev->flags & IFF_LOOPBACK) &&
  	    rt->rt6i_idev && rt->rt6i_idev->dev->ifindex == oif)
  		return 1;
  	return 0;

  }

  static inline enum rt6_nud_state rt6_check_neigh(struct rt6_info *rt)

  {

  	struct neighbour *neigh;

  	enum rt6_nud_state ret = RT6_NUD_FAIL_HARD;

  	if (rt->rt6i_flags & RTF_NONEXTHOP ||
  	    !(rt->rt6i_flags & RTF_GATEWAY))

  		return RT6_NUD_SUCCEED;

  
  	rcu_read_lock_bh();
  	neigh = __ipv6_neigh_lookup_noref(rt->dst.dev, &rt->rt6i_gateway);
  	if (neigh) {
  		read_lock(&neigh->lock);

  		if (neigh->nud_state & NUD_VALID)

  			ret = RT6_NUD_SUCCEED;

  #ifdef CONFIG_IPV6_ROUTER_PREF

  		else if (!(neigh->nud_state & NUD_FAILED))

  			ret = RT6_NUD_SUCCEED;

  		else
  			ret = RT6_NUD_FAIL_PROBE;

  #endif

  		read_unlock(&neigh->lock);

  	} else {
  		ret = IS_ENABLED(CONFIG_IPV6_ROUTER_PREF) ?

  		      RT6_NUD_SUCCEED : RT6_NUD_FAIL_DO_RR;

  	}

  	rcu_read_unlock_bh();

  	return ret;

  }

  static int rt6_score_route(struct rt6_info *rt, int oif,
  			   int strict)

  {

  	int m;

  	m = rt6_check_dev(rt, oif);

  	if (!m && (strict & RT6_LOOKUP_F_IFACE))

  		return RT6_NUD_FAIL_HARD;

  #ifdef CONFIG_IPV6_ROUTER_PREF
  	m |= IPV6_DECODE_PREF(IPV6_EXTRACT_PREF(rt->rt6i_flags)) << 2;
  #endif

  	if (strict & RT6_LOOKUP_F_REACHABLE) {
  		int n = rt6_check_neigh(rt);
  		if (n < 0)
  			return n;
  	}

  	return m;
  }

  static struct rt6_info *find_match(struct rt6_info *rt, int oif, int strict,

  				   int *mpri, struct rt6_info *match,
  				   bool *do_rr)

  {

  	int m;

  	bool match_do_rr = false;

  	struct inet6_dev *idev = rt->rt6i_idev;
  	struct net_device *dev = rt->dst.dev;
  
  	if (dev && !netif_carrier_ok(dev) &&

  	    idev->cnf.ignore_routes_with_linkdown &&
  	    !(strict & RT6_LOOKUP_F_IGNORE_LINKSTATE))

  		goto out;

  
  	if (rt6_check_expired(rt))
  		goto out;
  
  	m = rt6_score_route(rt, oif, strict);

  	if (m == RT6_NUD_FAIL_DO_RR) {

  		match_do_rr = true;
  		m = 0; /* lowest valid score */

  	} else if (m == RT6_NUD_FAIL_HARD) {

  		goto out;

  	}
  
  	if (strict & RT6_LOOKUP_F_REACHABLE)
  		rt6_probe(rt);

  	/* note that m can be RT6_NUD_FAIL_PROBE at this point */

  	if (m > *mpri) {

  		*do_rr = match_do_rr;

  		*mpri = m;
  		match = rt;

  	}

  out:
  	return match;
  }
  
  static struct rt6_info *find_rr_leaf(struct fib6_node *fn,
  				     struct rt6_info *rr_head,

  				     u32 metric, int oif, int strict,
  				     bool *do_rr)

  {

  	struct rt6_info *rt, *match, *cont;

  	int mpri = -1;

  	match = NULL;

  	cont = NULL;
  	for (rt = rr_head; rt; rt = rt->dst.rt6_next) {
  		if (rt->rt6i_metric != metric) {
  			cont = rt;
  			break;
  		}
  
  		match = find_match(rt, oif, strict, &mpri, match, do_rr);
  	}
  
  	for (rt = fn->leaf; rt && rt != rr_head; rt = rt->dst.rt6_next) {
  		if (rt->rt6i_metric != metric) {
  			cont = rt;
  			break;
  		}

  		match = find_match(rt, oif, strict, &mpri, match, do_rr);

  	}
  
  	if (match || !cont)
  		return match;
  
  	for (rt = cont; rt; rt = rt->dst.rt6_next)

  		match = find_match(rt, oif, strict, &mpri, match, do_rr);

  	return match;
  }

  static struct rt6_info *rt6_select(struct fib6_node *fn, int oif, int strict)
  {
  	struct rt6_info *match, *rt0;

  	struct net *net;

  	bool do_rr = false;

  	rt0 = fn->rr_ptr;
  	if (!rt0)
  		fn->rr_ptr = rt0 = fn->leaf;

  	match = find_rr_leaf(fn, rt0, rt0->rt6i_metric, oif, strict,
  			     &do_rr);

  	if (do_rr) {

  		struct rt6_info *next = rt0->dst.rt6_next;

  		/* no entries matched; do round-robin */

  		if (!next || next->rt6i_metric != rt0->rt6i_metric)
  			next = fn->leaf;
  
  		if (next != rt0)
  			fn->rr_ptr = next;

  	}

  	net = dev_net(rt0->dst.dev);

  	return match ? match : net->ipv6.ip6_null_entry;

  }

  static bool rt6_is_gw_or_nonexthop(const struct rt6_info *rt)
  {
  	return (rt->rt6i_flags & (RTF_NONEXTHOP | RTF_GATEWAY));
  }

  #ifdef CONFIG_IPV6_ROUTE_INFO
  int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,

  		  const struct in6_addr *gwaddr)

  {

  	struct net *net = dev_net(dev);

  	struct route_info *rinfo = (struct route_info *) opt;
  	struct in6_addr prefix_buf, *prefix;
  	unsigned int pref;

  	unsigned long lifetime;

  	struct rt6_info *rt;
  
  	if (len < sizeof(struct route_info)) {
  		return -EINVAL;
  	}
  
  	/* Sanity check for prefix_len and length */
  	if (rinfo->length > 3) {
  		return -EINVAL;
  	} else if (rinfo->prefix_len > 128) {
  		return -EINVAL;
  	} else if (rinfo->prefix_len > 64) {
  		if (rinfo->length < 2) {
  			return -EINVAL;
  		}
  	} else if (rinfo->prefix_len > 0) {
  		if (rinfo->length < 1) {
  			return -EINVAL;
  		}
  	}
  
  	pref = rinfo->route_pref;
  	if (pref == ICMPV6_ROUTER_PREF_INVALID)

  		return -EINVAL;

  	lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);

  
  	if (rinfo->length == 3)
  		prefix = (struct in6_addr *)rinfo->prefix;
  	else {
  		/* this function is safe */
  		ipv6_addr_prefix(&prefix_buf,
  				 (struct in6_addr *)rinfo->prefix,
  				 rinfo->prefix_len);
  		prefix = &prefix_buf;
  	}

  	if (rinfo->prefix_len == 0)
  		rt = rt6_get_dflt_router(gwaddr, dev);
  	else
  		rt = rt6_get_route_info(net, prefix, rinfo->prefix_len,

  					gwaddr, dev);

  
  	if (rt && !lifetime) {

  		ip6_del_rt(rt);

  		rt = NULL;
  	}
  
  	if (!rt && lifetime)

  		rt = rt6_add_route_info(net, prefix, rinfo->prefix_len, gwaddr,
  					dev, pref);

  	else if (rt)
  		rt->rt6i_flags = RTF_ROUTEINFO |
  				 (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
  
  	if (rt) {

  		if (!addrconf_finite_timeout(lifetime))
  			rt6_clean_expires(rt);
  		else
  			rt6_set_expires(rt, jiffies + HZ * lifetime);

  		ip6_rt_put(rt);

  	}
  	return 0;
  }
  #endif

  static struct fib6_node* fib6_backtrack(struct fib6_node *fn,
  					struct in6_addr *saddr)
  {
  	struct fib6_node *pn;
  	while (1) {
  		if (fn->fn_flags & RTN_TL_ROOT)
  			return NULL;
  		pn = fn->parent;
  		if (FIB6_SUBTREE(pn) && FIB6_SUBTREE(pn) != fn)
  			fn = fib6_lookup(FIB6_SUBTREE(pn), NULL, saddr);
  		else
  			fn = pn;
  		if (fn->fn_flags & RTN_RTINFO)
  			return fn;
  	}
  }

  static struct rt6_info *ip6_pol_route_lookup(struct net *net,
  					     struct fib6_table *table,

  					     struct flowi6 *fl6, int flags)

  {
  	struct fib6_node *fn;
  	struct rt6_info *rt;

  	if (fl6->flowi6_flags & FLOWI_FLAG_SKIP_NH_OIF)
  		flags &= ~RT6_LOOKUP_F_IFACE;

  	read_lock_bh(&table->tb6_lock);

  	fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);

  restart:
  	rt = fn->leaf;

  	rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags);

  	if (rt->rt6i_nsiblings && fl6->flowi6_oif == 0)

  		rt = rt6_multipath_select(rt, fl6, fl6->flowi6_oif, flags);

  	if (rt == net->ipv6.ip6_null_entry) {
  		fn = fib6_backtrack(fn, &fl6->saddr);
  		if (fn)
  			goto restart;
  	}

  	dst_use(&rt->dst, jiffies);

  	read_unlock_bh(&table->tb6_lock);

  
  	trace_fib6_table_lookup(net, rt, table->tb6_id, fl6);

  	return rt;
  
  }

  struct dst_entry *ip6_route_lookup(struct net *net, struct flowi6 *fl6,

  				    int flags)
  {
  	return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_lookup);
  }
  EXPORT_SYMBOL_GPL(ip6_route_lookup);

  struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr,
  			    const struct in6_addr *saddr, int oif, int strict)

  {

  	struct flowi6 fl6 = {
  		.flowi6_oif = oif,
  		.daddr = *daddr,

  	};
  	struct dst_entry *dst;

  	int flags = strict ? RT6_LOOKUP_F_IFACE : 0;

  	if (saddr) {

  		memcpy(&fl6.saddr, saddr, sizeof(*saddr));

  		flags |= RT6_LOOKUP_F_HAS_SADDR;
  	}

  	dst = fib6_rule_lookup(net, &fl6, flags, ip6_pol_route_lookup);

  	if (dst->error == 0)
  		return (struct rt6_info *) dst;
  
  	dst_release(dst);

  	return NULL;
  }

  EXPORT_SYMBOL(rt6_lookup);

  /* ip6_ins_rt is called with FREE table->tb6_lock.

   * It takes new route entry, the addition fails by any reason the
   * route is released.
   * Caller must hold dst before calling it.

   */

  static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info,

  			struct mx6_config *mxc,
  			struct netlink_ext_ack *extack)

  {
  	int err;

  	struct fib6_table *table;

  	table = rt->rt6i_table;
  	write_lock_bh(&table->tb6_lock);

  	err = fib6_add(&table->tb6_root, rt, info, mxc, extack);

  	write_unlock_bh(&table->tb6_lock);

  
  	return err;
  }

  int ip6_ins_rt(struct rt6_info *rt)
  {

  	struct nl_info info = {	.nl_net = dev_net(rt->dst.dev), };
  	struct mx6_config mxc = { .mx = NULL, };

  	/* Hold dst to account for the reference from the fib6 tree */
  	dst_hold(&rt->dst);

  	return __ip6_ins_rt(rt, &info, &mxc, NULL);

  }

  /* called with rcu_lock held */
  static struct net_device *ip6_rt_get_dev_rcu(struct rt6_info *rt)
  {
  	struct net_device *dev = rt->dst.dev;

  	if (rt->rt6i_flags & (RTF_LOCAL | RTF_ANYCAST)) {

  		/* for copies of local routes, dst->dev needs to be the
  		 * device if it is a master device, the master device if
  		 * device is enslaved, and the loopback as the default
  		 */
  		if (netif_is_l3_slave(dev) &&
  		    !rt6_need_strict(&rt->rt6i_dst.addr))
  			dev = l3mdev_master_dev_rcu(dev);
  		else if (!netif_is_l3_master(dev))
  			dev = dev_net(dev)->loopback_dev;
  		/* last case is netif_is_l3_master(dev) is true in which
  		 * case we want dev returned to be dev
  		 */
  	}
  
  	return dev;
  }

  static struct rt6_info *ip6_rt_cache_alloc(struct rt6_info *ort,
  					   const struct in6_addr *daddr,
  					   const struct in6_addr *saddr)

  {

  	struct net_device *dev;

  	struct rt6_info *rt;
  
  	/*
  	 *	Clone the route.
  	 */

  	if (ort->rt6i_flags & (RTF_CACHE | RTF_PCPU))

  		ort = (struct rt6_info *)ort->dst.from;

  	rcu_read_lock();
  	dev = ip6_rt_get_dev_rcu(ort);
  	rt = __ip6_dst_alloc(dev_net(dev), dev, 0);
  	rcu_read_unlock();

  	if (!rt)
  		return NULL;
  
  	ip6_rt_copy_init(rt, ort);
  	rt->rt6i_flags |= RTF_CACHE;
  	rt->rt6i_metric = 0;
  	rt->dst.flags |= DST_HOST;
  	rt->rt6i_dst.addr = *daddr;
  	rt->rt6i_dst.plen = 128;

  	if (!rt6_is_gw_or_nonexthop(ort)) {
  		if (ort->rt6i_dst.plen != 128 &&
  		    ipv6_addr_equal(&ort->rt6i_dst.addr, daddr))
  			rt->rt6i_flags |= RTF_ANYCAST;

  #ifdef CONFIG_IPV6_SUBTREES

  		if (rt->rt6i_src.plen && saddr) {
  			rt->rt6i_src.addr = *saddr;
  			rt->rt6i_src.plen = 128;

  		}

  #endif

  	}

  	return rt;
  }

  static struct rt6_info *ip6_rt_pcpu_alloc(struct rt6_info *rt)
  {

  	struct net_device *dev;

  	struct rt6_info *pcpu_rt;

  	rcu_read_lock();
  	dev = ip6_rt_get_dev_rcu(rt);
  	pcpu_rt = __ip6_dst_alloc(dev_net(dev), dev, rt->dst.flags);
  	rcu_read_unlock();

  	if (!pcpu_rt)
  		return NULL;
  	ip6_rt_copy_init(pcpu_rt, rt);
  	pcpu_rt->rt6i_protocol = rt->rt6i_protocol;
  	pcpu_rt->rt6i_flags |= RTF_PCPU;
  	return pcpu_rt;
  }
  
  /* It should be called with read_lock_bh(&tb6_lock) acquired */
  static struct rt6_info *rt6_get_pcpu_route(struct rt6_info *rt)
  {

  	struct rt6_info *pcpu_rt, **p;

  
  	p = this_cpu_ptr(rt->rt6i_pcpu);
  	pcpu_rt = *p;

  	if (pcpu_rt) {
  		dst_hold(&pcpu_rt->dst);
  		rt6_dst_from_metrics_check(pcpu_rt);
  	}
  	return pcpu_rt;
  }
  
  static struct rt6_info *rt6_make_pcpu_route(struct rt6_info *rt)
  {

  	struct fib6_table *table = rt->rt6i_table;

  	struct rt6_info *pcpu_rt, *prev, **p;

  
  	pcpu_rt = ip6_rt_pcpu_alloc(rt);
  	if (!pcpu_rt) {
  		struct net *net = dev_net(rt->dst.dev);

  		dst_hold(&net->ipv6.ip6_null_entry->dst);
  		return net->ipv6.ip6_null_entry;

  	}

  	read_lock_bh(&table->tb6_lock);
  	if (rt->rt6i_pcpu) {
  		p = this_cpu_ptr(rt->rt6i_pcpu);
  		prev = cmpxchg(p, NULL, pcpu_rt);
  		if (prev) {
  			/* If someone did it before us, return prev instead */
  			dst_release_immediate(&pcpu_rt->dst);
  			pcpu_rt = prev;
  		}
  	} else {
  		/* rt has been removed from the fib6 tree
  		 * before we have a chance to acquire the read_lock.
  		 * In this case, don't brother to create a pcpu rt
  		 * since rt is going away anyway.  The next
  		 * dst_check() will trigger a re-lookup.
  		 */

  		dst_release_immediate(&pcpu_rt->dst);

  		pcpu_rt = rt;

  	}

  	dst_hold(&pcpu_rt->dst);

  	rt6_dst_from_metrics_check(pcpu_rt);

  	read_unlock_bh(&table->tb6_lock);

  	return pcpu_rt;
  }

  struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table,
  			       int oif, struct flowi6 *fl6, int flags)

  {

  	struct fib6_node *fn, *saved_fn;

  	struct rt6_info *rt;

  	int strict = 0;

  	strict |= flags & RT6_LOOKUP_F_IFACE;

  	strict |= flags & RT6_LOOKUP_F_IGNORE_LINKSTATE;

  	if (net->ipv6.devconf_all->forwarding == 0)
  		strict |= RT6_LOOKUP_F_REACHABLE;

  	read_lock_bh(&table->tb6_lock);

  	fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);

  	saved_fn = fn;

  	if (fl6->flowi6_flags & FLOWI_FLAG_SKIP_NH_OIF)
  		oif = 0;

  redo_rt6_select:

  	rt = rt6_select(fn, oif, strict);

  	if (rt->rt6i_nsiblings)

  		rt = rt6_multipath_select(rt, fl6, oif, strict);

  	if (rt == net->ipv6.ip6_null_entry) {
  		fn = fib6_backtrack(fn, &fl6->saddr);
  		if (fn)
  			goto redo_rt6_select;

  		else if (strict & RT6_LOOKUP_F_REACHABLE) {
  			/* also consider unreachable route */
  			strict &= ~RT6_LOOKUP_F_REACHABLE;
  			fn = saved_fn;
  			goto redo_rt6_select;

  		}

  	}

  	if (rt == net->ipv6.ip6_null_entry || (rt->rt6i_flags & RTF_CACHE)) {

  		dst_use(&rt->dst, jiffies);
  		read_unlock_bh(&table->tb6_lock);
  
  		rt6_dst_from_metrics_check(rt);

  
  		trace_fib6_table_lookup(net, rt, table->tb6_id, fl6);

  		return rt;

  	} else if (unlikely((fl6->flowi6_flags & FLOWI_FLAG_KNOWN_NH) &&
  			    !(rt->rt6i_flags & RTF_GATEWAY))) {
  		/* Create a RTF_CACHE clone which will not be
  		 * owned by the fib6 tree.  It is for the special case where
  		 * the daddr in the skb during the neighbor look-up is different
  		 * from the fl6->daddr used to look-up route here.
  		 */
  
  		struct rt6_info *uncached_rt;

  		dst_use(&rt->dst, jiffies);
  		read_unlock_bh(&table->tb6_lock);

  		uncached_rt = ip6_rt_cache_alloc(rt, &fl6->daddr, NULL);
  		dst_release(&rt->dst);

  		if (uncached_rt) {
  			/* Uncached_rt's refcnt is taken during ip6_rt_cache_alloc()
  			 * No need for another dst_hold()
  			 */

  			rt6_uncached_list_add(uncached_rt);

  		} else {

  			uncached_rt = net->ipv6.ip6_null_entry;

  			dst_hold(&uncached_rt->dst);
  		}

  
  		trace_fib6_table_lookup(net, uncached_rt, table->tb6_id, fl6);

  		return uncached_rt;

  	} else {
  		/* Get a percpu copy */
  
  		struct rt6_info *pcpu_rt;
  
  		rt->dst.lastuse = jiffies;
  		rt->dst.__use++;
  		pcpu_rt = rt6_get_pcpu_route(rt);

  		if (pcpu_rt) {
  			read_unlock_bh(&table->tb6_lock);
  		} else {

  			/* We have to do the read_unlock first
  			 * because rt6_make_pcpu_route() may trigger
  			 * ip6_dst_gc() which will take the write_lock.
  			 */
  			dst_hold(&rt->dst);
  			read_unlock_bh(&table->tb6_lock);
  			pcpu_rt = rt6_make_pcpu_route(rt);
  			dst_release(&rt->dst);

  		}

  		trace_fib6_table_lookup(net, pcpu_rt, table->tb6_id, fl6);

  		return pcpu_rt;

  	}

  }

  EXPORT_SYMBOL_GPL(ip6_pol_route);

  static struct rt6_info *ip6_pol_route_input(struct net *net, struct fib6_table *table,

  					    struct flowi6 *fl6, int flags)

  {

  	return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, flags);

  }

  struct dst_entry *ip6_route_input_lookup(struct net *net,
  					 struct net_device *dev,
  					 struct flowi6 *fl6, int flags)

  {
  	if (rt6_need_strict(&fl6->daddr) && dev->type != ARPHRD_PIMREG)
  		flags |= RT6_LOOKUP_F_IFACE;
  
  	return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_input);
  }

  EXPORT_SYMBOL_GPL(ip6_route_input_lookup);

  static void ip6_multipath_l3_keys(const struct sk_buff *skb,
  				  struct flow_keys *keys)
  {
  	const struct ipv6hdr *outer_iph = ipv6_hdr(skb);
  	const struct ipv6hdr *key_iph = outer_iph;
  	const struct ipv6hdr *inner_iph;
  	const struct icmp6hdr *icmph;
  	struct ipv6hdr _inner_iph;

  	struct icmp6hdr _icmph;

  
  	if (likely(outer_iph->nexthdr != IPPROTO_ICMPV6))
  		goto out;

  	icmph = skb_header_pointer(skb, skb_transport_offset(skb),
  				   sizeof(_icmph), &_icmph);
  	if (!icmph)
  		goto out;

  	if (icmph->icmp6_type != ICMPV6_DEST_UNREACH &&
  	    icmph->icmp6_type != ICMPV6_PKT_TOOBIG &&
  	    icmph->icmp6_type != ICMPV6_TIME_EXCEED &&
  	    icmph->icmp6_type != ICMPV6_PARAMPROB)
  		goto out;
  
  	inner_iph = skb_header_pointer(skb,
  				       skb_transport_offset(skb) + sizeof(*icmph),
  				       sizeof(_inner_iph), &_inner_iph);
  	if (!inner_iph)
  		goto out;
  
  	key_iph = inner_iph;
  out:
  	memset(keys, 0, sizeof(*keys));
  	keys->control.addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS;
  	keys->addrs.v6addrs.src = key_iph->saddr;
  	keys->addrs.v6addrs.dst = key_iph->daddr;

  	keys->tags.flow_label = ip6_flowlabel(key_iph);

  	keys->basic.ip_proto = key_iph->nexthdr;
  }
  
  /* if skb is set it will be used and fl6 can be NULL */
  u32 rt6_multipath_hash(const struct flowi6 *fl6, const struct sk_buff *skb)
  {
  	struct flow_keys hash_keys;
  
  	if (skb) {
  		ip6_multipath_l3_keys(skb, &hash_keys);
  		return flow_hash_from_keys(&hash_keys);
  	}
  
  	return get_hash_from_flowi6(fl6);
  }

  void ip6_route_input(struct sk_buff *skb)
  {

  	const struct ipv6hdr *iph = ipv6_hdr(skb);

  	struct net *net = dev_net(skb->dev);

  	int flags = RT6_LOOKUP_F_HAS_SADDR;

  	struct ip_tunnel_info *tun_info;

  	struct flowi6 fl6 = {

  		.flowi6_iif = skb->dev->ifindex,

  		.daddr = iph->daddr,
  		.saddr = iph->saddr,

  		.flowlabel = ip6_flowinfo(iph),

  		.flowi6_mark = skb->mark,
  		.flowi6_proto = iph->nexthdr,

  	};

  	tun_info = skb_tunnel_info(skb);

  	if (tun_info && !(tun_info->mode & IP_TUNNEL_INFO_TX))

  		fl6.flowi6_tun_key.tun_id = tun_info->key.tun_id;

  	if (unlikely(fl6.flowi6_proto == IPPROTO_ICMPV6))
  		fl6.mp_hash = rt6_multipath_hash(&fl6, skb);

  	skb_dst_drop(skb);

  	skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));

  }

  static struct rt6_info *ip6_pol_route_output(struct net *net, struct fib6_table *table,

  					     struct flowi6 *fl6, int flags)

  {

  	return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, flags);

  }

  struct dst_entry *ip6_route_output_flags(struct net *net, const struct sock *sk,
  					 struct flowi6 *fl6, int flags)

  {

  	bool any_src;

  	if (rt6_need_strict(&fl6->daddr)) {
  		struct dst_entry *dst;
  
  		dst = l3mdev_link_scope_lookup(net, fl6);
  		if (dst)
  			return dst;
  	}

  	fl6->flowi6_iif = LOOPBACK_IFINDEX;

  	any_src = ipv6_addr_any(&fl6->saddr);

  	if ((sk && sk->sk_bound_dev_if) || rt6_need_strict(&fl6->daddr) ||

  	    (fl6->flowi6_oif && any_src))

  		flags |= RT6_LOOKUP_F_IFACE;

  	if (!any_src)

  		flags |= RT6_LOOKUP_F_HAS_SADDR;

  	else if (sk)
  		flags |= rt6_srcprefs2flags(inet6_sk(sk)->srcprefs);

  	return fib6_rule_lookup(net, fl6, flags, ip6_pol_route_output);

  }

  EXPORT_SYMBOL_GPL(ip6_route_output_flags);

  struct dst_entry *ip6_blackhole_route(struct net *net, struct dst_entry *dst_orig)

  {

  	struct rt6_info *rt, *ort = (struct rt6_info *) dst_orig;

  	struct net_device *loopback_dev = net->loopback_dev;

  	struct dst_entry *new = NULL;

  	rt = dst_alloc(&ip6_dst_blackhole_ops, loopback_dev, 1,

  		       DST_OBSOLETE_DEAD, 0);

  	if (rt) {

  		rt6_info_init(rt);

  		new = &rt->dst;

  		new->__use = 1;

  		new->input = dst_discard;

  		new->output = dst_discard_out;

  		dst_copy_metrics(new, &ort->dst);

  		rt->rt6i_idev = in6_dev_get(loopback_dev);

  		rt->rt6i_gateway = ort->rt6i_gateway;

  		rt->rt6i_flags = ort->rt6i_flags & ~RTF_PCPU;

  		rt->rt6i_metric = 0;
  
  		memcpy(&rt->rt6i_dst, &ort->rt6i_dst, sizeof(struct rt6key));
  #ifdef CONFIG_IPV6_SUBTREES
  		memcpy(&rt->rt6i_src, &ort->rt6i_src, sizeof(struct rt6key));
  #endif

  	}

  	dst_release(dst_orig);
  	return new ? new : ERR_PTR(-ENOMEM);

  }

  /*
   *	Destination cache support functions
   */

  static void rt6_dst_from_metrics_check(struct rt6_info *rt)
  {
  	if (rt->dst.from &&
  	    dst_metrics_ptr(&rt->dst) != dst_metrics_ptr(rt->dst.from))
  		dst_init_metrics(&rt->dst, dst_metrics_ptr(rt->dst.from), true);
  }

  static struct dst_entry *rt6_check(struct rt6_info *rt, u32 cookie)
  {

  	u32 rt_cookie = 0;

  
  	if (!rt6_get_cookie_safe(rt, &rt_cookie) || rt_cookie != cookie)

  		return NULL;
  
  	if (rt6_check_expired(rt))
  		return NULL;
  
  	return &rt->dst;
  }
  
  static struct dst_entry *rt6_dst_from_check(struct rt6_info *rt, u32 cookie)
  {

  	if (!__rt6_check_expired(rt) &&
  	    rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&

  	    rt6_check((struct rt6_info *)(rt->dst.from), cookie))
  		return &rt->dst;
  	else
  		return NULL;
  }

  static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
  {
  	struct rt6_info *rt;
  
  	rt = (struct rt6_info *) dst;

  	/* All IPV6 dsts are created with ->obsolete set to the value
  	 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
  	 * into this function always.
  	 */

  	rt6_dst_from_metrics_check(rt);

  	if (rt->rt6i_flags & RTF_PCPU ||

  	    (unlikely(!list_empty(&rt->rt6i_uncached)) && rt->dst.from))

  		return rt6_dst_from_check(rt, cookie);
  	else
  		return rt6_check(rt, cookie);

  }
  
  static struct dst_entry *ip6_negative_advice(struct dst_entry *dst)
  {
  	struct rt6_info *rt = (struct rt6_info *) dst;
  
  	if (rt) {

  		if (rt->rt6i_flags & RTF_CACHE) {
  			if (rt6_check_expired(rt)) {
  				ip6_del_rt(rt);
  				dst = NULL;
  			}
  		} else {

  			dst_release(dst);

  			dst = NULL;
  		}

  	}

  	return dst;

  }
  
  static void ip6_link_failure(struct sk_buff *skb)
  {
  	struct rt6_info *rt;

  	icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);

  	rt = (struct rt6_info *) skb_dst(skb);

  	if (rt) {

  		if (rt->rt6i_flags & RTF_CACHE) {

  			if (dst_hold_safe(&rt->dst))
  				ip6_del_rt(rt);

  		} else {
  			struct fib6_node *fn;
  
  			rcu_read_lock();
  			fn = rcu_dereference(rt->rt6i_node);
  			if (fn && (rt->rt6i_flags & RTF_DEFAULT))
  				fn->fn_sernum = -1;
  			rcu_read_unlock();

  		}

  	}
  }

  static void rt6_do_update_pmtu(struct rt6_info *rt, u32 mtu)
  {
  	struct net *net = dev_net(rt->dst.dev);
  
  	rt->rt6i_flags |= RTF_MODIFIED;
  	rt->rt6i_pmtu = mtu;
  	rt6_update_expires(rt, net->ipv6.sysctl.ip6_rt_mtu_expires);
  }

  static bool rt6_cache_allowed_for_pmtu(const struct rt6_info *rt)
  {
  	return !(rt->rt6i_flags & RTF_CACHE) &&

  		(rt->rt6i_flags & RTF_PCPU ||
  		 rcu_access_pointer(rt->rt6i_node));

  }

  static void __ip6_rt_update_pmtu(struct dst_entry *dst, const struct sock *sk,
  				 const struct ipv6hdr *iph, u32 mtu)

  {

  	const struct in6_addr *daddr, *saddr;

  	struct rt6_info *rt6 = (struct rt6_info *)dst;

  	if (dst_metric_locked(dst, RTAX_MTU))
  		return;

  	if (iph) {
  		daddr = &iph->daddr;
  		saddr = &iph->saddr;
  	} else if (sk) {
  		daddr = &sk->sk_v6_daddr;
  		saddr = &inet6_sk(sk)->saddr;
  	} else {
  		daddr = NULL;
  		saddr = NULL;
  	}
  	dst_confirm_neigh(dst, daddr);

  	mtu = max_t(u32, mtu, IPV6_MIN_MTU);
  	if (mtu >= dst_mtu(dst))
  		return;

  	if (!rt6_cache_allowed_for_pmtu(rt6)) {

  		rt6_do_update_pmtu(rt6, mtu);

  	} else if (daddr) {

  		struct rt6_info *nrt6;

  		nrt6 = ip6_rt_cache_alloc(rt6, daddr, saddr);
  		if (nrt6) {
  			rt6_do_update_pmtu(nrt6, mtu);
  
  			/* ip6_ins_rt(nrt6) will bump the
  			 * rt6->rt6i_node->fn_sernum
  			 * which will fail the next rt6_check() and
  			 * invalidate the sk->sk_dst_cache.
  			 */
  			ip6_ins_rt(nrt6);

  			/* Release the reference taken in
  			 * ip6_rt_cache_alloc()
  			 */
  			dst_release(&nrt6->dst);

  		}

  	}
  }

  static void ip6_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
  			       struct sk_buff *skb, u32 mtu)
  {
  	__ip6_rt_update_pmtu(dst, sk, skb ? ipv6_hdr(skb) : NULL, mtu);
  }

  void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,

  		     int oif, u32 mark, kuid_t uid)