Release 4.14 net/ipv4/route.c

/*
 * INET         An implementation of the TCP/IP protocol suite for the LINUX
 *              operating system.  INET is implemented using the  BSD Socket
 *              interface as the means of communication with the user level.
 *
 *              ROUTE - implementation of the IP router.
 *
 * Authors:     Ross Biro
 *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
 *              Alan Cox, <gw4pts@gw4pts.ampr.org>
 *              Linus Torvalds, <Linus.Torvalds@helsinki.fi>
 *              Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 *
 * Fixes:
 *              Alan Cox        :       Verify area fixes.
 *              Alan Cox        :       cli() protects routing changes
 *              Rui Oliveira    :       ICMP routing table updates
 *              (rco@di.uminho.pt)      Routing table insertion and update
 *              Linus Torvalds  :       Rewrote bits to be sensible
 *              Alan Cox        :       Added BSD route gw semantics
 *              Alan Cox        :       Super /proc >4K
 *              Alan Cox        :       MTU in route table
 *              Alan Cox        :       MSS actually. Also added the window
 *                                      clamper.
 *              Sam Lantinga    :       Fixed route matching in rt_del()
 *              Alan Cox        :       Routing cache support.
 *              Alan Cox        :       Removed compatibility cruft.
 *              Alan Cox        :       RTF_REJECT support.
 *              Alan Cox        :       TCP irtt support.
 *              Jonathan Naylor :       Added Metric support.
 *      Miquel van Smoorenburg  :       BSD API fixes.
 *      Miquel van Smoorenburg  :       Metrics.
 *              Alan Cox        :       Use __u32 properly
 *              Alan Cox        :       Aligned routing errors more closely with BSD
 *                                      our system is still very different.
 *              Alan Cox        :       Faster /proc handling
 *      Alexey Kuznetsov        :       Massive rework to support tree based routing,
 *                                      routing caches and better behaviour.
 *
 *              Olaf Erb        :       irtt wasn't being copied right.
 *              Bjorn Ekwall    :       Kerneld route support.
 *              Alan Cox        :       Multicast fixed (I hope)
 *              Pavel Krauz     :       Limited broadcast fixed
 *              Mike McLagan    :       Routing by source
 *      Alexey Kuznetsov        :       End of old history. Split to fib.c and
 *                                      route.c and rewritten from scratch.
 *              Andi Kleen      :       Load-limit warning messages.
 *      Vitaly E. Lavrov        :       Transparent proxy revived after year coma.
 *      Vitaly E. Lavrov        :       Race condition in ip_route_input_slow.
 *      Tobias Ringstrom        :       Uninitialized res.type in ip_route_output_slow.
 *      Vladimir V. Ivanov      :       IP rule info (flowid) is really useful.
 *              Marc Boucher    :       routing by fwmark
 *      Robert Olsson           :       Added rt_cache statistics
 *      Arnaldo C. Melo         :       Convert proc stuff to seq_file
 *      Eric Dumazet            :       hashed spinlocks and rt_check_expire() fixes.
 *      Ilia Sotnikov           :       Ignore TOS on PMTUD and Redirect
 *      Ilia Sotnikov           :       Removed TOS from hash calculations
 *
 *              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.
 */


#define pr_fmt(fmt) "IPv4: " fmt

#include <linux/module.h>
#include <linux/uaccess.h>
#include <linux/bitops.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/errno.h>
#include <linux/in.h>
#include <linux/inet.h>
#include <linux/netdevice.h>
#include <linux/proc_fs.h>
#include <linux/init.h>
#include <linux/skbuff.h>
#include <linux/inetdevice.h>
#include <linux/igmp.h>
#include <linux/pkt_sched.h>
#include <linux/mroute.h>
#include <linux/netfilter_ipv4.h>
#include <linux/random.h>
#include <linux/rcupdate.h>
#include <linux/times.h>
#include <linux/slab.h>
#include <linux/jhash.h>
#include <net/dst.h>
#include <net/dst_metadata.h>
#include <net/net_namespace.h>
#include <net/protocol.h>
#include <net/ip.h>
#include <net/route.h>
#include <net/inetpeer.h>
#include <net/sock.h>
#include <net/ip_fib.h>
#include <net/arp.h>
#include <net/tcp.h>
#include <net/icmp.h>
#include <net/xfrm.h>
#include <net/lwtunnel.h>
#include <net/netevent.h>
#include <net/rtnetlink.h>
#ifdef CONFIG_SYSCTL
#include <linux/sysctl.h>
#include <linux/kmemleak.h>
#endif
#include <net/secure_seq.h>
#include <net/ip_tunnels.h>
#include <net/l3mdev.h>

#include "fib_lookup.h"


#define RT_FL_TOS(oldflp4) \
	((oldflp4)->flowi4_tos & (IPTOS_RT_MASK | RTO_ONLINK))


#define RT_GC_TIMEOUT (300*HZ)


static int ip_rt_max_size;

static int ip_rt_redirect_number __read_mostly	= 9;

static int ip_rt_redirect_load __read_mostly	= HZ / 50;

static int ip_rt_redirect_silence __read_mostly	= ((HZ / 50) << (9 + 1));

static int ip_rt_error_cost __read_mostly	= HZ;

static int ip_rt_error_burst __read_mostly	= 5 * HZ;

static int ip_rt_mtu_expires __read_mostly	= 10 * 60 * HZ;

static int ip_rt_min_pmtu __read_mostly		= 512 + 20 + 20;

static int ip_rt_min_advmss __read_mostly	= 256;


static int ip_rt_gc_timeout __read_mostly	= RT_GC_TIMEOUT;
/*
 *      Interface to generic destination cache.
 */

static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
static unsigned int	 ipv4_default_advmss(const struct dst_entry *dst);
static unsigned int	 ipv4_mtu(const struct dst_entry *dst);
static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
static void		 ipv4_link_failure(struct sk_buff *skb);
static void		 ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
					   struct sk_buff *skb, u32 mtu);
static void		 ip_do_redirect(struct dst_entry *dst, struct sock *sk,
					struct sk_buff *skb);
static void		ipv4_dst_destroy(struct dst_entry *dst);



static u32 *ipv4_cow_metrics(struct dst_entry *dst, unsigned long old)
{
	WARN_ON(1);
	return NULL;
}

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

static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
					   struct sk_buff *skb,
					   const void *daddr);
static void ipv4_confirm_neigh(const struct dst_entry *dst, const void *daddr);


static struct dst_ops ipv4_dst_ops = {
	.family =		AF_INET,
	.check =		ipv4_dst_check,
	.default_advmss =	ipv4_default_advmss,
	.mtu =			ipv4_mtu,
	.cow_metrics =		ipv4_cow_metrics,
	.destroy =		ipv4_dst_destroy,
	.negative_advice =	ipv4_negative_advice,
	.link_failure =		ipv4_link_failure,
	.update_pmtu =		ip_rt_update_pmtu,
	.redirect =		ip_do_redirect,
	.local_out =		__ip_local_out,
	.neigh_lookup =		ipv4_neigh_lookup,
	.confirm_neigh =	ipv4_confirm_neigh,
};


#define ECN_OR_COST(class)	TC_PRIO_##class


const __u8 ip_tos2prio[16] = {
	TC_PRIO_BESTEFFORT,
	ECN_OR_COST(BESTEFFORT),
	TC_PRIO_BESTEFFORT,
	ECN_OR_COST(BESTEFFORT),
	TC_PRIO_BULK,
	ECN_OR_COST(BULK),
	TC_PRIO_BULK,
	ECN_OR_COST(BULK),
	TC_PRIO_INTERACTIVE,
	ECN_OR_COST(INTERACTIVE),
	TC_PRIO_INTERACTIVE,
	ECN_OR_COST(INTERACTIVE),
	TC_PRIO_INTERACTIVE_BULK,
	ECN_OR_COST(INTERACTIVE_BULK),
	TC_PRIO_INTERACTIVE_BULK,
	ECN_OR_COST(INTERACTIVE_BULK)
};

EXPORT_SYMBOL(ip_tos2prio);

static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);

#define RT_CACHE_STAT_INC(field) raw_cpu_inc(rt_cache_stat.field)

#ifdef CONFIG_PROC_FS


static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
{
	if (*pos)
		return NULL;
	return SEQ_START_TOKEN;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
23
85.19%
1
50.00%
Pavel Emelyanov
4
14.81%
1
50.00%
Total
27
100.00%
2
100.00%



static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	++*pos;
	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
24
88.89%
1
25.00%
Linus Torvalds (pre-git)
2
7.41%
2
50.00%
Eric Dumazet
1
3.70%
1
25.00%
Total
27
100.00%
4
100.00%



static void rt_cache_seq_stop(struct seq_file *seq, void *v)
{
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
12
85.71%
1
50.00%
Adrian Bunk
2
14.29%
1
50.00%
Total
14
100.00%
2
100.00%



static int rt_cache_seq_show(struct seq_file *seq, void *v)
{
	if (v == SEQ_START_TOKEN)
		seq_printf(seq, "%-127s\n",
			   "Iface\tDestination\tGateway \tFlags\t\tRefCnt\tUse\t"
			   "Metric\tSource\t\tMTU\tWindow\tIRTT\tTOS\tHHRef\t"
			   "HHUptod\tSpecDst");
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
26
74.29%
2
33.33%
Linus Torvalds (pre-git)
6
17.14%
2
33.33%
Stephen Hemminger
2
5.71%
1
16.67%
Denis V. Lunev
1
2.86%
1
16.67%
Total
35
100.00%
6
100.00%


static const struct seq_operations rt_cache_seq_ops = {
	.start  = rt_cache_seq_start,
	.next   = rt_cache_seq_next,
	.stop   = rt_cache_seq_stop,
	.show   = rt_cache_seq_show,
};



static int rt_cache_seq_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &rt_cache_seq_ops);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Denis V. Lunev
13
52.00%
1
50.00%
David S. Miller
12
48.00%
1
50.00%
Total
25
100.00%
2
100.00%


static const struct file_operations rt_cache_seq_fops = {
	.owner	 = THIS_MODULE,
	.open	 = rt_cache_seq_open,
	.read	 = seq_read,
	.llseek	 = seq_lseek,
	.release = seq_release,
};




static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
{
	int cpu;

	if (*pos == 0)
		return SEQ_START_TOKEN;

	for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
		if (!cpu_possible(cpu))
			continue;
		*pos = cpu+1;
		return &per_cpu(rt_cache_stat, cpu);
	}
	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
44
58.67%
1
11.11%
Linus Torvalds (pre-git)
12
16.00%
3
33.33%
Eric Dumazet
10
13.33%
3
33.33%
Arnaldo Carvalho de Melo
7
9.33%
1
11.11%
Hideaki Yoshifuji / 吉藤英明
2
2.67%
1
11.11%
Total
75
100.00%
9
100.00%



static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	int cpu;

	for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
		if (!cpu_possible(cpu))
			continue;
		*pos = cpu+1;
		return &per_cpu(rt_cache_stat, cpu);
	}
	return NULL;

}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
40
59.70%
1
16.67%
Arnaldo Carvalho de Melo
16
23.88%
1
16.67%
Eric Dumazet
7
10.45%
2
33.33%
Hideaki Yoshifuji / 吉藤英明
3
4.48%
1
16.67%
Linus Torvalds (pre-git)
1
1.49%
1
16.67%
Total
67
100.00%
6
100.00%



static void rt_cpu_seq_stop(struct seq_file *seq, void *v)
{

}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
11
78.57%
1
50.00%
Denis V. Lunev
3
21.43%
1
50.00%
Total
14
100.00%
2
100.00%



static int rt_cpu_seq_show(struct seq_file *seq, void *v)
{
	struct rt_cache_stat *st = v;

	if (v == SEQ_START_TOKEN) {
		seq_printf(seq, "entries  in_hit in_slow_tot in_slow_mc in_no_route in_brd in_martian_dst in_martian_src  out_hit out_slow_tot out_slow_mc  gc_total gc_ignored gc_goal_miss gc_dst_overflow in_hlist_search out_hlist_search\n");
		return 0;
	}

	seq_printf(seq,"%08x  %08x %08x %08x %08x %08x %08x %08x "
		   " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
		   dst_entries_get_slow(&ipv4_dst_ops),
		   0, /* st->in_hit */
		   st->in_slow_tot,
		   st->in_slow_mc,
		   st->in_no_route,
		   st->in_brd,
		   st->in_martian_dst,
		   st->in_martian_src,

		   0, /* st->out_hit */
		   st->out_slow_tot,
		   st->out_slow_mc,

		   0, /* st->gc_total */
		   0, /* st->gc_ignored */
		   0, /* st->gc_goal_miss */
		   0, /* st->gc_dst_overflow */
		   0, /* st->in_hlist_search */
		   0  /* st->out_hlist_search */
		);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
70
61.95%
1
20.00%
Eric Dumazet
16
14.16%
1
20.00%
Denis V. Lunev
15
13.27%
1
20.00%
Hideaki Yoshifuji / 吉藤英明
12
10.62%
2
40.00%
Total
113
100.00%
5
100.00%


static const struct seq_operations rt_cpu_seq_ops = {
	.start  = rt_cpu_seq_start,
	.next   = rt_cpu_seq_next,
	.stop   = rt_cpu_seq_stop,
	.show   = rt_cpu_seq_show,
};




static int rt_cpu_seq_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &rt_cpu_seq_ops);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
14
56.00%
1
50.00%
Arnaldo Carvalho de Melo
11
44.00%
1
50.00%
Total
25
100.00%
2
100.00%


static const struct file_operations rt_cpu_seq_fops = {
	.owner	 = THIS_MODULE,
	.open	 = rt_cpu_seq_open,
	.read	 = seq_read,
	.llseek	 = seq_lseek,
	.release = seq_release,
};

#ifdef CONFIG_IP_ROUTE_CLASSID


static int rt_acct_proc_show(struct seq_file *m, void *v)
{
	struct ip_rt_acct *dst, *src;
	unsigned int i, j;

	dst = kcalloc(256, sizeof(struct ip_rt_acct), GFP_KERNEL);
	if (!dst)
		return -ENOMEM;

	for_each_possible_cpu(i) {
		src = (struct ip_rt_acct *)per_cpu_ptr(ip_rt_acct, i);
		for (j = 0; j < 256; j++) {
			dst[j].o_bytes   += src[j].o_bytes;
			dst[j].o_packets += src[j].o_packets;
			dst[j].i_bytes   += src[j].i_bytes;
			dst[j].i_packets += src[j].i_packets;
		}
	}

	seq_write(m, dst, 256 * sizeof(struct ip_rt_acct));
	kfree(dst);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
133
79.64%
1
20.00%
Arnaldo Carvalho de Melo
26
15.57%
1
20.00%
Eric Dumazet
5
2.99%
1
20.00%
Denis V. Lunev
2
1.20%
1
20.00%
Linus Torvalds (pre-git)
1
0.60%
1
20.00%
Total
167
100.00%
5
100.00%



static int rt_acct_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, rt_acct_proc_show, NULL);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
17
65.38%
1
33.33%
Arnaldo Carvalho de Melo
8
30.77%
1
33.33%
Linus Torvalds (pre-git)
1
3.85%
1
33.33%
Total
26
100.00%
3
100.00%


static const struct file_operations rt_acct_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= rt_acct_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};
#endif



