Release 4.11 net/ipv6/route.c

/*
 *      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->dst.flags |= DST_NOCACHE;
	rt->rt6i_uncached_list = ul;

	spin_lock_bh(&ul->lock);
	list_add_tail(&rt->rt6i_uncached, &ul->head);
	spin_unlock_bh(&ul->lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
65
100.00%
1
100.00%
Total
65
100.00%
1
100.00%



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);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
57
100.00%
1
100.00%
Total
57
100.00%
1
100.00%



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);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
152
95.60%
1
50.00%
Eric W. Biedermann
7
4.40%
1
50.00%
Total
159
100.00%
2
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
22
100.00%
1
100.00%
Total
22
100.00%
1
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
30
47.62%
1
20.00%
Martin KaFai Lau
27
42.86%
3
60.00%
Zheng Yan
6
9.52%
1
20.00%
Total
63
100.00%
5
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
67
100.00%
3
100.00%
Total
67
100.00%
3
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
83
100.00%
4
100.00%
Total
83
100.00%
4
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Julian Anastasov
89
100.00%
1
100.00%
Total
89
100.00%
1
100.00%


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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Steffen Klassert
20
58.82%
3
75.00%
Roland Dreier
14
41.18%
1
25.00%
Total
34
100.00%
4
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
23
100.00%
2
100.00%
Total
23
100.00%
2
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
20
100.00%
2
100.00%
Total
20
100.00%
2
100.00%


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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
21
36.21%
2
22.22%
Steffen Klassert
14
24.14%
1
11.11%
Martin KaFai Lau
11
18.97%
2
22.22%
Nicolas Dichtel
8
13.79%
1
11.11%
Hideaki Yoshifuji / 吉藤英明
2
3.45%
2
22.22%
Benjamin Thery
2
3.45%
1
11.11%
Total
58
100.00%
9
100.00%

/* 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,
					0, DST_OBSOLETE_FORCE_CHK, flags);

	if (rt)
		rt6_info_init(rt);

	return rt;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
52
92.86%
1
33.33%
David S. Miller
2
3.57%
1
33.33%
Kazunori Miyazawa
2
3.57%
1
33.33%
Total
56
100.00%
3
100.00%



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_destroy((struct dst_entry *)rt);
			return NULL;
		}
	}

	return rt;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
112
100.00%
1
100.00%
Total
112
100.00%
1
100.00%


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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Hideaki Yoshifuji / 吉藤英明
49
55.68%
3
37.50%
Martin KaFai Lau
23
26.14%
2
25.00%
Gao Feng
8
9.09%
1
12.50%
Zheng Yan
7
7.95%
1
12.50%
David S. Miller
1
1.14%
1
12.50%
Total
88
100.00%
8
100.00%



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 (dev != loopback_dev) {
		if (idev && idev->dev == dev) {
			struct inet6_dev *loopback_idev =
				in6_dev_get(loopback_dev);
			if (loopback_idev) {
				rt->rt6i_idev = loopback_idev;
				in6_dev_put(idev);
			}
		}
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Hideaki Yoshifuji / 吉藤英明
75
75.76%
4
57.14%
Herbert Xu
10
10.10%
1
14.29%
Denis V. Lunev
9
9.09%
1
14.29%
David S. Miller
5
5.05%
1
14.29%
Total
99
100.00%
7
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
36
100.00%
1
100.00%
Total
36
100.00%
1
100.00%



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 rt6_check_expired((struct rt6_info *) rt->dst.from);
	}
	return false;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Gao Feng
44
65.67%
1
25.00%
Hideaki Yoshifuji / 吉藤英明
17
25.37%
1
25.00%
Li RongQing
3
4.48%
1
25.00%
Eric Dumazet
3
4.48%
1
25.00%
Total
67
100.00%
4
100.00%

/* Multipath route selection:
 *   Hash based function using packet header and flowlabel.
 * Adapted from fib_info_hashfn()
 */


static int rt6_info_hash_nhsfn(unsigned int candidate_count,
			       const struct flowi6 *fl6)
{
	return get_hash_from_flowi6(fl6) % candidate_count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Nicolas Dichtel
20
83.33%
1
33.33%
Hideaki Yoshifuji / 吉藤英明
2
8.33%
1
33.33%
Tom Herbert
2
8.33%
1
33.33%
Total
24
100.00%
3
100.00%



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;

	route_choosen = rt6_info_hash_nhsfn(match->rt6i_nsiblings + 1, fl6);
	/* 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Nicolas Dichtel
98
100.00%
2
100.00%
Total
98
100.00%
2
100.00%

/*
 *      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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Hideaki Yoshifuji / 吉藤英明
93
44.50%
4
33.33%
Linus Torvalds (pre-git)
71
33.97%
3
25.00%
Daniel Lezcano
37
17.70%
1
8.33%
Eric Dumazet
4
1.91%
2
16.67%
David S. Miller
4
1.91%
2
16.67%
Total
209
100.00%
12
100.00%

#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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Hannes Frederic Sowa
69
95.83%
1
33.33%
Erik Nordmark
2
2.78%
1
33.33%
Michael Büsch
1
1.39%
1
33.33%
Total
72
100.00%
3
100.00%



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();
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Hideaki Yoshifuji / 吉藤英明
113
52.07%
5
41.67%
Hannes Frederic Sowa
47
21.66%
1
8.33%
Martin KaFai Lau
44
20.28%
2
16.67%
Eric Dumazet
6
2.76%
1
8.33%
Jiri Benc
3
1.38%
1
8.33%
David S. Miller
3
1.38%
1
8.33%
Daniel Lezcano
1
0.46%
1
8.33%
Total
217
100.00%
12
100.00%

#else


static inline void rt6_probe(struct rt6_info *rt)
{
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Hideaki Yoshifuji / 吉藤英明
10
90.91%
1
50.00%
Joe Perches
1
9.09%
1
50.00%
Total
11
100.00%
2
100.00%

#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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Hideaki Yoshifuji / 吉藤英明
55
78.57%
4
57.14%
David S. Miller
14
20.00%
2
28.57%
Dave Jones
1
1.43%
1
14.29%
Total
70
100.00%
7
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Hideaki Yoshifuji / 吉藤英明
85
59.44%
6
42.86%
Hannes Frederic Sowa
21
14.69%
2
14.29%
Linus Torvalds (pre-git)
21
14.69%
3
21.43%
Paul Marks
8
5.59%
1
7.14%
Jiri Benc
6
4.20%
1
7.14%
Eric Dumazet
2
1.40%
1
7.14%
Total
143
100.00%
14
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Hideaki Yoshifuji / 吉藤英明
65
72.22%
5
62.50%
Hannes Frederic Sowa
17
18.89%
1
12.50%
Linus Torvalds (pre-git)
6
6.67%
1
12.50%
Paul Marks
2
2.22%
1
12.50%
Total
90
100.00%
8
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Hideaki Yoshifuji / 吉藤英明
62
35.23%
6
50.00%
Hannes Frederic Sowa
40
22.73%
1
8.33%
Andy Gospodarek
39
22.16%
1
8.33%
David S. Miller
21
11.93%
1
8.33%
David Ahern
7
3.98%
1
8.33%
Jiri Benc
4
2.27%
1
8.33%
Linus Torvalds (pre-git)
3
1.70%
1
8.33%
Total
176
100.00%
12
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
106
50.24%
1
14.29%
Steffen Klassert
81
38.39%
1
14.29%
Hideaki Yoshifuji / 吉藤英明
10
4.74%
3
42.86%
Hannes Frederic Sowa
8
3.79%
1
14.29%
Eric Dumazet
6
2.84%
1
14.29%
Total
211
100.00%
7
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
107
71.81%
2
20.00%
Daniel Lezcano
14
9.40%
1
10.00%
Hideaki Yoshifuji / 吉藤英明
13
8.72%
4
40.00%
Hannes Frederic Sowa
9
6.04%
1
10.00%
Linus Torvalds (pre-git)
3
2.01%
1
10.00%
Eric Dumazet
3
2.01%
1
10.00%
Total
149
100.00%
10
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
25
100.00%
1
100.00%
Total
25
100.00%
1
100.00%

#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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Hideaki Yoshifuji / 吉藤英明
303
79.53%
3
20.00%
Linus Torvalds (pre-git)
35
9.19%
5
33.33%
Duan Jiong
18
4.72%
1
6.67%
Daniel Lezcano
11
2.89%
1
6.67%
Gao Feng
7
1.84%
1
6.67%
Jens Rosenboom
4
1.05%
1
6.67%
Eric Dumazet
1
0.26%
1
6.67%
Al Viro
1
0.26%
1
6.67%
Américo Wang
1
0.26%
1
6.67%
Total
381
100.00%
15
100.00%

#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;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
86
95.56%
1
33.33%
Hideaki Yoshifuji / 吉藤英明
3
3.33%
1
33.33%
Daniel Lezcano
1
1.11%
1
33.33%
Total
90
100.00%
3
100.00%



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;

	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;

}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Hideaki Yoshifuji / 吉藤英明
56
30.43%
3
21.43%
Thomas Graf
33
17.93%
1
7.14%
Nicolas Dichtel
27
14.67%
2
14.29%
Martin KaFai Lau
23
12.50%
1
7.14%
David Ahern
13
7.07%
1
7.14%
David S. Miller
12
6.52%
1
7.14%
Daniel Lezcano
9
4.89%
1
7.14%
Linus Torvalds (pre-git)
8
4.35%
3
21.43%
Pavel Emelyanov
3
1.63%
1
7.14%
Total
184
100.00%
14
100.00%



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);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Florian Westphal
32
100.00%
1
100.00%
Total
32
100.00%
1
100.00%


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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Thomas Graf
92
73.60%
2
22.22%
Linus Torvalds (pre-git)
15
12.00%
2
22.22%
Daniel Lezcano
8
6.40%
2
22.22%
David S. Miller
7
5.60%
1
11.11%
Hideaki Yoshifuji / 吉藤英明
3
2.40%
2
22.22%
Total
125
100.00%
9
100.00%


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 freed. In any case, if caller does not hold it, it may
   be destroyed.
 */



static int __ip6_ins_rt(struct rt6_info *rt, struct nl_info *info,
			struct mx6_config *mxc)
{
	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);
	write_unlock_bh(&table->tb6_lock);

	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
34
48.57%
3
30.00%
Thomas Graf
25
35.71%
3
30.00%
Michal Kubeček
4
5.71%
1
10.00%
Florian Westphal
3
4.29%
1
10.00%
Mathew Richardson
3
4.29%
1
10.00%
Jamal Hadi Salim
1
1.43%
1
10.00%
Total
70
100.00%
10
100.00%



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, };

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Thomas Graf
17
33.33%
1
12.50%
Florian Westphal
14
27.45%
1
12.50%
Denis V. Lunev
11
21.57%
2
25.00%
David S. Miller
3
5.88%
1
12.50%
Hideaki Yoshifuji / 吉藤英明
3
5.88%
1
12.50%
Daniel Lezcano
2
3.92%
1
12.50%
Michal Kubeček
1
1.96%
1
12.50%
Total
51
100.00%
8
100.00%



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

	/*
         *      Clone the route.
         */

	if (ort->rt6i_flags & (RTF_CACHE | RTF_PCPU))
		ort = (struct rt6_info *)ort->dst.from;

	rt = __ip6_dst_alloc(dev_net(ort->dst.dev), ort->dst.dev, 0);

	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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
98
47.80%
3
20.00%
Linus Torvalds (pre-git)
81
39.51%
5
33.33%
Hideaki Yoshifuji / 吉藤英明
19
9.27%
3
20.00%
Eric Dumazet
4
1.95%
2
13.33%
Alexey Dobriyan
2
0.98%
1
6.67%
David S. Miller
1
0.49%
1
6.67%
Total
205
100.00%
15
100.00%



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

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

	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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
76
100.00%
1
100.00%
Total
76
100.00%
1
100.00%

/* 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
58
100.00%
2
100.00%
Total
58
100.00%
2
100.00%



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_destroy(&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_destroy(&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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
176
100.00%
3
100.00%
Total
176
100.00%
3
100.00%



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)
			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;

	}
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
266
56.48%
8
27.59%
David Ahern
57
12.10%
3
10.34%
Linus Torvalds (pre-git)
38
8.07%
4
13.79%
Hideaki Yoshifuji / 吉藤英明
35
7.43%
7
24.14%
Thomas Graf
25
5.31%
1
3.45%
Nicolas Dichtel
19
4.03%
2
6.90%
David S. Miller
19
4.03%
2
6.90%
Daniel Lezcano
7
1.49%
1
3.45%
Pavel Emelyanov
5
1.06%
1
3.45%
Total
471
100.00%
29
100.00%


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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Pavel Emelyanov
30
71.43%
1
33.33%
Daniel Lezcano
7
16.67%
1
33.33%
David S. Miller
5
11.90%
1
33.33%
Total
42
100.00%
3
100.00%



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);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Shmulik Ladkani
57
100.00%
1
100.00%
Total
57
100.00%
1
100.00%


EXPORT_SYMBOL_GPL(ip6_route_input_lookup);



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;
	skb_dst_drop(skb);
	skb_dst_set(skb, ip6_route_input_lookup(net, skb->dev, &fl6, flags));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Thomas Graf
61
40.67%
3
15.79%
Jiri Benc
42
28.00%
3
15.79%
Daniel Lezcano
12
8.00%
2
10.53%
David S. Miller
9
6.00%
1
5.26%
Hideaki Yoshifuji / 吉藤英明
7
4.67%
3
15.79%
Eric Dumazet
5
3.33%
2
10.53%
Shmulik Ladkani
5
3.33%
1
5.26%
Linus Torvalds (pre-git)
4
2.67%
2
10.53%
Arnaldo Carvalho de Melo
3
2.00%
1
5.26%
David Ahern
2
1.33%
1
5.26%
Total
150
100.00%
19
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
12
28.57%
2
25.00%
Thomas Graf
11
26.19%
1
12.50%
Daniel Lezcano
7
16.67%
1
12.50%
David S. Miller
5
11.90%
1
12.50%
Hideaki Yoshifuji / 吉藤英明
4
9.52%
2
25.00%
Pavel Emelyanov
3
7.14%
1
12.50%
Total
42
100.00%
8
100.00%



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);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David Ahern
55
37.67%
4
20.00%
Thomas Graf
39
26.71%
2
10.00%
Hideaki Yoshifuji / 吉藤英明
18
12.33%
3
15.00%
Daniel Lezcano
7
4.79%
2
10.00%
Brian Haley
6
4.11%
1
5.00%
David McCullough
5
3.42%
1
5.00%
David S. Miller
5
3.42%
1
5.00%
Paolo Abeni
4
2.74%
1
5.00%
Linus Torvalds (pre-git)
3
2.05%
2
10.00%
Jiri Olsa
2
1.37%
1
5.00%
Pavel Emelyanov
1
0.68%
1
5.00%
Florian Westphal
1
0.68%
1
5.00%
Total
146
100.00%
20
100.00%


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 dst_entry *new = NULL;

	rt = dst_alloc(&ip6_dst_blackhole_ops, ort->dst.dev, 1, DST_OBSOLETE_NONE, 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 = ort->rt6i_idev;
		if (rt->rt6i_idev)
			in6_dev_hold(rt->rt6i_idev);

		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_free(new);
	}

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
199
92.56%
7
53.85%
Martin KaFai Lau
8
3.72%
1
7.69%
Steffen Klassert
4
1.86%
1
7.69%
Alexey Dobriyan
1
0.47%
1
7.69%
Herbert Xu
1
0.47%
1
7.69%
Gao Feng
1
0.47%
1
7.69%
Eric W. Biedermann
1
0.47%
1
7.69%
Total
215
100.00%
13
100.00%

/*
 *      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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
55
100.00%
1
100.00%
Total
55
100.00%
1
100.00%



static struct dst_entry *rt6_check(struct rt6_info *rt, u32 cookie)
{
	if (!rt->rt6i_node || (rt->rt6i_node->fn_sernum != cookie))
		return NULL;

	if (rt6_check_expired(rt))
		return NULL;

	return &rt->dst;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
29
55.77%
3
50.00%
Hannes Frederic Sowa
11
21.15%
1
16.67%
Martin KaFai Lau
10
19.23%
1
16.67%
Nicolas Dichtel
2
3.85%
1
16.67%
Total
52
100.00%
6
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
60
100.00%
2
100.00%
Total
60
100.00%
2
100.00%



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(dst->flags & DST_NOCACHE) && rt->dst.from))
		return rt6_dst_from_check(rt, cookie);
	else
		return rt6_check(rt, cookie);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
75
96.15%
4
66.67%
Hannes Frederic Sowa
2
2.56%
1
16.67%
Linus Torvalds (pre-git)
1
1.28%
1
16.67%
Total
78
100.00%
6
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
52
70.27%
3
75.00%
Hideaki Yoshifuji / 吉藤英明
22
29.73%
1
25.00%
Total
74
100.00%
4
100.00%



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) {
			dst_hold(&rt->dst);
			ip6_del_rt(rt);
		} else if (rt->rt6i_node && (rt->rt6i_flags & RTF_DEFAULT)) {
			rt->rt6i_node->fn_sernum = -1;
		}
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
78
82.98%
2
50.00%
Hannes Frederic Sowa
13
13.83%
1
25.00%
Eric Dumazet
3
3.19%
1
25.00%
Total
94
100.00%
4
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
51
96.23%
1
50.00%
Alexey Kuznetsov
2
3.77%
1
50.00%
Total
53
100.00%
2
100.00%



static bool rt6_cache_allowed_for_pmtu(const struct rt6_info *rt)
{
	return !(rt->rt6i_flags & RTF_CACHE) &&
		(rt->rt6i_flags & RTF_PCPU || rt->rt6i_node);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
34
100.00%
1
100.00%
Total
34
100.00%
1
100.00%



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 (rt6->rt6i_flags & RTF_LOCAL)
		return;

	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);
		}
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
82
39.42%
2
25.00%
Julian Anastasov
72
34.62%
1
12.50%
Alexey Kuznetsov
25
12.02%
1
12.50%
David S. Miller
15
7.21%
2
25.00%
Xin Long
10
4.81%
1
12.50%
Shirley Ma
4
1.92%
1
12.50%
Total
208
100.00%
8
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
42
100.00%
1
100.00%
Total
42
100.00%
1
100.00%



void ip6_update_pmtu(struct sk_buff *skb, struct net *net, __be32 mtu,
		     int oif, u32 mark, kuid_t uid)
{
	const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
	struct dst_entry *dst;
	struct flowi6 fl6;

	memset(&fl6, 0, sizeof(fl6));
	fl6.flowi6_oif = oif;
	fl6.flowi6_mark = mark ? mark : IP6_REPLY_MARK(net, skb->mark);
	fl6.daddr = iph->daddr;
	fl6.saddr = iph->saddr;
	fl6.flowlabel = ip6_flowinfo(iph);
	fl6.flowi6_uid = uid;

	dst = ip6_route_output(net, NULL, &fl6);
	if (!dst->error)
		__ip6_rt_update_pmtu(dst, NULL, iph, ntohl(mtu));
	dst_release(dst);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
130
83.33%
3
37.50%
Lorenzo Colitti
20
12.82%
2
25.00%
Hideaki Yoshifuji / 吉藤英明
3
1.92%
1
12.50%
Martin KaFai Lau
2
1.28%
1
12.50%
Alexey Kuznetsov
1
0.64%
1
12.50%
Total
156
100.00%
8
100.00%


EXPORT_SYMBOL_GPL(ip6_update_pmtu);



void ip6_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, __be32 mtu)
{
	struct dst_entry *dst;

	ip6_update_pmtu(skb, sock_net(sk), mtu,
			sk->sk_bound_dev_if, sk->sk_mark, sk->sk_uid);

	dst = __sk_dst_get(sk);
	if (!dst || !dst->obsolete ||
	    dst->ops->check(dst, inet6_sk(sk)->dst_cookie))
		return;

	bh_lock_sock(sk);
	if (!sock_owned_by_user(sk) && !ipv6_addr_v4mapped(&sk->sk_v6_daddr))
		ip6_datagram_dst_update(sk, false);
	bh_unlock_sock(sk);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
73
63.48%
1
25.00%
David S. Miller
37
32.17%
1
25.00%
Lorenzo Colitti
4
3.48%
1
25.00%
Alexey Kuznetsov
1
0.87%
1
25.00%
Total
115
100.00%
4
100.00%


EXPORT_SYMBOL_GPL(ip6_sk_update_pmtu);

/* Handle redirects */