static int __net_init ip_rt_do_proc_init(struct net *net)
{
	struct proc_dir_entry *pde;

	pde = proc_create("rt_cache", S_IRUGO, net->proc_net,
			  &rt_cache_seq_fops);
	if (!pde)
		goto err1;

	pde = proc_create("rt_cache", S_IRUGO,
			  net->proc_net_stat, &rt_cpu_seq_fops);
	if (!pde)
		goto err2;

#ifdef CONFIG_IP_ROUTE_CLASSID
	pde = proc_create("rt_acct", 0, net->proc_net, &rt_acct_proc_fops);
	if (!pde)
		goto err3;
#endif
	return 0;

#ifdef CONFIG_IP_ROUTE_CLASSID
err3:
	remove_proc_entry("rt_cache", net->proc_net_stat);
#endif
err2:
	remove_proc_entry("rt_cache", net->proc_net);
err1:
	return -ENOMEM;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
93
71.54%
1
11.11%
Linus Torvalds (pre-git)
17
13.08%
5
55.56%
Arnaldo Carvalho de Melo
10
7.69%
1
11.11%
Gao Feng
5
3.85%
1
11.11%
Alexey Kuznetsov
5
3.85%
1
11.11%
Total
130
100.00%
9
100.00%



static void __net_exit ip_rt_do_proc_exit(struct net *net)
{
	remove_proc_entry("rt_cache", net->proc_net_stat);
	remove_proc_entry("rt_cache", net->proc_net);
#ifdef CONFIG_IP_ROUTE_CLASSID
	remove_proc_entry("rt_acct", net->proc_net);
#endif
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
35
79.55%
1
16.67%
Arnaldo Carvalho de Melo
4
9.09%
1
16.67%
Linus Torvalds (pre-git)
3
6.82%
3
50.00%
Pavel Emelyanov
2
4.55%
1
16.67%
Total
44
100.00%
6
100.00%


static struct pernet_operations ip_rt_proc_ops __net_initdata =  {
	.init = ip_rt_do_proc_init,
	.exit = ip_rt_do_proc_exit,
};



static int __init ip_rt_proc_init(void)
{
	return register_pernet_subsys(&ip_rt_proc_ops);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds
6
37.50%
1
25.00%
David S. Miller
5
31.25%
1
25.00%
Pavel Emelyanov
3
18.75%
1
25.00%
Stephen Hemminger
2
12.50%
1
25.00%
Total
16
100.00%
4
100.00%

#else


static inline int ip_rt_proc_init(void)
{
	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
10
83.33%
1
50.00%
Stephen Hemminger
2
16.67%
1
50.00%
Total
12
100.00%
2
100.00%

#endif /* CONFIG_PROC_FS */



static inline bool rt_is_expired(const struct rtable *rth)
{
	return rth->rt_genid != rt_genid_ipv4(dev_net(rth->dst.dev));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
15
50.00%
1
20.00%
Stephen Hemminger
11
36.67%
1
20.00%
Eric Dumazet
2
6.67%
1
20.00%
Harald Welte
1
3.33%
1
20.00%
Fan Du
1
3.33%
1
20.00%
Total
30
100.00%
5
100.00%



void rt_cache_flush(struct net *net)
{
	rt_genid_bump_ipv4(net);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Stephen Hemminger
8
53.33%
1
20.00%
David S. Miller
4
26.67%
1
20.00%
Fan Du
1
6.67%
1
20.00%
Eric Dumazet
1
6.67%
1
20.00%
Linus Torvalds
1
6.67%
1
20.00%
Total
15
100.00%
5
100.00%



static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
					   struct sk_buff *skb,
					   const void *daddr)
{
	struct net_device *dev = dst->dev;
	const __be32 *pkey = daddr;
	const struct rtable *rt;
	struct neighbour *n;

	rt = (const struct rtable *) dst;
	if (rt->rt_gateway)
		pkey = (const __be32 *) &rt->rt_gateway;
	else if (skb)
		pkey = &ip_hdr(skb)->daddr;

	n = __ipv4_neigh_lookup(dev, *(__force u32 *)pkey);
	if (n)
		return n;
	return neigh_create(&arp_tbl, pkey, dev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
98
77.17%
1
16.67%
Stephen Hemminger
14
11.02%
1
16.67%
Harald Welte
9
7.09%
1
16.67%
Linus Torvalds
3
2.36%
1
16.67%
Robert Olsson
2
1.57%
1
16.67%
Ravikiran G. Thirumalai
1
0.79%
1
16.67%
Total
127
100.00%
6
100.00%



static void ipv4_confirm_neigh(const struct dst_entry *dst, const void *daddr)
{
	struct net_device *dev = dst->dev;
	const __be32 *pkey = daddr;
	const struct rtable *rt;

	rt = (const struct rtable *)dst;
	if (rt->rt_gateway)
		pkey = (const __be32 *)&rt->rt_gateway;
	else if (!daddr ||
		 (rt->rt_flags &
		  (RTCF_MULTICAST | RTCF_BROADCAST | RTCF_LOCAL)))
		return;

	__ipv4_confirm_neigh(dev, *(__force u32 *)pkey);
}

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


#define IP_IDENTS_SZ 2048u


static atomic_t *ip_idents __read_mostly;

static u32 *ip_tstamps __read_mostly;

/* In order to protect privacy, we add a perturbation to identifiers
 * if one generator is seldom used. This makes hard for an attacker
 * to infer how many packets were sent between two points in time.
 */


u32 ip_idents_reserve(u32 hash, int segs)
{
	u32 *p_tstamp = ip_tstamps + hash % IP_IDENTS_SZ;
	atomic_t *p_id = ip_idents + hash % IP_IDENTS_SZ;
	u32 old = ACCESS_ONCE(*p_tstamp);
	u32 now = (u32)jiffies;
	u32 new, delta = 0;

	if (old != now && cmpxchg(p_tstamp, old, now) == old)
		delta = prandom_u32_max(now - old);

	/* Do not use atomic_add_return() as it makes UBSAN unhappy */
	do {
		old = (u32)atomic_read(p_id);
		new = old + delta + segs;
	} while (atomic_cmpxchg(p_id, old, new) != old);

	return new - segs;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Eric Dumazet
122
100.00%
3
100.00%
Total
122
100.00%
3
100.00%


EXPORT_SYMBOL(ip_idents_reserve);



void __ip_select_ident(struct net *net, struct iphdr *iph, int segs)
{
	static u32 ip_idents_hashrnd __read_mostly;
	u32 hash, id;

	net_get_random_once(&ip_idents_hashrnd, sizeof(ip_idents_hashrnd));

	hash = jhash_3words((__force u32)iph->daddr,
			    (__force u32)iph->saddr,
			    iph->protocol ^ net_hash_mix(net),
			    ip_idents_hashrnd);
	id = ip_idents_reserve(hash, segs);
	iph->id = htons(id);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Eric Dumazet
37
41.57%
2
28.57%
David S. Miller
27
30.34%
1
14.29%
Hannes Frederic Sowa
10
11.24%
1
14.29%
Arnaldo Carvalho de Melo
7
7.87%
1
14.29%
Pavel Emelyanov
7
7.87%
1
14.29%
Alexey Dobriyan
1
1.12%
1
14.29%
Total
89
100.00%
7
100.00%


EXPORT_SYMBOL(__ip_select_ident);



static void __build_flow_key(const struct net *net, struct flowi4 *fl4,
			     const struct sock *sk,
			     const struct iphdr *iph,
			     int oif, u8 tos,
			     u8 prot, u32 mark, int flow_flags)
{
	if (sk) {
		const struct inet_sock *inet = inet_sk(sk);

		oif = sk->sk_bound_dev_if;
		mark = sk->sk_mark;
		tos = RT_CONN_FLAGS(sk);
		prot = inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol;
	}
	flowi4_init_output(fl4, oif, mark, tos,
			   RT_SCOPE_UNIVERSE, prot,
			   flow_flags,
			   iph->daddr, iph->saddr, 0, 0,
			   sock_net_uid(net, sk));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
82
64.06%
1
20.00%
Pavel Emelyanov
23
17.97%
1
20.00%
Lorenzo Colitti
13
10.16%
1
20.00%
Alexey Dobriyan
9
7.03%
1
20.00%
Wang Chen
1
0.78%
1
20.00%
Total
128
100.00%
5
100.00%



static void build_skb_flow_key(struct flowi4 *fl4, const struct sk_buff *skb,
			       const struct sock *sk)
{
	const struct net *net = dev_net(skb->dev);
	const struct iphdr *iph = ip_hdr(skb);
	int oif = skb->dev->ifindex;
	u8 tos = RT_TOS(iph->tos);
	u8 prot = iph->protocol;
	u32 mark = skb->mark;

	__build_flow_key(net, fl4, sk, iph, oif, tos, prot, mark, 0);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
68
67.33%
1
20.00%
Denis V. Lunev
16
15.84%
1
20.00%
Lorenzo Colitti
15
14.85%
2
40.00%
Pavel Emelyanov
2
1.98%
1
20.00%
Total
101
100.00%
5
100.00%



static void build_sk_flow_key(struct flowi4 *fl4, const struct sock *sk)
{
	const struct inet_sock *inet = inet_sk(sk);
	const struct ip_options_rcu *inet_opt;
	__be32 daddr = inet->inet_daddr;

	rcu_read_lock();
	inet_opt = rcu_dereference(inet->inet_opt);
	if (inet_opt && inet_opt->opt.srr)
		daddr = inet_opt->opt.faddr;
	flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
			   RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
			   inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol,
			   inet_sk_flowi_flags(sk),
			   daddr, inet->inet_saddr, 0, 0, sk->sk_uid);
	rcu_read_unlock();
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
98
79.67%
3
27.27%
Linus Torvalds (pre-git)
19
15.45%
6
54.55%
Lorenzo Colitti
4
3.25%
1
9.09%
Dipankar Sarma
2
1.63%
1
9.09%
Total
123
100.00%
11
100.00%



static void ip_rt_build_flow_key(struct flowi4 *fl4, const struct sock *sk,
				 const struct sk_buff *skb)
{
	if (skb)
		build_skb_flow_key(fl4, skb, sk);
	else
		build_sk_flow_key(fl4, sk);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
27
61.36%
1
33.33%
Linus Torvalds (pre-git)
16
36.36%
1
33.33%
Linus Torvalds
1
2.27%
1
33.33%
Total
44
100.00%
3
100.00%

static DEFINE_SPINLOCK(fnhe_lock);



static void fnhe_flush_routes(struct fib_nh_exception *fnhe)
{
	struct rtable *rt;

	rt = rcu_dereference(fnhe->fnhe_rth_input);
	if (rt) {
		RCU_INIT_POINTER(fnhe->fnhe_rth_input, NULL);
		dst_dev_put(&rt->dst);
		dst_release(&rt->dst);
	}
	rt = rcu_dereference(fnhe->fnhe_rth_output);
	if (rt) {
		RCU_INIT_POINTER(fnhe->fnhe_rth_output, NULL);
		dst_dev_put(&rt->dst);
		dst_release(&rt->dst);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Timo Teräs
64
66.67%
1
33.33%
Wei Wang
32
33.33%
2
66.67%
Total
96
100.00%
3
100.00%



static struct fib_nh_exception *fnhe_oldest(struct fnhe_hash_bucket *hash)
{
	struct fib_nh_exception *fnhe, *oldest;

	oldest = rcu_dereference(hash->chain);
	for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe;
	     fnhe = rcu_dereference(fnhe->fnhe_next)) {
		if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp))
			oldest = fnhe;
	}
	fnhe_flush_routes(oldest);
	return oldest;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
58
73.42%
3
42.86%
Alexey Kuznetsov
17
21.52%
2
28.57%
Neil Horman
3
3.80%
1
14.29%
Timo Teräs
1
1.27%
1
14.29%
Total
79
100.00%
7
100.00%



static inline u32 fnhe_hashfun(__be32 daddr)
{
	static u32 fnhe_hashrnd __read_mostly;
	u32 hval;

	net_get_random_once(&fnhe_hashrnd, sizeof(fnhe_hashrnd));
	hval = jhash_1word((__force u32) daddr, fnhe_hashrnd);
	return hash_32(hval, FNHE_HASH_SHIFT);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Eric Dumazet
31
62.00%
2
50.00%
David S. Miller
12
24.00%
1
25.00%
Neil Horman
7
14.00%
1
25.00%
Total
50
100.00%
4
100.00%



static void fill_route_from_fnhe(struct rtable *rt, struct fib_nh_exception *fnhe)
{
	rt->rt_pmtu = fnhe->fnhe_pmtu;
	rt->dst.expires = fnhe->fnhe_expires;

	if (fnhe->fnhe_gw) {
		rt->rt_flags |= RTCF_REDIRECTED;
		rt->rt_gateway = fnhe->fnhe_gw;
		rt->rt_uses_gateway = 1;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Timo Teräs
62
100.00%
1
100.00%
Total
62
100.00%
1
100.00%



static void update_or_create_fnhe(struct fib_nh *nh, __be32 daddr, __be32 gw,
				  u32 pmtu, unsigned long expires)
{
	struct fnhe_hash_bucket *hash;
	struct fib_nh_exception *fnhe;
	struct rtable *rt;
	unsigned int i;
	int depth;
	u32 hval = fnhe_hashfun(daddr);

	spin_lock_bh(&fnhe_lock);

	hash = rcu_dereference(nh->nh_exceptions);
	if (!hash) {
		hash = kzalloc(FNHE_HASH_SIZE * sizeof(*hash), GFP_ATOMIC);
		if (!hash)
			goto out_unlock;
		rcu_assign_pointer(nh->nh_exceptions, hash);
	}

	hash += hval;

	depth = 0;
	for (fnhe = rcu_dereference(hash->chain); fnhe;
	     fnhe = rcu_dereference(fnhe->fnhe_next)) {
		if (fnhe->fnhe_daddr == daddr)
			break;
		depth++;
	}

	if (fnhe) {
		if (gw)
			fnhe->fnhe_gw = gw;
		if (pmtu) {
			fnhe->fnhe_pmtu = pmtu;
			fnhe->fnhe_expires = max(1UL, expires);
		}
		/* Update all cached dsts too */
		rt = rcu_dereference(fnhe->fnhe_rth_input);
		if (rt)
			fill_route_from_fnhe(rt, fnhe);
		rt = rcu_dereference(fnhe->fnhe_rth_output);
		if (rt)
			fill_route_from_fnhe(rt, fnhe);
	} else {
		if (depth > FNHE_RECLAIM_DEPTH)
			fnhe = fnhe_oldest(hash);
		else {
			fnhe = kzalloc(sizeof(*fnhe), GFP_ATOMIC);
			if (!fnhe)
				goto out_unlock;

			fnhe->fnhe_next = hash->chain;
			rcu_assign_pointer(hash->chain, fnhe);
		}
		fnhe->fnhe_genid = fnhe_genid(dev_net(nh->nh_dev));
		fnhe->fnhe_daddr = daddr;
		fnhe->fnhe_gw = gw;
		fnhe->fnhe_pmtu = pmtu;
		fnhe->fnhe_expires = expires;

		/* Exception created; mark the cached routes for the nexthop
                 * stale, so anyone caching it rechecks if this exception
                 * applies to them.
                 */
		rt = rcu_dereference(nh->nh_rth_input);
		if (rt)
			rt->dst.obsolete = DST_OBSOLETE_KILL;

		for_each_possible_cpu(i) {
			struct rtable __rcu **prt;
			prt = per_cpu_ptr(nh->nh_pcpu_rth_output, i);
			rt = rcu_dereference(*prt);
			if (rt)
				rt->dst.obsolete = DST_OBSOLETE_KILL;
		}
	}

	fnhe->fnhe_stamp = jiffies;

out_unlock:
	spin_unlock_bh(&fnhe_lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
178
43.73%
3
30.00%
Timo Teräs
135
33.17%
3
30.00%
Julian Anastasov
79
19.41%
1
10.00%
Eric Dumazet
8
1.97%
2
20.00%
François Romieu
7
1.72%
1
10.00%
Total
407
100.00%
10
100.00%



static void __ip_do_redirect(struct rtable *rt, struct sk_buff *skb, struct flowi4 *fl4,
			     bool kill_route)
{
	__be32 new_gw = icmp_hdr(skb)->un.gateway;
	__be32 old_gw = ip_hdr(skb)->saddr;
	struct net_device *dev = skb->dev;
	struct in_device *in_dev;
	struct fib_result res;
	struct neighbour *n;
	struct net *net;

	switch (icmp_hdr(skb)->code & 7) {
	case ICMP_REDIR_NET:
	case ICMP_REDIR_NETTOS:
	case ICMP_REDIR_HOST:
	case ICMP_REDIR_HOSTTOS:
		break;

	default:
		return;
	}

	if (rt->rt_gateway != old_gw)
		return;

	in_dev = __in_dev_get_rcu(dev);
	if (!in_dev)
		return;

	net = dev_net(dev);
	if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) ||
	    ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw) ||
	    ipv4_is_zeronet(new_gw))
		goto reject_redirect;

	if (!IN_DEV_SHARED_MEDIA(in_dev)) {
		if (!inet_addr_onlink(in_dev, new_gw, old_gw))
			goto reject_redirect;
		if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
			goto reject_redirect;
	} else {
		if (inet_addr_type(net, new_gw) != RTN_UNICAST)
			goto reject_redirect;
	}

	n = __ipv4_neigh_lookup(rt->dst.dev, new_gw);
	if (!n)
		n = neigh_create(&arp_tbl, &new_gw, rt->dst.dev);
	if (!IS_ERR(n)) {
		if (!(n->nud_state & NUD_VALID)) {
			neigh_event_send(n, NULL);
		} else {
			if (fib_lookup(net, fl4, &res, 0) == 0) {
				struct fib_nh *nh = &FIB_RES_NH(res);

				update_or_create_fnhe(nh, fl4->daddr, new_gw,
						0, jiffies + ip_rt_gc_timeout);
			}
			if (kill_route)
				rt->dst.obsolete = DST_OBSOLETE_KILL;
			call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, n);
		}
		neigh_release(n);
	}
	return;

reject_redirect:
#ifdef CONFIG_IP_ROUTE_VERBOSE
	if (IN_DEV_LOG_MARTIANS(in_dev)) {
		const struct iphdr *iph = (const struct iphdr *) skb->data;
		__be32 daddr = iph->daddr;
		__be32 saddr = iph->saddr;

		net_info_ratelimited("Redirect from %pI4 on %s about %pI4 ignored\n"
				     "  Advised path = %pI4 -> %pI4\n",
				     &old_gw, dev->name, &new_gw,
				     &saddr, &daddr);
	}
#endif
	;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
391
91.36%
6
54.55%
Stephen Suryaputra Lin
23
5.37%
1
9.09%
Julian Anastasov
5
1.17%
1
9.09%
Américo Wang
4
0.93%
1
9.09%
Xin Long
3
0.70%
1
9.09%
Andy Gospodarek
2
0.47%
1
9.09%
Total
428
100.00%
11
100.00%



static void ip_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
{
	struct rtable *rt;
	struct flowi4 fl4;
	const struct iphdr *iph = (const struct iphdr *) skb->data;
	struct net *net = dev_net(skb->dev);
	int oif = skb->dev->ifindex;
	u8 tos = RT_TOS(iph->tos);
	u8 prot = iph->protocol;
	u32 mark = skb->mark;

	rt = (struct rtable *) dst;

	__build_flow_key(net, &fl4, sk, iph, oif, tos, prot, mark, 0);
	__ip_do_redirect(rt, skb, &fl4, true);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Michal Kubeček
61
45.52%
1
20.00%
David S. Miller
59
44.03%
2
40.00%
Lorenzo Colitti
14
10.45%
2
40.00%
Total
134
100.00%
5
100.00%



static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
{
	struct rtable *rt = (struct rtable *)dst;
	struct dst_entry *ret = dst;

	if (rt) {
		if (dst->obsolete > 0) {
			ip_rt_put(rt);
			ret = NULL;
		} else if ((rt->rt_flags & RTCF_REDIRECTED) ||
			   rt->dst.expires) {
			ip_rt_put(rt);
			ret = NULL;
		}
	}
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
50
56.82%
5
45.45%
David S. Miller
17
19.32%
3
27.27%
Linus Torvalds
15
17.05%
1
9.09%
Eric Dumazet
4
4.55%
1
9.09%
Timo Teräs
2
2.27%
1
9.09%
Total
88
100.00%
11
100.00%

/*
 * Algorithm:
 *      1. The first ip_rt_redirect_number redirects are sent
 *         with exponential backoff, then we stop sending them at all,
 *         assuming that the host ignores our redirects.
 *      2. If we did not see packets requiring redirects
 *         during ip_rt_redirect_silence, we assume that the host
 *         forgot redirected route and start to send redirects again.
 *
 * This algorithm is much cheaper and more intelligent than dumb load limiting
 * in icmp.c.
 *
 * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
 * and "frag. need" (breaks PMTU discovery) in icmp.c.
 */



void ip_rt_send_redirect(struct sk_buff *skb)
{
	struct rtable *rt = skb_rtable(skb);
	struct in_device *in_dev;
	struct inet_peer *peer;
	struct net *net;
	int log_martians;
	int vif;

	rcu_read_lock();
	in_dev = __in_dev_get_rcu(rt->dst.dev);
	if (!in_dev || !IN_DEV_TX_REDIRECTS(in_dev)) {
		rcu_read_unlock();
		return;
	}
	log_martians = IN_DEV_LOG_MARTIANS(in_dev);
	vif = l3mdev_master_ifindex_rcu(rt->dst.dev);
	rcu_read_unlock();

	net = dev_net(rt->dst.dev);
	peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, vif, 1);
	if (!peer) {
		icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST,
			  rt_nexthop(rt, ip_hdr(skb)->daddr));
		return;
	}

	/* No redirected packets during ip_rt_redirect_silence;
         * reset the algorithm.
         */
	if (time_after(jiffies, peer->rate_last + ip_rt_redirect_silence))
		peer->rate_tokens = 0;

	/* Too many ignored redirects; do not send anything
         * set dst.rate_last to the last seen redirected packet.
         */
	if (peer->rate_tokens >= ip_rt_redirect_number) {
		peer->rate_last = jiffies;
		goto out_put_peer;
	}

	/* Check for load limit; set rate_last to the latest sent
         * redirect.
         */
	if (peer->rate_tokens == 0 ||
	    time_after(jiffies,
		       (peer->rate_last +
			(ip_rt_redirect_load << peer->rate_tokens)))) {
		__be32 gw = rt_nexthop(rt, ip_hdr(skb)->daddr);

		icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, gw);
		peer->rate_last = jiffies;
		++peer->rate_tokens;
#ifdef CONFIG_IP_ROUTE_VERBOSE
		if (log_martians &&
		    peer->rate_tokens == ip_rt_redirect_number)
			net_warn_ratelimited("host %pI4/if%d ignores redirects for %pI4 to %pI4\n",
					     &ip_hdr(skb)->saddr, inet_iif(skb),
					     &ip_hdr(skb)->daddr, &gw);
#endif
	}
out_put_peer:
	inet_putpeer(peer);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
121
38.66%
7
28.00%
David S. Miller
107
34.19%
8
32.00%
Eric Dumazet
32
10.22%
2
8.00%
Julian Anastasov
26
8.31%
1
4.00%
David Ahern
16
5.11%
2
8.00%
Li Yewang
5
1.60%
1
4.00%
Harvey Harrison
3
0.96%
1
4.00%
Joe Perches
2
0.64%
2
8.00%
Changli Gao
1
0.32%
1
4.00%
Total
313
100.00%
25
100.00%



static int ip_error(struct sk_buff *skb)
{
	struct in_device *in_dev = __in_dev_get_rcu(skb->dev);
	struct rtable *rt = skb_rtable(skb);
	struct inet_peer *peer;
	unsigned long now;
	struct net *net;
	bool send;
	int code;

	/* IP on this device is disabled. */
	if (!in_dev)
		goto out;

	net = dev_net(rt->dst.dev);
	if (!IN_DEV_FORWARD(in_dev)) {
		switch (rt->dst.error) {
		case EHOSTUNREACH:
			__IP_INC_STATS(net, IPSTATS_MIB_INADDRERRORS);
			break;

		case ENETUNREACH:
			__IP_INC_STATS(net, IPSTATS_MIB_INNOROUTES);
			break;
		}
		goto out;
	}

	switch (rt->dst.error) {
	case EINVAL:
	default:
		goto out;
	case EHOSTUNREACH:
		code = ICMP_HOST_UNREACH;
		break;
	case ENETUNREACH:
		code = ICMP_NET_UNREACH;
		__IP_INC_STATS(net, IPSTATS_MIB_INNOROUTES);
		break;
	case EACCES:
		code = ICMP_PKT_FILTERED;
		break;
	}

	peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr,
			       l3mdev_master_ifindex(skb->dev), 1);

	send = true;
	if (peer) {
		now = jiffies;
		peer->rate_tokens += now - peer->rate_last;
		if (peer->rate_tokens > ip_rt_error_burst)
			peer->rate_tokens = ip_rt_error_burst;
		peer->rate_last = now;
		if (peer->rate_tokens >= ip_rt_error_cost)
			peer->rate_tokens -= ip_rt_error_cost;
		else
			send = false;
		inet_putpeer(peer);
	}
	if (send)
		icmp_send(skb, ICMP_DEST_UNREACH, code, 0);

out:	kfree_skb(skb);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
131
45.80%
5
26.32%
Linus Torvalds (pre-git)
118
41.26%
6
31.58%
Linus Torvalds
10
3.50%
1
5.26%
Eric W. Biedermann
9
3.15%
1
5.26%
David Ahern
7
2.45%
2
10.53%
Eric Dumazet
6
2.10%
2
10.53%
Mitsuru Chinen
4
1.40%
1
5.26%
Pavel Emelyanov
1
0.35%
1
5.26%
Total
286
100.00%
19
100.00%



static void __ip_rt_update_pmtu(struct rtable *rt, struct flowi4 *fl4, u32 mtu)
{
	struct dst_entry *dst = &rt->dst;
	struct fib_result res;

	if (dst_metric_locked(dst, RTAX_MTU))
		return;

	if (ipv4_mtu(dst) < mtu)
		return;

	if (mtu < ip_rt_min_pmtu)
		mtu = ip_rt_min_pmtu;

	if (rt->rt_pmtu == mtu &&
	    time_before(jiffies, dst->expires - ip_rt_mtu_expires / 2))
		return;

	rcu_read_lock();
	if (fib_lookup(dev_net(dst->dev), fl4, &res, 0) == 0) {
		struct fib_nh *nh = &FIB_RES_NH(res);

		update_or_create_fnhe(nh, fl4->daddr, 0, mtu,
				      jiffies + ip_rt_mtu_expires);
	}
	rcu_read_unlock();
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
67
47.18%
4
25.00%
Steffen Klassert
23
16.20%
3
18.75%
Timo Teräs
22
15.49%
1
6.25%
Eric Dumazet
6
4.23%
1
6.25%
Li Wei
6
4.23%
1
6.25%
Julian Anastasov
5
3.52%
1
6.25%
Linus Torvalds (pre-git)
5
3.52%
1
6.25%
Herbert Xu
3
2.11%
1
6.25%
Alexey Kuznetsov
2
1.41%
1
6.25%
Andy Gospodarek
2
1.41%
1
6.25%
Hiroaki SHIMODA
1
0.70%
1
6.25%
Total
142
100.00%
16
100.00%



static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
			      struct sk_buff *skb, u32 mtu)
{
	struct rtable *rt = (struct rtable *) dst;
	struct flowi4 fl4;

	ip_rt_build_flow_key(&fl4, sk, skb);
	__ip_rt_update_pmtu(rt, &fl4, mtu);
}

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



void ipv4_update_pmtu(struct sk_buff *skb, struct net *net, u32 mtu,
		      int oif, u32 mark, u8 protocol, int flow_flags)
{
	const struct iphdr *iph = (const struct iphdr *) skb->data;
	struct flowi4 fl4;
	struct rtable *rt;

	if (!mark)
		mark = IP4_REPLY_MARK(net, skb->mark);

	__build_flow_key(net, &fl4, NULL, iph, oif,
			 RT_TOS(iph->tos), protocol, mark, flow_flags);
	rt = __ip_route_output_key(net, &fl4);
	if (!IS_ERR(rt)) {
		__ip_rt_update_pmtu(rt, &fl4, mtu);
		ip_rt_put(rt);
	}
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
115
86.47%
3
60.00%
Lorenzo Colitti
18
13.53%
2
40.00%
Total
133
100.00%
5
100.00%


EXPORT_SYMBOL_GPL(ipv4_update_pmtu);



static void __ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
{
	const struct iphdr *iph = (const struct iphdr *) skb->data;
	struct flowi4 fl4;
	struct rtable *rt;

	__build_flow_key(sock_net(sk), &fl4, sk, iph, 0, 0, 0, 0, 0);

	if (!fl4.flowi4_mark)
		fl4.flowi4_mark = IP4_REPLY_MARK(sock_net(sk), skb->mark);

	rt = __ip_route_output_key(sock_net(sk), &fl4);
	if (!IS_ERR(rt)) {
		__ip_rt_update_pmtu(rt, &fl4, mtu);
		ip_rt_put(rt);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
77
59.23%
4
25.00%
Lorenzo Colitti
28
21.54%
2
12.50%
Linus Torvalds (pre-git)
16
12.31%
5
31.25%
Dave Jones
3
2.31%
1
6.25%
Eric Dumazet
2
1.54%
1
6.25%
Steffen Klassert
2
1.54%
1
6.25%
Harvey Harrison
1
0.77%
1
6.25%
Arnaldo Carvalho de Melo
1
0.77%
1
6.25%
Total
130
100.00%
16
100.00%



void ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
{
	const struct iphdr *iph = (const struct iphdr *) skb->data;
	struct flowi4 fl4;
	struct rtable *rt;
	struct dst_entry *odst = NULL;
	bool new = false;
	struct net *net = sock_net(sk);

	bh_lock_sock(sk);

	if (!ip_sk_accept_pmtu(sk))
		goto out;

	odst = sk_dst_get(sk);

	if (sock_owned_by_user(sk) || !odst) {
		__ipv4_sk_update_pmtu(skb, sk, mtu);
		goto out;
	}

	__build_flow_key(net, &fl4, sk, iph, 0, 0, 0, 0, 0);

	rt = (struct rtable *)odst;
	if (odst->obsolete && !odst->ops->check(odst, 0)) {
		rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
		if (IS_ERR(rt))
			goto out;

		new = true;
	}

	__ip_rt_update_pmtu((struct rtable *) rt->dst.path, &fl4, mtu);

	if (!dst_check(&rt->dst, 0)) {
		if (new)
			dst_release(&rt->dst);

		rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
		if (IS_ERR(rt))
			goto out;

		new = true;
	}

	if (new)
		sk_dst_set(sk, &rt->dst);

out:
	bh_unlock_sock(sk);
	dst_release(odst);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Steffen Klassert
235
80.20%
2
33.33%
Eric Dumazet
34
11.60%
1
16.67%
Lorenzo Colitti
12
4.10%
1
16.67%
Hannes Frederic Sowa
11
3.75%
1
16.67%
Ian Morris
1
0.34%
1
16.67%
Total
293
100.00%
6
100.00%


EXPORT_SYMBOL_GPL(ipv4_sk_update_pmtu);



void ipv4_redirect(struct sk_buff *skb, struct net *net,
		   int oif, u32 mark, u8 protocol, int flow_flags)
{
	const struct iphdr *iph = (const struct iphdr *) skb->data;
	struct flowi4 fl4;
	struct rtable *rt;

	__build_flow_key(net, &fl4, NULL, iph, oif,
			 RT_TOS(iph->tos), protocol, mark, flow_flags);
	rt = __ip_route_output_key(net, &fl4);
	if (!IS_ERR(rt)) {
		__ip_do_redirect(rt, skb, &fl4, false);
		ip_rt_put(rt);
	}
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
88
75.86%
6
46.15%
Linus Torvalds (pre-git)
22
18.97%
3
23.08%
Lorenzo Colitti
2
1.72%
1
7.69%
Julian Anastasov
2
1.72%
1
7.69%
Hideaki Yoshifuji / 吉藤英明
1
0.86%
1
7.69%
Denis V. Lunev
1
0.86%
1
7.69%
Total
116
100.00%
13
100.00%


EXPORT_SYMBOL_GPL(ipv4_redirect);



void ipv4_sk_redirect(struct sk_buff *skb, struct sock *sk)
{
	const struct iphdr *iph = (const struct iphdr *) skb->data;
	struct flowi4 fl4;
	struct rtable *rt;
	struct net *net = sock_net(sk);

	__build_flow_key(net, &fl4, sk, iph, 0, 0, 0, 0, 0);
	rt = __ip_route_output_key(net, &fl4);
	if (!IS_ERR(rt)) {
		__ip_do_redirect(rt, skb, &fl4, false);
		ip_rt_put(rt);
	}
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
74
67.89%
2
50.00%
Linus Torvalds (pre-git)
22
20.18%
1
25.00%
Lorenzo Colitti
13
11.93%
1
25.00%
Total
109
100.00%
4
100.00%


EXPORT_SYMBOL_GPL(ipv4_sk_redirect);



static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
{
	struct rtable *rt = (struct rtable *) dst;

	/* All IPV4 dsts are created with ->obsolete set to the value
         * DST_OBSOLETE_FORCE_CHK which forces validation calls down
         * into this function always.
         *
         * When a PMTU/redirect information update invalidates a route,
         * this is indicated by setting obsolete to DST_OBSOLETE_KILL or
         * DST_OBSOLETE_DEAD by dst_free().
         */
	if (dst->obsolete != DST_OBSOLETE_FORCE_CHK || rt_is_expired(rt))
		return NULL;
	return dst;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
39
81.25%
3
50.00%
Linus Torvalds (pre-git)
6
12.50%
2
33.33%
Timo Teräs
3
6.25%
1
16.67%
Total
48
100.00%
6
100.00%



static void ipv4_link_failure(struct sk_buff *skb)
{
	struct rtable *rt;

	icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);

	rt = skb_rtable(skb);
	if (rt)
		dst_set_expires(&rt->dst, 0);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
39
81.25%
3
37.50%
Steffen Klassert
5
10.42%
2
25.00%
Linus Torvalds (pre-git)
3
6.25%
2
25.00%
Alexey Kuznetsov
1
2.08%
1
12.50%
Total
48
100.00%
8
100.00%



static int ip_rt_bug(struct net *net, struct sock *sk, struct sk_buff *skb)
{
	pr_debug("%s: %pI4 -> %pI4, %s\n",
		 __func__, &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
		 skb->dev ? skb->dev->name : "?");
	kfree_skb(skb);
	WARN_ON(1);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
59
85.51%
3
60.00%
Eric W. Biedermann
5
7.25%
1
20.00%
Eric Dumazet
5
7.25%
1
20.00%
Total
69
100.00%
5
100.00%

/*
   We do not cache source address of outgoing interface,
   because it is used only by IP RR, TS and SRR options,
   so that it out of fast path.

   BTW remember: "addr" is allowed to be not aligned
   in IP options!
 */



void ip_rt_get_source(u8 *addr, struct sk_buff *skb, struct rtable *rt)
{
	__be32 src;

	if (rt_is_output_route(rt))
		src = ip_hdr(skb)->saddr;
	else {
		struct fib_result res;
		struct flowi4 fl4;
		struct iphdr *iph;

		iph = ip_hdr(skb);

		memset(&fl4, 0, sizeof(fl4));
		fl4.daddr = iph->daddr;
		fl4.saddr = iph->saddr;
		fl4.flowi4_tos = RT_TOS(iph->tos);
		fl4.flowi4_oif = rt->dst.dev->ifindex;
		fl4.flowi4_iif = skb->dev->ifindex;
		fl4.flowi4_mark = skb->mark;

		rcu_read_lock();
		if (fib_lookup(dev_net(rt->dst.dev), &fl4, &res, 0) == 0)
			src = FIB_RES_PREFSRC(dev_net(rt->dst.dev), res);
		else
			src = inet_select_addr(rt->dst.dev,
					       rt_nexthop(rt, iph->daddr),
					       RT_SCOPE_UNIVERSE);
		rcu_read_unlock();
	}
	memcpy(addr, &src, 4);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
188
89.52%
4
66.67%
Julian Anastasov
20
9.52%
1
16.67%
Andy Gospodarek
2
0.95%
1
16.67%
Total
210
100.00%
6
100.00%

#ifdef CONFIG_IP_ROUTE_CLASSID


static void set_class_tag(struct rtable *rt, u32 tag)
{
	if (!(rt->dst.tclassid & 0xFFFF))
		rt->dst.tclassid |= tag & 0xFFFF;
	if (!(rt->dst.tclassid & 0xFFFF0000))
		rt->dst.tclassid |= tag & 0xFFFF0000;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
40
66.67%
5
55.56%
Linus Torvalds (pre-git)
20
33.33%
4
44.44%
Total
60
100.00%
9
100.00%

#endif



static unsigned int ipv4_default_advmss(const struct dst_entry *dst)
{
	unsigned int header_size = sizeof(struct tcphdr) + sizeof(struct iphdr);
	unsigned int advmss = max_t(unsigned int, dst->dev->mtu - header_size,
				    ip_rt_min_advmss);

	return min(advmss, IPV4_MAX_PMTU - header_size);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
30
57.69%
3
75.00%
Gao Feng
22
42.31%
1
25.00%
Total
52
100.00%
4
100.00%



static unsigned int ipv4_mtu(const struct dst_entry *dst)
{
	const struct rtable *rt = (const struct rtable *) dst;
	unsigned int mtu = rt->rt_pmtu;

	if (!mtu || time_after_eq(jiffies, rt->dst.expires))
		mtu = dst_metric_raw(dst, RTAX_MTU);

	if (mtu)
		return mtu;

	mtu = READ_ONCE(dst->dev->mtu);

	if (unlikely(dst_metric_locked(dst, RTAX_MTU))) {
		if (rt->rt_uses_gateway && mtu > 576)
			mtu = 576;
	}

	mtu = min_t(unsigned int, mtu, IP_MAX_MTU);

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
71
55.04%
1
7.14%
Linus Torvalds (pre-git)
20
15.50%
6
42.86%
Roopa Prabhu
14
10.85%
1
7.14%
Eric Dumazet
13
10.08%
3
21.43%
Thomas Graf
8
6.20%
1
7.14%
Alexander Duyck
2
1.55%
1
7.14%
Julian Anastasov
1
0.78%
1
7.14%
Total
129
100.00%
14
100.00%



static struct fib_nh_exception *find_exception(struct fib_nh *nh, __be32 daddr)
{
	struct fnhe_hash_bucket *hash = rcu_dereference(nh->nh_exceptions);
	struct fib_nh_exception *fnhe;
	u32 hval;

	if (!hash)
		return NULL;

	hval = fnhe_hashfun(daddr);

	for (fnhe = rcu_dereference(hash[hval].chain); fnhe;
	     fnhe = rcu_dereference(fnhe->fnhe_next)) {
		if (fnhe->fnhe_daddr == daddr)
			return fnhe;
	}
	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
82
89.13%
3
42.86%
Linus Torvalds (pre-git)
7
7.61%
3
42.86%
Eric Dumazet
3
3.26%
1
14.29%
Total
92
100.00%
7
100.00%



static bool rt_bind_exception(struct rtable *rt, struct fib_nh_exception *fnhe,
			      __be32 daddr, const bool do_cache)
{
	bool ret = false;

	spin_lock_bh(&fnhe_lock);

	if (daddr == fnhe->fnhe_daddr) {
		struct rtable __rcu **porig;
		struct rtable *orig;
		int genid = fnhe_genid(dev_net(rt->dst.dev));

		if (rt_is_input_route(rt))
			porig = &fnhe->fnhe_rth_input;
		else
			porig = &fnhe->fnhe_rth_output;
		orig = rcu_dereference(*porig);

		if (fnhe->fnhe_genid != genid) {
			fnhe->fnhe_genid = genid;
			fnhe->fnhe_gw = 0;
			fnhe->fnhe_pmtu = 0;
			fnhe->fnhe_expires = 0;
			fnhe_flush_routes(fnhe);
			orig = NULL;
		}
		fill_route_from_fnhe(rt, fnhe);
		if (!rt->rt_gateway)
			rt->rt_gateway = daddr;

		if (do_cache) {
			dst_hold(&rt->dst);
			rcu_assign_pointer(*porig, rt);
			if (orig) {
				dst_dev_put(&orig->dst);
				dst_release(&orig->dst);
			}
			ret = true;
		}

		fnhe->fnhe_stamp = jiffies;
	}
	spin_unlock_bh(&fnhe_lock);

	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Timo Teräs
86
37.89%
3
17.65%
David S. Miller
64
28.19%
4
23.53%
Wei Wang
31
13.66%
3
17.65%
Steffen Klassert
25
11.01%
1
5.88%
Julian Anastasov
14
6.17%
1
5.88%
Eric Dumazet
3
1.32%
1
5.88%
Linus Torvalds (pre-git)
3
1.32%
3
17.65%
Hirofumi Ogawa
1
0.44%
1
5.88%
Total
227
100.00%
17
100.00%



static bool rt_cache_route(struct fib_nh *nh, struct rtable *rt)
{
	struct rtable *orig, *prev, **p;
	bool ret = true;

	if (rt_is_input_route(rt)) {
		p = (struct rtable **)&nh->nh_rth_input;
	} else {
		p = (struct rtable **)raw_cpu_ptr(nh->nh_pcpu_rth_output);
	}
	orig = *p;

	/* hold dst before doing cmpxchg() to avoid race condition
         * on this dst
         */
	dst_hold(&rt->dst);
	prev = cmpxchg(p, orig, rt);
	if (prev == orig) {
		if (orig) {
			dst_dev_put(&orig->dst);
			dst_release(&orig->dst);
		}
	} else {
		dst_release(&rt->dst);
		ret = false;
	}

	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
76
52.05%
4
44.44%
Wei Wang
37
25.34%
2
22.22%
Eric Dumazet
32
21.92%
2
22.22%
Christoph Lameter
1
0.68%
1
11.11%
Total
146
100.00%
9
100.00%


struct uncached_list {
	
spinlock_t		lock;
	
struct list_head	head;
};

static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt_uncached_list);



static void rt_add_uncached_list(struct rtable *rt)
{
	struct uncached_list *ul = raw_cpu_ptr(&rt_uncached_list);

	rt->rt_uncached_list = ul;

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
31
54.39%
1
50.00%
Eric Dumazet
26
45.61%
1
50.00%
Total
57
100.00%
2
100.00%



static void ipv4_dst_destroy(struct dst_entry *dst)
{
	struct dst_metrics *p = (struct dst_metrics *)DST_METRICS_PTR(dst);
	struct rtable *rt = (struct rtable *) dst;

	if (p != &dst_default_metrics && refcount_dec_and_test(&p->refcnt))
		kfree(p);

	if (!list_empty(&rt->rt_uncached)) {
		struct uncached_list *ul = rt->rt_uncached_list;

		spin_lock_bh(&ul->lock);
		list_del(&rt->rt_uncached);
		spin_unlock_bh(&ul->lock);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Eric Dumazet
57
54.81%
4
80.00%
David S. Miller
47
45.19%
1
20.00%
Total
104
100.00%
5
100.00%



void rt_flush_dev(struct net_device *dev)
{
	struct net *net = dev_net(dev);
	struct rtable *rt;
	int cpu;

	for_each_possible_cpu(cpu) {
		struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);

		spin_lock_bh(&ul->lock);
		list_for_each_entry(rt, &ul->head, rt_uncached) {
			if (rt->dst.dev != dev)
				continue;
			rt->dst.dev = net->loopback_dev;
			dev_hold(rt->dst.dev);
			dev_put(dev);
		}
		spin_unlock_bh(&ul->lock);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
79
73.15%
2
50.00%
Eric Dumazet
28
25.93%
1
25.00%
Linus Torvalds (pre-git)
1
0.93%
1
25.00%
Total
108
100.00%
4
100.00%



static bool rt_cache_valid(const struct rtable *rt)
{
	return	rt &&
		rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
		!rt_is_expired(rt);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
22
75.86%
1
50.00%
Eric Dumazet
7
24.14%
1
50.00%
Total
29
100.00%
2
100.00%



static void rt_set_nexthop(struct rtable *rt, __be32 daddr,
			   const struct fib_result *res,
			   struct fib_nh_exception *fnhe,
			   struct fib_info *fi, u16 type, u32 itag,
			   const bool do_cache)
{
	bool cached = false;

	if (fi) {
		struct fib_nh *nh = &FIB_RES_NH(*res);

		if (nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK) {
			rt->rt_gateway = nh->nh_gw;
			rt->rt_uses_gateway = 1;
		}
		dst_init_metrics(&rt->dst, fi->fib_metrics->metrics, true);
		if (fi->fib_metrics != &dst_default_metrics) {
			rt->dst._metrics |= DST_METRICS_REFCOUNTED;
			refcount_inc(&fi->fib_metrics->refcnt);
		}
#ifdef CONFIG_IP_ROUTE_CLASSID
		rt->dst.tclassid = nh->nh_tclassid;
#endif
		rt->dst.lwtstate = lwtstate_get(nh->nh_lwtstate);
		if (unlikely(fnhe))
			cached = rt_bind_exception(rt, fnhe, daddr, do_cache);
		else if (do_cache)
			cached = rt_cache_route(nh, rt);
		if (unlikely(!cached)) {
			/* Routes we intend to cache in nexthop exception or
                         * FIB nexthop have the DST_NOCACHE bit clear.
                         * However, if we are unsuccessful at storing this
                         * route into the cache we really need to set it.
                         */
			if (!rt->rt_gateway)
				rt->rt_gateway = daddr;
			rt_add_uncached_list(rt);
		}
	} else
		rt_add_uncached_list(rt);

#ifdef CONFIG_IP_ROUTE_CLASSID
#ifdef CONFIG_IP_MULTIPLE_TABLES
	set_class_tag(rt, res->tclassid);
#endif
	set_class_tag(rt, itag);
#endif
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
162
62.55%
6
33.33%
Eric Dumazet
31
11.97%
2
11.11%
Julian Anastasov
31
11.97%
1
5.56%
Linus Torvalds (pre-git)
12
4.63%
4
22.22%
Roopa Prabhu
9
3.47%
1
5.56%
Wei Wang
7
2.70%
1
5.56%
Jiri Benc
3
1.16%
1
5.56%
Nicolas Dichtel
3
1.16%
1
5.56%
Pavel Emelyanov
1
0.39%
1
5.56%
Total
259
100.00%
18
100.00%



struct rtable *rt_dst_alloc(struct net_device *dev,
			    unsigned int flags, u16 type,
			    bool nopolicy, bool noxfrm, bool will_cache)
{
	struct rtable *rt;

	rt = dst_alloc(&ipv4_dst_ops, dev, 1, DST_OBSOLETE_FORCE_CHK,
		       (will_cache ? 0 : DST_HOST) |
		       (nopolicy ? DST_NOPOLICY : 0) |
		       (noxfrm ? DST_NOXFRM : 0));

	if (rt) {
		rt->rt_genid = rt_genid_ipv4(dev_net(dev));
		rt->rt_flags = flags;
		rt->rt_type = type;
		rt->rt_is_input = 0;
		rt->rt_iif = 0;
		rt->rt_pmtu = 0;
		rt->rt_gateway = 0;
		rt->rt_uses_gateway = 0;
		rt->rt_table_id = 0;
		INIT_LIST_HEAD(&rt->rt_uncached);

		rt->dst.output = ip_output;
		if (flags & RTCF_LOCAL)
			rt->dst.input = ip_local_deliver;
	}

	return rt;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David Ahern
113
66.47%
2
18.18%
David S. Miller
38
22.35%
4
36.36%
lkml@einar-lueck.de
7
4.12%
1
9.09%
Linus Torvalds (pre-git)
7
4.12%
2
18.18%
Joe Perches
4
2.35%
1
9.09%
Harvey Harrison
1
0.59%
1
9.09%
Total
170
100.00%
11
100.00%


EXPORT_SYMBOL(rt_dst_alloc);

/* called in rcu_read_lock() section */


int ip_mc_validate_source(struct sk_buff *skb, __be32 daddr, __be32 saddr,
			  u8 tos, struct net_device *dev,
			  struct in_device *in_dev, u32 *itag)
{
	int err;

	/* Primary sanity checks. */
	if (!in_dev)
		return -EINVAL;

	if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
	    skb->protocol != htons(ETH_P_IP))
		return -EINVAL;

	if (ipv4_is_loopback(saddr) && !IN_DEV_ROUTE_LOCALNET(in_dev))
		return -EINVAL;

	if (ipv4_is_zeronet(saddr)) {
		if (!ipv4_is_local_multicast(daddr))
			return -EINVAL;
	} else {
		err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
					  in_dev, itag);
		if (err < 0)
			return err;
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
62
42.76%
2
15.38%
Paolo Abeni
24
16.55%
1
7.69%
lkml@einar-lueck.de
24
16.55%
1
7.69%
Linus Torvalds (pre-git)
24
16.55%
3
23.08%
Alexander Duyck
4
2.76%
1
7.69%
Al Viro
3
2.07%
2
15.38%
Michael Smith
2
1.38%
1
7.69%
Ian Morris
1
0.69%
1
7.69%
Ravikiran G. Thirumalai
1
0.69%
1
7.69%
Total
145
100.00%
13
100.00%

/* called in rcu_read_lock() section */


static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
			     u8 tos, struct net_device *dev, int our)
{
	struct in_device *in_dev = __in_dev_get_rcu(dev);
	unsigned int flags = RTCF_MULTICAST;
	struct rtable *rth;
	u32 itag = 0;
	int err;

	err = ip_mc_validate_source(skb, daddr, saddr, tos, dev, in_dev, &itag);
	if (err)
		return err;

	if (our)
		flags |= RTCF_LOCAL;

	rth = rt_dst_alloc(dev_net(dev)->loopback_dev, flags, RTN_MULTICAST,
			   IN_DEV_CONF_GET(in_dev, NOPOLICY), false, false);
	if (!rth)
		return -ENOBUFS;

#ifdef CONFIG_IP_ROUTE_CLASSID
	rth->dst.tclassid = itag;
#endif
	rth->dst.output = ip_rt_bug;
	rth->rt_is_input= 1;

#ifdef CONFIG_IP_MROUTE
	if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
		rth->dst.input = ip_mr_input;
#endif
	RT_CACHE_STAT_INC(in_slow_mc);

	skb_dst_set(skb, &rth->dst);
	return 0;
}


Contributors
Person
Tokens
Prop
Commits
CommitProp
Paolo Abeni
87
43.72%
1
5.88%
David S. Miller
79
39.70%
6
35.29%
Linus Torvalds (pre-git)
17
8.54%
6
35.29%
David Ahern
12
6.03%
1
5.88%
Hirofumi Ogawa
2
1.01%
1
5.88%
Eric Dumazet
1
0.50%
1
5.88%
lkml@einar-lueck.de
1
0.50%
1
5.88%
Total
199
100.00%
17
100.00%



static void ip_handle_martian_source(struct net_device *dev,
				     struct in_device *in_dev,
				     struct sk_buff *skb,
				     __be32 daddr,
				     __be32 saddr)
{
	RT_CACHE_STAT_INC(in_martian_src);
#ifdef CONFIG_IP_ROUTE_VERBOSE
	if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
		/*
                 *      RFC1812 recommendation, if source is martian,
                 *      the only hint is MAC header.
                 */
		pr_warn("martian source %pI4 from %pI4, on dev %s\n",
			&daddr, &saddr, dev->name);
		if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
			print_hex_dump(KERN_WARNING, "ll header: ",
				       DUMP_PREFIX_OFFSET, 16, 1,
				       skb_mac_header(skb),
				       dev->hard_header_len, true);
		}
	}
#endif
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
56
54.90%
2
20.00%
lkml@einar-lueck.de
27
26.47%
1
10.00%
Linus Torvalds (pre-git)
13
12.75%
3
30.00%
Al Viro
3
2.94%
2
20.00%
Pavel Emelyanov
2
1.96%
1
10.00%
Denis V. Lunev
1
0.98%
1
10.00%
Total
102
100.00%
10
100.00%



static void ip_del_fnhe(struct fib_nh *nh, __be32 daddr)
{
	struct fnhe_hash_bucket *hash;
	struct fib_nh_exception *fnhe, __rcu **fnhe_p;
	u32 hval = fnhe_hashfun(daddr);

	spin_lock_bh(&fnhe_lock);

	hash = rcu_dereference_protected(nh->nh_exceptions,
					 lockdep_is_held(&fnhe_lock));
	hash += hval;

	fnhe_p = &hash->chain;
	fnhe = rcu_dereference_protected(*fnhe_p, lockdep_is_held(&fnhe_lock));
	while (fnhe) {
		if (fnhe->fnhe_daddr == daddr) {
			rcu_assign_pointer(*fnhe_p, rcu_dereference_protected(
				fnhe->fnhe_next, lockdep_is_held(&fnhe_lock)));
			fnhe_flush_routes(fnhe);
			kfree_rcu(fnhe, rcu);
			break;
		}
		fnhe_p = &fnhe->fnhe_next;
		fnhe = rcu_dereference_protected(fnhe->fnhe_next,
						 lockdep_is_held(&fnhe_lock));
	}

	spin_unlock_bh(&fnhe_lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Xin Long
159
100.00%
1
100.00%
Total
159
100.00%
1
100.00%



static void set_lwt_redirect(struct rtable *rth)
{
	if (lwtunnel_output_redirect(rth->dst.lwtstate)) {
		rth->dst.lwtstate->orig_output = rth->dst.output;
		rth->dst.output = lwtunnel_output;
	}

	if (lwtunnel_input_redirect(rth->dst.lwtstate)) {
		rth->dst.lwtstate->orig_input = rth->dst.input;
		rth->dst.input = lwtunnel_input;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Thomas Graf
81
100.00%
1
100.00%
Total
81
100.00%
1
100.00%

/* called in rcu_read_lock() section */


static int __mkroute_input(struct sk_buff *skb,
			   const struct fib_result *res,
			   struct in_device *in_dev,
			   __be32 daddr, __be32 saddr, u32 tos)
{
	struct fib_nh_exception *fnhe;
	struct rtable *rth;
	int err;
	struct in_device *out_dev;
	bool do_cache;
	u32 itag = 0;

	/* get a working reference to the output device */
	out_dev = __in_dev_get_rcu(FIB_RES_DEV(*res));
	if (!out_dev) {
		net_crit_ratelimited("Bug in ip_route_input_slow(). Please report.\n");
		return -EINVAL;
	}

	err = fib_validate_source(skb, saddr, daddr, tos, FIB_RES_OIF(*res),
				  in_dev->dev, in_dev, &itag);
	if (err < 0) {
		ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
					 saddr);

		goto cleanup;
	}

	do_cache = res->fi && !itag;
	if (out_dev == in_dev && err && IN_DEV_TX_REDIRECTS(out_dev) &&
	    skb->protocol == htons(ETH_P_IP) &&
	    (IN_DEV_SHARED_MEDIA(out_dev) ||
	     inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
		IPCB(skb)->flags |= IPSKB_DOREDIRECT;

	if (skb->protocol != htons(ETH_P_IP)) {
		/* Not IP (i.e. ARP). Do not create route, if it is
                 * invalid for proxy arp. DNAT routes are always valid.
                 *
                 * Proxy arp feature have been extended to allow, ARP
                 * replies back to the same interface, to support
                 * Private VLAN switch technologies. See arp.c.
                 */
		if (out_dev == in_dev &&
		    IN_DEV_PROXY_ARP_PVLAN(in_dev) == 0) {
			err = -EINVAL;
			goto cleanup;
		}
	}

	fnhe = find_exception(&FIB_RES_NH(*res), daddr);
	if (do_cache) {
		if (fnhe) {
			rth = rcu_dereference(fnhe->fnhe_rth_input);
			if (rth && rth->dst.expires &&
			    time_after(jiffies, rth->dst.expires)) {
				ip_del_fnhe(&FIB_RES_NH(*res), daddr);
				fnhe = NULL;
			} else {
				goto rt_cache;
			}
		}

		rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input);

rt_cache:
		if (rt_cache_valid(rth)) {
			skb_dst_set_noref(skb, &rth->dst);
			goto out;
		}
	}

	rth = rt_dst_alloc(out_dev->dev, 0, res->type,
			   IN_DEV_CONF_GET(in_dev, NOPOLICY),
			   IN_DEV_CONF_GET(out_dev, NOXFRM), do_cache);
	if (!rth) {
		err = -ENOBUFS;
		goto cleanup;
	}

	rth->rt_is_input = 1;
	if (res->table)
		rth->rt_table_id = res->table->tb_id;
	RT_CACHE_STAT_INC(in_slow_tot);

	rth->dst.input = ip_forward;

	rt_set_nexthop(rth, daddr, res, fnhe, res->fi, res->type, itag,
		       do_cache);
	set_lwt_redirect(rth);
	skb_dst_set(skb, &rth->dst);
out:
	err = 0;
 cleanup:
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
247
51.14%
7
21.21%
Xin Long
48
9.94%
1
3.03%
Timo Teräs
34
7.04%
1
3.03%
lkml@einar-lueck.de
27
5.59%
1
3.03%
David Ahern
22
4.55%
2
6.06%
elueck@de.ibm.com
21
4.35%
1
3.03%
Linus Torvalds (pre-git)
17
3.52%
4
12.12%
Julian Anastasov
15
3.11%
1
3.03%
Hannes Frederic Sowa
15
3.11%
1
3.03%
Thomas Graf
11
2.28%
2
6.06%
Duan Jiong
5
1.04%
1
3.03%
Al Viro
4
0.83%
2
6.06%
Eric Dumazet
4
0.83%
2
6.06%
Tom Herbert
4
0.83%
1
3.03%
Wei Wang
2
0.41%
1
3.03%
Hideaki Yoshifuji / 吉藤英明
2
0.41%
1
3.03%
Li RongQing
2
0.41%
1
3.03%
Daniel Lezcano
1
0.21%
1
3.03%
Denis V. Lunev
1
0.21%
1
3.03%
Ian Morris
1
0.21%
1
3.03%
Total
483
100.00%
33
100.00%

#ifdef CONFIG_IP_ROUTE_MULTIPATH
/* To make ICMP packets follow the right flow, the multipath hash is
 * calculated from the inner IP addresses.
 */


static void ip_multipath_l3_keys(const struct sk_buff *skb,
				 struct flow_keys *hash_keys)
{
	const struct iphdr *outer_iph = ip_hdr(skb);
	const struct iphdr *inner_iph;
	const struct icmphdr *icmph;
	struct iphdr _inner_iph;
	struct icmphdr _icmph;

	hash_keys->addrs.v4addrs.src = outer_iph->saddr;
	hash_keys->addrs.v4addrs.dst = outer_iph->daddr;
	if (likely(outer_iph->protocol != IPPROTO_ICMP))
		return;

	if (unlikely((outer_iph->frag_off & htons(IP_OFFSET)) != 0))
		return;

	icmph = skb_header_pointer(skb, outer_iph->ihl * 4, sizeof(_icmph),
				   &_icmph);
	if (!icmph)
		return;

	if (icmph->type != ICMP_DEST_UNREACH &&
	    icmph->type != ICMP_REDIRECT &&
	    icmph->type != ICMP_TIME_EXCEEDED &&
	    icmph->type != ICMP_PARAMETERPROB)
		return;

	inner_iph = skb_header_pointer(skb,
				       outer_iph->ihl * 4 + sizeof(_icmph),
				       sizeof(_inner_iph), &_inner_iph);
	if (!inner_iph)
		return;
	hash_keys->addrs.v4addrs.src = inner_iph->saddr;
	hash_keys->addrs.v4addrs.dst = inner_iph->daddr;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Peter Christensen
137
64.32%
1
50.00%
Nikolay Aleksandrov
76
35.68%
1
50.00%
Total
213
100.00%
2
100.00%

/* if skb is set it will be used and fl4 can be NULL */


int fib_multipath_hash(const struct fib_info *fi, const struct flowi4 *fl4,
		       const struct sk_buff *skb)
{
	struct net *net = fi->fib_net;
	struct flow_keys hash_keys;
	u32 mhash;

	switch (net->ipv4.sysctl_fib_multipath_hash_policy) {
	case 0:
		memset(&hash_keys, 0, sizeof(hash_keys));
		hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
		if (skb) {
			ip_multipath_l3_keys(skb, &hash_keys);
		} else {
			hash_keys.addrs.v4addrs.src = fl4->saddr;
			hash_keys.addrs.v4addrs.dst = fl4->daddr;
		}
		break;
	case 1:
		/* skb is currently provided only when forwarding */
		if (skb) {
			unsigned int flag = FLOW_DISSECTOR_F_STOP_AT_ENCAP;
			struct flow_keys keys;

			/* short-circuit if we already have L4 hash present */
			if (skb->l4_hash)
				return skb_get_hash_raw(skb) >> 1;
			memset(&hash_keys, 0, sizeof(hash_keys));
			skb_flow_dissect_flow_keys(skb, &keys, flag);
			hash_keys.addrs.v4addrs.src = keys.addrs.v4addrs.src;
			hash_keys.addrs.v4addrs.dst = keys.addrs.v4addrs.dst;
			hash_keys.ports.src = keys.ports.src;
			hash_keys.ports.dst = keys.ports.dst;
			hash_keys.basic.ip_proto = keys.basic.ip_proto;
		} else {
			memset(&hash_keys, 0, sizeof(hash_keys));
			hash_keys.control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
			hash_keys.addrs.v4addrs.src = fl4->saddr;
			hash_keys.addrs.v4addrs.dst = fl4->daddr;
			hash_keys.ports.src = fl4->fl4_sport;
			hash_keys.ports.dst = fl4->fl4_dport;
			hash_keys.basic.ip_proto = fl4->flowi4_proto;
		}
		break;
	}
	mhash = flow_hash_from_keys(&hash_keys);

	return mhash >> 1;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Nikolay Aleksandrov
320
96.10%
1
50.00%
Peter Christensen
13
3.90%
1
50.00%
Total
333
100.00%
2
100.00%


EXPORT_SYMBOL_GPL(fib_multipath_hash);
#endif /* CONFIG_IP_ROUTE_MULTIPATH */



static int ip_mkroute_input(struct sk_buff *skb,
			    struct fib_result *res,
			    struct in_device *in_dev,
			    __be32 daddr, __be32 saddr, u32 tos)
{
#ifdef CONFIG_IP_ROUTE_MULTIPATH
	if (res->fi && res->fi->fib_nhs > 1) {
		int h = fib_multipath_hash(res->fi, NULL, skb);

		fib_select_multipath(res, h);
	}
#endif

	/* create a routing cache entry */
	return __mkroute_input(skb, res, in_dev, daddr, saddr, tos);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
54
60.67%
2
33.33%
Peter Christensen
10
11.24%
1
16.67%
lkml@einar-lueck.de
10
11.24%
1
16.67%
Nikolay Aleksandrov
8
8.99%
1
16.67%
Linus Torvalds (pre-git)
7
7.87%
1
16.67%
Total
89
100.00%
6
100.00%

/*
 *      NOTE. We drop all the packets that has local source
 *      addresses, because every properly looped back packet
 *      must have correct destination already attached by output routine.
 *
 *      Such approach solves two big problems:
 *      1. Not simplex devices are handled properly.
 *      2. IP spoofing attempts are filtered with 100% of guarantee.
 *      called with rcu_read_lock()
 */



static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
			       u8 tos, struct net_device *dev,
			       struct fib_result *res)
{
	struct in_device *in_dev = __in_dev_get_rcu(dev);
	struct ip_tunnel_info *tun_info;
	struct flowi4	fl4;
	unsigned int	flags = 0;
	u32		itag = 0;
	struct rtable	*rth;
	int		err = -EINVAL;
	struct net    *net = dev_net(dev);
	bool do_cache;

	/* IP on this device is disabled. */

	if (!in_dev)
		goto out;

	/* Check for the most weird martians, which can be not detected
           by fib_lookup.
         */

	tun_info = skb_tunnel_info(skb);
	if (tun_info && !(tun_info->mode & IP_TUNNEL_INFO_TX))
		fl4.flowi4_tun_key.tun_id = tun_info->key.tun_id;
	else
		fl4.flowi4_tun_key.tun_id = 0;
	skb_dst_drop(skb);

	if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr))
		goto martian_source;

	res->fi = NULL;
	res->table = NULL;
	if (ipv4_is_lbcast(daddr) || (saddr == 0 && daddr == 0))
		goto brd_input;

	/* Accept zero addresses only to limited broadcast;
         * I even do not know to fix it or not. Waiting for complains :-)
         */
	if (ipv4_is_zeronet(saddr))
		goto martian_source;

	if (ipv4_is_zeronet(daddr))
		goto martian_destination;

	/* Following code try to avoid calling IN_DEV_NET_ROUTE_LOCALNET(),
         * and call it once if daddr or/and saddr are loopback addresses
         */
	if (ipv4_is_loopback(daddr)) {
		if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
			goto martian_destination;
	} else if (ipv4_is_loopback(saddr)) {
		if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
			goto martian_source;
	}

	/*
         *      Now we are ready to route packet.
         */
	fl4.flowi4_oif = 0;
	fl4.flowi4_iif = dev->ifindex;
	fl4.flowi4_mark = skb->mark;
	fl4.flowi4_tos = tos;
	fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
	fl4.flowi4_flags = 0;
	fl4.daddr = daddr;
	fl4.saddr = saddr;
	fl4.flowi4_uid = sock_net_uid(net, NULL);
	err = fib_lookup(net, &fl4, res, 0);
	if (err != 0) {
		if (!IN_DEV_FORWARD(in_dev))
			err = -EHOSTUNREACH;
		goto no_route;
	}

	if (res->type == RTN_BROADCAST)
		goto brd_input;

	if (res->type == RTN_LOCAL) {
		err = fib_validate_source(skb, saddr, daddr, tos,
					  0, dev, in_dev, &itag);
		if (err < 0)
			goto martian_source;
		goto local_input;
	}

	if (!IN_DEV_FORWARD(in_dev)) {
		err = -EHOSTUNREACH;
		goto no_route;
	}
	if (res->type != RTN_UNICAST)
		goto martian_destination;

	err = ip_mkroute_input(skb, res, in_dev, daddr, saddr, tos);
out:	return err;

brd_input:
	if (skb->protocol != htons(ETH_P_IP))
		goto e_inval;

	if (!ipv4_is_zeronet(saddr)) {
		err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
					  in_dev, &itag);
		if (err < 0)
			goto martian_source;
	}
	flags |= RTCF_BROADCAST;
	res->type = RTN_BROADCAST;
	RT_CACHE_STAT_INC(in_brd);

local_input:
	do_cache = false;
	if (res->fi) {
		if (!itag) {
			rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input);
			if (rt_cache_valid(rth)) {
				skb_dst_set_noref(skb, &rth->dst);
				err = 0;
				goto out;
			}
			do_cache = true;
		}
	}

	rth = rt_dst_alloc(l3mdev_master_dev_rcu(dev) ? : net->loopback_dev,
			   flags | RTCF_LOCAL, res->type,
			   IN_DEV_CONF_GET(in_dev, NOPOLICY), false, do_cache);
	if (!rth)
		goto e_nobufs;

	rth->dst.output= ip_rt_bug;
#ifdef CONFIG_IP_ROUTE_CLASSID
	rth->dst.tclassid = itag;
#endif
	rth->rt_is_input = 1;
	if (res->table)
		rth->rt_table_id = res->table->tb_id;

	RT_CACHE_STAT_INC(in_slow_tot);
	if (res->type == RTN_UNREACHABLE) {
		rth->dst.input= ip_error;
		rth->dst.error= -err;
		rth->rt_flags 	&= ~RTCF_LOCAL;
	}

	if (do_cache) {
		struct fib_nh *nh = &FIB_RES_NH(*res);

		rth->dst.lwtstate = lwtstate_get(nh->nh_lwtstate);
		if (lwtunnel_input_redirect(rth->dst.lwtstate)) {
			WARN_ON(rth->dst.input == lwtunnel_input);
			rth->dst.lwtstate->orig_input = rth->dst.input;
			rth->dst.input = lwtunnel_input;
		}

		if (unlikely(!rt_cache_route(nh, rth)))
			rt_add_uncached_list(rth);
	}
	skb_dst_set(skb, &rth->dst);
	err = 0;
	goto out;

no_route:
	RT_CACHE_STAT_INC(in_no_route);
	res->type = RTN_UNREACHABLE;
	res->fi = NULL;
	res->table = NULL;
	goto local_input;

	/*
         *      Do not cache martian addresses: they should be logged (RFC1812)
         */
martian_destination:
	RT_CACHE_STAT_INC(in_martian_dst);
#ifdef CONFIG_IP_ROUTE_VERBOSE
	if (IN_DEV_LOG_MARTIANS(in_dev))
		net_warn_ratelimited("martian destination %pI4 from %pI4, dev %s\n",
				     &daddr, &saddr, dev->name);
#endif

e_inval:
	err = -EINVAL;
	goto out;

e_nobufs:
	err = -ENOBUFS;
	goto out;

martian_source:
	ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
	goto out;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
529
56.58%
10
19.61%
Thomas Graf
117
12.51%
3
5.88%
lkml@einar-lueck.de
82
8.77%
1
1.96%
David Ahern
68
7.27%
9
17.65%
Eric Dumazet
49
5.24%
9
17.65%
Duan Jiong
24
2.57%
2
3.92%
Linus Torvalds (pre-git)
15
1.60%
5
9.80%
Alexei Starovoitov
14
1.50%
1
1.96%
Julian Anastasov
11
1.18%
1
1.96%
Neil Horman
6
0.64%
1
1.96%
Nicolas Cavallari
5
0.53%
1
1.96%
Jiri Benc
5
0.53%
1
1.96%
Denis V. Lunev
3
0.32%
2
3.92%
Hideaki Yoshifuji / 吉藤英明
2
0.21%
1
1.96%
Andy Gospodarek
2
0.21%
1
1.96%
Al Viro
1
0.11%
1
1.96%
Cong Wang
1
0.11%
1
1.96%
Pavel Emelyanov
1
0.11%
1
1.96%
Total
935
100.00%
51
100.00%



int ip_route_input_noref(struct sk_buff *skb, __be32 daddr, __be32 saddr,
			 u8 tos, struct net_device *dev)
{
	struct fib_result res;
	int err;

	tos &= IPTOS_RT_MASK;
	rcu_read_lock();
	err = ip_route_input_rcu(skb, daddr, saddr, tos, dev, &res);
	rcu_read_unlock();

	return err;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David Ahern
30
48.39%
1
25.00%
David S. Miller
28
45.16%
2
50.00%
Julian Anastasov
4
6.45%
1
25.00%
Total
62
100.00%
4
100.00%


EXPORT_SYMBOL(ip_route_input_noref);

/* called with rcu_read_lock held */


int ip_route_input_rcu(struct sk_buff *skb, __be32 daddr, __be32 saddr,
		       u8 tos, struct net_device *dev, struct fib_result *res)
{
	/* Multicast recognition logic is moved from route cache to here.
           The problem was that too many Ethernet cards have broken/missing
           hardware multicast filters :-( As result the host on multicasting
           network acquires a lot of useless route cache entries, sort of
           SDR messages from all the world. Now we try to get rid of them.
           Really, provided software IP multicast filter is organized
           reasonably (at least, hashed), it does not result in a slowdown
           comparing with route cache reject entries.
           Note, that multicast routers are not affected, because
           route cache entry is created eventually.
         */
	if (ipv4_is_multicast(daddr)) {
		struct in_device *in_dev = __in_dev_get_rcu(dev);
		int our = 0;
		int err = -EINVAL;

		if (in_dev)
			our = ip_check_mc_rcu(in_dev, daddr, saddr,
					      ip_hdr(skb)->protocol);

		/* check l3 master if no match yet */
		if ((!in_dev || !our) && netif_is_l3_slave(dev)) {
			struct in_device *l3_in_dev;

			l3_in_dev = __in_dev_get_rcu(skb->dev);
			if (l3_in_dev)
				our = ip_check_mc_rcu(l3_in_dev, daddr, saddr,
						      ip_hdr(skb)->protocol);
		}

		if (our
#ifdef CONFIG_IP_MROUTE
			||
		    (!ipv4_is_local_multicast(daddr) &&
		     IN_DEV_MFORWARD(in_dev))
#endif
		   ) {
			err = ip_route_input_mc(skb, daddr, saddr,
						tos, dev, our);
		}
		return err;
	}

	return ip_route_input_slow(skb, daddr, saddr, tos, dev, res);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David Ahern
100
51.02%
2
25.00%
lkml@einar-lueck.de
82
41.84%
1
12.50%
Eric Dumazet
7
3.57%
1
12.50%
Arnaldo Carvalho de Melo
3
1.53%
1
12.50%
Joe Perches
2
1.02%
1
12.50%
Herbert Xu
1
0.51%
1
12.50%
David S. Miller
1
0.51%
1
12.50%
Total
196
100.00%
8
100.00%

/* called with rcu_read_lock() */


static struct rtable *__mkroute_output(const struct fib_result *res,
				       const struct flowi4 *fl4, int orig_oif,
				       struct net_device *dev_out,
				       unsigned int flags)
{
	struct fib_info *fi = res->fi;
	struct fib_nh_exception *fnhe;
	struct in_device *in_dev;
	u16 type = res->type;
	struct rtable *rth;
	bool do_cache;

	in_dev = __in_dev_get_rcu(dev_out);
	if (!in_dev)
		return ERR_PTR(-EINVAL);

	if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
		if (ipv4_is_loopback(fl4->saddr) &&
		    !(dev_out->flags & IFF_LOOPBACK) &&
		    !netif_is_l3_master(dev_out))
			return ERR_PTR(-EINVAL);

	if (ipv4_is_lbcast(fl4->daddr))
		type = RTN_BROADCAST;
	else if (ipv4_is_multicast(fl4->daddr))
		type = RTN_MULTICAST;
	else if (ipv4_is_zeronet(fl4->daddr))
		return ERR_PTR(-EINVAL);

	if (dev_out->flags & IFF_LOOPBACK)
		flags |= RTCF_LOCAL;

	do_cache = true;
	if (type == RTN_BROADCAST) {
		flags |= RTCF_BROADCAST | RTCF_LOCAL;
		fi = NULL;
	} else if (type == RTN_MULTICAST) {
		flags |= RTCF_MULTICAST | RTCF_LOCAL;
		if (!ip_check_mc_rcu(in_dev, fl4->daddr, fl4->saddr,
				     fl4->flowi4_proto))
			flags &= ~RTCF_LOCAL;
		else
			do_cache = false;
		/* If multicast route do not exist use
                 * default one, but do not gateway in this case.
                 * Yes, it is hack.
                 */
		if (fi && res->prefixlen < 4)
			fi = NULL;
	} else if ((type == RTN_LOCAL) && (orig_oif != 0) &&
		   (orig_oif != dev_out->ifindex)) {
		/* For local routes that require a particular output interface
                 * we do not want to cache the result.  Caching the result
                 * causes incorrect behaviour when there are multiple source
                 * addresses on the interface, the end result being that if the
                 * intended recipient is waiting on that interface for the
                 * packet he won't receive it because it will be delivered on
                 * the loopback interface and the IP_PKTINFO ipi_ifindex will
                 * be set to the loopback interface as well.
                 */
		fi = NULL;
	}

	fnhe = NULL;
	do_cache &= fi != NULL;
	if (do_cache) {
		struct rtable __rcu **prth;
		struct fib_nh *nh = &FIB_RES_NH(*res);

		fnhe = find_exception(nh, fl4->daddr);
		if (fnhe) {
			prth = &fnhe->fnhe_rth_output;
			rth = rcu_dereference(*prth);
			if (rth && rth->dst.expires &&
			    time_after(jiffies, rth->dst.expires)) {
				ip_del_fnhe(nh, fl4->daddr);
				fnhe = NULL;
			} else {
				goto rt_cache;
			}
		}

		if (unlikely(fl4->flowi4_flags &
			     FLOWI_FLAG_KNOWN_NH &&
			     !(nh->nh_gw &&
			       nh->nh_scope == RT_SCOPE_LINK))) {
			do_cache = false;
			goto add;
		}
		prth = raw_cpu_ptr(nh->nh_pcpu_rth_output);
		rth = rcu_dereference(*prth);

rt_cache:
		if (rt_cache_valid(rth) && dst_hold_safe(&rth->dst))
			return rth;
	}

add:
	rth = rt_dst_alloc(dev_out, flags, type,
			   IN_DEV_CONF_GET(in_dev, NOPOLICY),
			   IN_DEV_CONF_GET(in_dev, NOXFRM),
			   do_cache);
	if (!rth)
		return ERR_PTR(-ENOBUFS);

	rth->rt_iif = orig_oif;
	if (res->table)
		rth->rt_table_id = res->table->tb_id;

	RT_CACHE_STAT_INC(out_slow_tot);

	if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
		if (flags & RTCF_LOCAL &&
		    !(dev_out->flags & IFF_LOOPBACK)) {
			rth->dst.output = ip_mc_output;
			RT_CACHE_STAT_INC(out_slow_mc);
		}
#ifdef CONFIG_IP_MROUTE
		if (type == RTN_MULTICAST) {
			if (IN_DEV_MFORWARD(in_dev) &&
			    !ipv4_is_local_multicast(fl4->daddr)) {
				rth->dst.input = ip_mr_input;
				rth->dst.output = ip_mc_output;
			}
		}
#endif
	}

	rt_set_nexthop(rth, fl4->daddr, res, fnhe, fi, type, 0, do_cache);
	set_lwt_redirect(rth);

	return rth;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
lkml@einar-lueck.de
229
34.75%
1
2.44%
David S. Miller
146
22.15%
11
26.83%
Julian Anastasov
72
10.93%
3
7.32%
Xin Long
52
7.89%
1
2.44%
Thomas Graf
31
4.70%
2
4.88%
Chris Friesen
30
4.55%
1
2.44%
Linus Torvalds (pre-git)
28
4.25%
5
12.20%
David Ahern
26
3.95%
3
7.32%
Eric Dumazet
14
2.12%
3
7.32%
Herbert Xu
7
1.06%
1
2.44%
Wei Wang
5
0.76%
2
4.88%
Joe Perches
4
0.61%
1
2.44%
Robert Shearman
4
0.61%
1
2.44%
elueck@de.ibm.com
3
0.46%
1
2.44%
Hirofumi Ogawa
3
0.46%
1
2.44%
Andy Walls
2
0.30%
1
2.44%
Al Viro
1
0.15%
1
2.44%
Timo Teräs
1
0.15%
1
2.44%
Christoph Lameter
1
0.15%
1
2.44%
Total
659
100.00%
41
100.00%

/*
 * Major route resolver routine.
 */



struct rtable *ip_route_output_key_hash(struct net *net, struct flowi4 *fl4,
					const struct sk_buff *skb)
{
	__u8 tos = RT_FL_TOS(fl4);
	struct fib_result res;
	struct rtable *rth;

	res.tclassid	= 0;
	res.fi		= NULL;
	res.table	= NULL;

	fl4->flowi4_iif = LOOPBACK_IFINDEX;
	fl4->flowi4_tos = tos & IPTOS_RT_MASK;
	fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
			 RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);

	rcu_read_lock();
	rth = ip_route_output_key_hash_rcu(net, fl4, &res, skb);
	rcu_read_unlock();

	return rth;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
55
49.55%
8
47.06%
David Ahern
22
19.82%
1
5.88%
lkml@einar-lueck.de
15
13.51%
1
5.88%
Linus Torvalds (pre-git)
7
6.31%
2
11.76%
Nikolay Aleksandrov
5
4.50%
1
5.88%
Denis V. Lunev
4
3.60%
1
5.88%
Julian Anastasov
1
0.90%
1
5.88%
Pavel Emelyanov
1
0.90%
1
5.88%
Peter Christensen
1
0.90%
1
5.88%
Total
111
100.00%
17
100.00%


EXPORT_SYMBOL_GPL(ip_route_output_key_hash);



struct rtable *ip_route_output_key_hash_rcu(struct net *net, struct flowi4 *fl4,
					    struct fib_result *res,
					    const struct sk_buff *skb)
{
	struct net_device *dev_out = NULL;
	int orig_oif = fl4->flowi4_oif;
	unsigned int flags = 0;
	struct rtable *rth;
	int err = -ENETUNREACH;

	if (fl4->saddr) {
		rth = ERR_PTR(-EINVAL);
		if (ipv4_is_multicast(fl4->saddr) ||
		    ipv4_is_lbcast(fl4->saddr) ||
		    ipv4_is_zeronet(fl4->saddr))
			goto out;

		/* I removed check for oif == dev_out->oif here.
                   It was wrong for two reasons:
                   1. ip_dev_find(net, saddr) can return wrong iface, if saddr
                      is assigned to multiple interfaces.
                   2. Moreover, we are allowed to send packets with saddr
                      of another iface. --ANK
                 */

		if (fl4->flowi4_oif == 0 &&
		    (ipv4_is_multicast(fl4->daddr) ||
		     ipv4_is_lbcast(fl4->daddr))) {
			/* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
			dev_out = __ip_dev_find(net, fl4->saddr, false);
			if (!dev_out)
				goto out;

			/* Special hack: user can direct multicasts
                           and limited broadcast via necessary interface
                           without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
                           This hack is not just for fun, it allows
                           vic,vat and friends to work.
                           They bind socket to loopback, set ttl to zero
                           and expect that it will work.
                           From the viewpoint of routing cache they are broken,
                           because we are not allowed to build multicast path
                           with loopback source addr (look, routing cache
                           cannot know, that ttl is zero, so that packet
                           will not leave this host and route is valid).
                           Luckily, this hack is good workaround.
                         */

			fl4->flowi4_oif = dev_out->ifindex;
			goto make_route;
		}

		if (!(fl4->flowi4_flags & FLOWI_FLAG_ANYSRC)) {
			/* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
			if (!__ip_dev_find(net, fl4->saddr, false))
				goto out;
		}
	}


	if (fl4->flowi4_oif) {
		dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);
		rth = ERR_PTR(-ENODEV);
		if (!dev_out)
			goto out;

		/* RACE: Check return value of inet_select_addr instead. */
		if (!(dev_out->flags & IFF_UP) || !__in_dev_get_rcu(dev_out)) {
			rth = ERR_PTR(-ENETUNREACH);
			goto out;
		}
		if (ipv4_is_local_multicast(fl4->daddr) ||
		    ipv4_is_lbcast(fl4->daddr) ||
		    fl4->flowi4_proto == IPPROTO_IGMP) {
			if (!fl4->saddr)
				fl4->saddr = inet_select_addr(dev_out, 0,
							      RT_SCOPE_LINK);
			goto make_route;
		}
		if (!fl4->saddr) {
			if (ipv4_is_multicast(fl4->daddr))
				fl4->saddr = inet_select_addr(dev_out, 0,
							      fl4->flowi4_scope);
			else if (!fl4->daddr)
				fl4->saddr = inet_select_addr(dev_out, 0,
							      RT_SCOPE_HOST);
		}
	}

	if (!fl4->daddr) {
		fl4->daddr = fl4->saddr;
		if (!fl4->daddr)
			fl4->daddr = fl4->saddr = htonl(INADDR_LOOPBACK);
		dev_out = net->loopback_dev;
		fl4->flowi4_oif = LOOPBACK_IFINDEX;
		res->type = RTN_LOCAL;
		flags |= RTCF_LOCAL;
		goto make_route;
	}

	err = fib_lookup(net, fl4, res, 0);
	if (err) {
		res->fi = NULL;
		res->table = NULL;
		if (fl4->flowi4_oif &&
		    (ipv4_is_multicast(fl4->daddr) ||
		    !netif_index_is_l3_master(net, fl4->flowi4_oif))) {
			/* Apparently, routing tables are wrong. Assume,
                           that the destination is on link.

                           WHY? DW.
                           Because we are allowed to send to iface
                           even if it has NO routes and NO assigned
                           addresses. When oif is specified, routing
                           tables are looked up with only one purpose:
                           to catch if destination is gatewayed, rather than
                           direct. Moreover, if MSG_DONTROUTE is set,
                           we send packet, ignoring both routing tables
                           and ifaddr state. --ANK


                           We could make it even if oif is unknown,
                           likely IPv6, but we do not.
                         */

			if (fl4->saddr == 0)
				fl4->saddr = inet_select_addr(dev_out, 0,
							      RT_SCOPE_LINK);
			res->type = RTN_UNICAST;
			goto make_route;
		}
		rth = ERR_PTR(err);
		goto out;
	}

	if (res->type == RTN_LOCAL) {
		if (!fl4->saddr) {
			if (res->fi->fib_prefsrc)
				fl4->saddr = res->fi->fib_prefsrc;
			else
				fl4->saddr = fl4->daddr;
		}

		/* L3 master device is the loopback for that domain */
		dev_out = l3mdev_master_dev_rcu(FIB_RES_DEV(*res)) ? :
			net->loopback_dev;

		/* make sure orig_oif points to fib result device even
                 * though packet rx/tx happens over loopback or l3mdev
                 */
		orig_oif = FIB_RES_OIF(*res);

		fl4->flowi4_oif = dev_out->ifindex;
		flags |= RTCF_LOCAL;
		goto make_route;
	}

	fib_select_path(net, res, fl4, skb);

	dev_out = FIB_RES_DEV(*res);
	fl4->flowi4_oif = dev_out->ifindex;


make_route:
	rth = __mkroute_output(res, fl4, orig_oif, dev_out, flags);

out:
	return rth;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
234
35.62%
9
16.36%
lkml@einar-lueck.de
117
17.81%
1
1.82%
David Ahern
104
15.83%
7
12.73%
Linus Torvalds (pre-git)
71
10.81%
9
16.36%
Julian Anastasov
35
5.33%
2
3.64%
Eric Dumazet
28
4.26%
3
5.45%
Nikola Forró
7
1.07%
1
1.82%
Joel Sing
6
0.91%
1
1.82%
Andrew Lunn
6
0.91%
1
1.82%
Alexey Kuznetsov
6
0.91%
1
1.82%
Joe Perches
5
0.76%
1
1.82%
Neil Horman
4
0.61%
1
1.82%
Robert Shearman
4
0.61%
1
1.82%
Andy Walls
4
0.61%
1
1.82%
Denis V. Lunev
4
0.61%
2
3.64%
Peter Christensen
3
0.46%
1
1.82%
Linus Torvalds
3
0.46%
2
3.64%
Robert Olsson
3
0.46%
1
1.82%
Andy Gospodarek
2
0.30%
1
1.82%
Ian Morris
2
0.30%
1
1.82%
Al Viro
2
0.30%
1
1.82%
Jan Engelhardt
1
0.15%
1
1.82%
Eric W. Biedermann
1
0.15%
1
1.82%
Pavel Emelyanov
1
0.15%
1
1.82%
Jiri Benc
1
0.15%
1
1.82%
Herbert Xu
1
0.15%
1
1.82%
David L Stevens
1
0.15%
1
1.82%
Nikolay Aleksandrov
1
0.15%
1
1.82%
Total
657
100.00%
55
100.00%



static struct dst_entry *ipv4_blackhole_dst_check(struct dst_entry *dst, u32 cookie)
{
	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jianzhao Wang
19
100.00%
1
100.00%
Total
19
100.00%
1
100.00%



static unsigned int ipv4_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 ipv4_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 ipv4_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 u32 *ipv4_rt_blackhole_cow_metrics(struct dst_entry *dst,
					  unsigned long old)
{
	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Held Bernhard
19
100.00%
1
100.00%
Total
19
100.00%
1
100.00%


static struct dst_ops ipv4_dst_blackhole_ops = {
	.family			=	AF_INET,
	.check			=	ipv4_blackhole_dst_check,
	.mtu			=	ipv4_blackhole_mtu,
	.default_advmss		=	ipv4_default_advmss,
	.update_pmtu		=	ipv4_rt_blackhole_update_pmtu,
	.redirect		=	ipv4_rt_blackhole_redirect,
	.cow_metrics		=	ipv4_rt_blackhole_cow_metrics,
	.neigh_lookup		=	ipv4_neigh_lookup,
};



struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig)
{
	struct rtable *ort = (struct rtable *) dst_orig;
	struct rtable *rt;

	rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, DST_OBSOLETE_DEAD, 0);
	if (rt) {
		struct dst_entry *new = &rt->dst;

		new->__use = 1;
		new->input = dst_discard;
		new->output = dst_discard_out;

		new->dev = net->loopback_dev;
		if (new->dev)
			dev_hold(new->dev);

		rt->rt_is_input = ort->rt_is_input;
		rt->rt_iif = ort->rt_iif;
		rt->rt_pmtu = ort->rt_pmtu;

		rt->rt_genid = rt_genid_ipv4(net);
		rt->rt_flags = ort->rt_flags;
		rt->rt_type = ort->rt_type;
		rt->rt_gateway = ort->rt_gateway;
		rt->rt_uses_gateway = ort->rt_uses_gateway;

		INIT_LIST_HEAD(&rt->rt_uncached);
	}

	dst_release(dst_orig);

	return rt ? &rt->dst : ERR_PTR(-ENOMEM);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
163
82.74%
8
44.44%
Julian Anastasov
8
4.06%
1
5.56%
Denis V. Lunev
7
3.55%
1
5.56%
Hirofumi Ogawa
6
3.05%
1
5.56%
Eric Dumazet
6
3.05%
1
5.56%
Wei Wang
3
1.52%
2
11.11%
Eric W. Biedermann
1
0.51%
1
5.56%
Steffen Klassert
1
0.51%
1
5.56%
Herbert Xu
1
0.51%
1
5.56%
Fan Du
1
0.51%
1
5.56%
Total
197
100.00%
18
100.00%



struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4,
				    const struct sock *sk)
{
	struct rtable *rt = __ip_route_output_key(net, flp4);

	if (IS_ERR(rt))
		return rt;

	if (flp4->flowi4_proto)
		rt = (struct rtable *)xfrm_lookup_route(net, &rt->dst,
							flowi4_to_flowi(flp4),
							sk, 0);

	return rt;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
49
61.25%
4
33.33%
Alexey Kuznetsov
19
23.75%
2
16.67%
Denis V. Lunev
7
8.75%
2
16.67%
Alexey Dobriyan
2
2.50%
1
8.33%
Eric Dumazet
1
1.25%
1
8.33%
Herbert Xu
1
1.25%
1
8.33%
Steffen Klassert
1
1.25%
1
8.33%
Total
80
100.00%
12
100.00%


EXPORT_SYMBOL_GPL(ip_route_output_flow);

/* called with rcu_read_lock held */


static int rt_fill_info(struct net *net,  __be32 dst, __be32 src, u32 table_id,
			struct flowi4 *fl4, struct sk_buff *skb, u32 portid,
			u32 seq)
{
	struct rtable *rt = skb_rtable(skb);
	struct rtmsg *r;
	struct nlmsghdr *nlh;
	unsigned long expires = 0;
	u32 error;
	u32 metrics[RTAX_MAX];

	nlh = nlmsg_put(skb, portid, seq, RTM_NEWROUTE, sizeof(*r), 0);
	if (!nlh)
		return -EMSGSIZE;

	r = nlmsg_data(nlh);
	r->rtm_family	 = AF_INET;
	r->rtm_dst_len	= 32;
	r->rtm_src_len	= 0;
	r->rtm_tos	= fl4->flowi4_tos;
	r->rtm_table	= table_id < 256 ? table_id : RT_TABLE_COMPAT;
	if (nla_put_u32(skb, RTA_TABLE, table_id))
		goto nla_put_failure;
	r->rtm_type	= rt->rt_type;
	r->rtm_scope	= RT_SCOPE_UNIVERSE;
	r->rtm_protocol = RTPROT_UNSPEC;
	r->rtm_flags	= (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
	if (rt->rt_flags & RTCF_NOTIFY)
		r->rtm_flags |= RTM_F_NOTIFY;
	if (IPCB(skb)->flags & IPSKB_DOREDIRECT)
		r->rtm_flags |= RTCF_DOREDIRECT;

	if (nla_put_in_addr(skb, RTA_DST, dst))
		goto nla_put_failure;
	if (src) {
		r->rtm_src_len = 32;
		if (nla_put_in_addr(skb, RTA_SRC, src))
			goto nla_put_failure;
	}
	if (rt->dst.dev &&
	    nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
		goto nla_put_failure;
#ifdef CONFIG_IP_ROUTE_CLASSID
	if (rt->dst.tclassid &&
	    nla_put_u32(skb, RTA_FLOW, rt->dst.tclassid))
		goto nla_put_failure;
#endif
	if (!rt_is_input_route(rt) &&
	    fl4->saddr != src) {
		if (nla_put_in_addr(skb, RTA_PREFSRC, fl4->saddr))
			goto nla_put_failure;
	}
	if (rt->rt_uses_gateway &&
	    nla_put_in_addr(skb, RTA_GATEWAY, rt->rt_gateway))
		goto nla_put_failure;

	expires = rt->dst.expires;
	if (expires) {
		unsigned long now = jiffies;

		if (time_before(now, expires))
			expires -= now;
		else
			expires = 0;
	}

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

	if (fl4->flowi4_mark &&
	    nla_put_u32(skb, RTA_MARK, fl4->flowi4_mark))
		goto nla_put_failure;

	if (!uid_eq(fl4->flowi4_uid, INVALID_UID) &&
	    nla_put_u32(skb, RTA_UID,
			from_kuid_munged(current_user_ns(), fl4->flowi4_uid)))
		goto nla_put_failure;

	error = rt->dst.error;

	if (rt_is_input_route(rt)) {
#ifdef CONFIG_IP_MROUTE
		if (ipv4_is_multicast(dst) && !ipv4_is_local_multicast(dst) &&
		    IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
			int err = ipmr_get_route(net, skb,
						 fl4->saddr, fl4->daddr,
						 r, portid);

			if (err <= 0) {
				if (err == 0)
					return 0;
				goto nla_put_failure;
			}
		} else
#endif
			if (nla_put_u32(skb, RTA_IIF, skb->dev->ifindex))
				goto nla_put_failure;
	}

	if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, error) < 0)
		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)
258
38.80%
9
19.57%
David S. Miller
95
14.29%
9
19.57%
Nicolas Dichtel
69
10.38%
1
2.17%
Thomas Graf
45
6.77%
2
4.35%
Julian Anastasov
44
6.62%
3
6.52%
Steffen Klassert
41
6.17%
2
4.35%
Lorenzo Colitti
32
4.81%
1
2.17%
Hannes Frederic Sowa
17
2.56%
1
2.17%
Eric Dumazet
13
1.95%
2
4.35%
David Ahern
13
1.95%
4
8.70%
Patrick McHardy
12
1.80%
3
6.52%
Roopa Prabhu
8
1.20%
1
2.17%
Benjamin Thery
5
0.75%
1
2.17%
Jiri Benc
4
0.60%
1
2.17%
Johannes Berg
3
0.45%
1
2.17%
Eric W. Biedermann
2
0.30%
1
2.17%
Nikolay Aleksandrov
1
0.15%
1
2.17%
Jamal Hadi Salim
1
0.15%
1
2.17%
Ian Morris
1
0.15%
1
2.17%
Stephen Hemminger
1
0.15%
1
2.17%
Total
665
100.00%
46
100.00%



static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh,
			     struct netlink_ext_ack *extack)
{
	struct net *net = sock_net(in_skb->sk);
	struct rtmsg *rtm;
	struct nlattr *tb[RTA_MAX+1];
	struct fib_result res = {};
	struct rtable *rt = NULL;
	struct flowi4 fl4;
	__be32 dst = 0;
	__be32 src = 0;
	u32 iif;
	int err;
	int mark;
	struct sk_buff *skb;
	u32 table_id = RT_TABLE_MAIN;
	kuid_t uid;

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

	rtm = nlmsg_data(nlh);

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

	/* Reserve room for dummy headers, this skb can pass
           through good chunk of routing engine.
         */
	skb_reset_mac_header(skb);
	skb_reset_network_header(skb);

	src = tb[RTA_SRC] ? nla_get_in_addr(tb[RTA_SRC]) : 0;
	dst = tb[RTA_DST] ? nla_get_in_addr(tb[RTA_DST]) : 0;
	iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
	mark = tb[RTA_MARK] ? nla_get_u32(tb[RTA_MARK]) : 0;
	if (tb[RTA_UID])
		uid = make_kuid(current_user_ns(), nla_get_u32(tb[RTA_UID]));
	else
		uid = (iif ? INVALID_UID : current_uid());

	/* Bugfix: need to give ip_route_input enough of an IP header to
         * not gag.
         */
	ip_hdr(skb)->protocol = IPPROTO_UDP;
	ip_hdr(skb)->saddr = src;
	ip_hdr(skb)->daddr = dst;

	skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));

	memset(&fl4, 0, sizeof(fl4));
	fl4.daddr = dst;
	fl4.saddr = src;
	fl4.flowi4_tos = rtm->rtm_tos;
	fl4.flowi4_oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0;
	fl4.flowi4_mark = mark;
	fl4.flowi4_uid = uid;

	rcu_read_lock();

	if (iif) {
		struct net_device *dev;

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

		skb->protocol	= htons(ETH_P_IP);
		skb->dev	= dev;
		skb->mark	= mark;
		err = ip_route_input_rcu(skb, dst, src, rtm->rtm_tos,
					 dev, &res);

		rt = skb_rtable(skb);
		if (err == 0 && rt->dst.error)
			err = -rt->dst.error;
	} else {
		rt = ip_route_output_key_hash_rcu(net, &fl4, &res, skb);
		err = 0;
		if (IS_ERR(rt))
			err = PTR_ERR(rt);
		else
			skb_dst_set(skb, &rt->dst);
	}

	if (err)
		goto errout_free;

	if (rtm->rtm_flags & RTM_F_NOTIFY)
		rt->rt_flags |= RTCF_NOTIFY;

	if (rtm->rtm_flags & RTM_F_LOOKUP_TABLE)
		table_id = rt->rt_table_id;

	if (rtm->rtm_flags & RTM_F_FIB_MATCH) {
		if (!res.fi) {
			err = fib_props[res.type].error;
			if (!err)
				err = -EHOSTUNREACH;
			goto errout_free;
		}
		err = fib_dump_info(skb, NETLINK_CB(in_skb).portid,
				    nlh->nlmsg_seq, RTM_NEWROUTE, table_id,
				    rt->rt_type, res.prefix, res.prefixlen,
				    fl4.flowi4_tos, res.fi, 0);
	} else {
		err = rt_fill_info(net, dst, src, table_id, &fl4, skb,
				   NETLINK_CB(in_skb).portid, nlh->nlmsg_seq);
	}
	if (err < 0)
		goto errout_free;

	rcu_read_unlock();

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

errout_free:
	rcu_read_unlock();
	kfree_skb(skb);
	goto errout;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
186
25.44%
11
22.00%
David S. Miller
128
17.51%
7
14.00%
Roopa Prabhu
100
13.68%
3
6.00%
Thomas Graf
88
12.04%
2
4.00%
David Ahern
53
7.25%
3
6.00%
Lorenzo Colitti
44
6.02%
1
2.00%
Florian Larysch
41
5.61%
1
2.00%
Eric Dumazet
31
4.24%
3
6.00%
Denis V. Lunev
15
2.05%
4
8.00%
Florian Westphal
9
1.23%
1
2.00%
Al Viro
9
1.23%
1
2.00%
Arnaldo Carvalho de Melo
7
0.96%
2
4.00%
Hideaki Yoshifuji / 吉藤英明
6
0.82%
4
8.00%
Linus Torvalds
4
0.55%
1
2.00%
Eric W. Biedermann
3
0.41%
2
4.00%
Jiri Benc
2
0.27%
1
2.00%
Ian Morris
2
0.27%
1
2.00%
Benjamin Thery
2
0.27%
1
2.00%
Johannes Berg
1
0.14%
1
2.00%
Total
731
100.00%
50
100.00%



void ip_rt_multicast_event(struct in_device *in_dev)
{
	rt_cache_flush(dev_net(in_dev->dev));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
14
70.00%
3
75.00%
Denis V. Lunev
6
30.00%
1
25.00%
Total
20
100.00%
4
100.00%

#ifdef CONFIG_SYSCTL

static int ip_rt_gc_interval __read_mostly  = 60 * HZ;

static int ip_rt_gc_min_interval __read_mostly	= HZ / 2;

static int ip_rt_gc_elasticity __read_mostly	= 8;



static int ipv4_sysctl_rtcache_flush(struct ctl_table *__ctl, int write,
					void __user *buffer,
					size_t *lenp, loff_t *ppos)
{
	struct net *net = (struct net *)__ctl->extra1;

	if (write) {
		rt_cache_flush(net);
		fnhe_genid_bump(net);
		return 0;
	}

	return -EINVAL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
29
45.31%
1
12.50%
Timo Teräs
19
29.69%
1
12.50%
Denis V. Lunev
9
14.06%
2
25.00%
Linus Torvalds
5
7.81%
2
25.00%
Al Viro
1
1.56%
1
12.50%
Joe Perches
1
1.56%
1
12.50%
Total
64
100.00%
8
100.00%


static struct ctl_table ipv4_route_table[] = {
	{
		.procname	= "gc_thresh",
		.data		= &ipv4_dst_ops.gc_thresh,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
        },
	{
		.procname	= "max_size",
		.data		= &ip_rt_max_size,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
        },
	{
		/*  Deprecated. Use gc_min_interval_ms */

		.procname	= "gc_min_interval",
		.data		= &ip_rt_gc_min_interval,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_jiffies,
        },
	{
		.procname	= "gc_min_interval_ms",
		.data		= &ip_rt_gc_min_interval,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_ms_jiffies,
        },
	{
		.procname	= "gc_timeout",
		.data		= &ip_rt_gc_timeout,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_jiffies,
        },
	{
		.procname	= "gc_interval",
		.data		= &ip_rt_gc_interval,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_jiffies,
        },
	{
		.procname	= "redirect_load",
		.data		= &ip_rt_redirect_load,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
        },
	{
		.procname	= "redirect_number",
		.data		= &ip_rt_redirect_number,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
        },
	{
		.procname	= "redirect_silence",
		.data		= &ip_rt_redirect_silence,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
        },
	{
		.procname	= "error_cost",
		.data		= &ip_rt_error_cost,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
        },
	{
		.procname	= "error_burst",
		.data		= &ip_rt_error_burst,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
        },
	{
		.procname	= "gc_elasticity",
		.data		= &ip_rt_gc_elasticity,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
        },
	{
		.procname	= "mtu_expires",
		.data		= &ip_rt_mtu_expires,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec_jiffies,
        },
	{
		.procname	= "min_pmtu",
		.data		= &ip_rt_min_pmtu,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
        },
	{
		.procname	= "min_adv_mss",
		.data		= &ip_rt_min_advmss,
		.maxlen		= sizeof(int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
        },
	{ }
};


static struct ctl_table ipv4_route_flush_table[] = {
	{
		.procname	= "flush",
		.maxlen		= sizeof(int),
		.mode		= 0200,
		.proc_handler	= ipv4_sysctl_rtcache_flush,
        },
	{ },
};



static __net_init int sysctl_route_net_init(struct net *net)
{
	struct ctl_table *tbl;

	tbl = ipv4_route_flush_table;
	if (!net_eq(net, &init_net)) {
		tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
		if (!tbl)
			goto err_dup;

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

	net->ipv4.route_hdr = register_net_sysctl(net, "net/ipv4/route", tbl);
	if (!net->ipv4.route_hdr)
		goto err_reg;
	return 0;

err_reg:
	if (tbl != ipv4_route_flush_table)
		kfree(tbl);
err_dup:
	return -ENOMEM;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Denis V. Lunev
105
78.95%
1
20.00%
Eric W. Biedermann
21
15.79%
2
40.00%
Octavian Purdila
5
3.76%
1
20.00%
Ian Morris
2
1.50%
1
20.00%
Total
133
100.00%
5
100.00%



static __net_exit void sysctl_route_net_exit(struct net *net)
{
	struct ctl_table *tbl;

	tbl = net->ipv4.route_hdr->ctl_table_arg;
	unregister_net_sysctl_table(net->ipv4.route_hdr);
	BUG_ON(tbl == ipv4_route_flush_table);
	kfree(tbl);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Denis V. Lunev
48
100.00%
1
100.00%
Total
48
100.00%
1
100.00%


static __net_initdata struct pernet_operations sysctl_route_ops = {
	.init = sysctl_route_net_init,
	.exit = sysctl_route_net_exit,
};
#endif



static __net_init int rt_genid_init(struct net *net)
{
	atomic_set(&net->ipv4.rt_genid, 0);
	atomic_set(&net->fnhe_genid, 0);
	atomic_set(&net->ipv4.dev_addr_genid, get_random_int());
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Denis V. Lunev
22
44.00%
2
25.00%
Timo Teräs
10
20.00%
1
12.50%
David S. Miller
10
20.00%
1
12.50%
Jason A. Donenfeld
3
6.00%
1
12.50%
Fan Du
2
4.00%
1
12.50%
Eric Dumazet
2
4.00%
1
12.50%
Neil Horman
1
2.00%
1
12.50%
Total
50
100.00%
8
100.00%


static __net_initdata struct pernet_operations rt_genid_ops = {
	.init = rt_genid_init,
};



static int __net_init ipv4_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->ipv4.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 ipv4_inetpeer_exit(struct net *net)
{
	struct inet_peer_base *bp = net->ipv4.peers;

	net->ipv4.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 __net_initdata struct pernet_operations ipv4_inetpeer_ops = {
	.init	=	ipv4_inetpeer_init,
	.exit	=	ipv4_inetpeer_exit,
};

#ifdef CONFIG_IP_ROUTE_CLASSID

struct ip_rt_acct __percpu *ip_rt_acct __read_mostly;
#endif /* CONFIG_IP_ROUTE_CLASSID */



int __init ip_rt_init(void)
{
	int rc = 0;
	int cpu;

	ip_idents = kmalloc(IP_IDENTS_SZ * sizeof(*ip_idents), GFP_KERNEL);
	if (!ip_idents)
		panic("IP: failed to allocate ip_idents\n");

	prandom_bytes(ip_idents, IP_IDENTS_SZ * sizeof(*ip_idents));

	ip_tstamps = kcalloc(IP_IDENTS_SZ, sizeof(*ip_tstamps), GFP_KERNEL);
	if (!ip_tstamps)
		panic("IP: failed to allocate ip_tstamps\n");

	for_each_possible_cpu(cpu) {
		struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);

		INIT_LIST_HEAD(&ul->head);
		spin_lock_init(&ul->lock);
	}
#ifdef CONFIG_IP_ROUTE_CLASSID
	ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
	if (!ip_rt_acct)
		panic("IP: failed to allocate ip_rt_acct\n");
#endif

	ipv4_dst_ops.kmem_cachep =
		kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
				  SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);

	ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;

	if (dst_entries_init(&ipv4_dst_ops) < 0)
		panic("IP: failed to allocate ipv4_dst_ops counter\n");

	if (dst_entries_init(&ipv4_dst_blackhole_ops) < 0)
		panic("IP: failed to allocate ipv4_dst_blackhole_ops counter\n");

	ipv4_dst_ops.gc_thresh = ~0;
	ip_rt_max_size = INT_MAX;

	devinet_init();
	ip_fib_init();

	if (ip_rt_proc_init())
		pr_err("Unable to create route proc files\n");
#ifdef CONFIG_XFRM
	xfrm_init();
	xfrm4_init();
#endif
	rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL,
		      RTNL_FLAG_DOIT_UNLOCKED);

#ifdef CONFIG_SYSCTL
	register_pernet_subsys(&sysctl_route_ops);
#endif
	register_pernet_subsys(&rt_genid_ops);
	register_pernet_subsys(&ipv4_inetpeer_ops);
	return rc;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Eric Dumazet
134
46.85%
5
13.89%
Linus Torvalds (pre-git)
70
24.48%
9
25.00%
David S. Miller
17
5.94%
3
8.33%
Denis V. Lunev
14
4.90%
3
8.33%
Thomas Graf
11
3.85%
1
2.78%
Arnaldo Carvalho de Melo
7
2.45%
1
2.78%
Neil Horman
6
2.10%
1
2.78%
Ingo Molnar
6
2.10%
1
2.78%
Andi Kleen
5
1.75%
1
2.78%
Alexey Kuznetsov
4
1.40%
2
5.56%
Hideaki Yoshifuji / 吉藤英明
2
0.70%
1
2.78%
Pavel Emelyanov
2
0.70%
1
2.78%
Alexey Dobriyan
2
0.70%
1
2.78%
Greg Rose
1
0.35%
1
2.78%
Stephen Hemminger
1
0.35%
1
2.78%
Florian Westphal
1
0.35%
1
2.78%
Steffen Klassert
1
0.35%
1
2.78%
Patrick McHardy
1
0.35%
1
2.78%
Joe Perches
1
0.35%
1
2.78%
Total
286
100.00%
36
100.00%

#ifdef CONFIG_SYSCTL
/*
 * We really need to sanitize the damn ipv4 init order, then all
 * this nonsense will go away.
 */


void __init ip_static_sysctl_init(void)
{
	register_net_sysctl(&init_net, "net/ipv4/route", ipv4_route_table);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Al Viro
11
61.11%
1
25.00%
Eric W. Biedermann
6
33.33%
2
50.00%
Jianpeng Ma (马建朋)
1
5.56%
1
25.00%
Total
18
100.00%
4
100.00%

#endif
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
David S. Miller
5993
40.15%
81
18.24%
Linus Torvalds (pre-git)
1772
11.87%
44
9.91%
Eric Dumazet
904
6.06%
47
10.59%
lkml@einar-lueck.de
627
4.20%
1
0.23%
David Ahern
606
4.06%
25
5.63%
Julian Anastasov
496
3.32%
14
3.15%
Timo Teräs
439
2.94%
5
1.13%
Nikolay Aleksandrov
418
2.80%
2
0.45%
Thomas Graf
401
2.69%
8
1.80%
Denis V. Lunev
361
2.42%
19
4.28%
Steffen Klassert
359
2.41%
15
3.38%
Xin Long
269
1.80%
1
0.23%
Lorenzo Colitti
195
1.31%
5
1.13%
Peter Christensen
170
1.14%
2
0.45%
Rusty Russell
139
0.93%
1
0.23%
Roopa Prabhu
137
0.92%
5
1.13%
Linus Torvalds
134
0.90%
5
1.13%
Arnaldo Carvalho de Melo
119
0.80%
6
1.35%
Wei Wang
117
0.78%
6
1.35%
Paolo Abeni
112
0.75%
1
0.23%
Nicolas Dichtel
72
0.48%
2
0.45%
Alexey Kuznetsov
72
0.48%
7
1.58%
Michal Kubeček
61
0.41%
1
0.23%
Stephen Hemminger
61
0.41%
5
1.13%
Eric W. Biedermann
54
0.36%
11
2.48%
Hannes Frederic Sowa
53
0.36%
3
0.68%
Gao Feng
52
0.35%
3
0.68%
Pavel Emelyanov
50
0.34%
8
1.80%
Al Viro
42
0.28%
7
1.58%
Florian Larysch
41
0.27%
1
0.23%
Hideaki Yoshifuji / 吉藤英明
38
0.25%
8
1.80%
Robert Olsson
32
0.21%
2
0.45%
Chris Friesen
30
0.20%
1
0.23%
Duan Jiong
29
0.19%
2
0.45%
Neil Horman
29
0.19%
2
0.45%
Joe Perches
27
0.18%
5
1.13%
Held Bernhard
24
0.16%
1
0.23%
elueck@de.ibm.com
24
0.16%
1
0.23%
Stephen Suryaputra Lin
23
0.15%
1
0.23%
Jianzhao Wang
20
0.13%
1
0.23%
Herbert Xu
19
0.13%
6
1.35%
Alexey Dobriyan
17
0.11%
3
0.68%
Roland Dreier
17
0.11%
1
0.23%
Patrick McHardy
15
0.10%
3
0.68%
Jiri Benc
15
0.10%
5
1.13%
Alexei Starovoitov
14
0.09%
1
0.23%
Adrian Bunk
13
0.09%
4
0.90%
Hirofumi Ogawa
12
0.08%
1
0.23%
Florian Westphal
10
0.07%
2
0.45%
Ian Morris
10
0.07%
1
0.23%
Harald Welte
10
0.07%
1
0.23%
Andy Gospodarek
10
0.07%
1
0.23%
Robert Shearman
8
0.05%
2
0.45%
Ingo Molnar
8
0.05%
2
0.45%
François Romieu
7
0.05%
1
0.23%
Nikola Forró
7
0.05%
1
0.23%
Benjamin Thery
7
0.05%
1
0.23%
Joel Sing
6
0.04%
1
0.23%
Alexander Duyck
6
0.04%
2
0.45%
Andrew Lunn
6
0.04%
1
0.23%
Li Wei
6
0.04%
1
0.23%
Andy Walls
6
0.04%
1
0.23%
Andi Kleen
5
0.03%
1
0.23%
Octavian Purdila
5
0.03%
1
0.23%
Fan Du
5
0.03%
1
0.23%
Li Yewang
5
0.03%
1
0.23%
Dipankar Sarma
5
0.03%
1
0.23%
Amir Vadai
5
0.03%
1
0.23%
Nicolas Cavallari
5
0.03%
1
0.23%
Harvey Harrison
5
0.03%
1
0.23%
Tom Herbert
4
0.03%
1
0.23%
Mitsuru Chinen
4
0.03%
1
0.23%
Américo Wang
4
0.03%
1
0.23%
Tejun Heo
4
0.03%
2
0.45%
Johannes Berg
4
0.03%
2
0.45%
Jason A. Donenfeld
3
0.02%
1
0.23%
Dave Jones
3
0.02%
1
0.23%
Christoph Lameter
3
0.02%
2
0.45%
Kazunori Miyazawa
3
0.02%
1
0.23%
Shan Wei
3
0.02%
1
0.23%
Li RongQing
2
0.01%
1
0.23%
Ravikiran G. Thirumalai
2
0.01%
1
0.23%
Michael Smith
2
0.01%
1
0.23%
Jamal Hadi Salim
1
0.01%
1
0.23%
David L Stevens
1
0.01%
1
0.23%
Dan Siemon
1
0.01%
1
0.23%
Changli Gao
1
0.01%
1
0.23%
Hiroaki SHIMODA
1
0.01%
1
0.23%
Tom Tucker
1
0.01%
1
0.23%
Daniel Lezcano
1
0.01%
1
0.23%
Jianpeng Ma (马建朋)
1
0.01%
1
0.23%
Jan Engelhardt
1
0.01%
1
0.23%
Philippe De Muyter
1
0.01%
1
0.23%
Wang Chen
1
0.01%
1
0.23%
Greg Rose
1
0.01%
1
0.23%
Cong Wang
1
0.01%
1
0.23%
Total
14925
100.00%
444
100.00%
Directory: net/ipv4

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