struct ip6rd_flowi {
	
struct flowi6 fl6;
	
struct in6_addr gateway;
};



static struct rt6_info *__ip6_route_redirect(struct net *net,
					     struct fib6_table *table,
					     struct flowi6 *fl6,
					     int flags)
{
	struct ip6rd_flowi *rdfl = (struct ip6rd_flowi *)fl6;
	struct rt6_info *rt;
	struct fib6_node *fn;

	/* Get the "current" route for this destination and
         * check if the redirect has come from appropriate router.
         *
         * RFC 4861 specifies that redirects should only be
         * accepted if they come from the nexthop to the target.
         * Due to the way the routes are chosen, this notion
         * is a bit fuzzy and one might need to check all possible
         * routes.
         */

	read_lock_bh(&table->tb6_lock);
	fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr);
restart:
	for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
		if (rt6_check_expired(rt))
			continue;
		if (rt->dst.error)
			break;
		if (!(rt->rt6i_flags & RTF_GATEWAY))
			continue;
		if (fl6->flowi6_oif != rt->dst.dev->ifindex)
			continue;
		if (!ipv6_addr_equal(&rdfl->gateway, &rt->rt6i_gateway))
			continue;
		break;
	}

	if (!rt)
		rt = net->ipv6.ip6_null_entry;
	else if (rt->dst.error) {
		rt = net->ipv6.ip6_null_entry;
		goto out;
	}

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

out:
	dst_hold(&rt->dst);

	read_unlock_bh(&table->tb6_lock);

	trace_fib6_table_lookup(net, rt, table->tb6_id, fl6);
	return rt;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Duan Jiong
219
83.91%
1
20.00%
Martin KaFai Lau
28
10.73%
2
40.00%
David Ahern
13
4.98%
1
20.00%
Alexander Alemayhu
1
0.38%
1
20.00%
Total
261
100.00%
5
100.00%

;



static struct dst_entry *ip6_route_redirect(struct net *net,
					const struct flowi6 *fl6,
					const struct in6_addr *gateway)
{
	int flags = RT6_LOOKUP_F_HAS_SADDR;
	struct ip6rd_flowi rdfl;

	rdfl.fl6 = *fl6;
	rdfl.gateway = *gateway;

	return fib6_rule_lookup(net, &rdfl.fl6,
				flags, __ip6_route_redirect);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Duan Jiong
63
100.00%
1
100.00%
Total
63
100.00%
1
100.00%



void ip6_redirect(struct sk_buff *skb, struct net *net, int oif, u32 mark,
		  kuid_t uid)
{
	const struct ipv6hdr *iph = (struct ipv6hdr *) skb->data;
	struct dst_entry *dst;
	struct flowi6 fl6;

	memset(&fl6, 0, sizeof(fl6));
	fl6.flowi6_iif = LOOPBACK_IFINDEX;
	fl6.flowi6_oif = oif;
	fl6.flowi6_mark = mark;
	fl6.daddr = iph->daddr;
	fl6.saddr = iph->saddr;
	fl6.flowlabel = ip6_flowinfo(iph);
	fl6.flowi6_uid = uid;

	dst = ip6_route_redirect(net, &fl6, &ipv6_hdr(skb)->saddr);
	rt6_do_redirect(dst, NULL, skb);
	dst_release(dst);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
115
80.99%
2
33.33%
Lorenzo Colitti
9
6.34%
1
16.67%
Duan Jiong
9
6.34%
1
16.67%
Julian Anastasov
6
4.23%
1
16.67%
Hideaki Yoshifuji / 吉藤英明
3
2.11%
1
16.67%
Total
142
100.00%
6
100.00%


EXPORT_SYMBOL_GPL(ip6_redirect);



void ip6_redirect_no_header(struct sk_buff *skb, struct net *net, int oif,
			    u32 mark)
{
	const struct ipv6hdr *iph = ipv6_hdr(skb);
	const struct rd_msg *msg = (struct rd_msg *)icmp6_hdr(skb);
	struct dst_entry *dst;
	struct flowi6 fl6;

	memset(&fl6, 0, sizeof(fl6));
	fl6.flowi6_iif = LOOPBACK_IFINDEX;
	fl6.flowi6_oif = oif;
	fl6.flowi6_mark = mark;
	fl6.daddr = msg->dest;
	fl6.saddr = iph->daddr;
	fl6.flowi6_uid = sock_net_uid(net, NULL);

	dst = ip6_route_redirect(net, &fl6, &iph->saddr);
	rt6_do_redirect(dst, NULL, skb);
	dst_release(dst);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Duan Jiong
127
88.19%
2
50.00%
Lorenzo Colitti
11
7.64%
1
25.00%
Julian Anastasov
6
4.17%
1
25.00%
Total
144
100.00%
4
100.00%



void ip6_sk_redirect(struct sk_buff *skb, struct sock *sk)
{
	ip6_redirect(skb, sock_net(sk), sk->sk_bound_dev_if, sk->sk_mark,
		     sk->sk_uid);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
33
89.19%
1
50.00%
Lorenzo Colitti
4
10.81%
1
50.00%
Total
37
100.00%
2
100.00%


EXPORT_SYMBOL_GPL(ip6_sk_redirect);



static unsigned int ip6_default_advmss(const struct dst_entry *dst)
{
	struct net_device *dev = dst->dev;
	unsigned int mtu = dst_mtu(dst);
	struct net *net = dev_net(dev);

	mtu -= sizeof(struct ipv6hdr) + sizeof(struct tcphdr);

	if (mtu < net->ipv6.sysctl.ip6_rt_min_advmss)
		mtu = net->ipv6.sysctl.ip6_rt_min_advmss;

	/*
         * Maximal non-jumbo IPv6 payload is IPV6_MAXPLEN and
         * corresponding MSS is IPV6_MAXPLEN - tcp_header_size.
         * IPV6_MAXPLEN is also valid and means: "any MSS,
         * rely only on pmtu discovery"
         */
	if (mtu > IPV6_MAXPLEN - sizeof(struct tcphdr))
		mtu = IPV6_MAXPLEN;
	return mtu;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Al Viro
44
45.36%
1
16.67%
David S. Miller
31
31.96%
1
16.67%
Daniel Lezcano
14
14.43%
2
33.33%
Shirley Ma
7
7.22%
1
16.67%
Hideaki Yoshifuji / 吉藤英明
1
1.03%
1
16.67%
Total
97
100.00%
6
100.00%



static unsigned int ip6_mtu(const struct dst_entry *dst)
{
	const struct rt6_info *rt = (const struct rt6_info *)dst;
	unsigned int mtu = rt->rt6i_pmtu;
	struct inet6_dev *idev;

	if (mtu)
		goto out;

	mtu = dst_metric_raw(dst, RTAX_MTU);
	if (mtu)
		goto out;

	mtu = IPV6_MIN_MTU;

	rcu_read_lock();
	idev = __in6_dev_get(dst->dev);
	if (idev)
		mtu = idev->cnf.mtu6;
	rcu_read_unlock();

out:
	mtu = min_t(unsigned int, mtu, IP6_MAX_MTU);

	return mtu - lwtunnel_headroom(dst->lwtstate, mtu);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
43
36.13%
1
16.67%
Martin KaFai Lau
30
25.21%
1
16.67%
Steffen Klassert
19
15.97%
2
33.33%
Roopa Prabhu
14
11.76%
1
16.67%
Eric Dumazet
13
10.92%
1
16.67%
Total
119
100.00%
6
100.00%


static struct dst_entry *icmp6_dst_gc_list;
static DEFINE_SPINLOCK(icmp6_dst_lock);



struct dst_entry *icmp6_dst_alloc(struct net_device *dev,
				  struct flowi6 *fl6)
{
	struct dst_entry *dst;
	struct rt6_info *rt;
	struct inet6_dev *idev = in6_dev_get(dev);
	struct net *net = dev_net(dev);

	if (unlikely(!idev))
		return ERR_PTR(-ENODEV);

	rt = ip6_dst_alloc(net, dev, 0);
	if (unlikely(!rt)) {
		in6_dev_put(idev);
		dst = ERR_PTR(-ENOMEM);
		goto out;
	}

	rt->dst.flags |= DST_HOST;
	rt->dst.output  = ip6_output;
	atomic_set(&rt->dst.__refcnt, 1);
	rt->rt6i_gateway  = fl6->daddr;
	rt->rt6i_dst.addr = fl6->daddr;
	rt->rt6i_dst.plen = 128;
	rt->rt6i_idev     = idev;
	dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);

	spin_lock_bh(&icmp6_dst_lock);
	rt->dst.next = icmp6_dst_gc_list;
	icmp6_dst_gc_list = &rt->dst;
	spin_unlock_bh(&icmp6_dst_lock);

	fib6_force_start_gc(net);

	dst = xfrm_lookup(net, &rt->dst, flowi6_to_flowi(fl6), NULL, 0);

out:
	return dst;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
118
51.53%
5
21.74%
Hideaki Yoshifuji / 吉藤英明
35
15.28%
5
21.74%
Zheng Yan
24
10.48%
1
4.35%
Gao Feng
11
4.80%
1
4.35%
Daniel Lezcano
10
4.37%
2
8.70%
Julian Anastasov
8
3.49%
1
4.35%
Patrick McHardy
7
3.06%
1
4.35%
Eric Dumazet
5
2.18%
1
4.35%
Benjamin Thery
3
1.31%
1
4.35%
Shirley Ma
3
1.31%
1
4.35%
Thomas Graf
2
0.87%
1
4.35%
Li RongQing
1
0.44%
1
4.35%
Alexey Dobriyan
1
0.44%
1
4.35%
Kazunori Miyazawa
1
0.44%
1
4.35%
Total
229
100.00%
23
100.00%



int icmp6_dst_gc(void)
{
	struct dst_entry *dst, **pprev;
	int more = 0;

	spin_lock_bh(&icmp6_dst_lock);
	pprev = &icmp6_dst_gc_list;

	while ((dst = *pprev) != NULL) {
		if (!atomic_read(&dst->__refcnt)) {
			*pprev = dst->next;
			dst_free(dst);
		} else {
			pprev = &dst->next;
			++more;
		}
	}

	spin_unlock_bh(&icmp6_dst_lock);

	return more;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
72
78.26%
1
25.00%
Thomas Graf
10
10.87%
1
25.00%
Stephen Hemminger
6
6.52%
1
25.00%
Hideaki Yoshifuji / 吉藤英明
4
4.35%
1
25.00%
Total
92
100.00%
4
100.00%



static void icmp6_clean_all(int (*func)(struct rt6_info *rt, void *arg),
			    void *arg)
{
	struct dst_entry *dst, **pprev;

	spin_lock_bh(&icmp6_dst_lock);
	pprev = &icmp6_dst_gc_list;
	while ((dst = *pprev) != NULL) {
		struct rt6_info *rt = (struct rt6_info *) dst;
		if (func(rt, arg)) {
			*pprev = dst->next;
			dst_free(dst);
		} else {
			pprev = &dst->next;
		}
	}
	spin_unlock_bh(&icmp6_dst_lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
110
100.00%
1
100.00%
Total
110
100.00%
1
100.00%



static int ip6_dst_gc(struct dst_ops *ops)
{
	struct net *net = container_of(ops, struct net, ipv6.ip6_dst_ops);
	int rt_min_interval = net->ipv6.sysctl.ip6_rt_gc_min_interval;
	int rt_max_size = net->ipv6.sysctl.ip6_rt_max_size;
	int rt_elasticity = net->ipv6.sysctl.ip6_rt_gc_elasticity;
	int rt_gc_timeout = net->ipv6.sysctl.ip6_rt_gc_timeout;
	unsigned long rt_last_gc = net->ipv6.ip6_rt_last_gc;
	int entries;

	entries = dst_entries_get_fast(ops);
	if (time_after(rt_last_gc + rt_min_interval, jiffies) &&
	    entries <= rt_max_size)
		goto out;

	net->ipv6.ip6_rt_gc_expire++;
	fib6_run_gc(net->ipv6.ip6_rt_gc_expire, net, true);
	entries = dst_entries_get_slow(ops);
	if (entries < ops->gc_thresh)
		net->ipv6.ip6_rt_gc_expire = rt_gc_timeout>>1;
out:
	net->ipv6.ip6_rt_gc_expire -= net->ipv6.ip6_rt_gc_expire>>rt_elasticity;
	return entries > rt_max_size;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Daniel Lezcano
68
38.64%
5
31.25%
Linus Torvalds (pre-git)
38
21.59%
3
18.75%
Benjamin Thery
36
20.45%
1
6.25%
Eric Dumazet
17
9.66%
1
6.25%
Alexey Dobriyan
10
5.68%
1
6.25%
Randy Dunlap
2
1.14%
1
6.25%
Michal Kubeček
2
1.14%
2
12.50%
Arnaldo Carvalho de Melo
2
1.14%
1
6.25%
Li RongQing
1
0.57%
1
6.25%
Total
176
100.00%
16
100.00%



static int ip6_convert_metrics(struct mx6_config *mxc,
			       const struct fib6_config *cfg)
{
	bool ecn_ca = false;
	struct nlattr *nla;
	int remaining;
	u32 *mp;

	if (!cfg->fc_mx)
		return 0;

	mp = kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);
	if (unlikely(!mp))
		return -ENOMEM;

	nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {
		int type = nla_type(nla);
		u32 val;

		if (!type)
			continue;
		if (unlikely(type > RTAX_MAX))
			goto err;

		if (type == RTAX_CC_ALGO) {
			char tmp[TCP_CA_NAME_MAX];

			nla_strlcpy(tmp, nla, sizeof(tmp));
			val = tcp_ca_get_key_by_name(tmp, &ecn_ca);
			if (val == TCP_CA_UNSPEC)
				goto err;
		} else {
			val = nla_get_u32(nla);
		}
		if (type == RTAX_HOPLIMIT && val > 255)
			val = 255;
		if (type == RTAX_FEATURES && (val & ~RTAX_FEATURE_MASK))
			goto err;

		mp[type - 1] = val;
		__set_bit(type - 1, mxc->mx_valid);
	}

	if (ecn_ca) {
		__set_bit(RTAX_FEATURES - 1, mxc->mx_valid);
		mp[RTAX_FEATURES - 1] |= DST_FEATURE_ECN_CA;
	}

	mxc->mx = mp;
	return 0;
 err:
	kfree(mp);
	return -EINVAL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Florian Westphal
139
53.05%
1
14.29%
Daniel Borkmann
108
41.22%
4
57.14%
Paolo Abeni
14
5.34%
1
14.29%
Ian Morris
1
0.38%
1
14.29%
Total
262
100.00%
7
100.00%



static struct rt6_info *ip6_nh_lookup_table(struct net *net,
					    struct fib6_config *cfg,
					    const struct in6_addr *gw_addr)
{
	struct flowi6 fl6 = {
		.flowi6_oif = cfg->fc_ifindex,
		.daddr = *gw_addr,
		.saddr = cfg->fc_prefsrc,
        };
	struct fib6_table *table;
	struct rt6_info *rt;
	int flags = RT6_LOOKUP_F_IFACE | RT6_LOOKUP_F_IGNORE_LINKSTATE;

	table = fib6_get_table(net, cfg->fc_table);
	if (!table)
		return NULL;

	if (!ipv6_addr_any(&cfg->fc_prefsrc))
		flags |= RT6_LOOKUP_F_HAS_SADDR;

	rt = ip6_pol_route(net, table, cfg->fc_ifindex, &fl6, flags);

	/* if table lookup failed, fall back to full lookup */
	if (rt == net->ipv6.ip6_null_entry) {
		ip6_rt_put(rt);
		rt = NULL;
	}

	return rt;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Ahern
143
99.31%
2
66.67%
Paolo Abeni
1
0.69%
1
33.33%
Total
144
100.00%
3
100.00%



static struct rt6_info *ip6_route_info_create(struct fib6_config *cfg)
{
	struct net *net = cfg->fc_nlinfo.nl_net;
	struct rt6_info *rt = NULL;
	struct net_device *dev = NULL;
	struct inet6_dev *idev = NULL;
	struct fib6_table *table;
	int addr_type;
	int err = -EINVAL;

	/* RTF_PCPU is an internal flag; can not be set by userspace */
	if (cfg->fc_flags & RTF_PCPU)
		goto out;

	if (cfg->fc_dst_len > 128 || cfg->fc_src_len > 128)
		goto out;
#ifndef CONFIG_IPV6_SUBTREES
	if (cfg->fc_src_len)
		goto out;
#endif
	if (cfg->fc_ifindex) {
		err = -ENODEV;
		dev = dev_get_by_index(net, cfg->fc_ifindex);
		if (!dev)
			goto out;
		idev = in6_dev_get(dev);
		if (!idev)
			goto out;
	}

	if (cfg->fc_metric == 0)
		cfg->fc_metric = IP6_RT_PRIO_USER;

	err = -ENOBUFS;
	if (cfg->fc_nlinfo.nlh &&
	    !(cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_CREATE)) {
		table = fib6_get_table(net, cfg->fc_table);
		if (!table) {
			pr_warn("NLM_F_CREATE should be specified when creating new route\n");
			table = fib6_new_table(net, cfg->fc_table);
		}
	} else {
		table = fib6_new_table(net, cfg->fc_table);
	}

	if (!table)
		goto out;

	rt = ip6_dst_alloc(net, NULL,
			   (cfg->fc_flags & RTF_ADDRCONF) ? 0 : DST_NOCOUNT);

	if (!rt) {
		err = -ENOMEM;
		goto out;
	}

	if (cfg->fc_flags & RTF_EXPIRES)
		rt6_set_expires(rt, jiffies +
				clock_t_to_jiffies(cfg->fc_expires));
	else
		rt6_clean_expires(rt);

	if (cfg->fc_protocol == RTPROT_UNSPEC)
		cfg->fc_protocol = RTPROT_BOOT;
	rt->rt6i_protocol = cfg->fc_protocol;

	addr_type = ipv6_addr_type(&cfg->fc_dst);

	if (addr_type & IPV6_ADDR_MULTICAST)
		rt->dst.input = ip6_mc_input;
	else if (cfg->fc_flags & RTF_LOCAL)
		rt->dst.input = ip6_input;
	else
		rt->dst.input = ip6_forward;

	rt->dst.output = ip6_output;

	if (cfg->fc_encap) {
		struct lwtunnel_state *lwtstate;

		err = lwtunnel_build_state(cfg->fc_encap_type,
					   cfg->fc_encap, AF_INET6, cfg,
					   &lwtstate);
		if (err)
			goto out;
		rt->dst.lwtstate = lwtstate_get(lwtstate);
		if (lwtunnel_output_redirect(rt->dst.lwtstate)) {
			rt->dst.lwtstate->orig_output = rt->dst.output;
			rt->dst.output = lwtunnel_output;
		}
		if (lwtunnel_input_redirect(rt->dst.lwtstate)) {
			rt->dst.lwtstate->orig_input = rt->dst.input;
			rt->dst.input = lwtunnel_input;
		}
	}

	ipv6_addr_prefix(&rt->rt6i_dst.addr, &cfg->fc_dst, cfg->fc_dst_len);
	rt->rt6i_dst.plen = cfg->fc_dst_len;
	if (rt->rt6i_dst.plen == 128)
		rt->dst.flags |= DST_HOST;

#ifdef CONFIG_IPV6_SUBTREES
	ipv6_addr_prefix(&rt->rt6i_src.addr, &cfg->fc_src, cfg->fc_src_len);
	rt->rt6i_src.plen = cfg->fc_src_len;
#endif

	rt->rt6i_metric = cfg->fc_metric;

	/* We cannot add true routes via loopback here,
           they would result in kernel looping; promote them to reject routes
         */
	if ((cfg->fc_flags & RTF_REJECT) ||
	    (dev && (dev->flags & IFF_LOOPBACK) &&
	     !(addr_type & IPV6_ADDR_LOOPBACK) &&
	     !(cfg->fc_flags & RTF_LOCAL))) {
		/* hold loopback dev/idev if we haven't done so. */
		if (dev != net->loopback_dev) {
			if (dev) {
				dev_put(dev);
				in6_dev_put(idev);
			}
			dev = net->loopback_dev;
			dev_hold(dev);
			idev = in6_dev_get(dev);
			if (!idev) {
				err = -ENODEV;
				goto out;
			}
		}
		rt->rt6i_flags = RTF_REJECT|RTF_NONEXTHOP;
		switch (cfg->fc_type) {
		case RTN_BLACKHOLE:
			rt->dst.error = -EINVAL;
			rt->dst.output = dst_discard_out;
			rt->dst.input = dst_discard;
			break;
		case RTN_PROHIBIT:
			rt->dst.error = -EACCES;
			rt->dst.output = ip6_pkt_prohibit_out;
			rt->dst.input = ip6_pkt_prohibit;
			break;
		case RTN_THROW:
		case RTN_UNREACHABLE:
		default:
			rt->dst.error = (cfg->fc_type == RTN_THROW) ? -EAGAIN
					: (cfg->fc_type == RTN_UNREACHABLE)
					? -EHOSTUNREACH : -ENETUNREACH;
			rt->dst.output = ip6_pkt_discard_out;
			rt->dst.input = ip6_pkt_discard;
			break;
		}
		goto install_route;
	}

	if (cfg->fc_flags & RTF_GATEWAY) {
		const struct in6_addr *gw_addr;
		int gwa_type;

		gw_addr = &cfg->fc_gateway;
		gwa_type = ipv6_addr_type(gw_addr);

		/* if gw_addr is local we will fail to detect this in case
                 * address is still TENTATIVE (DAD in progress). rt6_lookup()
                 * will return already-added prefix route via interface that
                 * prefix route was assigned to, which might be non-loopback.
                 */
		err = -EINVAL;
		if (ipv6_chk_addr_and_flags(net, gw_addr,
					    gwa_type & IPV6_ADDR_LINKLOCAL ?
					    dev : NULL, 0, 0))
			goto out;

		rt->rt6i_gateway = *gw_addr;

		if (gwa_type != (IPV6_ADDR_LINKLOCAL|IPV6_ADDR_UNICAST)) {
			struct rt6_info *grt = NULL;

			/* IPv6 strictly inhibits using not link-local
                           addresses as nexthop address.
                           Otherwise, router will not able to send redirects.
                           It is very good, but in some (rare!) circumstances
                           (SIT, PtP, NBMA NOARP links) it is handy to allow
                           some exceptions. --ANK
                           We allow IPv4-mapped nexthops to support RFC4798-type
                           addressing
                         */
			if (!(gwa_type & (IPV6_ADDR_UNICAST |
					  IPV6_ADDR_MAPPED)))
				goto out;

			if (cfg->fc_table) {
				grt = ip6_nh_lookup_table(net, cfg, gw_addr);

				if (grt) {
					if (grt->rt6i_flags & RTF_GATEWAY ||
					    (dev && dev != grt->dst.dev)) {
						ip6_rt_put(grt);
						grt = NULL;
					}
				}
			}

			if (!grt)
				grt = rt6_lookup(net, gw_addr, NULL,
						 cfg->fc_ifindex, 1);

			err = -EHOSTUNREACH;
			if (!grt)
				goto out;
			if (dev) {
				if (dev != grt->dst.dev) {
					ip6_rt_put(grt);
					goto out;
				}
			} else {
				dev = grt->dst.dev;
				idev = grt->rt6i_idev;
				dev_hold(dev);
				in6_dev_hold(grt->rt6i_idev);
			}
			if (!(grt->rt6i_flags & RTF_GATEWAY))
				err = 0;
			ip6_rt_put(grt);

			if (err)
				goto out;
		}
		err = -EINVAL;
		if (!dev || (dev->flags & IFF_LOOPBACK))
			goto out;
	}

	err = -ENODEV;
	if (!dev)
		goto out;

	if (!ipv6_addr_any(&cfg->fc_prefsrc)) {
		if (!ipv6_chk_addr(net, &cfg->fc_prefsrc, dev, 0)) {
			err = -EINVAL;
			goto out;
		}
		rt->rt6i_prefsrc.addr = cfg->fc_prefsrc;
		rt->rt6i_prefsrc.plen = 128;
	} else
		rt->rt6i_prefsrc.plen = 0;

	rt->rt6i_flags = cfg->fc_flags;

install_route:
	rt->dst.dev = dev;
	rt->rt6i_idev = idev;
	rt->rt6i_table = table;

	cfg->fc_nlinfo.nl_net = dev_net(dev);

	return rt;
out:
	if (dev)
		dev_put(dev);
	if (idev)
		in6_dev_put(idev);
	if (rt)
		dst_free(&rt->dst);

	return ERR_PTR(err);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
419
32.33%
12
18.18%
Hideaki Yoshifuji / 吉藤英明
126
9.72%
8
12.12%
Roopa Prabhu
107
8.26%
4
6.06%
Thomas Graf
85
6.56%
2
3.03%
Daniel Walter
64
4.94%
1
1.52%
Matti Vaittinen
60
4.63%
1
1.52%
Nicolas Dichtel
60
4.63%
4
6.06%
Kamala R
53
4.09%
1
1.52%
Tom Herbert
45
3.47%
2
3.03%
Vincent Bernat
39
3.01%
1
1.52%
Florian Westphal
37
2.85%
2
3.03%
David Ahern
36
2.78%
2
3.03%
Daniel Lezcano
28
2.16%
4
6.06%
Maciej Żenczykowski
26
2.01%
1
1.52%
David S. Miller
18
1.39%
6
9.09%
Jiri Benc
17
1.31%
1
1.52%
Nikola Forró
14
1.08%
1
1.52%
Gao Feng
14
1.08%
1
1.52%
Mathew Richardson
11
0.85%
1
1.52%
Sabrina Dubroca
10
0.77%
1
1.52%
Patrick McHardy
8
0.62%
1
1.52%
Erik Nordmark
5
0.39%
1
1.52%
Alexey Dobriyan
3
0.23%
1
1.52%
Benjamin Thery
3
0.23%
1
1.52%
Américo Wang
2
0.15%
1
1.52%
Joe Perches
2
0.15%
1
1.52%
Eric W. Biedermann
2
0.15%
2
3.03%
Jamal Hadi Salim
1
0.08%
1
1.52%
Eric Dumazet
1
0.08%
1
1.52%
Total
1296
100.00%
66
100.00%



int ip6_route_add(struct fib6_config *cfg)
{
	struct mx6_config mxc = { .mx = NULL, };
	struct rt6_info *rt;
	int err;

	rt = ip6_route_info_create(cfg);
	if (IS_ERR(rt)) {
		err = PTR_ERR(rt);
		rt = NULL;
		goto out;
	}

	err = ip6_convert_metrics(&mxc, cfg);
	if (err)
		goto out;

	err = __ip6_ins_rt(rt, &cfg->fc_nlinfo, &mxc);

	kfree(mxc.mx);

	return err;
out:
	if (rt)
		dst_free(&rt->dst);

	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Roopa Prabhu
58
49.15%
2
14.29%
Florian Westphal
31
26.27%
1
7.14%
Linus Torvalds (pre-git)
17
14.41%
5
35.71%
Thomas Graf
5
4.24%
2
14.29%
Hideaki Yoshifuji / 吉藤英明
3
2.54%
1
7.14%
Patrick McHardy
2
1.69%
1
7.14%
Michal Kubeček
1
0.85%
1
7.14%
Mathew Richardson
1
0.85%
1
7.14%
Total
118
100.00%
14
100.00%



static int __ip6_del_rt(struct rt6_info *rt, struct nl_info *info)
{
	int err;
	struct fib6_table *table;
	struct net *net = dev_net(rt->dst.dev);

	if (rt == net->ipv6.ip6_null_entry ||
	    rt->dst.flags & DST_NOCACHE) {
		err = -ENOENT;
		goto out;
	}

	table = rt->rt6i_table;
	write_lock_bh(&table->tb6_lock);
	err = fib6_del(rt, info);
	write_unlock_bh(&table->tb6_lock);

out:
	ip6_rt_put(rt);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
30
28.04%
4
23.53%
Thomas Graf
19
17.76%
3
17.65%
Gao Feng
14
13.08%
1
5.88%
Daniel Lezcano
12
11.21%
1
5.88%
Martin KaFai Lau
8
7.48%
1
5.88%
Patrick McHardy
8
7.48%
1
5.88%
Herbert Xu
5
4.67%
1
5.88%
Hideaki Yoshifuji / 吉藤英明
3
2.80%
1
5.88%
David S. Miller
3
2.80%
1
5.88%
Mathew Richardson
3
2.80%
1
5.88%
Américo Wang
1
0.93%
1
5.88%
Jamal Hadi Salim
1
0.93%
1
5.88%
Total
107
100.00%
17
100.00%



int ip6_del_rt(struct rt6_info *rt)
{
	struct nl_info info = {
		.nl_net = dev_net(rt->dst.dev),
        };
	return __ip6_del_rt(rt, &info);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Thomas Graf
17
45.95%
1
16.67%
Denis V. Lunev
12
32.43%
2
33.33%
David S. Miller
3
8.11%
1
16.67%
Hideaki Yoshifuji / 吉藤英明
3
8.11%
1
16.67%
Daniel Lezcano
2
5.41%
1
16.67%
Total
37
100.00%
6
100.00%



static int __ip6_del_rt_siblings(struct rt6_info *rt, struct fib6_config *cfg)
{
	struct nl_info *info = &cfg->fc_nlinfo;
	struct net *net = info->nl_net;
	struct sk_buff *skb = NULL;
	struct fib6_table *table;
	int err = -ENOENT;

	if (rt == net->ipv6.ip6_null_entry)
		goto out_put;
	table = rt->rt6i_table;
	write_lock_bh(&table->tb6_lock);

	if (rt->rt6i_nsiblings && cfg->fc_delete_all_nh) {
		struct rt6_info *sibling, *next_sibling;

		/* prefer to send a single notification with all hops */
		skb = nlmsg_new(rt6_nlmsg_size(rt), gfp_any());
		if (skb) {
			u32 seq = info->nlh ? info->nlh->nlmsg_seq : 0;

			if (rt6_fill_node(net, skb, rt,
					  NULL, NULL, 0, RTM_DELROUTE,
					  info->portid, seq, 0) < 0) {
				kfree_skb(skb);
				skb = NULL;
			} else
				info->skip_notify = 1;
		}

		list_for_each_entry_safe(sibling, next_sibling,
					 &rt->rt6i_siblings,
					 rt6i_siblings) {
			err = fib6_del(sibling, info);
			if (err)
				goto out_unlock;
		}
	}

	err = fib6_del(rt, info);
out_unlock:
	write_unlock_bh(&table->tb6_lock);
out_put:
	ip6_rt_put(rt);

	if (skb) {
		rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
			    info->nlh, gfp_any());
	}
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Ahern
234
88.30%
2
66.67%
Américo Wang
31
11.70%
1
33.33%
Total
265
100.00%
3
100.00%



static int ip6_route_del(struct fib6_config *cfg)
{
	struct fib6_table *table;
	struct fib6_node *fn;
	struct rt6_info *rt;
	int err = -ESRCH;

	table = fib6_get_table(cfg->fc_nlinfo.nl_net, cfg->fc_table);
	if (!table)
		return err;

	read_lock_bh(&table->tb6_lock);

	fn = fib6_locate(&table->tb6_root,
			 &cfg->fc_dst, cfg->fc_dst_len,
			 &cfg->fc_src, cfg->fc_src_len);

	if (fn) {
		for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
			if ((rt->rt6i_flags & RTF_CACHE) &&
			    !(cfg->fc_flags & RTF_CACHE))
				continue;
			if (cfg->fc_ifindex &&
			    (!rt->dst.dev ||
			     rt->dst.dev->ifindex != cfg->fc_ifindex))
				continue;
			if (cfg->fc_flags & RTF_GATEWAY &&
			    !ipv6_addr_equal(&cfg->fc_gateway, &rt->rt6i_gateway))
				continue;
			if (cfg->fc_metric && cfg->fc_metric != rt->rt6i_metric)
				continue;
			if (cfg->fc_protocol && cfg->fc_protocol != rt->rt6i_protocol)
				continue;
			dst_hold(&rt->dst);
			read_unlock_bh(&table->tb6_lock);

			/* if gateway was specified only delete the one hop */
			if (cfg->fc_flags & RTF_GATEWAY)
				return __ip6_del_rt(rt, &cfg->fc_nlinfo);

			return __ip6_del_rt_siblings(rt, cfg);
		}
	}
	read_unlock_bh(&table->tb6_lock);

	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
138
50.55%
9
36.00%
Thomas Graf
60
21.98%
3
12.00%
Martin KaFai Lau
20
7.33%
1
4.00%
David Ahern
17
6.23%
1
4.00%
Mantas M
15
5.49%
1
4.00%
David S. Miller
8
2.93%
2
8.00%
Daniel Lezcano
6
2.20%
2
8.00%
Eric Dumazet
3
1.10%
1
4.00%
Hideaki Yoshifuji / 吉藤英明
2
0.73%
1
4.00%
James Morris
1
0.37%
1
4.00%
Stephen Rothwell
1
0.37%
1
4.00%
Jamal Hadi Salim
1
0.37%
1
4.00%
Mathew Richardson
1
0.37%
1
4.00%
Total
273
100.00%
25
100.00%



static void rt6_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
{
	struct netevent_redirect netevent;
	struct rt6_info *rt, *nrt = NULL;
	struct ndisc_options ndopts;
	struct inet6_dev *in6_dev;
	struct neighbour *neigh;
	struct rd_msg *msg;
	int optlen, on_link;
	u8 *lladdr;

	optlen = skb_tail_pointer(skb) - skb_transport_header(skb);
	optlen -= sizeof(*msg);

	if (optlen < 0) {
		net_dbg_ratelimited("rt6_do_redirect: packet too short\n");
		return;
	}

	msg = (struct rd_msg *)icmp6_hdr(skb);

	if (ipv6_addr_is_multicast(&msg->dest)) {
		net_dbg_ratelimited("rt6_do_redirect: destination address is multicast\n");
		return;
	}

	on_link = 0;
	if (ipv6_addr_equal(&msg->dest, &msg->target)) {
		on_link = 1;
	} else if (ipv6_addr_type(&msg->target) !=
		   (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
		net_dbg_ratelimited("rt6_do_redirect: target address is not link-local unicast\n");
		return;
	}

	in6_dev = __in6_dev_get(skb->dev);
	if (!in6_dev)
		return;
	if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects)
		return;

	/* RFC2461 8.1:
         *      The IP source address of the Redirect MUST be the same as the current
         *      first-hop router for the specified ICMP Destination Address.
         */

	if (!ndisc_parse_options(skb->dev, msg->opt, optlen, &ndopts)) {
		net_dbg_ratelimited("rt6_redirect: invalid ND options\n");
		return;
	}

	lladdr = NULL;
	if (ndopts.nd_opts_tgt_lladdr) {
		lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
					     skb->dev);
		if (!lladdr) {
			net_dbg_ratelimited("rt6_redirect: invalid link-layer address length\n");
			return;
		}
	}

	rt = (struct rt6_info *) dst;
	if (rt->rt6i_flags & RTF_REJECT) {
		net_dbg_ratelimited("rt6_redirect: source isn't a valid nexthop for redirect target\n");
		return;
	}

	/* Redirect received -> path was valid.
         * Look, redirects are sent only in response to data packets,
         * so that this nexthop apparently is reachable. --ANK
         */
	dst_confirm_neigh(&rt->dst, &ipv6_hdr(skb)->saddr);

	neigh = __neigh_lookup(&nd_tbl, &msg->target, skb->dev, 1);
	if (!neigh)
		return;

	/*
         *      We have finally decided to accept it.
         */

	ndisc_update(skb->dev, neigh, lladdr, NUD_STALE,
		     NEIGH_UPDATE_F_WEAK_OVERRIDE|
		     NEIGH_UPDATE_F_OVERRIDE|
		     (on_link ? 0 : (NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
				     NEIGH_UPDATE_F_ISROUTER)),
		     NDISC_REDIRECT, &ndopts);

	nrt = ip6_rt_cache_alloc(rt, &msg->dest, NULL);
	if (!nrt)
		goto out;

	nrt->rt6i_flags = RTF_GATEWAY|RTF_UP|RTF_DYNAMIC|RTF_CACHE;
	if (on_link)
		nrt->rt6i_flags &= ~RTF_GATEWAY;

	nrt->rt6i_gateway = *(struct in6_addr *)neigh->primary_key;

	if (ip6_ins_rt(nrt))
		goto out;

	netevent.old = &rt->dst;
	netevent.new = &nrt->dst;
	netevent.daddr = &msg->dest;
	netevent.neigh = neigh;
	call_netevent_notifiers(NETEVENT_REDIRECT, &netevent);

	if (rt->rt6i_flags & RTF_CACHE) {
		rt = (struct rt6_info *) dst_clone(&rt->dst);
		ip6_del_rt(rt);
	}

out:
	neigh_release(neigh);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
303
57.93%
5
20.00%
Hideaki Yoshifuji / 吉藤英明
77
14.72%
6
24.00%
Linus Torvalds (pre-git)
75
14.34%
5
20.00%
Tom Tucker
26
4.97%
1
4.00%
Alexander Aring
14
2.68%
1
4.00%
Julian Anastasov
9
1.72%
1
4.00%
Simon Horman
6
1.15%
1
4.00%
Martin KaFai Lau
3
0.57%
1
4.00%
Daniel Lezcano
3
0.57%
1
4.00%
Matthias Schiffer
3
0.57%
1
4.00%
Eric Dumazet
2
0.38%
1
4.00%
Alexey Dobriyan
2
0.38%
1
4.00%
Total
523
100.00%
25
100.00%

/*
 *      Misc support functions
 */



static void rt6_set_from(struct rt6_info *rt, struct rt6_info *from)
{
	BUG_ON(from->dst.from);

	rt->rt6i_flags &= ~RTF_EXPIRES;
	dst_hold(&from->dst);
	rt->dst.from = &from->dst;
	dst_init_metrics(&rt->dst, dst_metrics_ptr(&from->dst), true);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin KaFai Lau
69
100.00%
1
100.00%
Total
69
100.00%
1
100.00%



static void ip6_rt_copy_init(struct rt6_info *rt, struct rt6_info *ort)
{
	rt->dst.input = ort->dst.input;
	rt->dst.output = ort->dst.output;
	rt->rt6i_dst = ort->rt6i_dst;
	rt->dst.error = ort->dst.error;
	rt->rt6i_idev = ort->rt6i_idev;
	if (rt->rt6i_idev)
		in6_dev_hold(rt->rt6i_idev);
	rt->dst.lastuse = jiffies;
	rt->rt6i_gateway = ort->rt6i_gateway;
	rt->rt6i_flags = ort->rt6i_flags;
	rt6_set_from(rt, ort);
	rt->rt6i_metric = ort->rt6i_metric;
#ifdef CONFIG_IPV6_SUBTREES
	rt->rt6i_src = ort->rt6i_src;
#endif
	rt->rt6i_prefsrc = ort->rt6i_prefsrc;
	rt->rt6i_table = ort->rt6i_table;
	rt->dst.lwtstate = lwtstate_get(ort->dst.lwtstate);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
73
44.51%
5
26.32%
Hideaki Yoshifuji / 吉藤英明
21
12.80%
1
5.26%
Nicolas Dichtel
10
6.10%
2
10.53%
Martin KaFai Lau
10
6.10%
1
5.26%
Ville Nuorvala
10
6.10%
1
5.26%
Thomas Graf
8
4.88%
1
5.26%
Gao Feng
8
4.88%
1
5.26%
Florian Westphal
7
4.27%
1
5.26%
Jiri Benc
6
3.66%
1
5.26%
Eric Dumazet
5
3.05%
1
5.26%
Zheng Yan
2
1.22%
1
5.26%
Alexey Dobriyan
2
1.22%
1
5.26%
Benjamin Thery
1
0.61%
1
5.26%
David S. Miller
1
0.61%
1
5.26%
Total
164
100.00%
19
100.00%

#ifdef CONFIG_IPV6_ROUTE_INFO


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)
{
	u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_INFO;
	int ifindex = dev->ifindex;
	struct fib6_node *fn;
	struct rt6_info *rt = NULL;
	struct fib6_table *table;

	table = fib6_get_table(net, tb_id);
	if (!table)
		return NULL;

	read_lock_bh(&table->tb6_lock);
	fn = fib6_locate(&table->tb6_root, prefix, prefixlen, NULL, 0);
	if (!fn)
		goto out;

	for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
		if (rt->dst.dev->ifindex != ifindex)
			continue;
		if ((rt->rt6i_flags & (RTF_ROUTEINFO|RTF_GATEWAY)) != (RTF_ROUTEINFO|RTF_GATEWAY))
			continue;
		if (!ipv6_addr_equal(&rt->rt6i_gateway, gwaddr))
			continue;
		dst_hold(&rt->dst);
		break;
	}
out:
	read_unlock_bh(&table->tb6_lock);
	return rt;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Hideaki Yoshifuji / 吉藤英明
141
67.46%
1
10.00%
Thomas Graf
27
12.92%
1
10.00%
David Ahern
23
11.00%
1
10.00%
Daniel Lezcano
7
3.35%
2
20.00%
Eric Dumazet
5
2.39%
2
20.00%
David S. Miller
4
1.91%
2
20.00%
Li RongQing
2
0.96%
1
10.00%
Total
209
100.00%
10
100.00%



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)
{
	struct fib6_config cfg = {
		.fc_metric	= IP6_RT_PRIO_USER,
		.fc_ifindex	= dev->ifindex,
		.fc_dst_len	= prefixlen,
		.fc_flags	= RTF_GATEWAY | RTF_ADDRCONF | RTF_ROUTEINFO |
				  RTF_UP | RTF_PREF(pref),
		.fc_nlinfo.portid = 0,
		.fc_nlinfo.nlh = NULL,
		.fc_nlinfo.nl_net = net,
        };

	cfg.fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_INFO,
	cfg.fc_dst = *prefix;
	cfg.fc_gateway = *gwaddr;

	/* We should treat it as a default route if prefix length is 0. */
	if (!prefixlen)
		cfg.fc_flags |= RTF_DEFAULT;

	ip6_route_add(&cfg);

	return rt6_get_route_info(net, prefix, prefixlen, gwaddr, dev);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Hideaki Yoshifuji / 吉藤英明
72
46.45%
2
18.18%
Thomas Graf
28
18.06%
1
9.09%
Daniel Lezcano
27
17.42%
1
9.09%
David Ahern
19
12.26%
2
18.18%
Alexey Dobriyan
4
2.58%
1
9.09%
Eric Dumazet
3
1.94%
2
18.18%
Rami Rosen
1
0.65%
1
9.09%
Eric W. Biedermann
1
0.65%
1
9.09%
Total
155
100.00%
11
100.00%

#endif



struct rt6_info *rt6_get_dflt_router(const struct in6_addr *addr, struct net_device *dev)
{
	u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_DFLT;
	struct rt6_info *rt;
	struct fib6_table *table;

	table = fib6_get_table(dev_net(dev), tb_id);
	if (!table)
		return NULL;

	read_lock_bh(&table->tb6_lock);
	for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
		if (dev == rt->dst.dev &&
		    ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) &&
		    ipv6_addr_equal(&rt->rt6i_gateway, addr))
			break;
	}
	if (rt)
		dst_hold(&rt->dst);
	read_unlock_bh(&table->tb6_lock);
	return rt;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
82
53.59%
6
31.58%
Hideaki Yoshifuji / 吉藤英明
24
15.69%
3
15.79%
Thomas Graf
22
14.38%
1
5.26%
David Ahern
12
7.84%
1
5.26%
Eric Dumazet
4
2.61%
2
10.53%
David S. Miller
4
2.61%
2
10.53%
Li RongQing
2
1.31%
1
5.26%
Daniel Lezcano
2
1.31%
2
10.53%
James Morris
1
0.65%
1
5.26%
Total
153
100.00%
19
100.00%



struct rt6_info *rt6_add_dflt_router(const struct in6_addr *gwaddr,
				     struct net_device *dev,
				     unsigned int pref)
{
	struct fib6_config cfg = {
		.fc_table	= l3mdev_fib_table(dev) ? : RT6_TABLE_DFLT,
		.fc_metric	= IP6_RT_PRIO_USER,
		.fc_ifindex	= dev->ifindex,
		.fc_flags	= RTF_GATEWAY | RTF_ADDRCONF | RTF_DEFAULT |
				  RTF_UP | RTF_EXPIRES | RTF_PREF(pref),
		.fc_nlinfo.portid = 0,
		.fc_nlinfo.nlh = NULL,
		.fc_nlinfo.nl_net = dev_net(dev),
        };

	cfg.fc_gateway = *gwaddr;

	if (!ip6_route_add(&cfg)) {
		struct fib6_table *table;

		table = fib6_get_table(dev_net(dev), cfg.fc_table);
		if (table)
			table->flags |= RT6_TABLE_HAS_DFLT_ROUTER;
	}

	return rt6_get_dflt_router(gwaddr, dev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
46
31.08%
4
26.67%
David Ahern
40
27.03%
2
13.33%
Thomas Graf
23
15.54%
1
6.67%
Daniel Lezcano
20
13.51%
1
6.67%
Hideaki Yoshifuji / 吉藤英明
14
9.46%
3
20.00%
Alexey Dobriyan
2
1.35%
1
6.67%
Rami Rosen
1
0.68%
1
6.67%
Eric W. Biedermann
1
0.68%
1
6.67%
Eric Dumazet
1
0.68%
1
6.67%
Total
148
100.00%
15
100.00%



static void __rt6_purge_dflt_routers(struct fib6_table *table)
{
	struct rt6_info *rt;

restart:
	read_lock_bh(&table->tb6_lock);
	for (rt = table->tb6_root.leaf; rt; rt = rt->dst.rt6_next) {
		if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) &&
		    (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) {
			dst_hold(&rt->dst);
			read_unlock_bh(&table->tb6_lock);
			ip6_del_rt(rt);
			goto restart;
		}
	}
	read_unlock_bh(&table->tb6_lock);

	table->flags &= ~RT6_TABLE_HAS_DFLT_ROUTER;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
67
56.78%
4
40.00%
Lorenzo Colitti
17
14.41%
1
10.00%
Thomas Graf
12
10.17%
1
10.00%
David Ahern
12
10.17%
1
10.00%
Hideaki Yoshifuji / 吉藤英明
5
4.24%
1
10.00%
Eric Dumazet
3
2.54%
1
10.00%
Daniel Lezcano
2
1.69%
1
10.00%
Total
118
100.00%
10
100.00%



void rt6_purge_dflt_routers(struct net *net)
{
	struct fib6_table *table;
	struct hlist_head *head;
	unsigned int h;

	rcu_read_lock();

	for (h = 0; h < FIB6_TABLE_HASHSZ; h++) {
		head = &net->ipv6.fib_table_hash[h];
		hlist_for_each_entry_rcu(table, head, tb6_hlist) {
			if (table->flags & RT6_TABLE_HAS_DFLT_ROUTER)
				__rt6_purge_dflt_routers(table);
		}
	}

	rcu_read_unlock();
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Ahern
79
98.75%
1
50.00%
Linus Torvalds (pre-git)
1
1.25%
1
50.00%
Total
80
100.00%
2
100.00%



static void rtmsg_to_fib6_config(struct net *net,
				 struct in6_rtmsg *rtmsg,
				 struct fib6_config *cfg)
{
	memset(cfg, 0, sizeof(*cfg));

	cfg->fc_table = l3mdev_fib_table_by_index(net, rtmsg->rtmsg_ifindex) ?
			 : RT6_TABLE_MAIN;
	cfg->fc_ifindex = rtmsg->rtmsg_ifindex;
	cfg->fc_metric = rtmsg->rtmsg_metric;
	cfg->fc_expires = rtmsg->rtmsg_info;
	cfg->fc_dst_len = rtmsg->rtmsg_dst_len;
	cfg->fc_src_len = rtmsg->rtmsg_src_len;
	cfg->fc_flags = rtmsg->rtmsg_flags;

	cfg->fc_nlinfo.nl_net = net;

	cfg->fc_dst = rtmsg->rtmsg_dst;
	cfg->fc_src = rtmsg->rtmsg_src;
	cfg->fc_gateway = rtmsg->rtmsg_gateway;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Thomas Graf
104
80.00%
1
20.00%
David Ahern
10
7.69%
1
20.00%
Benjamin Thery
7
5.38%
1
20.00%
Daniel Lezcano
6
4.62%
1
20.00%
Alexey Dobriyan
3
2.31%
1
20.00%
Total
130
100.00%
5
100.00%



int ipv6_route_ioctl(struct net *net, unsigned int cmd, void __user *arg)
{
	struct fib6_config cfg;
	struct in6_rtmsg rtmsg;
	int err;

	switch (cmd) {
	case SIOCADDRT:		/* Add a route */
	case SIOCDELRT:		/* Delete a route */
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
			return -EPERM;
		err = copy_from_user(&rtmsg, arg,
				     sizeof(struct in6_rtmsg));
		if (err)
			return -EFAULT;

		rtmsg_to_fib6_config(net, &rtmsg, &cfg);

		rtnl_lock();
		switch (cmd) {
		case SIOCADDRT:
			err = ip6_route_add(&cfg);
			break;
		case SIOCDELRT:
			err = ip6_route_del(&cfg);
			break;
		default:
			err = -EINVAL;
		}
		rtnl_unlock();

		return err;
	}

	return -EINVAL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
115
79.86%
5
50.00%
Thomas Graf
15
10.42%
1
10.00%
Daniel Lezcano
7
4.86%
1
10.00%
Eric W. Biedermann
5
3.47%
1
10.00%
Al Viro
1
0.69%
1
10.00%
David S. Miller
1
0.69%
1
10.00%
Total
144
100.00%
10
100.00%

/*
 *      Drop the packet on the floor
 */



static int ip6_pkt_drop(struct sk_buff *skb, u8 code, int ipstats_mib_noroutes)
{
	int type;
	struct dst_entry *dst = skb_dst(skb);
	switch (ipstats_mib_noroutes) {
	case IPSTATS_MIB_INNOROUTES:
		type = ipv6_addr_type(&ipv6_hdr(skb)->daddr);
		if (type == IPV6_ADDR_ANY) {
			IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
				      IPSTATS_MIB_INADDRERRORS);
			break;
		}
		/* FALLTHROUGH */
	case IPSTATS_MIB_OUTNOROUTES:
		IP6_INC_STATS(dev_net(dst->dev), ip6_dst_idev(dst),
			      ipstats_mib_noroutes);
		break;
	}
	icmpv6_send(skb, ICMPV6_DEST_UNREACH, code, 0);
	kfree_skb(skb);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Hideaki Yoshifuji / 吉藤英明
35
29.41%
2
14.29%
Linus Torvalds (pre-git)
31
26.05%
5
35.71%
Denis V. Lunev
21
17.65%
1
7.14%
Lv Liangying
20
16.81%
1
7.14%
Arnaldo Carvalho de Melo
4
3.36%
2
14.29%
Thomas Graf
4
3.36%
1
7.14%
Eric Dumazet
3
2.52%
1
7.14%
Brian Haley
1
0.84%
1
7.14%
Total
119
100.00%
14
100.00%



static int ip6_pkt_discard(struct sk_buff *skb)
{
	return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_INNOROUTES);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Thomas Graf
19
90.48%
1
50.00%
Hideaki Yoshifuji / 吉藤英明
2
9.52%
1
50.00%
Total
21
100.00%
2
100.00%



static int ip6_pkt_discard_out(struct net *net, struct sock *sk, struct sk_buff *skb)
{
	skb->dev = skb_dst(skb)->dev;
	return ip6_pkt_drop(skb, ICMPV6_NOROUTE, IPSTATS_MIB_OUTNOROUTES);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
James Morris
13
30.95%
1
12.50%
Eric Dumazet
8
19.05%
2
25.00%
Dave Craig
6
14.29%
1
12.50%
Hideaki Yoshifuji / 吉藤英明
5
11.90%
1
12.50%
Eric W. Biedermann
5
11.90%
1
12.50%
Herbert Xu
4
9.52%
1
12.50%
Arnaldo Carvalho de Melo
1
2.38%
1
12.50%
Total
42
100.00%
8
100.00%



static int ip6_pkt_prohibit(struct sk_buff *skb)
{
	return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_INNOROUTES);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Thomas Graf
19
90.48%
1
50.00%
Hideaki Yoshifuji / 吉藤英明
2
9.52%
1
50.00%
Total
21
100.00%
2
100.00%



static int ip6_pkt_prohibit_out(struct net *net, struct sock *sk, struct sk_buff *skb)
{
	skb->dev = skb_dst(skb)->dev;
	return ip6_pkt_drop(skb, ICMPV6_ADM_PROHIBITED, IPSTATS_MIB_OUTNOROUTES);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Thomas Graf
24
57.14%
1
20.00%
Eric Dumazet
8
19.05%
2
40.00%
Hideaki Yoshifuji / 吉藤英明
5
11.90%
1
20.00%
Eric W. Biedermann
5
11.90%
1
20.00%
Total
42
100.00%
5
100.00%

/*
 *      Allocate a dst for local (unicast / anycast) address.
 */



struct rt6_info *addrconf_dst_alloc(struct inet6_dev *idev,
				    const struct in6_addr *addr,
				    bool anycast)
{
	u32 tb_id;
	struct net *net = dev_net(idev->dev);
	struct net_device *dev = net->loopback_dev;
	struct rt6_info *rt;

	/* use L3 Master device as loopback for host routes if device
         * is enslaved and address is not link local or multicast
         */
	if (!rt6_need_strict(addr))
		dev = l3mdev_master_dev_rcu(idev->dev) ? : dev;

	rt = ip6_dst_alloc(net, dev, DST_NOCOUNT);
	if (!rt)
		return ERR_PTR(-ENOMEM);

	in6_dev_hold(idev);

	rt->dst.flags |= DST_HOST;
	rt->dst.input = ip6_input;
	rt->dst.output = ip6_output;
	rt->rt6i_idev = idev;

	rt->rt6i_protocol = RTPROT_KERNEL;
	rt->rt6i_flags = RTF_UP | RTF_NONEXTHOP;
	if (anycast)
		rt->rt6i_flags |= RTF_ANYCAST;
	else
		rt->rt6i_flags |= RTF_LOCAL;

	rt->rt6i_gateway  = *addr;
	rt->rt6i_dst.addr = *addr;
	rt->rt6i_dst.plen = 128;
	tb_id = l3mdev_fib_table(idev->dev) ? : RT6_TABLE_LOCAL;
	rt->rt6i_table = fib6_get_table(net, tb_id);
	rt->dst.flags |= DST_NOCACHE;

	atomic_set(&rt->dst.__refcnt, 1);

	return rt;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
78
33.91%
5
17.86%
David Ahern
57
24.78%
3
10.71%
Hideaki Yoshifuji / 吉藤英明
37
16.09%
5
17.86%
Alexey Kuznetsov
12
5.22%
1
3.57%
Daniel Lezcano
11
4.78%
2
7.14%
Martin KaFai Lau
8
3.48%
1
3.57%
Thomas Graf
8
3.48%
1
3.57%
Julian Anastasov
7
3.04%
1
3.57%
David S. Miller
6
2.61%
6
21.43%
Benjamin Thery
3
1.30%
1
3.57%
Alexey Dobriyan
2
0.87%
1
3.57%
Hannes Frederic Sowa
1
0.43%
1
3.57%
Total
230
100.00%
28
100.00%

/* remove deleted ip from prefsrc entries */

struct arg_dev_net_ip {
	
struct net_device *dev;
	
struct net *net;
	
struct in6_addr *addr;
};



static int fib6_remove_prefsrc(struct rt6_info *rt, void *arg)
{
	struct net_device *dev = ((struct arg_dev_net_ip *)arg)->dev;
	struct net *net = ((struct arg_dev_net_ip *)arg)->net;
	struct in6_addr *addr = ((struct arg_dev_net_ip *)arg)->addr;

	if (((void *)rt->dst.dev == dev || !dev) &&
	    rt != net->ipv6.ip6_null_entry &&
	    ipv6_addr_equal(addr, &rt->rt6i_prefsrc.addr)) {
		/* remove prefsrc entry */
		rt->rt6i_prefsrc.plen = 0;
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Daniel Walter
112
96.55%
1
33.33%
David S. Miller
4
3.45%
2
66.67%
Total
116
100.00%
3
100.00%



void rt6_remove_prefsrc(struct inet6_ifaddr *ifp)
{
	struct net *net = dev_net(ifp->idev->dev);
	struct arg_dev_net_ip adni = {
		.dev = ifp->idev->dev,
		.net = net,
		.addr = &ifp->addr,
        };
	fib6_clean_all(net, fib6_remove_prefsrc, &adni);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Daniel Walter
62
100.00%
1
100.00%
Total
62
100.00%
1
100.00%


#define RTF_RA_ROUTER		(RTF_ADDRCONF | RTF_DEFAULT | RTF_GATEWAY)

#define RTF_CACHE_GATEWAY	(RTF_GATEWAY | RTF_CACHE)

/* Remove routers and update dst entries when gateway turn into host. */


static int fib6_clean_tohost(struct rt6_info *rt, void *arg)
{
	struct in6_addr *gateway = (struct in6_addr *)arg;

	if ((((rt->rt6i_flags & RTF_RA_ROUTER) == RTF_RA_ROUTER) ||
	     ((rt->rt6i_flags & RTF_CACHE_GATEWAY) == RTF_CACHE_GATEWAY)) &&
	     ipv6_addr_equal(gateway, &rt->rt6i_gateway)) {
		return -1;
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Duan Jiong
74
100.00%
1
100.00%
Total
74
100.00%
1
100.00%



void rt6_clean_tohost(struct net *net, struct in6_addr *gateway)
{
	fib6_clean_all(net, fib6_clean_tohost, gateway);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Duan Jiong
24
100.00%
1
100.00%
Total
24
100.00%
1
100.00%


struct arg_dev_net {
	
struct net_device *dev;
	
struct net *net;
};

/* called with write lock held for table with rt */


static int fib6_ifdown(struct rt6_info *rt, void *arg)
{
	const struct arg_dev_net *adn = arg;
	const struct net_device *dev = adn->dev;

	if ((rt->dst.dev == dev || !dev) &&
	    rt != adn->net->ipv6.ip6_null_entry &&
	    (rt->rt6i_nsiblings == 0 ||
	     !rt->rt6i_idev->cnf.ignore_routes_with_linkdown))
		return -1;

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
35
42.68%
2
28.57%
David Ahern
17
20.73%
1
14.29%
Daniel Lezcano
16
19.51%
1
14.29%
Stephen Hemminger
10
12.20%
1
14.29%
David S. Miller
4
4.88%
2
28.57%
Total
82
100.00%
7
100.00%



void rt6_ifdown(struct net *net, struct net_device *dev)
{
	struct arg_dev_net adn = {
		.dev = dev,
		.net = net,
        };

	fib6_clean_all(net, fib6_ifdown, &adn);
	icmp6_clean_all(fib6_ifdown, &adn);
	if (dev)
		rt6_uncached_list_flush_dev(net, dev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Daniel Lezcano
25
41.67%
2
22.22%
Linus Torvalds (pre-git)
15
25.00%
3
33.33%
David S. Miller
8
13.33%
1
11.11%
Martin KaFai Lau
7
11.67%
1
11.11%
Eric W. Biedermann
4
6.67%
1
11.11%
Thomas Graf
1
1.67%
1
11.11%
Total
60
100.00%
9
100.00%


struct rt6_mtu_change_arg {
	
struct net_device *dev;
	
unsigned int mtu;
};



static int rt6_mtu_change_route(struct rt6_info *rt, void *p_arg)
{
	struct rt6_mtu_change_arg *arg = (struct rt6_mtu_change_arg *) p_arg;
	struct inet6_dev *idev;

	/* In IPv6 pmtu discovery is not optional,
           so that RTAX_MTU lock cannot disable it.
           We still use this lock to block changes
           caused by addrconf/ndisc.
        */

	idev = __in6_dev_get(arg->dev);
	if (!idev)
		return 0;

	/* For administrative MTU increase, there is no way to discover
           IPv6 PMTU increase, so PMTU increase should be updated here.
           Since RFC 1981 doesn't include administrative MTU increase
           update PMTU increase is a MUST. (i.e. jumbo frame)
         */
	/*
           If new MTU is less than route PMTU, this new MTU will be the
           lowest MTU in the path, update the route PMTU to reflect PMTU
           decreases; if new MTU is greater than route PMTU, and the
           old MTU is the lowest MTU in the path, update the route PMTU
           to reflect the increase. In this case if the other nodes' MTU
           also have the lowest MTU, TOO BIG MESSAGE will be lead to
           PMTU discovery.
         */
	if (rt->dst.dev == arg->dev &&
	    dst_metric_raw(&rt->dst, RTAX_MTU) &&
	    !dst_metric_locked(&rt->dst, RTAX_MTU)) {
		if (rt->rt6i_flags & RTF_CACHE) {
			/* For RTF_CACHE with rt6i_pmtu == 0
                         * (i.e. a redirected route),
                         * the metrics of its rt->dst.from has already
                         * been updated.
                         */
			if (rt->rt6i_pmtu && rt->rt6i_pmtu > arg->mtu)
				rt->rt6i_pmtu = arg->mtu;
		} else if (dst_mtu(&rt->dst) >= arg->mtu ||
			   (dst_mtu(&rt->dst) < arg->mtu &&
			    dst_mtu(&rt->dst) == idev->cnf.mtu6)) {
			dst_metric_set(&rt->dst, RTAX_MTU, arg->mtu);
		}
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
51
28.02%
3
18.75%
Shirley Ma
47
25.82%
1
6.25%
Martin KaFai Lau
38
20.88%
1
6.25%
Alexey Kuznetsov
12
6.59%
2
12.50%
David S. Miller
10
5.49%
3
18.75%
Maciej Żenczykowski
10
5.49%
1
6.25%
Linus Torvalds
7
3.85%
1
6.25%
Herbert Xu
3
1.65%
1
6.25%
Simon Arlott
2
1.10%
1
6.25%
Jim Paris
1
0.55%
1
6.25%
Alexander Alemayhu
1
0.55%
1
6.25%
Total
182
100.00%
16
100.00%



void rt6_mtu_change(struct net_device *dev, unsigned int mtu)
{
	struct rt6_mtu_change_arg arg = {
		.dev = dev,
		.mtu = mtu,
        };

	fib6_clean_all(dev_net(dev), rt6_mtu_change_route, &arg);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
31
72.09%
3
42.86%
Thomas Graf
6
13.95%
1
14.29%
Hideaki Yoshifuji / 吉藤英明
3
6.98%
1
14.29%
Daniel Lezcano
2
4.65%
1
14.29%
Eric Dumazet
1
2.33%
1
14.29%
Total
43
100.00%
7
100.00%


static const struct nla_policy rtm_ipv6_policy[RTA_MAX+1] = {
	[RTA_GATEWAY]           = { .len = sizeof(struct in6_addr) },
	[RTA_OIF]               = { .type = NLA_U32 },
	[RTA_IIF]		= { .type = NLA_U32 },
	[RTA_PRIORITY]          = { .type = NLA_U32 },
	[RTA_METRICS]           = { .type = NLA_NESTED },
	[RTA_MULTIPATH]		= { .len = sizeof(struct rtnexthop) },
	[RTA_PREF]              = { .type = NLA_U8 },
	[RTA_ENCAP_TYPE]	= { .type = NLA_U16 },
	[RTA_ENCAP]		= { .type = NLA_NESTED },
	[RTA_EXPIRES]		= { .type = NLA_U32 },
	[RTA_UID]		= { .type = NLA_U32 },
	[RTA_MARK]		= { .type = NLA_U32 },
};



static int rtm_to_fib6_config(struct sk_buff *skb, struct nlmsghdr *nlh,
			      struct fib6_config *cfg)
{
	struct rtmsg *rtm;
	struct nlattr *tb[RTA_MAX+1];
	unsigned int pref;
	int err;

	err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
	if (err < 0)
		goto errout;

	err = -EINVAL;
	rtm = nlmsg_data(nlh);
	memset(cfg, 0, sizeof(*cfg));

	cfg->fc_table = rtm->rtm_table;
	cfg->fc_dst_len = rtm->rtm_dst_len;
	cfg->fc_src_len = rtm->rtm_src_len;
	cfg->fc_flags = RTF_UP;
	cfg->fc_protocol = rtm->rtm_protocol;
	cfg->fc_type = rtm->rtm_type;

	if (rtm->rtm_type == RTN_UNREACHABLE ||
	    rtm->rtm_type == RTN_BLACKHOLE ||
	    rtm->rtm_type == RTN_PROHIBIT ||
	    rtm->rtm_type == RTN_THROW)
		cfg->fc_flags |= RTF_REJECT;

	if (rtm->rtm_type == RTN_LOCAL)
		cfg->fc_flags |= RTF_LOCAL;

	if (rtm->rtm_flags & RTM_F_CLONED)
		cfg->fc_flags |= RTF_CACHE;

	cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
	cfg->fc_nlinfo.nlh = nlh;
	cfg->fc_nlinfo.nl_net = sock_net(skb->sk);

	if (tb[RTA_GATEWAY]) {
		cfg->fc_gateway = nla_get_in6_addr(tb[RTA_GATEWAY]);
		cfg->fc_flags |= RTF_GATEWAY;
	}

	if (tb[RTA_DST]) {
		int plen = (rtm->rtm_dst_len + 7) >> 3;

		if (nla_len(tb[RTA_DST]) < plen)
			goto errout;

		nla_memcpy(&cfg->fc_dst, tb[RTA_DST], plen);
	}

	if (tb[RTA_SRC]) {
		int plen = (rtm->rtm_src_len + 7) >> 3;

		if (nla_len(tb[RTA_SRC]) < plen)
			goto errout;

		nla_memcpy(&cfg->fc_src, tb[RTA_SRC], plen);
	}

	if (tb[RTA_PREFSRC])
		cfg->fc_prefsrc = nla_get_in6_addr(tb[RTA_PREFSRC]);

	if (tb[RTA_OIF])
		cfg->fc_ifindex = nla_get_u32(tb[RTA_OIF]);

	if (tb[RTA_PRIORITY])
		cfg->fc_metric = nla_get_u32(tb[RTA_PRIORITY]);

	if (tb[RTA_METRICS]) {
		cfg->fc_mx = nla_data(tb[RTA_METRICS]);
		cfg->fc_mx_len = nla_len(tb[RTA_METRICS]);
	}

	if (tb[RTA_TABLE])
		cfg->fc_table = nla_get_u32(tb[RTA_TABLE]);

	if (tb[RTA_MULTIPATH]) {
		cfg->fc_mp = nla_data(tb[RTA_MULTIPATH]);
		cfg->fc_mp_len = nla_len(tb[RTA_MULTIPATH]);

		err = lwtunnel_valid_encap_type_attr(cfg->fc_mp,
						     cfg->fc_mp_len);
		if (err < 0)
			goto errout;
	}

	if (tb[RTA_PREF]) {
		pref = nla_get_u8(tb[RTA_PREF]);
		if (pref != ICMPV6_ROUTER_PREF_LOW &&
		    pref != ICMPV6_ROUTER_PREF_HIGH)
			pref = ICMPV6_ROUTER_PREF_MEDIUM;
		cfg->fc_flags |= RTF_PREF(pref);
	}

	if (tb[RTA_ENCAP])
		cfg->fc_encap = tb[RTA_ENCAP];

	if (tb[RTA_ENCAP_TYPE]) {
		cfg->fc_encap_type = nla_get_u16(tb[RTA_ENCAP_TYPE]);

		err = lwtunnel_valid_encap_type(cfg->fc_encap_type);
		if (err < 0)
			goto errout;
	}

	if (tb[RTA_EXPIRES]) {
		unsigned long timeout = addrconf_timeout_fixup(nla_get_u32(tb[RTA_EXPIRES]), HZ);

		if (addrconf_finite_timeout(timeout)) {
			cfg->fc_expires = jiffies_to_clock_t(timeout * HZ);
			cfg->fc_flags |= RTF_EXPIRES;
		}
	}

	err = 0;
errout:
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Thomas Graf
234
33.96%
1
5.56%
Linus Torvalds (pre-git)
156
22.64%
3
16.67%
Nicolas Dichtel
59
8.56%
3
16.67%
Xin Long
52
7.55%
1
5.56%
Lubomir Rintel
46
6.68%
1
5.56%
David Ahern
42
6.10%
1
5.56%
Roopa Prabhu
35
5.08%
1
5.56%
Daniel Walter
16
2.32%
1
5.56%
Maciej Żenczykowski
14
2.03%
1
5.56%
Martin KaFai Lau
14
2.03%
1
5.56%
Benjamin Thery
10
1.45%
1
5.56%
Jiri Benc
6
0.87%
1
5.56%
Hideaki Yoshifuji / 吉藤英明
3
0.44%
1
5.56%
Eric W. Biedermann
2
0.29%
1
5.56%
Total
689
100.00%
18
100.00%


struct rt6_nh {
	
struct rt6_info *rt6_info;
	
struct fib6_config r_cfg;
	
struct mx6_config mxc;
	
struct list_head next;
};



static void ip6_print_replace_route_err(struct list_head *rt6_nh_list)
{
	struct rt6_nh *nh;

	list_for_each_entry(nh, rt6_nh_list, next) {
		pr_warn("IPV6: multipath route replace failed (check consistency of installed routes): %pI6c nexthop %pI6c ifi %d\n",
		        &nh->r_cfg.fc_dst, &nh->r_cfg.fc_gateway,
		        nh->r_cfg.fc_ifindex);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Roopa Prabhu
34
66.67%
1
33.33%
Nicolas Dichtel
16
31.37%
1
33.33%
David Ahern
1
1.96%
1
33.33%
Total
51
100.00%
3
100.00%



static int ip6_route_info_append(struct list_head *rt6_nh_list,
				 struct rt6_info *rt, struct fib6_config *r_cfg)
{
	struct rt6_nh *nh;
	struct rt6_info *rtnh;
	int err = -EEXIST;

	list_for_each_entry(nh, rt6_nh_list, next) {
		/* check if rt6_info already exists */
		rtnh = nh->rt6_info;

		if (rtnh->dst.dev == rt->dst.dev &&
		    rtnh->rt6i_idev == rt->rt6i_idev &&
		    ipv6_addr_equal(&rtnh->rt6i_gateway,
				    &rt->rt6i_gateway))
			return err;
	}

	nh = kzalloc(sizeof(*nh), GFP_KERNEL);
	if (!nh)
		return -ENOMEM;
	nh->rt6_info = rt;
	err = ip6_convert_metrics(&nh->mxc, r_cfg);
	if (err) {
		kfree(nh);
		return err;
	}
	memcpy(&nh->r_cfg, r_cfg, sizeof(*r_cfg));
	list_add_tail(&nh->next, rt6_nh_list);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Roopa Prabhu
175
100.00%
1
100.00%
Total
175
100.00%
1
100.00%



static void ip6_route_mpath_notify(struct rt6_info *rt,
				   struct rt6_info *rt_last,
				   struct nl_info *info,
				   __u16 nlflags)
{
	/* if this is an APPEND route, then rt points to the first route
         * inserted and rt_last points to last route inserted. Userspace
         * wants a consistent dump of the route which starts at the first
         * nexthop. Since sibling routes are always added at the end of
         * the list, find the first sibling of the last route appended
         */
	if ((nlflags & NLM_F_APPEND) && rt_last && rt_last->rt6i_nsiblings) {
		rt = list_first_entry(&rt_last->rt6i_siblings,
				      struct rt6_info,
				      rt6i_siblings);
	}

	if (rt)
		inet6_rt_notify(RTM_NEWROUTE, rt, info, nlflags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Ahern
71
100.00%
1
100.00%
Total
71
100.00%
1
100.00%



static int ip6_route_multipath_add(struct fib6_config *cfg)
{
	struct rt6_info *rt_notif = NULL, *rt_last = NULL;
	struct nl_info *info = &cfg->fc_nlinfo;
	struct fib6_config r_cfg;
	struct rtnexthop *rtnh;
	struct rt6_info *rt;
	struct rt6_nh *err_nh;
	struct rt6_nh *nh, *nh_safe;
	__u16 nlflags;
	int remaining;
	int attrlen;
	int err = 1;
	int nhn = 0;
	int replace = (cfg->fc_nlinfo.nlh &&
		       (cfg->fc_nlinfo.nlh->nlmsg_flags & NLM_F_REPLACE));
	LIST_HEAD(rt6_nh_list);

	nlflags = replace ? NLM_F_REPLACE : NLM_F_CREATE;
	if (info->nlh && info->nlh->nlmsg_flags & NLM_F_APPEND)
		nlflags |= NLM_F_APPEND;

	remaining = cfg->fc_mp_len;
	rtnh = (struct rtnexthop *)cfg->fc_mp;

	/* Parse a Multipath Entry and build a list (rt6_nh_list) of
         * rt6_info structs per nexthop
         */
	while (rtnh_ok(rtnh, remaining)) {
		memcpy(&r_cfg, cfg, sizeof(*cfg));
		if (rtnh->rtnh_ifindex)
			r_cfg.fc_ifindex = rtnh->rtnh_ifindex;

		attrlen = rtnh_attrlen(rtnh);
		if (attrlen > 0) {
			struct nlattr *nla, *attrs = rtnh_attrs(rtnh);

			nla = nla_find(attrs, attrlen, RTA_GATEWAY);
			if (nla) {
				r_cfg.fc_gateway = nla_get_in6_addr(nla);
				r_cfg.fc_flags |= RTF_GATEWAY;
			}
			r_cfg.fc_encap = nla_find(attrs, attrlen, RTA_ENCAP);
			nla = nla_find(attrs, attrlen, RTA_ENCAP_TYPE);
			if (nla)
				r_cfg.fc_encap_type = nla_get_u16(nla);
		}

		rt = ip6_route_info_create(&r_cfg);
		if (IS_ERR(rt)) {
			err = PTR_ERR(rt);
			rt = NULL;
			goto cleanup;
		}

		err = ip6_route_info_append(&rt6_nh_list, rt, &r_cfg);
		if (err) {
			dst_free(&rt->dst);
			goto cleanup;
		}

		rtnh = rtnh_next(rtnh, &remaining);
	}

	/* for add and replace send one notification with all nexthops.
         * Skip the notification in fib6_add_rt2node and send one with
         * the full route when done
         */
	info->skip_notify = 1;

	err_nh = NULL;
	list_for_each_entry(nh, &rt6_nh_list, next) {
		rt_last = nh->rt6_info;
		err = __ip6_ins_rt(nh->rt6_info, info, &nh->mxc);
		/* save reference to first route for notification */
		if (!rt_notif && !err)
			rt_notif = nh->rt6_info;

		/* nh->rt6_info is used or freed at this point, reset to NULL*/
		nh->rt6_info = NULL;
		if (err) {
			if (replace && nhn)
				ip6_print_replace_route_err(&rt6_nh_list);
			err_nh = nh;
			goto add_errout;
		}

		/* Because each route is added like a single route we remove
                 * these flags after the first nexthop: if there is a collision,
                 * we have already failed to add the first nexthop:
                 * fib6_add_rt2node() has rejected it; when replacing, old
                 * nexthops have been replaced by first new, the rest should
                 * be added to it.
                 */
		cfg->fc_nlinfo.nlh->nlmsg_flags &= ~(NLM_F_EXCL |
						     NLM_F_REPLACE);
		nhn++;
	}

	/* success ... tell user about new route */
	ip6_route_mpath_notify(rt_notif, rt_last, info, nlflags);
	goto cleanup;

add_errout:
	/* send notification for routes that were added so that
         * the delete notifications sent by ip6_route_del are
         * coherent
         */
	if (rt_notif)
		ip6_route_mpath_notify(rt_notif, rt_last, info, nlflags);

	/* Delete routes that were already added */
	list_for_each_entry(nh, &rt6_nh_list, next) {
		if (err_nh == nh)
			break;
		ip6_route_del(&nh->r_cfg);
	}

cleanup:
	list_for_each_entry_safe(nh, nh_safe, &rt6_nh_list, next) {
		if (nh->rt6_info)
			dst_free(&nh->rt6_info->dst);
		kfree(nh->mxc.mx);
		list_del(&nh->next);
		kfree(nh);
	}

	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Roopa Prabhu
456
78.49%
2
40.00%
David Ahern
108
18.59%
1
20.00%
Nicolas Dichtel
16
2.75%
1
20.00%
Jiri Benc
1
0.17%
1
20.00%
Total
581
100.00%
5
100.00%



static int ip6_route_multipath_del(struct fib6_config *cfg)
{
	struct fib6_config r_cfg;
	struct rtnexthop *rtnh;
	int remaining;
	int attrlen;
	int err = 1, last_err = 0;

	remaining = cfg->fc_mp_len;
	rtnh = (struct rtnexthop *)cfg->fc_mp;

	/* Parse a Multipath Entry */
	while (rtnh_ok(rtnh, remaining)) {
		memcpy(&r_cfg, cfg, sizeof(*cfg));
		if (rtnh->rtnh_ifindex)
			r_cfg.fc_ifindex = rtnh->rtnh_ifindex;

		attrlen = rtnh_attrlen(rtnh);
		if (attrlen > 0) {
			struct nlattr *nla, *attrs = rtnh_attrs(rtnh);

			nla = nla_find(attrs, attrlen, RTA_GATEWAY);
			if (nla) {
				nla_memcpy(&r_cfg.fc_gateway, nla, 16);
				r_cfg.fc_flags |= RTF_GATEWAY;
			}
		}
		err = ip6_route_del(&r_cfg);
		if (err)
			last_err = err;

		rtnh = rtnh_next(rtnh, &remaining);
	}

	return last_err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Roopa Prabhu
152
82.61%
2
66.67%
Nicolas Dichtel
32
17.39%
1
33.33%
Total
184
100.00%
3
100.00%



static int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh)
{
	struct fib6_config cfg;
	int err;

	err = rtm_to_fib6_config(skb, nlh, &cfg);
	if (err < 0)
		return err;

	if (cfg.fc_mp)
		return ip6_route_multipath_del(&cfg);
	else {
		cfg.fc_delete_all_nh = 1;
		return ip6_route_del(&cfg);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
31
42.47%
2
25.00%
Thomas Graf
19
26.03%
2
25.00%
Nicolas Dichtel
13
17.81%
1
12.50%
David Ahern
8
10.96%
1
12.50%
Patrick McHardy
1
1.37%
1
12.50%
Roopa Prabhu
1
1.37%
1
12.50%
Total
73
100.00%
8
100.00%



static int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh)
{
	struct fib6_config cfg;
	int err;

	err = rtm_to_fib6_config(skb, nlh, &cfg);
	if (err < 0)
		return err;

	if (cfg.fc_mp)
		return ip6_route_multipath_add(&cfg);
	else
		return ip6_route_add(&cfg);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
31
47.69%
3
37.50%
Thomas Graf
19
29.23%
2
25.00%
Nicolas Dichtel
13
20.00%
1
12.50%
Patrick McHardy
1
1.54%
1
12.50%
Roopa Prabhu
1
1.54%
1
12.50%
Total
65
100.00%
8
100.00%



static size_t rt6_nlmsg_size(struct rt6_info *rt)
{
	int nexthop_len = 0;

	if (rt->rt6i_nsiblings) {
		nexthop_len = nla_total_size(0)	 /* RTA_MULTIPATH */
			    + NLA_ALIGN(sizeof(struct rtnexthop))
			    + nla_total_size(16) /* RTA_GATEWAY */
			    + lwtunnel_get_encap_size(rt->dst.lwtstate);

		nexthop_len *= rt->rt6i_nsiblings;
	}

	return NLMSG_ALIGN(sizeof(struct rtmsg))
	       + nla_total_size(16) /* RTA_SRC */
	       + nla_total_size(16) /* RTA_DST */
	       + nla_total_size(16) /* RTA_GATEWAY */
	       + nla_total_size(16) /* RTA_PREFSRC */
	       + nla_total_size(4) /* RTA_TABLE */
	       + nla_total_size(4) /* RTA_IIF */
	       + nla_total_size(4) /* RTA_OIF */
	       + nla_total_size(4) /* RTA_PRIORITY */
	       + RTAX_MAX * nla_total_size(4) /* RTA_METRICS */
	       + nla_total_size(sizeof(struct rta_cacheinfo))
	       + nla_total_size(TCP_CA_NAME_MAX) /* RTAX_CC_ALGO */
	       + nla_total_size(1) /* RTA_PREF */
	       + lwtunnel_get_encap_size(rt->dst.lwtstate)
	       + nexthop_len;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Thomas Graf
72
45.00%
1
14.29%
David Ahern
55
34.38%
1
14.29%
Roopa Prabhu
10
6.25%
1
14.29%
Noriaki Takamiya
8
5.00%
1
14.29%
Daniel Borkmann
6
3.75%
1
14.29%
Lubomir Rintel
6
3.75%
1
14.29%
Jiri Benc
3
1.88%
1
14.29%
Total
160
100.00%
7
100.00%



static int rt6_nexthop_info(struct sk_buff *skb, struct rt6_info *rt,
			    unsigned int *flags, bool skip_oif)
{
	if (!netif_running(rt->dst.dev) || !netif_carrier_ok(rt->dst.dev)) {
		*flags |= RTNH_F_LINKDOWN;
		if (rt->rt6i_idev->cnf.ignore_routes_with_linkdown)
			*flags |= RTNH_F_DEAD;
	}

	if (rt->rt6i_flags & RTF_GATEWAY) {
		if (nla_put_in6_addr(skb, RTA_GATEWAY, &rt->rt6i_gateway) < 0)
			goto nla_put_failure;
	}

	/* not needed for multipath encoding b/c it has a rtnexthop struct */
	if (!skip_oif && rt->dst.dev &&
	    nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
		goto nla_put_failure;

	if (rt->dst.lwtstate &&
	    lwtunnel_fill_encap(skb, rt->dst.lwtstate) < 0)
		goto nla_put_failure;

	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Ahern
160
100.00%
2
100.00%
Total
160
100.00%
2
100.00%

/* add multipath next hop */


static int rt6_add_nexthop(struct sk_buff *skb, struct rt6_info *rt)
{
	struct rtnexthop *rtnh;
	unsigned int flags = 0;

	rtnh = nla_reserve_nohdr(skb, sizeof(*rtnh));
	if (!rtnh)
		goto nla_put_failure;

	rtnh->rtnh_hops = 0;
	rtnh->rtnh_ifindex = rt->dst.dev ? rt->dst.dev->ifindex : 0;

	if (rt6_nexthop_info(skb, rt, &flags, true) < 0)
		goto nla_put_failure;

	rtnh->rtnh_flags = flags;

	/* length of rtnetlink header + attributes */
	rtnh->rtnh_len = nlmsg_get_pos(skb) - (void *)rtnh;

	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Ahern
122
98.39%
2
50.00%
Thomas Graf
1
0.81%
1
25.00%
Roopa Prabhu
1
0.81%
1
25.00%
Total
124
100.00%
4
100.00%



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)
{
	u32 metrics[RTAX_MAX];
	struct rtmsg *rtm;
	struct nlmsghdr *nlh;
	long expires;
	u32 table;

	nlh = nlmsg_put(skb, portid, seq, type, sizeof(*rtm), flags);
	if (!nlh)
		return -EMSGSIZE;

	rtm = nlmsg_data(nlh);
	rtm->rtm_family = AF_INET6;
	rtm->rtm_dst_len = rt->rt6i_dst.plen;
	rtm->rtm_src_len = rt->rt6i_src.plen;
	rtm->rtm_tos = 0;
	if (rt->rt6i_table)
		table = rt->rt6i_table->tb6_id;
	else
		table = RT6_TABLE_UNSPEC;
	rtm->rtm_table = table;
	if (nla_put_u32(skb, RTA_TABLE, table))
		goto nla_put_failure;
	if (rt->rt6i_flags & RTF_REJECT) {
		switch (rt->dst.error) {
		case -EINVAL:
			rtm->rtm_type = RTN_BLACKHOLE;
			break;
		case -EACCES:
			rtm->rtm_type = RTN_PROHIBIT;
			break;
		case -EAGAIN:
			rtm->rtm_type = RTN_THROW;
			break;
		default:
			rtm->rtm_type = RTN_UNREACHABLE;
			break;
		}
	}
	else if (rt->rt6i_flags & RTF_LOCAL)
		rtm->rtm_type = RTN_LOCAL;
	else if (rt->rt6i_flags & RTF_ANYCAST)
		rtm->rtm_type = RTN_ANYCAST;
	else if (rt->dst.dev && (rt->dst.dev->flags & IFF_LOOPBACK))
		rtm->rtm_type = RTN_LOCAL;
	else
		rtm->rtm_type = RTN_UNICAST;
	rtm->rtm_flags = 0;
	rtm->rtm_scope = RT_SCOPE_UNIVERSE;
	rtm->rtm_protocol = rt->rt6i_protocol;
	if (rt->rt6i_flags & RTF_DYNAMIC)
		rtm->rtm_protocol = RTPROT_REDIRECT;
	else if (rt->rt6i_flags & RTF_ADDRCONF) {
		if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ROUTEINFO))
			rtm->rtm_protocol = RTPROT_RA;
		else
			rtm->rtm_protocol = RTPROT_KERNEL;
	}

	if (rt->rt6i_flags & RTF_CACHE)
		rtm->rtm_flags |= RTM_F_CLONED;

	if (dst) {
		if (nla_put_in6_addr(skb, RTA_DST, dst))
			goto nla_put_failure;
		rtm->rtm_dst_len = 128;
	} else if (rtm->rtm_dst_len)
		if (nla_put_in6_addr(skb, RTA_DST, &rt->rt6i_dst.addr))
			goto nla_put_failure;
#ifdef CONFIG_IPV6_SUBTREES
	if (src) {
		if (nla_put_in6_addr(skb, RTA_SRC, src))
			goto nla_put_failure;
		rtm->rtm_src_len = 128;
	} else if (rtm->rtm_src_len &&
		   nla_put_in6_addr(skb, RTA_SRC, &rt->rt6i_src.addr))
		goto nla_put_failure;
#endif
	if (iif) {
#ifdef CONFIG_IPV6_MROUTE
		if (ipv6_addr_is_multicast(&rt->rt6i_dst.addr)) {
			int err = ip6mr_get_route(net, skb, rtm, portid);

			if (err == 0)
				return 0;
			if (err < 0)
				goto nla_put_failure;
		} else
#endif
			if (nla_put_u32(skb, RTA_IIF, iif))
				goto nla_put_failure;
	} else if (dst) {
		struct in6_addr saddr_buf;
		if (ip6_route_get_saddr(net, rt, dst, 0, &saddr_buf) == 0 &&
		    nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
			goto nla_put_failure;
	}

	if (rt->rt6i_prefsrc.plen) {
		struct in6_addr saddr_buf;
		saddr_buf = rt->rt6i_prefsrc.addr;
		if (nla_put_in6_addr(skb, RTA_PREFSRC, &saddr_buf))
			goto nla_put_failure;
	}

	memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
	if (rt->rt6i_pmtu)
		metrics[RTAX_MTU - 1] = rt->rt6i_pmtu;
	if (rtnetlink_put_metrics(skb, metrics) < 0)
		goto nla_put_failure;

	if (nla_put_u32(skb, RTA_PRIORITY, rt->rt6i_metric))
		goto nla_put_failure;

	/* For multipath routes, walk the siblings list and add
         * each as a nexthop within RTA_MULTIPATH.
         */
	if (rt->rt6i_nsiblings) {
		struct rt6_info *sibling, *next_sibling;
		struct nlattr *mp;

		mp = nla_nest_start(skb, RTA_MULTIPATH);
		if (!mp)
			goto nla_put_failure;

		if (rt6_add_nexthop(skb, rt) < 0)
			goto nla_put_failure;

		list_for_each_entry_safe(sibling, next_sibling,
					 &rt->rt6i_siblings, rt6i_siblings) {
			if (rt6_add_nexthop(skb, sibling) < 0)
				goto nla_put_failure;
		}

		nla_nest_end(skb, mp);
	} else {
		if (rt6_nexthop_info(skb, rt, &rtm->rtm_flags, false) < 0)
			goto nla_put_failure;
	}

	expires = (rt->rt6i_flags & RTF_EXPIRES) ? rt->dst.expires - jiffies : 0;

	if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, rt->dst.error) < 0)
		goto nla_put_failure;

	if (nla_put_u8(skb, RTA_PREF, IPV6_EXTRACT_PREF(rt->rt6i_flags)))
		goto nla_put_failure;


	nlmsg_end(skb, nlh);
	return 0;

nla_put_failure:
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
381
41.96%
6
13.64%
David Ahern
102
11.23%
4
9.09%
David S. Miller
73
8.04%
4
9.09%
Hideaki Yoshifuji / 吉藤英明
62
6.83%
5
11.36%
Thomas Graf
54
5.95%
3
6.82%
Nicolas Dichtel
47
5.18%
2
4.55%
Martin KaFai Lau
39
4.30%
1
2.27%
Daniel Walter
29
3.19%
1
2.27%
Patrick McHardy
22
2.42%
2
4.55%
Lubomir Rintel
19
2.09%
1
2.27%
Maciej Żenczykowski
15
1.65%
1
2.27%
Denis Ovsienko
13
1.43%
1
2.27%
Brian Haley
13
1.43%
2
4.55%
Eric Dumazet
10
1.10%
2
4.55%
Jiri Benc
6
0.66%
1
2.27%
Li Wei
5
0.55%
1
2.27%
Jamal Hadi Salim
5
0.55%
1
2.27%
Mathew Richardson
4
0.44%
1
2.27%
Johannes Berg
3
0.33%
1
2.27%
Benjamin Thery
2
0.22%
1
2.27%
Eric W. Biedermann
2
0.22%
1
2.27%
Alexey Dobriyan
1
0.11%
1
2.27%
Nikolay Aleksandrov
1
0.11%
1
2.27%
Total
908
100.00%
44
100.00%



int rt6_dump_route(struct rt6_info *rt, void *p_arg)
{
	struct rt6_rtnl_dump_arg *arg = (struct rt6_rtnl_dump_arg *) p_arg;
	struct net *net = arg->net;

	if (rt == net->ipv6.ip6_null_entry)
		return 0;

	if (nlmsg_len(arg->cb->nlh) >= sizeof(struct rtmsg)) {
		struct rtmsg *rtm = nlmsg_data(arg->cb->nlh);

		/* user wants prefix routes only */
		if (rtm->rtm_flags & RTM_F_PREFIX &&
		    !(rt->rt6i_flags & RTF_PREFIX_RT)) {
			/* success since this is not a prefix route */
			return 1;
		}
	}

	return rt6_fill_node(net,
		     arg->skb, rt, NULL, NULL, 0, RTM_NEWROUTE,
		     NETLINK_CB(arg->cb->skb).portid, arg->cb->nlh->nlmsg_seq,
		     NLM_F_MULTI);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
60
41.10%
3
25.00%
David Ahern
40
27.40%
2
16.67%
Ville Nuorvala
21
14.38%
1
8.33%
Krishna Kumar
14
9.59%
1
8.33%
Thomas Graf
4
2.74%
1
8.33%
Brian Haley
4
2.74%
1
8.33%
Eric W. Biedermann
1
0.68%
1
8.33%
Mathew Richardson
1
0.68%
1
8.33%
Jamal Hadi Salim
1
0.68%
1
8.33%
Total
146
100.00%
12
100.00%



static int inet6_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
{
	struct net *net = sock_net(in_skb->sk);
	struct nlattr *tb[RTA_MAX+1];
	struct rt6_info *rt;
	struct sk_buff *skb;
	struct rtmsg *rtm;
	struct flowi6 fl6;
	int err, iif = 0, oif = 0;

	err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv6_policy);
	if (err < 0)
		goto errout;

	err = -EINVAL;
	memset(&fl6, 0, sizeof(fl6));
	rtm = nlmsg_data(nlh);
	fl6.flowlabel = ip6_make_flowinfo(rtm->rtm_tos, 0);

	if (tb[RTA_SRC]) {
		if (nla_len(tb[RTA_SRC]) < sizeof(struct in6_addr))
			goto errout;

		fl6.saddr = *(struct in6_addr *)nla_data(tb[RTA_SRC]);
	}

	if (tb[RTA_DST]) {
		if (nla_len(tb[RTA_DST]) < sizeof(struct in6_addr))
			goto errout;

		fl6.daddr = *(struct in6_addr *)nla_data(tb[RTA_DST]);
	}

	if (tb[RTA_IIF])
		iif = nla_get_u32(tb[RTA_IIF]);

	if (tb[RTA_OIF])
		oif = nla_get_u32(tb[RTA_OIF]);

	if (tb[RTA_MARK])
		fl6.flowi6_mark = nla_get_u32(tb[RTA_MARK]);

	if (tb[RTA_UID])
		fl6.flowi6_uid = make_kuid(current_user_ns(),
					   nla_get_u32(tb[RTA_UID]));
	else
		fl6.flowi6_uid = iif ? INVALID_UID : current_uid();

	if (iif) {
		struct net_device *dev;
		int flags = 0;

		dev = __dev_get_by_index(net, iif);
		if (!dev) {
			err = -ENODEV;
			goto errout;
		}

		fl6.flowi6_iif = iif;

		if (!ipv6_addr_any(&fl6.saddr))
			flags |= RT6_LOOKUP_F_HAS_SADDR;

		rt = (struct rt6_info *)ip6_route_input_lookup(net, dev, &fl6,
							       flags);
	} else {
		fl6.flowi6_oif = oif;

		rt = (struct rt6_info *)ip6_route_output(net, NULL, &fl6);
	}

	if (rt == net->ipv6.ip6_null_entry) {
		err = rt->dst.error;
		ip6_rt_put(rt);
		goto errout;
	}

	skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
	if (!skb) {
		ip6_rt_put(rt);
		err = -ENOBUFS;
		goto errout;
	}

	skb_dst_set(skb, &rt->dst);

	err = rt6_fill_node(net, skb, rt, &fl6.daddr, &fl6.saddr, iif,
			    RTM_NEWROUTE, NETLINK_CB(in_skb).portid,
			    nlh->nlmsg_seq, 0);
	if (err < 0) {
		kfree_skb(skb);
		goto errout;
	}

	err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
errout:
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
162
28.72%
4
13.33%
Thomas Graf
136
24.11%
3
10.00%
Shmulik Ladkani
80
14.18%
2
6.67%
Lorenzo Colitti
56
9.93%
2
6.67%
Américo Wang
29
5.14%
2
6.67%
David S. Miller
24
4.26%
4
13.33%
Hannes Frederic Sowa
20
3.55%
1
3.33%
James Morris
17
3.01%
1
3.33%
Alexey Dobriyan
14
2.48%
1
3.33%
Denis V. Lunev
10
1.77%
2
6.67%
Eric Dumazet
4
0.71%
1
3.33%
Eric W. Biedermann
3
0.53%
2
6.67%
Hideaki Yoshifuji / 吉藤英明
3
0.53%
1
3.33%
Daniel Lezcano
2
0.35%
1
3.33%
Brian Haley
2
0.35%
1
3.33%
Krishna Kumar
1
0.18%
1
3.33%
Mathew Richardson
1
0.18%
1
3.33%
Total
564
100.00%
30
100.00%



void inet6_rt_notify(int event, struct rt6_info *rt, struct nl_info *info,
		     unsigned int nlm_flags)
{
	struct sk_buff *skb;
	struct net *net = info->nl_net;
	u32 seq;
	int err;

	err = -ENOBUFS;
	seq = info->nlh ? info->nlh->nlmsg_seq : 0;

	skb = nlmsg_new(rt6_nlmsg_size(rt), gfp_any());
	if (!skb)
		goto errout;

	err = rt6_fill_node(net, skb, rt, NULL, NULL, 0,
				event, info->portid, seq, nlm_flags);
	if (err < 0) {
		/* -EMSGSIZE implies BUG in rt6_nlmsg_size() */
		WARN_ON(err == -EMSGSIZE);
		kfree_skb(skb);
		goto errout;
	}
	rtnl_notify(skb, net, info->portid, RTNLGRP_IPV6_ROUTE,
		    info->nlh, gfp_any());
	return;
errout:
	if (err < 0)
		rtnl_set_sk_err(net, RTNLGRP_IPV6_ROUTE, err);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
57
33.14%
5
22.73%
Thomas Graf
45
26.16%
3
13.64%
Patrick McHardy
21
12.21%
2
9.09%
Denis V. Lunev
16
9.30%
2
9.09%
Daniel Lezcano
11
6.40%
1
4.55%
Roopa Prabhu
8
4.65%
2
9.09%
Jamal Hadi Salim
4
2.33%
1
4.55%
Mathew Richardson
3
1.74%
1
4.55%
Brian Haley
2
1.16%
1
4.55%
Eric W. Biedermann
2
1.16%
1
4.55%
David S. Miller
1
0.58%
1
4.55%
Krishna Kumar
1
0.58%
1
4.55%
Pablo Neira Ayuso
1
0.58%
1
4.55%
Total
172
100.00%
22
100.00%



static int ip6_route_dev_notify(struct notifier_block *this,
				unsigned long event, void *ptr)
{
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
	struct net *net = dev_net(dev);

	if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
		net->ipv6.ip6_null_entry->dst.dev = dev;
		net->ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(dev);
#ifdef CONFIG_IPV6_MULTIPLE_TABLES
		net->ipv6.ip6_prohibit_entry->dst.dev = dev;
		net->ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(dev);
		net->ipv6.ip6_blk_hole_entry->dst.dev = dev;
		net->ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(dev);
#endif
	}

	return NOTIFY_OK;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Daniel Lezcano
130
94.20%
1
33.33%
Jiri Pirko
5
3.62%
1
33.33%
Hideaki Yoshifuji / 吉藤英明
3
2.17%
1
33.33%
Total
138
100.00%
3
100.00%

/*
 *      /proc
 */

#ifdef CONFIG_PROC_FS


static const struct file_operations ipv6_route_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= ipv6_route_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= seq_release_net,
};



static int rt6_stats_seq_show(struct seq_file *seq, void *v)
{
	struct net *net = (struct net *)seq->private;
	seq_printf(seq, "%04x %04x %04x %04x %04x %04x %04x\n",
		   net->ipv6.rt6_stats->fib_nodes,
		   net->ipv6.rt6_stats->fib_route_nodes,
		   net->ipv6.rt6_stats->fib_rt_alloc,
		   net->ipv6.rt6_stats->fib_rt_entries,
		   net->ipv6.rt6_stats->fib_rt_cache,
		   dst_entries_get_slow(&net->ipv6.ip6_dst_ops),
		   net->ipv6.rt6_stats->fib_discarded_routes);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
33
34.02%
3
30.00%
Daniel Lezcano
32
32.99%
2
20.00%
Benjamin Thery
16
16.49%
2
20.00%
Randy Dunlap
15
15.46%
2
20.00%
Eric Dumazet
1
1.03%
1
10.00%
Total
97
100.00%
10
100.00%



static int rt6_stats_seq_open(struct inode *inode, struct file *file)
{
	return single_open_net(inode, file, rt6_stats_seq_show);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Randy Dunlap
19
73.08%
1
20.00%
Pavel Emelyanov
4
15.38%
2
40.00%
Daniel Lezcano
2
7.69%
1
20.00%
Linus Torvalds (pre-git)
1
3.85%
1
20.00%
Total
26
100.00%
5
100.00%


static const struct file_operations rt6_stats_seq_fops = {
	.owner	 = THIS_MODULE,
	.open	 = rt6_stats_seq_open,
	.read	 = seq_read,
	.llseek	 = seq_lseek,
	.release = single_release_net,
};
#endif	/* CONFIG_PROC_FS */

#ifdef CONFIG_SYSCTL


static

int ipv6_sysctl_rtcache_flush(struct ctl_table *ctl, int write,
			      void __user *buffer, size_t *lenp, loff_t *ppos)
{
	struct net *net;
	int delay;
	if (!write)
		return -EINVAL;

	net = (struct net *)ctl->extra1;
	delay = net->ipv6.sysctl.flush_delay;
	proc_dointvec(ctl, write, buffer, lenp, ppos);
	fib6_run_gc(delay <= 0 ? 0 : (unsigned long)delay, net, delay > 0);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
43
42.16%
1
11.11%
Lucian Adrian Grijincu
24
23.53%
1
11.11%
Daniel Lezcano
18
17.65%
2
22.22%
Linus Torvalds
6
5.88%
1
11.11%
Michal Kubeček
5
4.90%
1
11.11%
Hideaki Yoshifuji / 吉藤英明
4
3.92%
1
11.11%
Al Viro
1
0.98%
1
11.11%
Joe Perches
1
0.98%
1
11.11%
Total
102
100.00%
9
100.00%


struct ctl_table ipv6_route_table_template[] = {
	{
		.procname	=	"flush",
		.data		=	&init_net.ipv6.sysctl.flush_delay,
		.maxlen		=	sizeof(int),
		.mode		=	0200,
		.proc_handler	=	ipv6_sysctl_rtcache_flush
	},
	{
		.procname	=	"gc_thresh",
		.data		=	&ip6_dst_ops_template.gc_thresh,
		.maxlen		=	sizeof(int),
		.mode		=	0644,
		.proc_handler	=	proc_dointvec,
        },
	{
		.procname	=	"max_size",
		.data		=	&init_net.ipv6.sysctl.ip6_rt_max_size,
		.maxlen		=	sizeof(int),
		.mode		=	0644,
		.proc_handler	=	proc_dointvec,
        },
	{
		.procname	=	"gc_min_interval",
		.data		=	&init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
		.maxlen		=	sizeof(int),
		.mode		=	0644,
		.proc_handler	=	proc_dointvec_jiffies,
        },
	{
		.procname	=	"gc_timeout",
		.data		=	&init_net.ipv6.sysctl.ip6_rt_gc_timeout,
		.maxlen		=	sizeof(int),
		.mode		=	0644,
		.proc_handler	=	proc_dointvec_jiffies,
        },
	{
		.procname	=	"gc_interval",
		.data		=	&init_net.ipv6.sysctl.ip6_rt_gc_interval,
		.maxlen		=	sizeof(int),
		.mode		=	0644,
		.proc_handler	=	proc_dointvec_jiffies,
        },
	{
		.procname	=	"gc_elasticity",
		.data		=	&init_net.ipv6.sysctl.ip6_rt_gc_elasticity,
		.maxlen		=	sizeof(int),
		.mode		=	0644,
		.proc_handler	=	proc_dointvec,
        },
	{
		.procname	=	"mtu_expires",
		.data		=	&init_net.ipv6.sysctl.ip6_rt_mtu_expires,
		.maxlen		=	sizeof(int),
		.mode		=	0644,
		.proc_handler	=	proc_dointvec_jiffies,
        },
	{
		.procname	=	"min_adv_mss",
		.data		=	&init_net.ipv6.sysctl.ip6_rt_min_advmss,
		.maxlen		=	sizeof(int),
		.mode		=	0644,
		.proc_handler	=	proc_dointvec,
        },
	{
		.procname	=	"gc_min_interval_ms",
		.data		=	&init_net.ipv6.sysctl.ip6_rt_gc_min_interval,
		.maxlen		=	sizeof(int),
		.mode		=	0644,
		.proc_handler	=	proc_dointvec_ms_jiffies,
        },
	{ }
};



struct ctl_table * __net_init ipv6_route_sysctl_init(struct net *net)
{
	struct ctl_table *table;

	table = kmemdup(ipv6_route_table_template,
			sizeof(ipv6_route_table_template),
			GFP_KERNEL);

	if (table) {
		table[0].data = &net->ipv6.sysctl.flush_delay;
		table[0].extra1 = net;
		table[1].data = &net->ipv6.ip6_dst_ops.gc_thresh;
		table[2].data = &net->ipv6.sysctl.ip6_rt_max_size;
		table[3].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;
		table[4].data = &net->ipv6.sysctl.ip6_rt_gc_timeout;
		table[5].data = &net->ipv6.sysctl.ip6_rt_gc_interval;
		table[6].data = &net->ipv6.sysctl.ip6_rt_gc_elasticity;
		table[7].data = &net->ipv6.sysctl.ip6_rt_mtu_expires;
		table[8].data = &net->ipv6.sysctl.ip6_rt_min_advmss;
		table[9].data = &net->ipv6.sysctl.ip6_rt_gc_min_interval;

		/* Don't export sysctls to unprivileged users */
		if (net->user_ns != &init_user_ns)
			table[0].procname = NULL;
	}

	return table;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Hideaki Yoshifuji / 吉藤英明
134
58.52%
1
11.11%
Daniel Lezcano
45
19.65%
2
22.22%
Eric W. Biedermann
19
8.30%
1
11.11%
Alexey Dobriyan
18
7.86%
3
33.33%
Lucian Adrian Grijincu
9
3.93%
1
11.11%
Benjamin Thery
4
1.75%
1
11.11%
Total
229
100.00%
9
100.00%

#endif



static int __net_init ip6_route_net_init(struct net *net)
{
	int ret = -ENOMEM;

	memcpy(&net->ipv6.ip6_dst_ops, &ip6_dst_ops_template,
	       sizeof(net->ipv6.ip6_dst_ops));

	if (dst_entries_init(&net->ipv6.ip6_dst_ops) < 0)
		goto out_ip6_dst_ops;

	net->ipv6.ip6_null_entry = kmemdup(&ip6_null_entry_template,
					   sizeof(*net->ipv6.ip6_null_entry),
					   GFP_KERNEL);
	if (!net->ipv6.ip6_null_entry)
		goto out_ip6_dst_entries;
	net->ipv6.ip6_null_entry->dst.path =
		(struct dst_entry *)net->ipv6.ip6_null_entry;
	net->ipv6.ip6_null_entry->dst.ops = &net->ipv6.ip6_dst_ops;
	dst_init_metrics(&net->ipv6.ip6_null_entry->dst,
			 ip6_template_metrics, true);

#ifdef CONFIG_IPV6_MULTIPLE_TABLES
	net->ipv6.ip6_prohibit_entry = kmemdup(&ip6_prohibit_entry_template,
					       sizeof(*net->ipv6.ip6_prohibit_entry),
					       GFP_KERNEL);
	if (!net->ipv6.ip6_prohibit_entry)
		goto out_ip6_null_entry;
	net->ipv6.ip6_prohibit_entry->dst.path =
		(struct dst_entry *)net->ipv6.ip6_prohibit_entry;
	net->ipv6.ip6_prohibit_entry->dst.ops = &net->ipv6.ip6_dst_ops;
	dst_init_metrics(&net->ipv6.ip6_prohibit_entry->dst,
			 ip6_template_metrics, true);

	net->ipv6.ip6_blk_hole_entry = kmemdup(&ip6_blk_hole_entry_template,
					       sizeof(*net->ipv6.ip6_blk_hole_entry),
					       GFP_KERNEL);
	if (!net->ipv6.ip6_blk_hole_entry)
		goto out_ip6_prohibit_entry;
	net->ipv6.ip6_blk_hole_entry->dst.path =
		(struct dst_entry *)net->ipv6.ip6_blk_hole_entry;
	net->ipv6.ip6_blk_hole_entry->dst.ops = &net->ipv6.ip6_dst_ops;
	dst_init_metrics(&net->ipv6.ip6_blk_hole_entry->dst,
			 ip6_template_metrics, true);
#endif

	net->ipv6.sysctl.flush_delay = 0;
	net->ipv6.sysctl.ip6_rt_max_size = 4096;
	net->ipv6.sysctl.ip6_rt_gc_min_interval = HZ / 2;
	net->ipv6.sysctl.ip6_rt_gc_timeout = 60*HZ;
	net->ipv6.sysctl.ip6_rt_gc_interval = 30*HZ;
	net->ipv6.sysctl.ip6_rt_gc_elasticity = 9;
	net->ipv6.sysctl.ip6_rt_mtu_expires = 10*60*HZ;
	net->ipv6.sysctl.ip6_rt_min_advmss = IPV6_MIN_MTU - 20 - 40;

	net->ipv6.ip6_rt_gc_expire = 30*HZ;

	ret = 0;
out:
	return ret;

#ifdef CONFIG_IPV6_MULTIPLE_TABLES
out_ip6_prohibit_entry:
	kfree(net->ipv6.ip6_prohibit_entry);
out_ip6_null_entry:
	kfree(net->ipv6.ip6_null_entry);
#endif
out_ip6_dst_entries:
	dst_entries_destroy(&net->ipv6.ip6_dst_ops);
out_ip6_dst_ops:
	goto out;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Daniel Lezcano
234
47.85%
4
26.67%
Peter Zijlstra
123
25.15%
2
13.33%
David S. Miller
48
9.82%
2
13.33%
Benjamin Thery
44
9.00%
2
13.33%
Eric Dumazet
30
6.13%
1
6.67%
Alexey Dobriyan
8
1.64%
2
13.33%
Pavel Emelyanov
1
0.20%
1
6.67%
Denis V. Lunev
1
0.20%
1
6.67%
Total
489
100.00%
15
100.00%



static void __net_exit ip6_route_net_exit(struct net *net)
{
	kfree(net->ipv6.ip6_null_entry);
#ifdef CONFIG_IPV6_MULTIPLE_TABLES
	kfree(net->ipv6.ip6_prohibit_entry);
	kfree(net->ipv6.ip6_blk_hole_entry);
#endif
	dst_entries_destroy(&net->ipv6.ip6_dst_ops);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Daniel Lezcano
43
79.63%
1
33.33%
Xiaotian Feng
10
18.52%
1
33.33%
Alexey Dobriyan
1
1.85%
1
33.33%
Total
54
100.00%
3
100.00%



static int __net_init ip6_route_net_init_late(struct net *net)
{
#ifdef CONFIG_PROC_FS
	proc_create("ipv6_route", 0, net->proc_net, &ipv6_route_proc_fops);
	proc_create("rt6_stats", S_IRUGO, net->proc_net, &rt6_stats_seq_fops);
#endif
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Thomas Graf
38
79.17%
1
50.00%
Gao Feng
10
20.83%
1
50.00%
Total
48
100.00%
2
100.00%



static void __net_exit ip6_route_net_exit_late(struct net *net)
{
#ifdef CONFIG_PROC_FS
	remove_proc_entry("ipv6_route", net->proc_net);
	remove_proc_entry("rt6_stats", net->proc_net);
#endif
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Thomas Graf
25
71.43%
1
50.00%
Gao Feng
10
28.57%
1
50.00%
Total
35
100.00%
2
100.00%


static struct pernet_operations ip6_route_net_ops = {
	.init = ip6_route_net_init,
	.exit = ip6_route_net_exit,
};



static int __net_init ipv6_inetpeer_init(struct net *net)
{
	struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);

	if (!bp)
		return -ENOMEM;
	inet_peer_base_init(bp);
	net->ipv6.peers = bp;
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
53
100.00%
1
100.00%
Total
53
100.00%
1
100.00%



static void __net_exit ipv6_inetpeer_exit(struct net *net)
{
	struct inet_peer_base *bp = net->ipv6.peers;

	net->ipv6.peers = NULL;
	inetpeer_invalidate_tree(bp);
	kfree(bp);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
41
100.00%
2
100.00%
Total
41
100.00%
2
100.00%


static struct pernet_operations ipv6_inetpeer_ops = {
	.init	=	ipv6_inetpeer_init,
	.exit	=	ipv6_inetpeer_exit,
};


static struct pernet_operations ip6_route_net_late_ops = {
	.init = ip6_route_net_init_late,
	.exit = ip6_route_net_exit_late,
};


static struct notifier_block ip6_route_dev_notifier = {
	.notifier_call = ip6_route_dev_notify,
	.priority = 0,
};



int __init ip6_route_init(void)
{
	int ret;
	int cpu;

	ret = -ENOMEM;
	ip6_dst_ops_template.kmem_cachep =
		kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
				  SLAB_HWCACHE_ALIGN, NULL);
	if (!ip6_dst_ops_template.kmem_cachep)
		goto out;

	ret = dst_entries_init(&ip6_dst_blackhole_ops);
	if (ret)
		goto out_kmem_cache;

	ret = register_pernet_subsys(&ipv6_inetpeer_ops);
	if (ret)
		goto out_dst_entries;

	ret = register_pernet_subsys(&ip6_route_net_ops);
	if (ret)
		goto out_register_inetpeer;

	ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops_template.kmem_cachep;

	/* Registering of the loopback is done before this portion of code,
         * the loopback reference in rt6_info will not be taken, do it
         * manually for init_net */
	init_net.ipv6.ip6_null_entry->dst.dev = init_net.loopback_dev;
	init_net.ipv6.ip6_null_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
  #ifdef CONFIG_IPV6_MULTIPLE_TABLES
	init_net.ipv6.ip6_prohibit_entry->dst.dev = init_net.loopback_dev;
	init_net.ipv6.ip6_prohibit_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
	init_net.ipv6.ip6_blk_hole_entry->dst.dev = init_net.loopback_dev;
	init_net.ipv6.ip6_blk_hole_entry->rt6i_idev = in6_dev_get(init_net.loopback_dev);
  #endif
	ret = fib6_init();
	if (ret)
		goto out_register_subsys;

	ret = xfrm6_init();
	if (ret)
		goto out_fib6_init;

	ret = fib6_rules_init();
	if (ret)
		goto xfrm6_init;

	ret = register_pernet_subsys(&ip6_route_net_late_ops);
	if (ret)
		goto fib6_rules_init;

	ret = -ENOBUFS;
	if (__rtnl_register(PF_INET6, RTM_NEWROUTE, inet6_rtm_newroute, NULL, NULL) ||
	    __rtnl_register(PF_INET6, RTM_DELROUTE, inet6_rtm_delroute, NULL, NULL) ||
	    __rtnl_register(PF_INET6, RTM_GETROUTE, inet6_rtm_getroute, NULL, NULL))
		goto out_register_late_subsys;

	ret = register_netdevice_notifier(&ip6_route_dev_notifier);
	if (ret)
		goto out_register_late_subsys;

	for_each_possible_cpu(cpu) {
		struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);

		INIT_LIST_HEAD(&ul->head);
		spin_lock_init(&ul->lock);
	}

out:
	return ret;

out_register_late_subsys:
	unregister_pernet_subsys(&ip6_route_net_late_ops);
fib6_rules_init:
	fib6_rules_cleanup();
xfrm6_init:
	xfrm6_fini();
out_fib6_init:
	fib6_gc_cleanup();
out_register_subsys:
	unregister_pernet_subsys(&ip6_route_net_ops);
out_register_inetpeer:
	unregister_pernet_subsys(&ipv6_inetpeer_ops);
out_dst_entries:
	dst_entries_destroy(&ip6_dst_blackhole_ops);
out_kmem_cache:
	kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
	goto out;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Daniel Lezcano
212
51.71%
6
27.27%
Thomas Graf
59
14.39%
3
13.64%
Martin KaFai Lau
38
9.27%
1
4.55%
David S. Miller
29
7.07%
3
13.64%
Linus Torvalds (pre-git)
29
7.07%
4
18.18%
Eric Dumazet
23
5.61%
1
4.55%
Arnaud Ebalard
8
1.95%
1
4.55%
Greg Rose
6
1.46%
1
4.55%
Hideaki Yoshifuji / 吉藤英明
3
0.73%
1
4.55%
Benjamin Thery
3
0.73%
1
4.55%
Total
410
100.00%
22
100.00%



void ip6_route_cleanup(void)
{
	unregister_netdevice_notifier(&ip6_route_dev_notifier);
	unregister_pernet_subsys(&ip6_route_net_late_ops);
	fib6_rules_cleanup();
	xfrm6_fini();
	fib6_gc_cleanup();
	unregister_pernet_subsys(&ipv6_inetpeer_ops);
	unregister_pernet_subsys(&ip6_route_net_ops);
	dst_entries_destroy(&ip6_dst_blackhole_ops);
	kmem_cache_destroy(ip6_dst_ops_template.kmem_cachep);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
13
24.53%
4
28.57%
Daniel Lezcano
11
20.75%
2
14.29%
David S. Miller
6
11.32%
1
7.14%
Xiaotian Feng
6
11.32%
1
7.14%
Thomas Graf
6
11.32%
1
7.14%
Daniel McNeil
5
9.43%
1
7.14%
Benjamin Thery
2
3.77%
1
7.14%
Hideaki Yoshifuji / 吉藤英明
2
3.77%
1
7.14%
Kazunori Miyazawa
1
1.89%
1
7.14%
Eric W. Biedermann
1
1.89%
1
7.14%
Total
53
100.00%
14
100.00%

Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
3176
15.13%
26
5.30%
David S. Miller
2334
11.12%
50
10.18%
Hideaki Yoshifuji / 吉藤英明
2258
10.76%
83
16.90%
Martin KaFai Lau
2252
10.73%
23
4.68%
Thomas Graf
1776
8.46%
18
3.67%
David Ahern
1637
7.80%
26
5.30%
Daniel Lezcano
1265
6.03%
21
4.28%
Roopa Prabhu
1090
5.19%
6
1.22%
Duan Jiong
558
2.66%
4
0.81%
Nicolas Dichtel
487
2.32%
9
1.83%
Daniel Walter
304
1.45%
1
0.20%
Hannes Frederic Sowa
294
1.40%
8
1.63%
Florian Westphal
269
1.28%
6
1.22%
Eric Dumazet
214
1.02%
14
2.85%
Julian Anastasov
202
0.96%
4
0.81%
Steffen Klassert
143
0.68%
5
1.02%
Shmulik Ladkani
142
0.68%
2
0.41%
Benjamin Thery
136
0.65%
6
1.22%
Lorenzo Colitti
132
0.63%
5
1.02%
Gao Feng
127
0.61%
5
1.02%
Peter Zijlstra
123
0.59%
2
0.41%
Daniel Borkmann
114
0.54%
4
0.81%
Jiri Benc
106
0.51%
7
1.43%
Alexey Kuznetsov
92
0.44%
3
0.61%
Alexey Dobriyan
91
0.43%
5
1.02%
Lubomir Rintel
82
0.39%
1
0.20%
Denis V. Lunev
80
0.38%
7
1.43%
Eric W. Biedermann
77
0.37%
9
1.83%
Kamala R
73
0.35%
1
0.20%
Xin Long
73
0.35%
2
0.41%
Patrick McHardy
71
0.34%
7
1.43%
Randy Dunlap
68
0.32%
4
0.81%
Maciej Żenczykowski
65
0.31%
2
0.41%
Américo Wang
64
0.30%
3
0.61%
Shirley Ma
61
0.29%
3
0.61%
Matti Vaittinen
60
0.29%
1
0.20%
Pavel Emelyanov
48
0.23%
7
1.43%
Al Viro
47
0.22%
3
0.61%
Tom Herbert
47
0.22%
3
0.61%
James Morris
42
0.20%
3
0.61%
Zheng Yan
39
0.19%
1
0.20%
Andy Gospodarek
39
0.19%
1
0.20%
Vincent Bernat
39
0.19%
1
0.20%
Lucian Adrian Grijincu
33
0.16%
1
0.20%
Herbert Xu
32
0.15%
6
1.22%
Ville Nuorvala
31
0.15%
2
0.41%
Tom Tucker
29
0.14%
1
0.20%
Brian Haley
28
0.13%
4
0.81%
Mathew Richardson
28
0.13%
1
0.20%
Paolo Abeni
21
0.10%
3
0.61%
Krishna Kumar
20
0.10%
2
0.41%
Lv Liangying
20
0.10%
1
0.20%
Roland Dreier
17
0.08%
1
0.20%
Stephen Hemminger
16
0.08%
2
0.41%
Xiaotian Feng
16
0.08%
1
0.20%
Jean-Mickael Guerin
15
0.07%
1
0.20%
Mantas M
15
0.07%
1
0.20%
Jamal Hadi Salim
14
0.07%
2
0.41%
Nikola Forró
14
0.07%
1
0.20%
Linus Torvalds
14
0.07%
3
0.61%
Alexander Aring
14
0.07%
1
0.20%
Michal Kubeček
13
0.06%
3
0.61%
Denis Ovsienko
13
0.06%
1
0.20%
Joe Perches
12
0.06%
3
0.61%
Liping Zhang
11
0.05%
1
0.20%
Paul Marks
10
0.05%
1
0.20%
Arnaldo Carvalho de Melo
10
0.05%
3
0.61%
Sabrina Dubroca
10
0.05%
1
0.20%
Li RongQing
10
0.05%
4
0.81%
Kazunori Miyazawa
10
0.05%
2
0.41%
Noriaki Takamiya
8
0.04%
1
0.20%
Arnaud Ebalard
8
0.04%
1
0.20%
Erik Nordmark
7
0.03%
2
0.41%
Dave Craig
6
0.03%
1
0.20%
Simon Horman
6
0.03%
1
0.20%
Greg Rose
6
0.03%
1
0.20%
Jiri Pirko
5
0.02%
1
0.20%
Mahesh Bandewar
5
0.02%
1
0.20%
Daniel McNeil
5
0.02%
1
0.20%
Li Wei
5
0.02%
1
0.20%
David McCullough
5
0.02%
1
0.20%
Held Bernhard
4
0.02%
1
0.20%
Jens Rosenboom
4
0.02%
1
0.20%
Tejun Heo
3
0.01%
1
0.20%
Changli Gao
3
0.01%
1
0.20%
Matthias Schiffer
3
0.01%
1
0.20%
Adrian Bunk
3
0.01%
3
0.61%
Johannes Berg
3
0.01%
1
0.20%
Paul Gortmaker
3
0.01%
1
0.20%
Alexander Alemayhu
2
0.01%
1
0.20%
Simon Arlott
2
0.01%
1
0.20%
Jiri Olsa
2
0.01%
1
0.20%
Dave Jones
2
0.01%
2
0.41%
Rami Rosen
2
0.01%
1
0.20%
Stephen Rothwell
2
0.01%
1
0.20%
Min Zhang
2
0.01%
1
0.20%
Ian Morris
1
0.00%
1
0.20%
Arjan van de Ven
1
0.00%
1
0.20%
Nikolay Aleksandrov
1
0.00%
1
0.20%
Pablo Neira Ayuso
1
0.00%
1
0.20%
Michael Büsch
1
0.00%
1
0.20%
Jim Paris
1
0.00%
1
0.20%
Total
20985
100.00%
491
100.00%
Directory: net/ipv6

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.