route.c 84.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7
/*
 * 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.
 *
8
 * Authors:	Ross Biro
L
Linus Torvalds 已提交
9 10 11 12 13 14 15 16 17 18 19 20
 *		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
21
 *		Alan Cox	:	Super /proc >4K
L
Linus Torvalds 已提交
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
 *		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.
39
 *
L
Linus Torvalds 已提交
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
 *		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
55
 *	Eric Dumazet		:	hashed spinlocks and rt_check_expire() fixes.
56 57
 * 	Ilia Sotnikov		:	Ignore TOS on PMTUD and Redirect
 * 	Ilia Sotnikov		:	Removed TOS from hash calculations
L
Linus Torvalds 已提交
58 59 60 61 62 63 64 65 66 67 68 69 70 71
 *
 *		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.
 */

#include <linux/module.h>
#include <asm/uaccess.h>
#include <asm/system.h>
#include <linux/bitops.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/mm.h>
72
#include <linux/bootmem.h>
L
Linus Torvalds 已提交
73 74 75 76 77 78 79 80 81
#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>
82
#include <linux/workqueue.h>
L
Linus Torvalds 已提交
83 84 85 86 87 88 89 90 91 92
#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/jhash.h>
#include <linux/rcupdate.h>
#include <linux/times.h>
93
#include <net/dst.h>
94
#include <net/net_namespace.h>
L
Linus Torvalds 已提交
95 96 97 98 99 100 101 102 103 104
#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>
105
#include <net/netevent.h>
106
#include <net/rtnetlink.h>
L
Linus Torvalds 已提交
107 108 109 110 111 112 113 114 115 116 117 118
#ifdef CONFIG_SYSCTL
#include <linux/sysctl.h>
#endif

#define RT_FL_TOS(oldflp) \
    ((u32)(oldflp->fl4_tos & (IPTOS_RT_MASK | RTO_ONLINK)))

#define IP_MAX_MTU	0xFFF0

#define RT_GC_TIMEOUT (300*HZ)

static int ip_rt_max_size;
119 120 121 122 123 124 125 126 127 128 129 130 131
static int ip_rt_gc_timeout __read_mostly	= RT_GC_TIMEOUT;
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_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_gc_elasticity __read_mostly	= 8;
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_secret_interval __read_mostly	= 10 * 60 * HZ;
132
static int rt_chain_length_max __read_mostly	= 20;
L
Linus Torvalds 已提交
133

134 135
static void rt_worker_func(struct work_struct *work);
static DECLARE_DELAYED_WORK(expires_work, rt_worker_func);
L
Linus Torvalds 已提交
136 137 138 139 140 141 142 143 144 145 146 147

/*
 *	Interface to generic destination cache.
 */

static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
static void		 ipv4_dst_destroy(struct dst_entry *dst);
static void		 ipv4_dst_ifdown(struct dst_entry *dst,
					 struct net_device *dev, int how);
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, u32 mtu);
148
static int rt_garbage_collect(struct dst_ops *ops);
149
static void rt_emergency_hash_rebuild(struct net *net);
L
Linus Torvalds 已提交
150 151 152 153


static struct dst_ops ipv4_dst_ops = {
	.family =		AF_INET,
154
	.protocol =		cpu_to_be16(ETH_P_IP),
L
Linus Torvalds 已提交
155 156 157 158 159 160 161
	.gc =			rt_garbage_collect,
	.check =		ipv4_dst_check,
	.destroy =		ipv4_dst_destroy,
	.ifdown =		ipv4_dst_ifdown,
	.negative_advice =	ipv4_negative_advice,
	.link_failure =		ipv4_link_failure,
	.update_pmtu =		ip_rt_update_pmtu,
162
	.local_out =		__ip_local_out,
163
	.entries =		ATOMIC_INIT(0),
L
Linus Torvalds 已提交
164 165 166 167
};

#define ECN_OR_COST(class)	TC_PRIO_##class

168
const __u8 ip_tos2prio[16] = {
L
Linus Torvalds 已提交
169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203
	TC_PRIO_BESTEFFORT,
	ECN_OR_COST(FILLER),
	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)
};


/*
 * Route cache.
 */

/* The locking scheme is rather straight forward:
 *
 * 1) Read-Copy Update protects the buckets of the central route hash.
 * 2) Only writers remove entries, and they hold the lock
 *    as they look at rtable reference counts.
 * 3) Only readers acquire references to rtable entries,
 *    they do so with atomic increments and with the
 *    lock held.
 */

struct rt_hash_bucket {
	struct rtable	*chain;
204
};
205

206 207
#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK) || \
	defined(CONFIG_PROVE_LOCKING)
208 209 210
/*
 * Instead of using one spinlock for each rt_hash_bucket, we use a table of spinlocks
 * The size of this table is a power of two and depends on the number of CPUS.
211
 * (on lockdep we have a quite big spinlock_t, so keep the size down there)
212
 */
213 214
#ifdef CONFIG_LOCKDEP
# define RT_HASH_LOCK_SZ	256
215
#else
216 217 218 219 220 221 222 223 224 225 226
# if NR_CPUS >= 32
#  define RT_HASH_LOCK_SZ	4096
# elif NR_CPUS >= 16
#  define RT_HASH_LOCK_SZ	2048
# elif NR_CPUS >= 8
#  define RT_HASH_LOCK_SZ	1024
# elif NR_CPUS >= 4
#  define RT_HASH_LOCK_SZ	512
# else
#  define RT_HASH_LOCK_SZ	256
# endif
227 228 229 230
#endif

static spinlock_t	*rt_hash_locks;
# define rt_hash_lock_addr(slot) &rt_hash_locks[(slot) & (RT_HASH_LOCK_SZ - 1)]
231 232 233 234 235 236 237 238 239 240 241 242 243

static __init void rt_hash_lock_init(void)
{
	int i;

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

	for (i = 0; i < RT_HASH_LOCK_SZ; i++)
		spin_lock_init(&rt_hash_locks[i]);
}
244 245
#else
# define rt_hash_lock_addr(slot) NULL
246 247 248 249

static inline void rt_hash_lock_init(void)
{
}
250
#endif
L
Linus Torvalds 已提交
251

252 253 254
static struct rt_hash_bucket 	*rt_hash_table __read_mostly;
static unsigned			rt_hash_mask __read_mostly;
static unsigned int		rt_hash_log  __read_mostly;
L
Linus Torvalds 已提交
255

256
static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
257
#define RT_CACHE_STAT_INC(field) \
258
	(__raw_get_cpu_var(rt_cache_stat).field++)
L
Linus Torvalds 已提交
259

260 261
static inline unsigned int rt_hash(__be32 daddr, __be32 saddr, int idx,
		int genid)
L
Linus Torvalds 已提交
262
{
S
Stephen Hemminger 已提交
263 264
	return jhash_3words((__force u32)(__be32)(daddr),
			    (__force u32)(__be32)(saddr),
265
			    idx, genid)
266
		& rt_hash_mask;
L
Linus Torvalds 已提交
267 268
}

269 270 271 272 273
static inline int rt_genid(struct net *net)
{
	return atomic_read(&net->ipv4.rt_genid);
}

L
Linus Torvalds 已提交
274 275
#ifdef CONFIG_PROC_FS
struct rt_cache_iter_state {
276
	struct seq_net_private p;
L
Linus Torvalds 已提交
277
	int bucket;
278
	int genid;
L
Linus Torvalds 已提交
279 280
};

281
static struct rtable *rt_cache_get_first(struct seq_file *seq)
L
Linus Torvalds 已提交
282
{
283
	struct rt_cache_iter_state *st = seq->private;
L
Linus Torvalds 已提交
284 285 286
	struct rtable *r = NULL;

	for (st->bucket = rt_hash_mask; st->bucket >= 0; --st->bucket) {
287 288
		if (!rt_hash_table[st->bucket].chain)
			continue;
L
Linus Torvalds 已提交
289
		rcu_read_lock_bh();
290 291
		r = rcu_dereference(rt_hash_table[st->bucket].chain);
		while (r) {
292
			if (dev_net(r->u.dst.dev) == seq_file_net(seq) &&
293
			    r->rt_genid == st->genid)
294 295 296
				return r;
			r = rcu_dereference(r->u.dst.rt_next);
		}
L
Linus Torvalds 已提交
297 298
		rcu_read_unlock_bh();
	}
299
	return r;
L
Linus Torvalds 已提交
300 301
}

302
static struct rtable *__rt_cache_get_next(struct seq_file *seq,
303
					  struct rtable *r)
L
Linus Torvalds 已提交
304
{
305
	struct rt_cache_iter_state *st = seq->private;
306

307
	r = r->u.dst.rt_next;
L
Linus Torvalds 已提交
308 309
	while (!r) {
		rcu_read_unlock_bh();
310 311 312 313
		do {
			if (--st->bucket < 0)
				return NULL;
		} while (!rt_hash_table[st->bucket].chain);
L
Linus Torvalds 已提交
314 315 316
		rcu_read_lock_bh();
		r = rt_hash_table[st->bucket].chain;
	}
317
	return rcu_dereference(r);
L
Linus Torvalds 已提交
318 319
}

320
static struct rtable *rt_cache_get_next(struct seq_file *seq,
321 322
					struct rtable *r)
{
323 324 325
	struct rt_cache_iter_state *st = seq->private;
	while ((r = __rt_cache_get_next(seq, r)) != NULL) {
		if (dev_net(r->u.dst.dev) != seq_file_net(seq))
326
			continue;
327 328 329 330 331 332
		if (r->rt_genid == st->genid)
			break;
	}
	return r;
}

333
static struct rtable *rt_cache_get_idx(struct seq_file *seq, loff_t pos)
L
Linus Torvalds 已提交
334
{
335
	struct rtable *r = rt_cache_get_first(seq);
L
Linus Torvalds 已提交
336 337

	if (r)
338
		while (pos && (r = rt_cache_get_next(seq, r)))
L
Linus Torvalds 已提交
339 340 341 342 343 344
			--pos;
	return pos ? NULL : r;
}

static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
{
345 346
	struct rt_cache_iter_state *st = seq->private;
	if (*pos)
347
		return rt_cache_get_idx(seq, *pos - 1);
348
	st->genid = rt_genid(seq_file_net(seq));
349
	return SEQ_START_TOKEN;
L
Linus Torvalds 已提交
350 351 352 353
}

static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
354
	struct rtable *r;
L
Linus Torvalds 已提交
355 356

	if (v == SEQ_START_TOKEN)
357
		r = rt_cache_get_first(seq);
L
Linus Torvalds 已提交
358
	else
359
		r = rt_cache_get_next(seq, v);
L
Linus Torvalds 已提交
360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
	++*pos;
	return r;
}

static void rt_cache_seq_stop(struct seq_file *seq, void *v)
{
	if (v && v != SEQ_START_TOKEN)
		rcu_read_unlock_bh();
}

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");
	else {
		struct rtable *r = v;
379
		int len;
L
Linus Torvalds 已提交
380

381 382
		seq_printf(seq, "%s\t%08lX\t%08lX\t%8X\t%d\t%u\t%d\t"
			      "%08lX\t%d\t%u\t%u\t%02X\t%d\t%1d\t%08X%n",
L
Linus Torvalds 已提交
383 384 385 386 387 388 389 390 391 392 393 394 395
			r->u.dst.dev ? r->u.dst.dev->name : "*",
			(unsigned long)r->rt_dst, (unsigned long)r->rt_gateway,
			r->rt_flags, atomic_read(&r->u.dst.__refcnt),
			r->u.dst.__use, 0, (unsigned long)r->rt_src,
			(dst_metric(&r->u.dst, RTAX_ADVMSS) ?
			     (int)dst_metric(&r->u.dst, RTAX_ADVMSS) + 40 : 0),
			dst_metric(&r->u.dst, RTAX_WINDOW),
			(int)((dst_metric(&r->u.dst, RTAX_RTT) >> 3) +
			      dst_metric(&r->u.dst, RTAX_RTTVAR)),
			r->fl.fl4_tos,
			r->u.dst.hh ? atomic_read(&r->u.dst.hh->hh_refcnt) : -1,
			r->u.dst.hh ? (r->u.dst.hh->hh_output ==
				       dev_queue_xmit) : 0,
396 397 398
			r->rt_spec_dst, &len);

		seq_printf(seq, "%*s\n", 127 - len, "");
399 400
	}
	return 0;
L
Linus Torvalds 已提交
401 402
}

403
static const struct seq_operations rt_cache_seq_ops = {
L
Linus Torvalds 已提交
404 405 406 407 408 409 410 411
	.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)
{
412
	return seq_open_net(inode, file, &rt_cache_seq_ops,
413
			sizeof(struct rt_cache_iter_state));
L
Linus Torvalds 已提交
414 415
}

416
static const struct file_operations rt_cache_seq_fops = {
L
Linus Torvalds 已提交
417 418 419 420
	.owner	 = THIS_MODULE,
	.open	 = rt_cache_seq_open,
	.read	 = seq_read,
	.llseek	 = seq_lseek,
421
	.release = seq_release_net,
L
Linus Torvalds 已提交
422 423 424 425 426 427 428 429 430 431
};


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

	if (*pos == 0)
		return SEQ_START_TOKEN;

432
	for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
L
Linus Torvalds 已提交
433 434 435
		if (!cpu_possible(cpu))
			continue;
		*pos = cpu+1;
436
		return &per_cpu(rt_cache_stat, cpu);
L
Linus Torvalds 已提交
437 438 439 440 441 442 443 444
	}
	return NULL;
}

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

445
	for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
L
Linus Torvalds 已提交
446 447 448
		if (!cpu_possible(cpu))
			continue;
		*pos = cpu+1;
449
		return &per_cpu(rt_cache_stat, cpu);
L
Linus Torvalds 已提交
450 451
	}
	return NULL;
452

L
Linus Torvalds 已提交
453 454 455 456 457 458 459 460 461 462 463 464
}

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

}

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

	if (v == SEQ_START_TOKEN) {
465
		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");
L
Linus Torvalds 已提交
466 467
		return 0;
	}
468

L
Linus Torvalds 已提交
469 470 471 472 473 474 475 476 477 478 479 480 481
	seq_printf(seq,"%08x  %08x %08x %08x %08x %08x %08x %08x "
		   " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
		   atomic_read(&ipv4_dst_ops.entries),
		   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,

		   st->out_hit,
		   st->out_slow_tot,
482
		   st->out_slow_mc,
L
Linus Torvalds 已提交
483 484 485 486 487 488 489 490 491 492 493

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

494
static const struct seq_operations rt_cpu_seq_ops = {
L
Linus Torvalds 已提交
495 496 497 498 499 500 501 502 503 504 505 506
	.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);
}

507
static const struct file_operations rt_cpu_seq_fops = {
L
Linus Torvalds 已提交
508 509 510 511 512 513 514
	.owner	 = THIS_MODULE,
	.open	 = rt_cpu_seq_open,
	.read	 = seq_read,
	.llseek	 = seq_lseek,
	.release = seq_release,
};

515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553
#ifdef CONFIG_NET_CLS_ROUTE
static int ip_rt_acct_read(char *buffer, char **start, off_t offset,
			   int length, int *eof, void *data)
{
	unsigned int i;

	if ((offset & 3) || (length & 3))
		return -EIO;

	if (offset >= sizeof(struct ip_rt_acct) * 256) {
		*eof = 1;
		return 0;
	}

	if (offset + length >= sizeof(struct ip_rt_acct) * 256) {
		length = sizeof(struct ip_rt_acct) * 256 - offset;
		*eof = 1;
	}

	offset /= sizeof(u32);

	if (length > 0) {
		u32 *dst = (u32 *) buffer;

		*start = buffer;
		memset(dst, 0, length);

		for_each_possible_cpu(i) {
			unsigned int j;
			u32 *src;

			src = ((u32 *) per_cpu_ptr(ip_rt_acct, i)) + offset;
			for (j = 0; j < length/4; j++)
				dst[j] += src[j];
		}
	}
	return length;
}
#endif
554

555
static int __net_init ip_rt_do_proc_init(struct net *net)
556 557 558 559 560 561 562 563
{
	struct proc_dir_entry *pde;

	pde = proc_net_fops_create(net, "rt_cache", S_IRUGO,
			&rt_cache_seq_fops);
	if (!pde)
		goto err1;

564 565
	pde = proc_create("rt_cache", S_IRUGO,
			  net->proc_net_stat, &rt_cpu_seq_fops);
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
	if (!pde)
		goto err2;

#ifdef CONFIG_NET_CLS_ROUTE
	pde = create_proc_read_entry("rt_acct", 0, net->proc_net,
			ip_rt_acct_read, NULL);
	if (!pde)
		goto err3;
#endif
	return 0;

#ifdef CONFIG_NET_CLS_ROUTE
err3:
	remove_proc_entry("rt_cache", net->proc_net_stat);
#endif
err2:
	remove_proc_entry("rt_cache", net->proc_net);
err1:
	return -ENOMEM;
}
586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603

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);
	remove_proc_entry("rt_acct", net->proc_net);
}

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

604
#else
605
static inline int ip_rt_proc_init(void)
606 607 608
{
	return 0;
}
L
Linus Torvalds 已提交
609
#endif /* CONFIG_PROC_FS */
610

S
Stephen Hemminger 已提交
611
static inline void rt_free(struct rtable *rt)
L
Linus Torvalds 已提交
612 613 614 615
{
	call_rcu_bh(&rt->u.dst.rcu_head, dst_rcu_free);
}

S
Stephen Hemminger 已提交
616
static inline void rt_drop(struct rtable *rt)
L
Linus Torvalds 已提交
617 618 619 620 621
{
	ip_rt_put(rt);
	call_rcu_bh(&rt->u.dst.rcu_head, dst_rcu_free);
}

S
Stephen Hemminger 已提交
622
static inline int rt_fast_clean(struct rtable *rth)
L
Linus Torvalds 已提交
623 624 625 626
{
	/* Kill broadcast/multicast entries very aggresively, if they
	   collide in hash table with more useful entries */
	return (rth->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST)) &&
627
		rth->fl.iif && rth->u.dst.rt_next;
L
Linus Torvalds 已提交
628 629
}

S
Stephen Hemminger 已提交
630
static inline int rt_valuable(struct rtable *rth)
L
Linus Torvalds 已提交
631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678
{
	return (rth->rt_flags & (RTCF_REDIRECTED | RTCF_NOTIFY)) ||
		rth->u.dst.expires;
}

static int rt_may_expire(struct rtable *rth, unsigned long tmo1, unsigned long tmo2)
{
	unsigned long age;
	int ret = 0;

	if (atomic_read(&rth->u.dst.__refcnt))
		goto out;

	ret = 1;
	if (rth->u.dst.expires &&
	    time_after_eq(jiffies, rth->u.dst.expires))
		goto out;

	age = jiffies - rth->u.dst.lastuse;
	ret = 0;
	if ((age <= tmo1 && !rt_fast_clean(rth)) ||
	    (age <= tmo2 && rt_valuable(rth)))
		goto out;
	ret = 1;
out:	return ret;
}

/* Bits of score are:
 * 31: very valuable
 * 30: not quite useless
 * 29..0: usage counter
 */
static inline u32 rt_score(struct rtable *rt)
{
	u32 score = jiffies - rt->u.dst.lastuse;

	score = ~score & ~(3<<30);

	if (rt_valuable(rt))
		score |= (1<<31);

	if (!rt->fl.iif ||
	    !(rt->rt_flags & (RTCF_BROADCAST|RTCF_MULTICAST|RTCF_LOCAL)))
		score |= (1<<30);

	return score;
}

679 680 681 682 683 684 685 686 687 688 689 690 691 692
static inline bool rt_caching(const struct net *net)
{
	return net->ipv4.current_rt_cache_rebuild_count <=
		net->ipv4.sysctl_rt_cache_rebuild_count;
}

static inline bool compare_hash_inputs(const struct flowi *fl1,
					const struct flowi *fl2)
{
	return (__force u32)(((fl1->nl_u.ip4_u.daddr ^ fl2->nl_u.ip4_u.daddr) |
		(fl1->nl_u.ip4_u.saddr ^ fl2->nl_u.ip4_u.saddr) |
		(fl1->iif ^ fl2->iif)) == 0);
}

L
Linus Torvalds 已提交
693 694
static inline int compare_keys(struct flowi *fl1, struct flowi *fl2)
{
695 696
	return ((__force u32)((fl1->nl_u.ip4_u.daddr ^ fl2->nl_u.ip4_u.daddr) |
		(fl1->nl_u.ip4_u.saddr ^ fl2->nl_u.ip4_u.saddr)) |
697
		(fl1->mark ^ fl2->mark) |
698 699 700 701
		(*(u16 *)&fl1->nl_u.ip4_u.tos ^
		 *(u16 *)&fl2->nl_u.ip4_u.tos) |
		(fl1->oif ^ fl2->oif) |
		(fl1->iif ^ fl2->iif)) == 0;
L
Linus Torvalds 已提交
702 703
}

704 705
static inline int compare_netns(struct rtable *rt1, struct rtable *rt2)
{
706
	return dev_net(rt1->u.dst.dev) == dev_net(rt2->u.dst.dev);
707 708
}

709 710 711 712 713
static inline int rt_is_expired(struct rtable *rth)
{
	return rth->rt_genid != rt_genid(dev_net(rth->u.dst.dev));
}

714 715 716 717 718 719 720 721 722
/*
 * Perform a full scan of hash table and free all entries.
 * Can be called by a softirq or a process.
 * In the later case, we want to be reschedule if necessary
 */
static void rt_do_flush(int process_context)
{
	unsigned int i;
	struct rtable *rth, *next;
723
	struct rtable * tail;
724 725 726 727 728 729 730 731 732

	for (i = 0; i <= rt_hash_mask; i++) {
		if (process_context && need_resched())
			cond_resched();
		rth = rt_hash_table[i].chain;
		if (!rth)
			continue;

		spin_lock_bh(rt_hash_lock_addr(i));
733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758
#ifdef CONFIG_NET_NS
		{
		struct rtable ** prev, * p;

		rth = rt_hash_table[i].chain;

		/* defer releasing the head of the list after spin_unlock */
		for (tail = rth; tail; tail = tail->u.dst.rt_next)
			if (!rt_is_expired(tail))
				break;
		if (rth != tail)
			rt_hash_table[i].chain = tail;

		/* call rt_free on entries after the tail requiring flush */
		prev = &rt_hash_table[i].chain;
		for (p = *prev; p; p = next) {
			next = p->u.dst.rt_next;
			if (!rt_is_expired(p)) {
				prev = &p->u.dst.rt_next;
			} else {
				*prev = next;
				rt_free(p);
			}
		}
		}
#else
759 760
		rth = rt_hash_table[i].chain;
		rt_hash_table[i].chain = NULL;
761 762
		tail = NULL;
#endif
763 764
		spin_unlock_bh(rt_hash_lock_addr(i));

765
		for (; rth != tail; rth = next) {
766 767 768 769 770 771
			next = rth->u.dst.rt_next;
			rt_free(rth);
		}
	}
}

772 773 774 775 776 777 778 779 780 781 782
/*
 * While freeing expired entries, we compute average chain length
 * and standard deviation, using fixed-point arithmetic.
 * This to have an estimation of rt_chain_length_max
 *  rt_chain_length_max = max(elasticity, AVG + 4*SD)
 * We use 3 bits for frational part, and 29 (or 61) for magnitude.
 */

#define FRACT_BITS 3
#define ONE (1UL << FRACT_BITS)

783
static void rt_check_expire(void)
L
Linus Torvalds 已提交
784
{
785 786
	static unsigned int rover;
	unsigned int i = rover, goal;
L
Linus Torvalds 已提交
787
	struct rtable *rth, **rthp;
788 789
	unsigned long length = 0, samples = 0;
	unsigned long sum = 0, sum2 = 0;
790 791 792 793 794 795
	u64 mult;

	mult = ((u64)ip_rt_gc_interval) << rt_hash_log;
	if (ip_rt_gc_timeout > 1)
		do_div(mult, ip_rt_gc_timeout);
	goal = (unsigned int)mult;
796 797
	if (goal > rt_hash_mask)
		goal = rt_hash_mask + 1;
798
	length = 0;
799
	for (; goal > 0; goal--) {
L
Linus Torvalds 已提交
800 801 802 803 804
		unsigned long tmo = ip_rt_gc_timeout;

		i = (i + 1) & rt_hash_mask;
		rthp = &rt_hash_table[i].chain;

805 806 807
		if (need_resched())
			cond_resched();

808 809
		samples++;

S
Stephen Hemminger 已提交
810
		if (*rthp == NULL)
811
			continue;
812
		spin_lock_bh(rt_hash_lock_addr(i));
L
Linus Torvalds 已提交
813
		while ((rth = *rthp) != NULL) {
814
			if (rt_is_expired(rth)) {
815 816 817 818
				*rthp = rth->u.dst.rt_next;
				rt_free(rth);
				continue;
			}
L
Linus Torvalds 已提交
819 820
			if (rth->u.dst.expires) {
				/* Entry is expired even if it is in use */
821
				if (time_before_eq(jiffies, rth->u.dst.expires)) {
L
Linus Torvalds 已提交
822
					tmo >>= 1;
823
					rthp = &rth->u.dst.rt_next;
824 825 826 827 828 829 830 831 832 833 834 835 836 837
					/*
					 * Only bump our length if the hash
					 * inputs on entries n and n+1 are not
					 * the same, we only count entries on
					 * a chain with equal hash inputs once
					 * so that entries for different QOS
					 * levels, and other non-hash input
					 * attributes don't unfairly skew
					 * the length computation
					 */
					if ((*rthp == NULL) ||
					    !compare_hash_inputs(&(*rthp)->fl,
								 &rth->fl))
						length += ONE;
L
Linus Torvalds 已提交
838 839 840 841
					continue;
				}
			} else if (!rt_may_expire(rth, tmo, ip_rt_gc_timeout)) {
				tmo >>= 1;
842
				rthp = &rth->u.dst.rt_next;
843 844 845 846
				if ((*rthp == NULL) ||
				    !compare_hash_inputs(&(*rthp)->fl,
							 &rth->fl))
					length += ONE;
L
Linus Torvalds 已提交
847 848 849 850
				continue;
			}

			/* Cleanup aged off entries. */
851
			*rthp = rth->u.dst.rt_next;
852
			rt_free(rth);
L
Linus Torvalds 已提交
853
		}
854
		spin_unlock_bh(rt_hash_lock_addr(i));
855 856 857 858 859 860 861 862 863
		sum += length;
		sum2 += length*length;
	}
	if (samples) {
		unsigned long avg = sum / samples;
		unsigned long sd = int_sqrt(sum2 / samples - avg*avg);
		rt_chain_length_max = max_t(unsigned long,
					ip_rt_gc_elasticity,
					(avg + 4*sd) >> FRACT_BITS);
L
Linus Torvalds 已提交
864 865
	}
	rover = i;
866 867 868 869
}

/*
 * rt_worker_func() is run in process context.
870
 * we call rt_check_expire() to scan part of the hash table
871 872 873
 */
static void rt_worker_func(struct work_struct *work)
{
874
	rt_check_expire();
875
	schedule_delayed_work(&expires_work, ip_rt_gc_interval);
L
Linus Torvalds 已提交
876 877
}

878 879 880 881 882
/*
 * Pertubation of rt_genid by a small quantity [1..256]
 * Using 8 bits of shuffling ensure we can call rt_cache_invalidate()
 * many times (2^24) without giving recent rt_genid.
 * Jenkins hash is strong enough that litle changes of rt_genid are OK.
L
Linus Torvalds 已提交
883
 */
884
static void rt_cache_invalidate(struct net *net)
L
Linus Torvalds 已提交
885
{
886
	unsigned char shuffle;
L
Linus Torvalds 已提交
887

888
	get_random_bytes(&shuffle, sizeof(shuffle));
889
	atomic_add(shuffle + 1U, &net->ipv4.rt_genid);
L
Linus Torvalds 已提交
890 891
}

892 893 894 895
/*
 * delay < 0  : invalidate cache (fast : entries will be deleted later)
 * delay >= 0 : invalidate & flush cache (can be long)
 */
896
void rt_cache_flush(struct net *net, int delay)
L
Linus Torvalds 已提交
897
{
898
	rt_cache_invalidate(net);
899 900
	if (delay >= 0)
		rt_do_flush(!in_softirq());
L
Linus Torvalds 已提交
901 902
}

903
/*
904
 * We change rt_genid and let gc do the cleanup
905
 */
906
static void rt_secret_rebuild(unsigned long __net)
L
Linus Torvalds 已提交
907
{
908
	struct net *net = (struct net *)__net;
909
	rt_cache_invalidate(net);
910
	mod_timer(&net->ipv4.rt_secret_timer, jiffies + ip_rt_secret_interval);
L
Linus Torvalds 已提交
911 912
}

913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932
static void rt_secret_rebuild_oneshot(struct net *net)
{
	del_timer_sync(&net->ipv4.rt_secret_timer);
	rt_cache_invalidate(net);
	if (ip_rt_secret_interval) {
		net->ipv4.rt_secret_timer.expires += ip_rt_secret_interval;
		add_timer(&net->ipv4.rt_secret_timer);
	}
}

static void rt_emergency_hash_rebuild(struct net *net)
{
	if (net_ratelimit()) {
		printk(KERN_WARNING "Route hash chain too long!\n");
		printk(KERN_WARNING "Adjust your secret_interval!\n");
	}

	rt_secret_rebuild_oneshot(net);
}

L
Linus Torvalds 已提交
933 934 935 936 937 938 939 940 941 942 943 944 945
/*
   Short description of GC goals.

   We want to build algorithm, which will keep routing cache
   at some equilibrium point, when number of aged off entries
   is kept approximately equal to newly generated ones.

   Current expiration strength is variable "expire".
   We try to adjust it dynamically, so that if networking
   is idle expires is large enough to keep enough of warm entries,
   and when load increases it reduces to limit cache size.
 */

946
static int rt_garbage_collect(struct dst_ops *ops)
L
Linus Torvalds 已提交
947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976
{
	static unsigned long expire = RT_GC_TIMEOUT;
	static unsigned long last_gc;
	static int rover;
	static int equilibrium;
	struct rtable *rth, **rthp;
	unsigned long now = jiffies;
	int goal;

	/*
	 * Garbage collection is pretty expensive,
	 * do not make it too frequently.
	 */

	RT_CACHE_STAT_INC(gc_total);

	if (now - last_gc < ip_rt_gc_min_interval &&
	    atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size) {
		RT_CACHE_STAT_INC(gc_ignored);
		goto out;
	}

	/* Calculate number of entries, which we want to expire now. */
	goal = atomic_read(&ipv4_dst_ops.entries) -
		(ip_rt_gc_elasticity << rt_hash_log);
	if (goal <= 0) {
		if (equilibrium < ipv4_dst_ops.gc_thresh)
			equilibrium = ipv4_dst_ops.gc_thresh;
		goal = atomic_read(&ipv4_dst_ops.entries) - equilibrium;
		if (goal > 0) {
977
			equilibrium += min_t(unsigned int, goal >> 1, rt_hash_mask + 1);
L
Linus Torvalds 已提交
978 979 980 981 982 983
			goal = atomic_read(&ipv4_dst_ops.entries) - equilibrium;
		}
	} else {
		/* We are in dangerous area. Try to reduce cache really
		 * aggressively.
		 */
984
		goal = max_t(unsigned int, goal >> 1, rt_hash_mask + 1);
L
Linus Torvalds 已提交
985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003
		equilibrium = atomic_read(&ipv4_dst_ops.entries) - goal;
	}

	if (now - last_gc >= ip_rt_gc_min_interval)
		last_gc = now;

	if (goal <= 0) {
		equilibrium += goal;
		goto work_done;
	}

	do {
		int i, k;

		for (i = rt_hash_mask, k = rover; i >= 0; i--) {
			unsigned long tmo = expire;

			k = (k + 1) & rt_hash_mask;
			rthp = &rt_hash_table[k].chain;
1004
			spin_lock_bh(rt_hash_lock_addr(k));
L
Linus Torvalds 已提交
1005
			while ((rth = *rthp) != NULL) {
1006
				if (!rt_is_expired(rth) &&
1007
					!rt_may_expire(rth, tmo, expire)) {
L
Linus Torvalds 已提交
1008
					tmo >>= 1;
1009
					rthp = &rth->u.dst.rt_next;
L
Linus Torvalds 已提交
1010 1011
					continue;
				}
1012
				*rthp = rth->u.dst.rt_next;
L
Linus Torvalds 已提交
1013 1014 1015
				rt_free(rth);
				goal--;
			}
1016
			spin_unlock_bh(rt_hash_lock_addr(k));
L
Linus Torvalds 已提交
1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070
			if (goal <= 0)
				break;
		}
		rover = k;

		if (goal <= 0)
			goto work_done;

		/* Goal is not achieved. We stop process if:

		   - if expire reduced to zero. Otherwise, expire is halfed.
		   - if table is not full.
		   - if we are called from interrupt.
		   - jiffies check is just fallback/debug loop breaker.
		     We will not spin here for long time in any case.
		 */

		RT_CACHE_STAT_INC(gc_goal_miss);

		if (expire == 0)
			break;

		expire >>= 1;
#if RT_CACHE_DEBUG >= 2
		printk(KERN_DEBUG "expire>> %u %d %d %d\n", expire,
				atomic_read(&ipv4_dst_ops.entries), goal, i);
#endif

		if (atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size)
			goto out;
	} while (!in_softirq() && time_before_eq(jiffies, now));

	if (atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size)
		goto out;
	if (net_ratelimit())
		printk(KERN_WARNING "dst cache overflow\n");
	RT_CACHE_STAT_INC(gc_dst_overflow);
	return 1;

work_done:
	expire += ip_rt_gc_min_interval;
	if (expire > ip_rt_gc_timeout ||
	    atomic_read(&ipv4_dst_ops.entries) < ipv4_dst_ops.gc_thresh)
		expire = ip_rt_gc_timeout;
#if RT_CACHE_DEBUG >= 2
	printk(KERN_DEBUG "expire++ %u %d %d %d\n", expire,
			atomic_read(&ipv4_dst_ops.entries), goal, rover);
#endif
out:	return 0;
}

static int rt_intern_hash(unsigned hash, struct rtable *rt, struct rtable **rp)
{
	struct rtable	*rth, **rthp;
1071
	struct rtable	*rthi;
L
Linus Torvalds 已提交
1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
	unsigned long	now;
	struct rtable *cand, **candp;
	u32 		min_score;
	int		chain_length;
	int attempts = !in_softirq();

restart:
	chain_length = 0;
	min_score = ~(u32)0;
	cand = NULL;
	candp = NULL;
	now = jiffies;

1085 1086 1087 1088 1089
	if (!rt_caching(dev_net(rt->u.dst.dev))) {
		rt_drop(rt);
		return 0;
	}

L
Linus Torvalds 已提交
1090
	rthp = &rt_hash_table[hash].chain;
1091
	rthi = NULL;
L
Linus Torvalds 已提交
1092

1093
	spin_lock_bh(rt_hash_lock_addr(hash));
L
Linus Torvalds 已提交
1094
	while ((rth = *rthp) != NULL) {
1095
		if (rt_is_expired(rth)) {
1096 1097 1098 1099
			*rthp = rth->u.dst.rt_next;
			rt_free(rth);
			continue;
		}
1100
		if (compare_keys(&rth->fl, &rt->fl) && compare_netns(rth, rt)) {
L
Linus Torvalds 已提交
1101
			/* Put it first */
1102
			*rthp = rth->u.dst.rt_next;
L
Linus Torvalds 已提交
1103 1104 1105 1106 1107
			/*
			 * Since lookup is lockfree, the deletion
			 * must be visible to another weakly ordered CPU before
			 * the insertion at the start of the hash chain.
			 */
1108
			rcu_assign_pointer(rth->u.dst.rt_next,
L
Linus Torvalds 已提交
1109 1110 1111 1112 1113 1114 1115
					   rt_hash_table[hash].chain);
			/*
			 * Since lookup is lockfree, the update writes
			 * must be ordered for consistency on SMP.
			 */
			rcu_assign_pointer(rt_hash_table[hash].chain, rth);

1116
			dst_use(&rth->u.dst, now);
1117
			spin_unlock_bh(rt_hash_lock_addr(hash));
L
Linus Torvalds 已提交
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135

			rt_drop(rt);
			*rp = rth;
			return 0;
		}

		if (!atomic_read(&rth->u.dst.__refcnt)) {
			u32 score = rt_score(rth);

			if (score <= min_score) {
				cand = rth;
				candp = rthp;
				min_score = score;
			}
		}

		chain_length++;

1136
		rthp = &rth->u.dst.rt_next;
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147

		/*
		 * check to see if the next entry in the chain
		 * contains the same hash input values as rt.  If it does
		 * This is where we will insert into the list, instead of
		 * at the head.  This groups entries that differ by aspects not
		 * relvant to the hash function together, which we use to adjust
		 * our chain length
		 */
		if (*rthp && compare_hash_inputs(&(*rthp)->fl, &rt->fl))
			rthi = rth;
L
Linus Torvalds 已提交
1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
	}

	if (cand) {
		/* ip_rt_gc_elasticity used to be average length of chain
		 * length, when exceeded gc becomes really aggressive.
		 *
		 * The second limit is less certain. At the moment it allows
		 * only 2 entries per bucket. We will see.
		 */
		if (chain_length > ip_rt_gc_elasticity) {
1158
			*candp = cand->u.dst.rt_next;
L
Linus Torvalds 已提交
1159 1160
			rt_free(cand);
		}
1161 1162 1163 1164 1165 1166 1167 1168 1169 1170
	} else {
		if (chain_length > rt_chain_length_max) {
			struct net *net = dev_net(rt->u.dst.dev);
			int num = ++net->ipv4.current_rt_cache_rebuild_count;
			if (!rt_caching(dev_net(rt->u.dst.dev))) {
				printk(KERN_WARNING "%s: %d rebuilds is over limit, route caching disabled\n",
					rt->u.dst.dev->name, num);
			}
			rt_emergency_hash_rebuild(dev_net(rt->u.dst.dev));
		}
L
Linus Torvalds 已提交
1171 1172 1173 1174 1175 1176 1177 1178
	}

	/* Try to bind route to arp only if it is output
	   route or unicast forwarding path.
	 */
	if (rt->rt_type == RTN_UNICAST || rt->fl.iif == 0) {
		int err = arp_bind_neighbour(&rt->u.dst);
		if (err) {
1179
			spin_unlock_bh(rt_hash_lock_addr(hash));
L
Linus Torvalds 已提交
1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194

			if (err != -ENOBUFS) {
				rt_drop(rt);
				return err;
			}

			/* Neighbour tables are full and nothing
			   can be released. Try to shrink route cache,
			   it is most likely it holds some neighbour records.
			 */
			if (attempts-- > 0) {
				int saved_elasticity = ip_rt_gc_elasticity;
				int saved_int = ip_rt_gc_min_interval;
				ip_rt_gc_elasticity	= 1;
				ip_rt_gc_min_interval	= 0;
1195
				rt_garbage_collect(&ipv4_dst_ops);
L
Linus Torvalds 已提交
1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207
				ip_rt_gc_min_interval	= saved_int;
				ip_rt_gc_elasticity	= saved_elasticity;
				goto restart;
			}

			if (net_ratelimit())
				printk(KERN_WARNING "Neighbour table overflow.\n");
			rt_drop(rt);
			return -ENOBUFS;
		}
	}

1208 1209 1210 1211 1212
	if (rthi)
		rt->u.dst.rt_next = rthi->u.dst.rt_next;
	else
		rt->u.dst.rt_next = rt_hash_table[hash].chain;

L
Linus Torvalds 已提交
1213
#if RT_CACHE_DEBUG >= 2
1214
	if (rt->u.dst.rt_next) {
L
Linus Torvalds 已提交
1215
		struct rtable *trt;
1216
		printk(KERN_DEBUG "rt_cache @%02x: %pI4", hash, &rt->rt_dst);
1217
		for (trt = rt->u.dst.rt_next; trt; trt = trt->u.dst.rt_next)
1218
			printk(" . %pI4", &trt->rt_dst);
L
Linus Torvalds 已提交
1219 1220 1221
		printk("\n");
	}
#endif
1222 1223 1224 1225 1226
	/*
	 * Since lookup is lockfree, we must make sure
	 * previous writes to rt are comitted to memory
	 * before making rt visible to other CPUS.
	 */
1227 1228 1229 1230 1231
	if (rthi)
		rcu_assign_pointer(rthi->u.dst.rt_next, rt);
	else
		rcu_assign_pointer(rt_hash_table[hash].chain, rt);

1232
	spin_unlock_bh(rt_hash_lock_addr(hash));
L
Linus Torvalds 已提交
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267
	*rp = rt;
	return 0;
}

void rt_bind_peer(struct rtable *rt, int create)
{
	static DEFINE_SPINLOCK(rt_peer_lock);
	struct inet_peer *peer;

	peer = inet_getpeer(rt->rt_dst, create);

	spin_lock_bh(&rt_peer_lock);
	if (rt->peer == NULL) {
		rt->peer = peer;
		peer = NULL;
	}
	spin_unlock_bh(&rt_peer_lock);
	if (peer)
		inet_putpeer(peer);
}

/*
 * Peer allocation may fail only in serious out-of-memory conditions.  However
 * we still can generate some output.
 * Random ID selection looks a bit dangerous because we have no chances to
 * select ID being unique in a reasonable period of time.
 * But broken packet identifier may be better than no packet at all.
 */
static void ip_select_fb_ident(struct iphdr *iph)
{
	static DEFINE_SPINLOCK(ip_fb_id_lock);
	static u32 ip_fallback_id;
	u32 salt;

	spin_lock_bh(&ip_fb_id_lock);
1268
	salt = secure_ip_id((__force __be32)ip_fallback_id ^ iph->daddr);
L
Linus Torvalds 已提交
1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289
	iph->id = htons(salt & 0xFFFF);
	ip_fallback_id = salt;
	spin_unlock_bh(&ip_fb_id_lock);
}

void __ip_select_ident(struct iphdr *iph, struct dst_entry *dst, int more)
{
	struct rtable *rt = (struct rtable *) dst;

	if (rt) {
		if (rt->peer == NULL)
			rt_bind_peer(rt, 1);

		/* If peer is attached to destination, it is never detached,
		   so that we need not to grab a lock to dereference it.
		 */
		if (rt->peer) {
			iph->id = htons(inet_getid(rt->peer, more));
			return;
		}
	} else
1290
		printk(KERN_DEBUG "rt_bind_peer(0) @%p\n",
1291
		       __builtin_return_address(0));
L
Linus Torvalds 已提交
1292 1293 1294 1295 1296 1297

	ip_select_fb_ident(iph);
}

static void rt_del(unsigned hash, struct rtable *rt)
{
1298
	struct rtable **rthp, *aux;
L
Linus Torvalds 已提交
1299

1300
	rthp = &rt_hash_table[hash].chain;
1301
	spin_lock_bh(rt_hash_lock_addr(hash));
L
Linus Torvalds 已提交
1302
	ip_rt_put(rt);
1303
	while ((aux = *rthp) != NULL) {
1304
		if (aux == rt || rt_is_expired(aux)) {
1305 1306 1307
			*rthp = aux->u.dst.rt_next;
			rt_free(aux);
			continue;
L
Linus Torvalds 已提交
1308
		}
1309 1310
		rthp = &aux->u.dst.rt_next;
	}
1311
	spin_unlock_bh(rt_hash_lock_addr(hash));
L
Linus Torvalds 已提交
1312 1313
}

A
Al Viro 已提交
1314 1315
void ip_rt_redirect(__be32 old_gw, __be32 daddr, __be32 new_gw,
		    __be32 saddr, struct net_device *dev)
L
Linus Torvalds 已提交
1316 1317 1318 1319
{
	int i, k;
	struct in_device *in_dev = in_dev_get(dev);
	struct rtable *rth, **rthp;
A
Al Viro 已提交
1320
	__be32  skeys[2] = { saddr, 0 };
L
Linus Torvalds 已提交
1321
	int  ikeys[2] = { dev->ifindex, 0 };
1322
	struct netevent_redirect netevent;
1323
	struct net *net;
L
Linus Torvalds 已提交
1324 1325 1326 1327

	if (!in_dev)
		return;

1328
	net = dev_net(dev);
L
Linus Torvalds 已提交
1329
	if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev)
1330
	    || ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw)
1331
	    || ipv4_is_zeronet(new_gw))
L
Linus Torvalds 已提交
1332 1333
		goto reject_redirect;

1334 1335 1336
	if (!rt_caching(net))
		goto reject_redirect;

L
Linus Torvalds 已提交
1337 1338 1339 1340 1341 1342
	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 {
1343
		if (inet_addr_type(net, new_gw) != RTN_UNICAST)
L
Linus Torvalds 已提交
1344 1345 1346 1347 1348
			goto reject_redirect;
	}

	for (i = 0; i < 2; i++) {
		for (k = 0; k < 2; k++) {
1349
			unsigned hash = rt_hash(daddr, skeys[i], ikeys[k],
1350
						rt_genid(net));
L
Linus Torvalds 已提交
1351 1352 1353 1354 1355 1356 1357 1358 1359 1360

			rthp=&rt_hash_table[hash].chain;

			rcu_read_lock();
			while ((rth = rcu_dereference(*rthp)) != NULL) {
				struct rtable *rt;

				if (rth->fl.fl4_dst != daddr ||
				    rth->fl.fl4_src != skeys[i] ||
				    rth->fl.oif != ikeys[k] ||
1361
				    rth->fl.iif != 0 ||
1362
				    rt_is_expired(rth) ||
1363
				    !net_eq(dev_net(rth->u.dst.dev), net)) {
1364
					rthp = &rth->u.dst.rt_next;
L
Linus Torvalds 已提交
1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398
					continue;
				}

				if (rth->rt_dst != daddr ||
				    rth->rt_src != saddr ||
				    rth->u.dst.error ||
				    rth->rt_gateway != old_gw ||
				    rth->u.dst.dev != dev)
					break;

				dst_hold(&rth->u.dst);
				rcu_read_unlock();

				rt = dst_alloc(&ipv4_dst_ops);
				if (rt == NULL) {
					ip_rt_put(rth);
					in_dev_put(in_dev);
					return;
				}

				/* Copy all the information. */
				*rt = *rth;
				rt->u.dst.__use		= 1;
				atomic_set(&rt->u.dst.__refcnt, 1);
				rt->u.dst.child		= NULL;
				if (rt->u.dst.dev)
					dev_hold(rt->u.dst.dev);
				if (rt->idev)
					in_dev_hold(rt->idev);
				rt->u.dst.obsolete	= 0;
				rt->u.dst.lastuse	= jiffies;
				rt->u.dst.path		= &rt->u.dst;
				rt->u.dst.neighbour	= NULL;
				rt->u.dst.hh		= NULL;
1399
#ifdef CONFIG_XFRM
L
Linus Torvalds 已提交
1400
				rt->u.dst.xfrm		= NULL;
1401
#endif
1402
				rt->rt_genid		= rt_genid(net);
L
Linus Torvalds 已提交
1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422
				rt->rt_flags		|= RTCF_REDIRECTED;

				/* Gateway is different ... */
				rt->rt_gateway		= new_gw;

				/* Redirect received -> path was valid */
				dst_confirm(&rth->u.dst);

				if (rt->peer)
					atomic_inc(&rt->peer->refcnt);

				if (arp_bind_neighbour(&rt->u.dst) ||
				    !(rt->u.dst.neighbour->nud_state &
					    NUD_VALID)) {
					if (rt->u.dst.neighbour)
						neigh_event_send(rt->u.dst.neighbour, NULL);
					ip_rt_put(rth);
					rt_drop(rt);
					goto do_next;
				}
1423

1424 1425
				netevent.old = &rth->u.dst;
				netevent.new = &rt->u.dst;
1426 1427
				call_netevent_notifiers(NETEVENT_REDIRECT,
							&netevent);
L
Linus Torvalds 已提交
1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444

				rt_del(hash, rth);
				if (!rt_intern_hash(hash, rt, &rt))
					ip_rt_put(rt);
				goto do_next;
			}
			rcu_read_unlock();
		do_next:
			;
		}
	}
	in_dev_put(in_dev);
	return;

reject_redirect:
#ifdef CONFIG_IP_ROUTE_VERBOSE
	if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit())
1445 1446 1447 1448
		printk(KERN_INFO "Redirect from %pI4 on %s about %pI4 ignored.\n"
			"  Advised path = %pI4 -> %pI4\n",
		       &old_gw, dev->name, &new_gw,
		       &saddr, &daddr);
L
Linus Torvalds 已提交
1449 1450 1451 1452 1453 1454
#endif
	in_dev_put(in_dev);
}

static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
{
1455
	struct rtable *rt = (struct rtable *)dst;
L
Linus Torvalds 已提交
1456 1457 1458 1459 1460 1461 1462 1463
	struct dst_entry *ret = dst;

	if (rt) {
		if (dst->obsolete) {
			ip_rt_put(rt);
			ret = NULL;
		} else if ((rt->rt_flags & RTCF_REDIRECTED) ||
			   rt->u.dst.expires) {
A
Al Viro 已提交
1464
			unsigned hash = rt_hash(rt->fl.fl4_dst, rt->fl.fl4_src,
1465
						rt->fl.oif,
1466
						rt_genid(dev_net(dst->dev)));
L
Linus Torvalds 已提交
1467
#if RT_CACHE_DEBUG >= 1
1468 1469
			printk(KERN_DEBUG "ipv4_negative_advice: redirect to %pI4/%02x dropped\n",
				&rt->rt_dst, rt->fl.fl4_tos);
L
Linus Torvalds 已提交
1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495
#endif
			rt_del(hash, rt);
			ret = NULL;
		}
	}
	return ret;
}

/*
 * 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)
{
1496
	struct rtable *rt = skb->rtable;
L
Linus Torvalds 已提交
1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521
	struct in_device *in_dev = in_dev_get(rt->u.dst.dev);

	if (!in_dev)
		return;

	if (!IN_DEV_TX_REDIRECTS(in_dev))
		goto out;

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

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

	/* Check for load limit; set rate_last to the latest sent
	 * redirect.
	 */
1522 1523
	if (rt->u.dst.rate_tokens == 0 ||
	    time_after(jiffies,
L
Linus Torvalds 已提交
1524 1525 1526 1527 1528 1529 1530 1531 1532
		       (rt->u.dst.rate_last +
			(ip_rt_redirect_load << rt->u.dst.rate_tokens)))) {
		icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, rt->rt_gateway);
		rt->u.dst.rate_last = jiffies;
		++rt->u.dst.rate_tokens;
#ifdef CONFIG_IP_ROUTE_VERBOSE
		if (IN_DEV_LOG_MARTIANS(in_dev) &&
		    rt->u.dst.rate_tokens == ip_rt_redirect_number &&
		    net_ratelimit())
1533 1534 1535
			printk(KERN_WARNING "host %pI4/if%d ignores redirects for %pI4 to %pI4.\n",
				&rt->rt_src, rt->rt_iif,
				&rt->rt_dst, &rt->rt_gateway);
L
Linus Torvalds 已提交
1536 1537 1538
#endif
	}
out:
1539
	in_dev_put(in_dev);
L
Linus Torvalds 已提交
1540 1541 1542 1543
}

static int ip_error(struct sk_buff *skb)
{
1544
	struct rtable *rt = skb->rtable;
L
Linus Torvalds 已提交
1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556
	unsigned long now;
	int code;

	switch (rt->u.dst.error) {
		case EINVAL:
		default:
			goto out;
		case EHOSTUNREACH:
			code = ICMP_HOST_UNREACH;
			break;
		case ENETUNREACH:
			code = ICMP_NET_UNREACH;
1557 1558
			IP_INC_STATS_BH(dev_net(rt->u.dst.dev),
					IPSTATS_MIB_INNOROUTES);
L
Linus Torvalds 已提交
1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576
			break;
		case EACCES:
			code = ICMP_PKT_FILTERED;
			break;
	}

	now = jiffies;
	rt->u.dst.rate_tokens += now - rt->u.dst.rate_last;
	if (rt->u.dst.rate_tokens > ip_rt_error_burst)
		rt->u.dst.rate_tokens = ip_rt_error_burst;
	rt->u.dst.rate_last = now;
	if (rt->u.dst.rate_tokens >= ip_rt_error_cost) {
		rt->u.dst.rate_tokens -= ip_rt_error_cost;
		icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
	}

out:	kfree_skb(skb);
	return 0;
1577
}
L
Linus Torvalds 已提交
1578 1579 1580 1581 1582 1583

/*
 *	The last two values are not from the RFC but
 *	are needed for AMPRnet AX.25 paths.
 */

1584
static const unsigned short mtu_plateau[] =
L
Linus Torvalds 已提交
1585 1586
{32000, 17914, 8166, 4352, 2002, 1492, 576, 296, 216, 128 };

S
Stephen Hemminger 已提交
1587
static inline unsigned short guess_mtu(unsigned short old_mtu)
L
Linus Torvalds 已提交
1588 1589
{
	int i;
1590

L
Linus Torvalds 已提交
1591 1592 1593 1594 1595 1596
	for (i = 0; i < ARRAY_SIZE(mtu_plateau); i++)
		if (old_mtu > mtu_plateau[i])
			return mtu_plateau[i];
	return 68;
}

1597
unsigned short ip_rt_frag_needed(struct net *net, struct iphdr *iph,
1598 1599
				 unsigned short new_mtu,
				 struct net_device *dev)
L
Linus Torvalds 已提交
1600
{
1601
	int i, k;
L
Linus Torvalds 已提交
1602 1603
	unsigned short old_mtu = ntohs(iph->tot_len);
	struct rtable *rth;
1604
	int  ikeys[2] = { dev->ifindex, 0 };
1605 1606
	__be32  skeys[2] = { iph->saddr, 0, };
	__be32  daddr = iph->daddr;
L
Linus Torvalds 已提交
1607 1608 1609 1610 1611
	unsigned short est_mtu = 0;

	if (ipv4_config.no_pmtu_disc)
		return 0;

1612 1613
	for (k = 0; k < 2; k++) {
		for (i = 0; i < 2; i++) {
1614
			unsigned hash = rt_hash(daddr, skeys[i], ikeys[k],
1615
						rt_genid(net));
1616 1617 1618 1619

			rcu_read_lock();
			for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
			     rth = rcu_dereference(rth->u.dst.rt_next)) {
L
Linus Torvalds 已提交
1620 1621
				unsigned short mtu = new_mtu;

1622 1623 1624 1625 1626 1627 1628 1629
				if (rth->fl.fl4_dst != daddr ||
				    rth->fl.fl4_src != skeys[i] ||
				    rth->rt_dst != daddr ||
				    rth->rt_src != iph->saddr ||
				    rth->fl.oif != ikeys[k] ||
				    rth->fl.iif != 0 ||
				    dst_metric_locked(&rth->u.dst, RTAX_MTU) ||
				    !net_eq(dev_net(rth->u.dst.dev), net) ||
1630
				    rt_is_expired(rth))
1631 1632
					continue;

L
Linus Torvalds 已提交
1633 1634 1635 1636
				if (new_mtu < 68 || new_mtu >= old_mtu) {

					/* BSD 4.2 compatibility hack :-( */
					if (mtu == 0 &&
1637
					    old_mtu >= dst_mtu(&rth->u.dst) &&
L
Linus Torvalds 已提交
1638 1639 1640 1641 1642
					    old_mtu >= 68 + (iph->ihl << 2))
						old_mtu -= iph->ihl << 2;

					mtu = guess_mtu(old_mtu);
				}
1643 1644
				if (mtu <= dst_mtu(&rth->u.dst)) {
					if (mtu < dst_mtu(&rth->u.dst)) {
L
Linus Torvalds 已提交
1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657
						dst_confirm(&rth->u.dst);
						if (mtu < ip_rt_min_pmtu) {
							mtu = ip_rt_min_pmtu;
							rth->u.dst.metrics[RTAX_LOCK-1] |=
								(1 << RTAX_MTU);
						}
						rth->u.dst.metrics[RTAX_MTU-1] = mtu;
						dst_set_expires(&rth->u.dst,
							ip_rt_mtu_expires);
					}
					est_mtu = mtu;
				}
			}
1658
			rcu_read_unlock();
L
Linus Torvalds 已提交
1659 1660 1661 1662 1663 1664 1665
		}
	}
	return est_mtu ? : new_mtu;
}

static void ip_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
{
1666
	if (dst_mtu(dst) > mtu && mtu >= 68 &&
L
Linus Torvalds 已提交
1667 1668 1669 1670 1671 1672 1673
	    !(dst_metric_locked(dst, RTAX_MTU))) {
		if (mtu < ip_rt_min_pmtu) {
			mtu = ip_rt_min_pmtu;
			dst->metrics[RTAX_LOCK-1] |= (1 << RTAX_MTU);
		}
		dst->metrics[RTAX_MTU-1] = mtu;
		dst_set_expires(dst, ip_rt_mtu_expires);
1674
		call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);
L
Linus Torvalds 已提交
1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704
	}
}

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

static void ipv4_dst_destroy(struct dst_entry *dst)
{
	struct rtable *rt = (struct rtable *) dst;
	struct inet_peer *peer = rt->peer;
	struct in_device *idev = rt->idev;

	if (peer) {
		rt->peer = NULL;
		inet_putpeer(peer);
	}

	if (idev) {
		rt->idev = NULL;
		in_dev_put(idev);
	}
}

static void ipv4_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
			    int how)
{
	struct rtable *rt = (struct rtable *) dst;
	struct in_device *idev = rt->idev;
1705
	if (dev != dev_net(dev)->loopback_dev && idev && idev->dev == dev) {
1706
		struct in_device *loopback_idev =
1707
			in_dev_get(dev_net(dev)->loopback_dev);
L
Linus Torvalds 已提交
1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720
		if (loopback_idev) {
			rt->idev = loopback_idev;
			in_dev_put(idev);
		}
	}
}

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

	icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);

1721
	rt = skb->rtable;
L
Linus Torvalds 已提交
1722 1723 1724 1725 1726 1727
	if (rt)
		dst_set_expires(&rt->u.dst, 0);
}

static int ip_rt_bug(struct sk_buff *skb)
{
1728 1729
	printk(KERN_DEBUG "ip_rt_bug: %pI4 -> %pI4, %s\n",
		&ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
L
Linus Torvalds 已提交
1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745
		skb->dev ? skb->dev->name : "?");
	kfree_skb(skb);
	return 0;
}

/*
   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 rtable *rt)
{
A
Al Viro 已提交
1746
	__be32 src;
L
Linus Torvalds 已提交
1747 1748 1749 1750
	struct fib_result res;

	if (rt->fl.iif == 0)
		src = rt->rt_src;
1751
	else if (fib_lookup(dev_net(rt->u.dst.dev), &rt->fl, &res) == 0) {
L
Linus Torvalds 已提交
1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781
		src = FIB_RES_PREFSRC(res);
		fib_res_put(&res);
	} else
		src = inet_select_addr(rt->u.dst.dev, rt->rt_gateway,
					RT_SCOPE_UNIVERSE);
	memcpy(addr, &src, 4);
}

#ifdef CONFIG_NET_CLS_ROUTE
static void set_class_tag(struct rtable *rt, u32 tag)
{
	if (!(rt->u.dst.tclassid & 0xFFFF))
		rt->u.dst.tclassid |= tag & 0xFFFF;
	if (!(rt->u.dst.tclassid & 0xFFFF0000))
		rt->u.dst.tclassid |= tag & 0xFFFF0000;
}
#endif

static void rt_set_nexthop(struct rtable *rt, struct fib_result *res, u32 itag)
{
	struct fib_info *fi = res->fi;

	if (fi) {
		if (FIB_RES_GW(*res) &&
		    FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK)
			rt->rt_gateway = FIB_RES_GW(*res);
		memcpy(rt->u.dst.metrics, fi->fib_metrics,
		       sizeof(rt->u.dst.metrics));
		if (fi->fib_mtu == 0) {
			rt->u.dst.metrics[RTAX_MTU-1] = rt->u.dst.dev->mtu;
1782
			if (dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
L
Linus Torvalds 已提交
1783 1784 1785 1786 1787 1788 1789 1790 1791 1792
			    rt->rt_gateway != rt->rt_dst &&
			    rt->u.dst.dev->mtu > 576)
				rt->u.dst.metrics[RTAX_MTU-1] = 576;
		}
#ifdef CONFIG_NET_CLS_ROUTE
		rt->u.dst.tclassid = FIB_RES_NH(*res).nh_tclassid;
#endif
	} else
		rt->u.dst.metrics[RTAX_MTU-1]= rt->u.dst.dev->mtu;

1793
	if (dst_metric(&rt->u.dst, RTAX_HOPLIMIT) == 0)
L
Linus Torvalds 已提交
1794
		rt->u.dst.metrics[RTAX_HOPLIMIT-1] = sysctl_ip_default_ttl;
1795
	if (dst_mtu(&rt->u.dst) > IP_MAX_MTU)
L
Linus Torvalds 已提交
1796
		rt->u.dst.metrics[RTAX_MTU-1] = IP_MAX_MTU;
1797
	if (dst_metric(&rt->u.dst, RTAX_ADVMSS) == 0)
L
Linus Torvalds 已提交
1798 1799
		rt->u.dst.metrics[RTAX_ADVMSS-1] = max_t(unsigned int, rt->u.dst.dev->mtu - 40,
				       ip_rt_min_advmss);
1800
	if (dst_metric(&rt->u.dst, RTAX_ADVMSS) > 65535 - 40)
L
Linus Torvalds 已提交
1801 1802 1803 1804 1805 1806 1807 1808
		rt->u.dst.metrics[RTAX_ADVMSS-1] = 65535 - 40;

#ifdef CONFIG_NET_CLS_ROUTE
#ifdef CONFIG_IP_MULTIPLE_TABLES
	set_class_tag(rt, fib_rules_tclass(res));
#endif
	set_class_tag(rt, itag);
#endif
1809
	rt->rt_type = res->type;
L
Linus Torvalds 已提交
1810 1811
}

A
Al Viro 已提交
1812
static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
L
Linus Torvalds 已提交
1813 1814 1815 1816
				u8 tos, struct net_device *dev, int our)
{
	unsigned hash;
	struct rtable *rth;
A
Al Viro 已提交
1817
	__be32 spec_dst;
L
Linus Torvalds 已提交
1818 1819 1820 1821 1822 1823 1824 1825
	struct in_device *in_dev = in_dev_get(dev);
	u32 itag = 0;

	/* Primary sanity checks. */

	if (in_dev == NULL)
		return -EINVAL;

1826
	if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
1827
	    ipv4_is_loopback(saddr) || skb->protocol != htons(ETH_P_IP))
L
Linus Torvalds 已提交
1828 1829
		goto e_inval;

1830 1831
	if (ipv4_is_zeronet(saddr)) {
		if (!ipv4_is_local_multicast(daddr))
L
Linus Torvalds 已提交
1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845
			goto e_inval;
		spec_dst = inet_select_addr(dev, 0, RT_SCOPE_LINK);
	} else if (fib_validate_source(saddr, 0, tos, 0,
					dev, &spec_dst, &itag) < 0)
		goto e_inval;

	rth = dst_alloc(&ipv4_dst_ops);
	if (!rth)
		goto e_nobufs;

	rth->u.dst.output= ip_rt_bug;

	atomic_set(&rth->u.dst.__refcnt, 1);
	rth->u.dst.flags= DST_HOST;
1846
	if (IN_DEV_CONF_GET(in_dev, NOPOLICY))
L
Linus Torvalds 已提交
1847 1848 1849 1850
		rth->u.dst.flags |= DST_NOPOLICY;
	rth->fl.fl4_dst	= daddr;
	rth->rt_dst	= daddr;
	rth->fl.fl4_tos	= tos;
1851
	rth->fl.mark    = skb->mark;
L
Linus Torvalds 已提交
1852 1853 1854 1855 1856 1857 1858
	rth->fl.fl4_src	= saddr;
	rth->rt_src	= saddr;
#ifdef CONFIG_NET_CLS_ROUTE
	rth->u.dst.tclassid = itag;
#endif
	rth->rt_iif	=
	rth->fl.iif	= dev->ifindex;
1859
	rth->u.dst.dev	= init_net.loopback_dev;
L
Linus Torvalds 已提交
1860 1861 1862 1863 1864
	dev_hold(rth->u.dst.dev);
	rth->idev	= in_dev_get(rth->u.dst.dev);
	rth->fl.oif	= 0;
	rth->rt_gateway	= daddr;
	rth->rt_spec_dst= spec_dst;
1865
	rth->rt_genid	= rt_genid(dev_net(dev));
L
Linus Torvalds 已提交
1866
	rth->rt_flags	= RTCF_MULTICAST;
1867
	rth->rt_type	= RTN_MULTICAST;
L
Linus Torvalds 已提交
1868 1869 1870 1871 1872 1873
	if (our) {
		rth->u.dst.input= ip_local_deliver;
		rth->rt_flags |= RTCF_LOCAL;
	}

#ifdef CONFIG_IP_MROUTE
1874
	if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
L
Linus Torvalds 已提交
1875 1876 1877 1878 1879
		rth->u.dst.input = ip_mr_input;
#endif
	RT_CACHE_STAT_INC(in_slow_mc);

	in_dev_put(in_dev);
1880
	hash = rt_hash(daddr, saddr, dev->ifindex, rt_genid(dev_net(dev)));
1881
	return rt_intern_hash(hash, rth, &skb->rtable);
L
Linus Torvalds 已提交
1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895

e_nobufs:
	in_dev_put(in_dev);
	return -ENOBUFS;

e_inval:
	in_dev_put(in_dev);
	return -EINVAL;
}


static void ip_handle_martian_source(struct net_device *dev,
				     struct in_device *in_dev,
				     struct sk_buff *skb,
A
Al Viro 已提交
1896 1897
				     __be32 daddr,
				     __be32 saddr)
L
Linus Torvalds 已提交
1898 1899 1900 1901 1902 1903 1904 1905
{
	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.
		 */
1906 1907
		printk(KERN_WARNING "martian source %pI4 from %pI4, on dev %s\n",
			&daddr, &saddr, dev->name);
1908
		if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
L
Linus Torvalds 已提交
1909
			int i;
1910
			const unsigned char *p = skb_mac_header(skb);
L
Linus Torvalds 已提交
1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922
			printk(KERN_WARNING "ll header: ");
			for (i = 0; i < dev->hard_header_len; i++, p++) {
				printk("%02x", *p);
				if (i < (dev->hard_header_len - 1))
					printk(":");
			}
			printk("\n");
		}
	}
#endif
}

S
Stephen Hemminger 已提交
1923 1924 1925 1926 1927
static int __mkroute_input(struct sk_buff *skb,
			   struct fib_result *res,
			   struct in_device *in_dev,
			   __be32 daddr, __be32 saddr, u32 tos,
			   struct rtable **result)
L
Linus Torvalds 已提交
1928 1929 1930 1931 1932 1933
{

	struct rtable *rth;
	int err;
	struct in_device *out_dev;
	unsigned flags = 0;
1934 1935
	__be32 spec_dst;
	u32 itag;
L
Linus Torvalds 已提交
1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946

	/* get a working reference to the output device */
	out_dev = in_dev_get(FIB_RES_DEV(*res));
	if (out_dev == NULL) {
		if (net_ratelimit())
			printk(KERN_CRIT "Bug in ip_route_input" \
			       "_slow(). Please, report\n");
		return -EINVAL;
	}


1947
	err = fib_validate_source(saddr, daddr, tos, FIB_RES_OIF(*res),
L
Linus Torvalds 已提交
1948 1949
				  in_dev->dev, &spec_dst, &itag);
	if (err < 0) {
1950
		ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
L
Linus Torvalds 已提交
1951
					 saddr);
1952

L
Linus Torvalds 已提交
1953 1954 1955 1956 1957 1958 1959
		err = -EINVAL;
		goto cleanup;
	}

	if (err)
		flags |= RTCF_DIRECTSRC;

1960
	if (out_dev == in_dev && err &&
L
Linus Torvalds 已提交
1961 1962 1963 1964 1965 1966 1967 1968
	    (IN_DEV_SHARED_MEDIA(out_dev) ||
	     inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
		flags |= RTCF_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.
		 */
1969
		if (out_dev == in_dev) {
L
Linus Torvalds 已提交
1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981
			err = -EINVAL;
			goto cleanup;
		}
	}


	rth = dst_alloc(&ipv4_dst_ops);
	if (!rth) {
		err = -ENOBUFS;
		goto cleanup;
	}

1982
	atomic_set(&rth->u.dst.__refcnt, 1);
L
Linus Torvalds 已提交
1983
	rth->u.dst.flags= DST_HOST;
1984
	if (IN_DEV_CONF_GET(in_dev, NOPOLICY))
L
Linus Torvalds 已提交
1985
		rth->u.dst.flags |= DST_NOPOLICY;
1986
	if (IN_DEV_CONF_GET(out_dev, NOXFRM))
L
Linus Torvalds 已提交
1987 1988 1989 1990
		rth->u.dst.flags |= DST_NOXFRM;
	rth->fl.fl4_dst	= daddr;
	rth->rt_dst	= daddr;
	rth->fl.fl4_tos	= tos;
1991
	rth->fl.mark    = skb->mark;
L
Linus Torvalds 已提交
1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004
	rth->fl.fl4_src	= saddr;
	rth->rt_src	= saddr;
	rth->rt_gateway	= daddr;
	rth->rt_iif 	=
		rth->fl.iif	= in_dev->dev->ifindex;
	rth->u.dst.dev	= (out_dev)->dev;
	dev_hold(rth->u.dst.dev);
	rth->idev	= in_dev_get(rth->u.dst.dev);
	rth->fl.oif 	= 0;
	rth->rt_spec_dst= spec_dst;

	rth->u.dst.input = ip_forward;
	rth->u.dst.output = ip_output;
2005
	rth->rt_genid = rt_genid(dev_net(rth->u.dst.dev));
L
Linus Torvalds 已提交
2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016

	rt_set_nexthop(rth, res, itag);

	rth->rt_flags = flags;

	*result = rth;
	err = 0;
 cleanup:
	/* release the working reference to the output device */
	in_dev_put(out_dev);
	return err;
2017
}
L
Linus Torvalds 已提交
2018

S
Stephen Hemminger 已提交
2019 2020 2021 2022 2023
static int ip_mkroute_input(struct sk_buff *skb,
			    struct fib_result *res,
			    const struct flowi *fl,
			    struct in_device *in_dev,
			    __be32 daddr, __be32 saddr, u32 tos)
L
Linus Torvalds 已提交
2024
{
C
Chuck Short 已提交
2025
	struct rtable* rth = NULL;
L
Linus Torvalds 已提交
2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039
	int err;
	unsigned hash;

#ifdef CONFIG_IP_ROUTE_MULTIPATH
	if (res->fi && res->fi->fib_nhs > 1 && fl->oif == 0)
		fib_select_multipath(fl, res);
#endif

	/* create a routing cache entry */
	err = __mkroute_input(skb, res, in_dev, daddr, saddr, tos, &rth);
	if (err)
		return err;

	/* put it into the cache */
2040 2041
	hash = rt_hash(daddr, saddr, fl->iif,
		       rt_genid(dev_net(rth->u.dst.dev)));
2042
	return rt_intern_hash(hash, rth, &skb->rtable);
L
Linus Torvalds 已提交
2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054
}

/*
 *	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.
 */

A
Al Viro 已提交
2055
static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
L
Linus Torvalds 已提交
2056 2057 2058 2059 2060 2061 2062 2063 2064 2065
			       u8 tos, struct net_device *dev)
{
	struct fib_result res;
	struct in_device *in_dev = in_dev_get(dev);
	struct flowi fl = { .nl_u = { .ip4_u =
				      { .daddr = daddr,
					.saddr = saddr,
					.tos = tos,
					.scope = RT_SCOPE_UNIVERSE,
				      } },
2066
			    .mark = skb->mark,
L
Linus Torvalds 已提交
2067 2068 2069 2070 2071
			    .iif = dev->ifindex };
	unsigned	flags = 0;
	u32		itag = 0;
	struct rtable * rth;
	unsigned	hash;
A
Al Viro 已提交
2072
	__be32		spec_dst;
L
Linus Torvalds 已提交
2073 2074
	int		err = -EINVAL;
	int		free_res = 0;
2075
	struct net    * net = dev_net(dev);
L
Linus Torvalds 已提交
2076 2077 2078 2079 2080 2081 2082 2083 2084 2085

	/* 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.
	 */

2086
	if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
2087
	    ipv4_is_loopback(saddr))
L
Linus Torvalds 已提交
2088 2089
		goto martian_source;

2090
	if (daddr == htonl(0xFFFFFFFF) || (saddr == 0 && daddr == 0))
L
Linus Torvalds 已提交
2091 2092 2093 2094 2095
		goto brd_input;

	/* Accept zero addresses only to limited broadcast;
	 * I even do not know to fix it or not. Waiting for complains :-)
	 */
2096
	if (ipv4_is_zeronet(saddr))
L
Linus Torvalds 已提交
2097 2098
		goto martian_source;

2099
	if (ipv4_is_lbcast(daddr) || ipv4_is_zeronet(daddr) ||
2100
	    ipv4_is_loopback(daddr))
L
Linus Torvalds 已提交
2101 2102 2103 2104 2105
		goto martian_destination;

	/*
	 *	Now we are ready to route packet.
	 */
2106
	if ((err = fib_lookup(net, &fl, &res)) != 0) {
L
Linus Torvalds 已提交
2107
		if (!IN_DEV_FORWARD(in_dev))
2108
			goto e_hostunreach;
L
Linus Torvalds 已提交
2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120
		goto no_route;
	}
	free_res = 1;

	RT_CACHE_STAT_INC(in_slow_tot);

	if (res.type == RTN_BROADCAST)
		goto brd_input;

	if (res.type == RTN_LOCAL) {
		int result;
		result = fib_validate_source(saddr, daddr, tos,
2121
					     net->loopback_dev->ifindex,
L
Linus Torvalds 已提交
2122 2123 2124 2125 2126 2127 2128 2129 2130 2131
					     dev, &spec_dst, &itag);
		if (result < 0)
			goto martian_source;
		if (result)
			flags |= RTCF_DIRECTSRC;
		spec_dst = daddr;
		goto local_input;
	}

	if (!IN_DEV_FORWARD(in_dev))
2132
		goto e_hostunreach;
L
Linus Torvalds 已提交
2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146
	if (res.type != RTN_UNICAST)
		goto martian_destination;

	err = ip_mkroute_input(skb, &res, &fl, in_dev, daddr, saddr, tos);
done:
	in_dev_put(in_dev);
	if (free_res)
		fib_res_put(&res);
out:	return err;

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

2147
	if (ipv4_is_zeronet(saddr))
L
Linus Torvalds 已提交
2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166
		spec_dst = inet_select_addr(dev, 0, RT_SCOPE_LINK);
	else {
		err = fib_validate_source(saddr, 0, tos, 0, dev, &spec_dst,
					  &itag);
		if (err < 0)
			goto martian_source;
		if (err)
			flags |= RTCF_DIRECTSRC;
	}
	flags |= RTCF_BROADCAST;
	res.type = RTN_BROADCAST;
	RT_CACHE_STAT_INC(in_brd);

local_input:
	rth = dst_alloc(&ipv4_dst_ops);
	if (!rth)
		goto e_nobufs;

	rth->u.dst.output= ip_rt_bug;
2167
	rth->rt_genid = rt_genid(net);
L
Linus Torvalds 已提交
2168 2169 2170

	atomic_set(&rth->u.dst.__refcnt, 1);
	rth->u.dst.flags= DST_HOST;
2171
	if (IN_DEV_CONF_GET(in_dev, NOPOLICY))
L
Linus Torvalds 已提交
2172 2173 2174 2175
		rth->u.dst.flags |= DST_NOPOLICY;
	rth->fl.fl4_dst	= daddr;
	rth->rt_dst	= daddr;
	rth->fl.fl4_tos	= tos;
2176
	rth->fl.mark    = skb->mark;
L
Linus Torvalds 已提交
2177 2178 2179 2180 2181 2182 2183
	rth->fl.fl4_src	= saddr;
	rth->rt_src	= saddr;
#ifdef CONFIG_NET_CLS_ROUTE
	rth->u.dst.tclassid = itag;
#endif
	rth->rt_iif	=
	rth->fl.iif	= dev->ifindex;
2184
	rth->u.dst.dev	= net->loopback_dev;
L
Linus Torvalds 已提交
2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196
	dev_hold(rth->u.dst.dev);
	rth->idev	= in_dev_get(rth->u.dst.dev);
	rth->rt_gateway	= daddr;
	rth->rt_spec_dst= spec_dst;
	rth->u.dst.input= ip_local_deliver;
	rth->rt_flags 	= flags|RTCF_LOCAL;
	if (res.type == RTN_UNREACHABLE) {
		rth->u.dst.input= ip_error;
		rth->u.dst.error= -err;
		rth->rt_flags 	&= ~RTCF_LOCAL;
	}
	rth->rt_type	= res.type;
2197
	hash = rt_hash(daddr, saddr, fl.iif, rt_genid(net));
2198
	err = rt_intern_hash(hash, rth, &skb->rtable);
L
Linus Torvalds 已提交
2199 2200 2201 2202 2203 2204
	goto done;

no_route:
	RT_CACHE_STAT_INC(in_no_route);
	spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
	res.type = RTN_UNREACHABLE;
2205 2206
	if (err == -ESRCH)
		err = -ENETUNREACH;
L
Linus Torvalds 已提交
2207 2208 2209 2210 2211 2212 2213 2214 2215
	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_ratelimit())
2216 2217
		printk(KERN_WARNING "martian destination %pI4 from %pI4, dev %s\n",
			&daddr, &saddr, dev->name);
L
Linus Torvalds 已提交
2218
#endif
2219 2220

e_hostunreach:
2221 2222
	err = -EHOSTUNREACH;
	goto done;
2223

L
Linus Torvalds 已提交
2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236
e_inval:
	err = -EINVAL;
	goto done;

e_nobufs:
	err = -ENOBUFS;
	goto done;

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

A
Al Viro 已提交
2237
int ip_route_input(struct sk_buff *skb, __be32 daddr, __be32 saddr,
L
Linus Torvalds 已提交
2238 2239 2240 2241 2242
		   u8 tos, struct net_device *dev)
{
	struct rtable * rth;
	unsigned	hash;
	int iif = dev->ifindex;
2243
	struct net *net;
L
Linus Torvalds 已提交
2244

2245
	net = dev_net(dev);
2246 2247 2248 2249

	if (!rt_caching(net))
		goto skip_cache;

L
Linus Torvalds 已提交
2250
	tos &= IPTOS_RT_MASK;
2251
	hash = rt_hash(daddr, saddr, iif, rt_genid(net));
L
Linus Torvalds 已提交
2252 2253 2254

	rcu_read_lock();
	for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
2255
	     rth = rcu_dereference(rth->u.dst.rt_next)) {
2256 2257 2258 2259 2260
		if (((rth->fl.fl4_dst ^ daddr) |
		     (rth->fl.fl4_src ^ saddr) |
		     (rth->fl.iif ^ iif) |
		     rth->fl.oif |
		     (rth->fl.fl4_tos ^ tos)) == 0 &&
2261
		    rth->fl.mark == skb->mark &&
2262
		    net_eq(dev_net(rth->u.dst.dev), net) &&
2263
		    !rt_is_expired(rth)) {
2264
			dst_use(&rth->u.dst, jiffies);
L
Linus Torvalds 已提交
2265 2266
			RT_CACHE_STAT_INC(in_hit);
			rcu_read_unlock();
2267
			skb->rtable = rth;
L
Linus Torvalds 已提交
2268 2269 2270 2271 2272 2273
			return 0;
		}
		RT_CACHE_STAT_INC(in_hlist_search);
	}
	rcu_read_unlock();

2274
skip_cache:
L
Linus Torvalds 已提交
2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285
	/* 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.
	 */
2286
	if (ipv4_is_multicast(daddr)) {
L
Linus Torvalds 已提交
2287 2288 2289
		struct in_device *in_dev;

		rcu_read_lock();
2290
		if ((in_dev = __in_dev_get_rcu(dev)) != NULL) {
L
Linus Torvalds 已提交
2291
			int our = ip_check_mc(in_dev, daddr, saddr,
2292
				ip_hdr(skb)->protocol);
L
Linus Torvalds 已提交
2293 2294
			if (our
#ifdef CONFIG_IP_MROUTE
2295 2296
			    || (!ipv4_is_local_multicast(daddr) &&
				IN_DEV_MFORWARD(in_dev))
L
Linus Torvalds 已提交
2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309
#endif
			    ) {
				rcu_read_unlock();
				return ip_route_input_mc(skb, daddr, saddr,
							 tos, dev, our);
			}
		}
		rcu_read_unlock();
		return -EINVAL;
	}
	return ip_route_input_slow(skb, daddr, saddr, tos, dev);
}

S
Stephen Hemminger 已提交
2310 2311 2312 2313 2314 2315
static int __mkroute_output(struct rtable **result,
			    struct fib_result *res,
			    const struct flowi *fl,
			    const struct flowi *oldflp,
			    struct net_device *dev_out,
			    unsigned flags)
L
Linus Torvalds 已提交
2316 2317 2318 2319 2320 2321
{
	struct rtable *rth;
	struct in_device *in_dev;
	u32 tos = RT_FL_TOS(oldflp);
	int err = 0;

2322
	if (ipv4_is_loopback(fl->fl4_src) && !(dev_out->flags&IFF_LOOPBACK))
L
Linus Torvalds 已提交
2323 2324
		return -EINVAL;

2325
	if (fl->fl4_dst == htonl(0xFFFFFFFF))
L
Linus Torvalds 已提交
2326
		res->type = RTN_BROADCAST;
2327
	else if (ipv4_is_multicast(fl->fl4_dst))
L
Linus Torvalds 已提交
2328
		res->type = RTN_MULTICAST;
2329
	else if (ipv4_is_lbcast(fl->fl4_dst) || ipv4_is_zeronet(fl->fl4_dst))
L
Linus Torvalds 已提交
2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347
		return -EINVAL;

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

	/* get work reference to inet device */
	in_dev = in_dev_get(dev_out);
	if (!in_dev)
		return -EINVAL;

	if (res->type == RTN_BROADCAST) {
		flags |= RTCF_BROADCAST | RTCF_LOCAL;
		if (res->fi) {
			fib_info_put(res->fi);
			res->fi = NULL;
		}
	} else if (res->type == RTN_MULTICAST) {
		flags |= RTCF_MULTICAST|RTCF_LOCAL;
2348
		if (!ip_check_mc(in_dev, oldflp->fl4_dst, oldflp->fl4_src,
L
Linus Torvalds 已提交
2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365
				 oldflp->proto))
			flags &= ~RTCF_LOCAL;
		/* If multicast route do not exist use
		   default one, but do not gateway in this case.
		   Yes, it is hack.
		 */
		if (res->fi && res->prefixlen < 4) {
			fib_info_put(res->fi);
			res->fi = NULL;
		}
	}


	rth = dst_alloc(&ipv4_dst_ops);
	if (!rth) {
		err = -ENOBUFS;
		goto cleanup;
2366
	}
L
Linus Torvalds 已提交
2367

2368
	atomic_set(&rth->u.dst.__refcnt, 1);
L
Linus Torvalds 已提交
2369
	rth->u.dst.flags= DST_HOST;
2370
	if (IN_DEV_CONF_GET(in_dev, NOXFRM))
L
Linus Torvalds 已提交
2371
		rth->u.dst.flags |= DST_NOXFRM;
2372
	if (IN_DEV_CONF_GET(in_dev, NOPOLICY))
L
Linus Torvalds 已提交
2373 2374 2375 2376 2377 2378
		rth->u.dst.flags |= DST_NOPOLICY;

	rth->fl.fl4_dst	= oldflp->fl4_dst;
	rth->fl.fl4_tos	= tos;
	rth->fl.fl4_src	= oldflp->fl4_src;
	rth->fl.oif	= oldflp->oif;
2379
	rth->fl.mark    = oldflp->mark;
L
Linus Torvalds 已提交
2380 2381 2382
	rth->rt_dst	= fl->fl4_dst;
	rth->rt_src	= fl->fl4_src;
	rth->rt_iif	= oldflp->oif ? : dev_out->ifindex;
2383
	/* get references to the devices that are to be hold by the routing
L
Linus Torvalds 已提交
2384 2385 2386 2387 2388 2389 2390 2391
	   cache entry */
	rth->u.dst.dev	= dev_out;
	dev_hold(dev_out);
	rth->idev	= in_dev_get(dev_out);
	rth->rt_gateway = fl->fl4_dst;
	rth->rt_spec_dst= fl->fl4_src;

	rth->u.dst.output=ip_output;
2392
	rth->rt_genid = rt_genid(dev_net(dev_out));
L
Linus Torvalds 已提交
2393 2394 2395 2396 2397 2398 2399 2400 2401

	RT_CACHE_STAT_INC(out_slow_tot);

	if (flags & RTCF_LOCAL) {
		rth->u.dst.input = ip_local_deliver;
		rth->rt_spec_dst = fl->fl4_dst;
	}
	if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
		rth->rt_spec_dst = fl->fl4_src;
2402
		if (flags & RTCF_LOCAL &&
L
Linus Torvalds 已提交
2403 2404 2405 2406 2407 2408 2409
		    !(dev_out->flags & IFF_LOOPBACK)) {
			rth->u.dst.output = ip_mc_output;
			RT_CACHE_STAT_INC(out_slow_mc);
		}
#ifdef CONFIG_IP_MROUTE
		if (res->type == RTN_MULTICAST) {
			if (IN_DEV_MFORWARD(in_dev) &&
2410
			    !ipv4_is_local_multicast(oldflp->fl4_dst)) {
L
Linus Torvalds 已提交
2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429
				rth->u.dst.input = ip_mr_input;
				rth->u.dst.output = ip_mc_output;
			}
		}
#endif
	}

	rt_set_nexthop(rth, res, 0);

	rth->rt_flags = flags;

	*result = rth;
 cleanup:
	/* release work reference to inet device */
	in_dev_put(in_dev);

	return err;
}

S
Stephen Hemminger 已提交
2430 2431 2432 2433 2434 2435
static int ip_mkroute_output(struct rtable **rp,
			     struct fib_result *res,
			     const struct flowi *fl,
			     const struct flowi *oldflp,
			     struct net_device *dev_out,
			     unsigned flags)
L
Linus Torvalds 已提交
2436
{
C
Chuck Short 已提交
2437
	struct rtable *rth = NULL;
L
Linus Torvalds 已提交
2438 2439 2440
	int err = __mkroute_output(&rth, res, fl, oldflp, dev_out, flags);
	unsigned hash;
	if (err == 0) {
2441
		hash = rt_hash(oldflp->fl4_dst, oldflp->fl4_src, oldflp->oif,
2442
			       rt_genid(dev_net(dev_out)));
L
Linus Torvalds 已提交
2443 2444
		err = rt_intern_hash(hash, rth, rp);
	}
2445

L
Linus Torvalds 已提交
2446 2447 2448 2449 2450 2451 2452
	return err;
}

/*
 * Major route resolver routine.
 */

2453 2454
static int ip_route_output_slow(struct net *net, struct rtable **rp,
				const struct flowi *oldflp)
L
Linus Torvalds 已提交
2455 2456 2457 2458 2459 2460 2461 2462 2463 2464
{
	u32 tos	= RT_FL_TOS(oldflp);
	struct flowi fl = { .nl_u = { .ip4_u =
				      { .daddr = oldflp->fl4_dst,
					.saddr = oldflp->fl4_src,
					.tos = tos & IPTOS_RT_MASK,
					.scope = ((tos & RTO_ONLINK) ?
						  RT_SCOPE_LINK :
						  RT_SCOPE_UNIVERSE),
				      } },
2465
			    .mark = oldflp->mark,
2466
			    .iif = net->loopback_dev->ifindex,
L
Linus Torvalds 已提交
2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481
			    .oif = oldflp->oif };
	struct fib_result res;
	unsigned flags = 0;
	struct net_device *dev_out = NULL;
	int free_res = 0;
	int err;


	res.fi		= NULL;
#ifdef CONFIG_IP_MULTIPLE_TABLES
	res.r		= NULL;
#endif

	if (oldflp->fl4_src) {
		err = -EINVAL;
2482
		if (ipv4_is_multicast(oldflp->fl4_src) ||
2483
		    ipv4_is_lbcast(oldflp->fl4_src) ||
2484
		    ipv4_is_zeronet(oldflp->fl4_src))
L
Linus Torvalds 已提交
2485 2486 2487 2488
			goto out;

		/* I removed check for oif == dev_out->oif here.
		   It was wrong for two reasons:
2489 2490
		   1. ip_dev_find(net, saddr) can return wrong iface, if saddr
		      is assigned to multiple interfaces.
L
Linus Torvalds 已提交
2491 2492 2493 2494
		   2. Moreover, we are allowed to send packets with saddr
		      of another iface. --ANK
		 */

2495
		if (oldflp->oif == 0
2496 2497
		    && (ipv4_is_multicast(oldflp->fl4_dst) ||
			oldflp->fl4_dst == htonl(0xFFFFFFFF))) {
2498 2499 2500 2501 2502
			/* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
			dev_out = ip_dev_find(net, oldflp->fl4_src);
			if (dev_out == NULL)
				goto out;

L
Linus Torvalds 已提交
2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520
			/* 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.
			 */

			fl.oif = dev_out->ifindex;
			goto make_route;
		}
2521 2522 2523 2524 2525 2526

		if (!(oldflp->flags & FLOWI_FLAG_ANYSRC)) {
			/* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
			dev_out = ip_dev_find(net, oldflp->fl4_src);
			if (dev_out == NULL)
				goto out;
L
Linus Torvalds 已提交
2527
			dev_put(dev_out);
2528 2529
			dev_out = NULL;
		}
L
Linus Torvalds 已提交
2530 2531 2532 2533
	}


	if (oldflp->oif) {
2534
		dev_out = dev_get_by_index(net, oldflp->oif);
L
Linus Torvalds 已提交
2535 2536 2537
		err = -ENODEV;
		if (dev_out == NULL)
			goto out;
2538 2539 2540

		/* RACE: Check return value of inet_select_addr instead. */
		if (__in_dev_get_rtnl(dev_out) == NULL) {
L
Linus Torvalds 已提交
2541 2542 2543 2544
			dev_put(dev_out);
			goto out;	/* Wrong error code */
		}

2545 2546
		if (ipv4_is_local_multicast(oldflp->fl4_dst) ||
		    oldflp->fl4_dst == htonl(0xFFFFFFFF)) {
L
Linus Torvalds 已提交
2547 2548 2549 2550 2551 2552
			if (!fl.fl4_src)
				fl.fl4_src = inet_select_addr(dev_out, 0,
							      RT_SCOPE_LINK);
			goto make_route;
		}
		if (!fl.fl4_src) {
2553
			if (ipv4_is_multicast(oldflp->fl4_dst))
L
Linus Torvalds 已提交
2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567
				fl.fl4_src = inet_select_addr(dev_out, 0,
							      fl.fl4_scope);
			else if (!oldflp->fl4_dst)
				fl.fl4_src = inet_select_addr(dev_out, 0,
							      RT_SCOPE_HOST);
		}
	}

	if (!fl.fl4_dst) {
		fl.fl4_dst = fl.fl4_src;
		if (!fl.fl4_dst)
			fl.fl4_dst = fl.fl4_src = htonl(INADDR_LOOPBACK);
		if (dev_out)
			dev_put(dev_out);
2568
		dev_out = net->loopback_dev;
L
Linus Torvalds 已提交
2569
		dev_hold(dev_out);
2570
		fl.oif = net->loopback_dev->ifindex;
L
Linus Torvalds 已提交
2571 2572 2573 2574 2575
		res.type = RTN_LOCAL;
		flags |= RTCF_LOCAL;
		goto make_route;
	}

2576
	if (fib_lookup(net, &fl, &res)) {
L
Linus Torvalds 已提交
2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614
		res.fi = NULL;
		if (oldflp->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 (fl.fl4_src == 0)
				fl.fl4_src = inet_select_addr(dev_out, 0,
							      RT_SCOPE_LINK);
			res.type = RTN_UNICAST;
			goto make_route;
		}
		if (dev_out)
			dev_put(dev_out);
		err = -ENETUNREACH;
		goto out;
	}
	free_res = 1;

	if (res.type == RTN_LOCAL) {
		if (!fl.fl4_src)
			fl.fl4_src = fl.fl4_dst;
		if (dev_out)
			dev_put(dev_out);
2615
		dev_out = net->loopback_dev;
L
Linus Torvalds 已提交
2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630
		dev_hold(dev_out);
		fl.oif = dev_out->ifindex;
		if (res.fi)
			fib_info_put(res.fi);
		res.fi = NULL;
		flags |= RTCF_LOCAL;
		goto make_route;
	}

#ifdef CONFIG_IP_ROUTE_MULTIPATH
	if (res.fi->fib_nhs > 1 && fl.oif == 0)
		fib_select_multipath(&fl, &res);
	else
#endif
	if (!res.prefixlen && res.type == RTN_UNICAST && !fl.oif)
2631
		fib_select_default(net, &fl, &res);
L
Linus Torvalds 已提交
2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653

	if (!fl.fl4_src)
		fl.fl4_src = FIB_RES_PREFSRC(res);

	if (dev_out)
		dev_put(dev_out);
	dev_out = FIB_RES_DEV(res);
	dev_hold(dev_out);
	fl.oif = dev_out->ifindex;


make_route:
	err = ip_mkroute_output(rp, &res, &fl, oldflp, dev_out, flags);


	if (free_res)
		fib_res_put(&res);
	if (dev_out)
		dev_put(dev_out);
out:	return err;
}

2654 2655
int __ip_route_output_key(struct net *net, struct rtable **rp,
			  const struct flowi *flp)
L
Linus Torvalds 已提交
2656 2657 2658 2659
{
	unsigned hash;
	struct rtable *rth;

2660 2661 2662
	if (!rt_caching(net))
		goto slow_output;

2663
	hash = rt_hash(flp->fl4_dst, flp->fl4_src, flp->oif, rt_genid(net));
L
Linus Torvalds 已提交
2664 2665 2666

	rcu_read_lock_bh();
	for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
2667
		rth = rcu_dereference(rth->u.dst.rt_next)) {
L
Linus Torvalds 已提交
2668 2669 2670 2671
		if (rth->fl.fl4_dst == flp->fl4_dst &&
		    rth->fl.fl4_src == flp->fl4_src &&
		    rth->fl.iif == 0 &&
		    rth->fl.oif == flp->oif &&
2672
		    rth->fl.mark == flp->mark &&
L
Linus Torvalds 已提交
2673
		    !((rth->fl.fl4_tos ^ flp->fl4_tos) &
2674
			    (IPTOS_RT_MASK | RTO_ONLINK)) &&
2675
		    net_eq(dev_net(rth->u.dst.dev), net) &&
2676
		    !rt_is_expired(rth)) {
2677
			dst_use(&rth->u.dst, jiffies);
L
Linus Torvalds 已提交
2678 2679 2680 2681 2682 2683 2684 2685 2686
			RT_CACHE_STAT_INC(out_hit);
			rcu_read_unlock_bh();
			*rp = rth;
			return 0;
		}
		RT_CACHE_STAT_INC(out_hlist_search);
	}
	rcu_read_unlock_bh();

2687
slow_output:
2688
	return ip_route_output_slow(net, rp, flp);
L
Linus Torvalds 已提交
2689 2690
}

2691 2692
EXPORT_SYMBOL_GPL(__ip_route_output_key);

2693 2694 2695 2696 2697 2698
static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu)
{
}

static struct dst_ops ipv4_dst_blackhole_ops = {
	.family			=	AF_INET,
2699
	.protocol		=	cpu_to_be16(ETH_P_IP),
2700 2701 2702
	.destroy		=	ipv4_dst_destroy,
	.check			=	ipv4_dst_check,
	.update_pmtu		=	ipv4_rt_blackhole_update_pmtu,
2703
	.entries		=	ATOMIC_INIT(0),
2704 2705 2706
};


2707
static int ipv4_dst_blackhole(struct net *net, struct rtable **rp, struct flowi *flp)
2708 2709 2710 2711 2712 2713 2714 2715 2716 2717
{
	struct rtable *ort = *rp;
	struct rtable *rt = (struct rtable *)
		dst_alloc(&ipv4_dst_blackhole_ops);

	if (rt) {
		struct dst_entry *new = &rt->u.dst;

		atomic_set(&new->__refcnt, 1);
		new->__use = 1;
2718 2719
		new->input = dst_discard;
		new->output = dst_discard;
2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730
		memcpy(new->metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));

		new->dev = ort->u.dst.dev;
		if (new->dev)
			dev_hold(new->dev);

		rt->fl = ort->fl;

		rt->idev = ort->idev;
		if (rt->idev)
			in_dev_hold(rt->idev);
2731
		rt->rt_genid = rt_genid(net);
2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750
		rt->rt_flags = ort->rt_flags;
		rt->rt_type = ort->rt_type;
		rt->rt_dst = ort->rt_dst;
		rt->rt_src = ort->rt_src;
		rt->rt_iif = ort->rt_iif;
		rt->rt_gateway = ort->rt_gateway;
		rt->rt_spec_dst = ort->rt_spec_dst;
		rt->peer = ort->peer;
		if (rt->peer)
			atomic_inc(&rt->peer->refcnt);

		dst_free(new);
	}

	dst_release(&(*rp)->u.dst);
	*rp = rt;
	return (rt ? 0 : -ENOMEM);
}

2751 2752
int ip_route_output_flow(struct net *net, struct rtable **rp, struct flowi *flp,
			 struct sock *sk, int flags)
L
Linus Torvalds 已提交
2753 2754 2755
{
	int err;

2756
	if ((err = __ip_route_output_key(net, rp, flp)) != 0)
L
Linus Torvalds 已提交
2757 2758 2759 2760 2761 2762 2763
		return err;

	if (flp->proto) {
		if (!flp->fl4_src)
			flp->fl4_src = (*rp)->rt_src;
		if (!flp->fl4_dst)
			flp->fl4_dst = (*rp)->rt_dst;
A
Alexey Dobriyan 已提交
2764
		err = __xfrm_lookup(net, (struct dst_entry **)rp, flp, sk,
2765
				    flags ? XFRM_LOOKUP_WAIT : 0);
2766
		if (err == -EREMOTE)
2767
			err = ipv4_dst_blackhole(net, rp, flp);
2768 2769

		return err;
L
Linus Torvalds 已提交
2770 2771 2772 2773 2774
	}

	return 0;
}

2775 2776
EXPORT_SYMBOL_GPL(ip_route_output_flow);

2777
int ip_route_output_key(struct net *net, struct rtable **rp, struct flowi *flp)
L
Linus Torvalds 已提交
2778
{
2779
	return ip_route_output_flow(net, rp, flp, NULL, 0);
L
Linus Torvalds 已提交
2780 2781
}

2782 2783
static int rt_fill_info(struct net *net,
			struct sk_buff *skb, u32 pid, u32 seq, int event,
2784
			int nowait, unsigned int flags)
L
Linus Torvalds 已提交
2785
{
2786
	struct rtable *rt = skb->rtable;
L
Linus Torvalds 已提交
2787
	struct rtmsg *r;
2788
	struct nlmsghdr *nlh;
2789 2790
	long expires;
	u32 id = 0, ts = 0, tsage = 0, error;
2791 2792 2793

	nlh = nlmsg_put(skb, pid, seq, event, sizeof(*r), flags);
	if (nlh == NULL)
2794
		return -EMSGSIZE;
2795 2796

	r = nlmsg_data(nlh);
L
Linus Torvalds 已提交
2797 2798 2799 2800 2801
	r->rtm_family	 = AF_INET;
	r->rtm_dst_len	= 32;
	r->rtm_src_len	= 0;
	r->rtm_tos	= rt->fl.fl4_tos;
	r->rtm_table	= RT_TABLE_MAIN;
2802
	NLA_PUT_U32(skb, RTA_TABLE, RT_TABLE_MAIN);
L
Linus Torvalds 已提交
2803 2804 2805 2806 2807 2808
	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;
2809

2810
	NLA_PUT_BE32(skb, RTA_DST, rt->rt_dst);
2811

L
Linus Torvalds 已提交
2812 2813
	if (rt->fl.fl4_src) {
		r->rtm_src_len = 32;
2814
		NLA_PUT_BE32(skb, RTA_SRC, rt->fl.fl4_src);
L
Linus Torvalds 已提交
2815 2816
	}
	if (rt->u.dst.dev)
2817
		NLA_PUT_U32(skb, RTA_OIF, rt->u.dst.dev->ifindex);
L
Linus Torvalds 已提交
2818 2819
#ifdef CONFIG_NET_CLS_ROUTE
	if (rt->u.dst.tclassid)
2820
		NLA_PUT_U32(skb, RTA_FLOW, rt->u.dst.tclassid);
L
Linus Torvalds 已提交
2821 2822
#endif
	if (rt->fl.iif)
2823
		NLA_PUT_BE32(skb, RTA_PREFSRC, rt->rt_spec_dst);
L
Linus Torvalds 已提交
2824
	else if (rt->rt_src != rt->fl.fl4_src)
2825
		NLA_PUT_BE32(skb, RTA_PREFSRC, rt->rt_src);
2826

L
Linus Torvalds 已提交
2827
	if (rt->rt_dst != rt->rt_gateway)
2828
		NLA_PUT_BE32(skb, RTA_GATEWAY, rt->rt_gateway);
2829

L
Linus Torvalds 已提交
2830
	if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
2831 2832
		goto nla_put_failure;

2833 2834
	error = rt->u.dst.error;
	expires = rt->u.dst.expires ? rt->u.dst.expires - jiffies : 0;
L
Linus Torvalds 已提交
2835
	if (rt->peer) {
2836
		id = rt->peer->ip_id_count;
L
Linus Torvalds 已提交
2837
		if (rt->peer->tcp_ts_stamp) {
2838
			ts = rt->peer->tcp_ts;
2839
			tsage = get_seconds() - rt->peer->tcp_ts_stamp;
L
Linus Torvalds 已提交
2840 2841
		}
	}
2842

L
Linus Torvalds 已提交
2843 2844
	if (rt->fl.iif) {
#ifdef CONFIG_IP_MROUTE
2845
		__be32 dst = rt->rt_dst;
L
Linus Torvalds 已提交
2846

2847
		if (ipv4_is_multicast(dst) && !ipv4_is_local_multicast(dst) &&
2848 2849
		    IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
			int err = ipmr_get_route(net, skb, r, nowait);
L
Linus Torvalds 已提交
2850 2851 2852 2853
			if (err <= 0) {
				if (!nowait) {
					if (err == 0)
						return 0;
2854
					goto nla_put_failure;
L
Linus Torvalds 已提交
2855 2856
				} else {
					if (err == -EMSGSIZE)
2857
						goto nla_put_failure;
2858
					error = err;
L
Linus Torvalds 已提交
2859 2860 2861 2862
				}
			}
		} else
#endif
2863
			NLA_PUT_U32(skb, RTA_IIF, rt->fl.iif);
L
Linus Torvalds 已提交
2864 2865
	}

2866 2867 2868
	if (rtnl_put_cacheinfo(skb, &rt->u.dst, id, ts, tsage,
			       expires, error) < 0)
		goto nla_put_failure;
2869 2870

	return nlmsg_end(skb, nlh);
L
Linus Torvalds 已提交
2871

2872
nla_put_failure:
2873 2874
	nlmsg_cancel(skb, nlh);
	return -EMSGSIZE;
L
Linus Torvalds 已提交
2875 2876
}

2877
static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
L
Linus Torvalds 已提交
2878
{
2879
	struct net *net = sock_net(in_skb->sk);
2880 2881
	struct rtmsg *rtm;
	struct nlattr *tb[RTA_MAX+1];
L
Linus Torvalds 已提交
2882
	struct rtable *rt = NULL;
A
Al Viro 已提交
2883 2884 2885
	__be32 dst = 0;
	__be32 src = 0;
	u32 iif;
2886
	int err;
L
Linus Torvalds 已提交
2887 2888
	struct sk_buff *skb;

2889 2890 2891 2892 2893 2894
	err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv4_policy);
	if (err < 0)
		goto errout;

	rtm = nlmsg_data(nlh);

L
Linus Torvalds 已提交
2895
	skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2896 2897 2898 2899
	if (skb == NULL) {
		err = -ENOBUFS;
		goto errout;
	}
L
Linus Torvalds 已提交
2900 2901 2902 2903

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

	/* Bugfix: need to give ip_route_input enough of an IP header to not gag. */
2908
	ip_hdr(skb)->protocol = IPPROTO_ICMP;
L
Linus Torvalds 已提交
2909 2910
	skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));

2911 2912
	src = tb[RTA_SRC] ? nla_get_be32(tb[RTA_SRC]) : 0;
	dst = tb[RTA_DST] ? nla_get_be32(tb[RTA_DST]) : 0;
2913
	iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
L
Linus Torvalds 已提交
2914 2915

	if (iif) {
2916 2917
		struct net_device *dev;

2918
		dev = __dev_get_by_index(net, iif);
2919 2920 2921 2922 2923
		if (dev == NULL) {
			err = -ENODEV;
			goto errout_free;
		}

L
Linus Torvalds 已提交
2924 2925 2926 2927 2928
		skb->protocol	= htons(ETH_P_IP);
		skb->dev	= dev;
		local_bh_disable();
		err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
		local_bh_enable();
2929

2930
		rt = skb->rtable;
2931
		if (err == 0 && rt->u.dst.error)
L
Linus Torvalds 已提交
2932 2933
			err = -rt->u.dst.error;
	} else {
2934 2935 2936 2937 2938 2939 2940 2941 2942 2943
		struct flowi fl = {
			.nl_u = {
				.ip4_u = {
					.daddr = dst,
					.saddr = src,
					.tos = rtm->rtm_tos,
				},
			},
			.oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0,
		};
2944
		err = ip_route_output_key(net, &rt, &fl);
L
Linus Torvalds 已提交
2945
	}
2946

L
Linus Torvalds 已提交
2947
	if (err)
2948
		goto errout_free;
L
Linus Torvalds 已提交
2949

2950
	skb->rtable = rt;
L
Linus Torvalds 已提交
2951 2952 2953
	if (rtm->rtm_flags & RTM_F_NOTIFY)
		rt->rt_flags |= RTCF_NOTIFY;

2954
	err = rt_fill_info(net, skb, NETLINK_CB(in_skb).pid, nlh->nlmsg_seq,
2955
			   RTM_NEWROUTE, 0, 0);
2956 2957
	if (err <= 0)
		goto errout_free;
L
Linus Torvalds 已提交
2958

2959
	err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).pid);
2960
errout:
2961
	return err;
L
Linus Torvalds 已提交
2962

2963
errout_free:
L
Linus Torvalds 已提交
2964
	kfree_skb(skb);
2965
	goto errout;
L
Linus Torvalds 已提交
2966 2967 2968 2969 2970 2971 2972
}

int ip_rt_dump(struct sk_buff *skb,  struct netlink_callback *cb)
{
	struct rtable *rt;
	int h, s_h;
	int idx, s_idx;
2973 2974
	struct net *net;

2975
	net = sock_net(skb->sk);
L
Linus Torvalds 已提交
2976 2977

	s_h = cb->args[0];
2978 2979
	if (s_h < 0)
		s_h = 0;
L
Linus Torvalds 已提交
2980
	s_idx = idx = cb->args[1];
2981 2982 2983
	for (h = s_h; h <= rt_hash_mask; h++, s_idx = 0) {
		if (!rt_hash_table[h].chain)
			continue;
L
Linus Torvalds 已提交
2984 2985
		rcu_read_lock_bh();
		for (rt = rcu_dereference(rt_hash_table[h].chain), idx = 0; rt;
2986
		     rt = rcu_dereference(rt->u.dst.rt_next), idx++) {
2987
			if (!net_eq(dev_net(rt->u.dst.dev), net) || idx < s_idx)
L
Linus Torvalds 已提交
2988
				continue;
2989
			if (rt_is_expired(rt))
2990
				continue;
L
Linus Torvalds 已提交
2991
			skb->dst = dst_clone(&rt->u.dst);
2992
			if (rt_fill_info(net, skb, NETLINK_CB(cb->skb).pid,
2993
					 cb->nlh->nlmsg_seq, RTM_NEWROUTE,
2994
					 1, NLM_F_MULTI) <= 0) {
L
Linus Torvalds 已提交
2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011
				dst_release(xchg(&skb->dst, NULL));
				rcu_read_unlock_bh();
				goto done;
			}
			dst_release(xchg(&skb->dst, NULL));
		}
		rcu_read_unlock_bh();
	}

done:
	cb->args[0] = h;
	cb->args[1] = idx;
	return skb->len;
}

void ip_rt_multicast_event(struct in_device *in_dev)
{
3012
	rt_cache_flush(dev_net(in_dev->dev), 0);
L
Linus Torvalds 已提交
3013 3014 3015
}

#ifdef CONFIG_SYSCTL
3016
static int ipv4_sysctl_rtcache_flush(ctl_table *__ctl, int write,
L
Linus Torvalds 已提交
3017 3018 3019 3020
					struct file *filp, void __user *buffer,
					size_t *lenp, loff_t *ppos)
{
	if (write) {
3021
		int flush_delay;
3022
		ctl_table ctl;
3023
		struct net *net;
3024

3025 3026 3027
		memcpy(&ctl, __ctl, sizeof(ctl));
		ctl.data = &flush_delay;
		proc_dointvec(&ctl, write, filp, buffer, lenp, ppos);
3028

3029
		net = (struct net *)__ctl->extra1;
3030
		rt_cache_flush(net, flush_delay);
L
Linus Torvalds 已提交
3031
		return 0;
3032
	}
L
Linus Torvalds 已提交
3033 3034 3035 3036 3037 3038 3039 3040

	return -EINVAL;
}

static int ipv4_sysctl_rtcache_flush_strategy(ctl_table *table,
						void __user *oldval,
						size_t __user *oldlenp,
						void __user *newval,
3041
						size_t newlen)
L
Linus Torvalds 已提交
3042 3043
{
	int delay;
3044
	struct net *net;
L
Linus Torvalds 已提交
3045 3046 3047
	if (newlen != sizeof(int))
		return -EINVAL;
	if (get_user(delay, (int __user *)newval))
3048
		return -EFAULT;
3049 3050
	net = (struct net *)table->extra1;
	rt_cache_flush(net, delay);
L
Linus Torvalds 已提交
3051 3052 3053
	return 0;
}

3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105
static void rt_secret_reschedule(int old)
{
	struct net *net;
	int new = ip_rt_secret_interval;
	int diff = new - old;

	if (!diff)
		return;

	rtnl_lock();
	for_each_net(net) {
		int deleted = del_timer_sync(&net->ipv4.rt_secret_timer);

		if (!new)
			continue;

		if (deleted) {
			long time = net->ipv4.rt_secret_timer.expires - jiffies;

			if (time <= 0 || (time += diff) <= 0)
				time = 0;

			net->ipv4.rt_secret_timer.expires = time;
		} else
			net->ipv4.rt_secret_timer.expires = new;

		net->ipv4.rt_secret_timer.expires += jiffies;
		add_timer(&net->ipv4.rt_secret_timer);
	}
	rtnl_unlock();
}

static int ipv4_sysctl_rt_secret_interval(ctl_table *ctl, int write,
					  struct file *filp,
					  void __user *buffer, size_t *lenp,
					  loff_t *ppos)
{
	int old = ip_rt_secret_interval;
	int ret = proc_dointvec_jiffies(ctl, write, filp, buffer, lenp, ppos);

	rt_secret_reschedule(old);

	return ret;
}

static int ipv4_sysctl_rt_secret_interval_strategy(ctl_table *table,
						   void __user *oldval,
						   size_t __user *oldlenp,
						   void __user *newval,
						   size_t newlen)
{
	int old = ip_rt_secret_interval;
A
Alexey Dobriyan 已提交
3106
	int ret = sysctl_jiffies(table, oldval, oldlenp, newval, newlen);
3107 3108 3109 3110 3111 3112

	rt_secret_reschedule(old);

	return ret;
}

A
Al Viro 已提交
3113
static ctl_table ipv4_route_table[] = {
L
Linus Torvalds 已提交
3114 3115 3116 3117 3118 3119
	{
		.ctl_name	= NET_IPV4_ROUTE_GC_THRESH,
		.procname	= "gc_thresh",
		.data		= &ipv4_dst_ops.gc_thresh,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3120
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3121 3122 3123 3124 3125 3126 3127
	},
	{
		.ctl_name	= NET_IPV4_ROUTE_MAX_SIZE,
		.procname	= "max_size",
		.data		= &ip_rt_max_size,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3128
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3129 3130 3131
	},
	{
		/*  Deprecated. Use gc_min_interval_ms */
3132

L
Linus Torvalds 已提交
3133 3134 3135 3136 3137
		.ctl_name	= NET_IPV4_ROUTE_GC_MIN_INTERVAL,
		.procname	= "gc_min_interval",
		.data		= &ip_rt_gc_min_interval,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3138 3139
		.proc_handler	= proc_dointvec_jiffies,
		.strategy	= sysctl_jiffies,
L
Linus Torvalds 已提交
3140 3141 3142 3143 3144 3145 3146
	},
	{
		.ctl_name	= NET_IPV4_ROUTE_GC_MIN_INTERVAL_MS,
		.procname	= "gc_min_interval_ms",
		.data		= &ip_rt_gc_min_interval,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3147 3148
		.proc_handler	= proc_dointvec_ms_jiffies,
		.strategy	= sysctl_ms_jiffies,
L
Linus Torvalds 已提交
3149 3150 3151 3152 3153 3154 3155
	},
	{
		.ctl_name	= NET_IPV4_ROUTE_GC_TIMEOUT,
		.procname	= "gc_timeout",
		.data		= &ip_rt_gc_timeout,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3156 3157
		.proc_handler	= proc_dointvec_jiffies,
		.strategy	= sysctl_jiffies,
L
Linus Torvalds 已提交
3158 3159 3160 3161 3162 3163 3164
	},
	{
		.ctl_name	= NET_IPV4_ROUTE_GC_INTERVAL,
		.procname	= "gc_interval",
		.data		= &ip_rt_gc_interval,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3165 3166
		.proc_handler	= proc_dointvec_jiffies,
		.strategy	= sysctl_jiffies,
L
Linus Torvalds 已提交
3167 3168 3169 3170 3171 3172 3173
	},
	{
		.ctl_name	= NET_IPV4_ROUTE_REDIRECT_LOAD,
		.procname	= "redirect_load",
		.data		= &ip_rt_redirect_load,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3174
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3175 3176 3177 3178 3179 3180 3181
	},
	{
		.ctl_name	= NET_IPV4_ROUTE_REDIRECT_NUMBER,
		.procname	= "redirect_number",
		.data		= &ip_rt_redirect_number,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3182
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3183 3184 3185 3186 3187 3188 3189
	},
	{
		.ctl_name	= NET_IPV4_ROUTE_REDIRECT_SILENCE,
		.procname	= "redirect_silence",
		.data		= &ip_rt_redirect_silence,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3190
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3191 3192 3193 3194 3195 3196 3197
	},
	{
		.ctl_name	= NET_IPV4_ROUTE_ERROR_COST,
		.procname	= "error_cost",
		.data		= &ip_rt_error_cost,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3198
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3199 3200 3201 3202 3203 3204 3205
	},
	{
		.ctl_name	= NET_IPV4_ROUTE_ERROR_BURST,
		.procname	= "error_burst",
		.data		= &ip_rt_error_burst,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3206
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3207 3208 3209 3210 3211 3212 3213
	},
	{
		.ctl_name	= NET_IPV4_ROUTE_GC_ELASTICITY,
		.procname	= "gc_elasticity",
		.data		= &ip_rt_gc_elasticity,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3214
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3215 3216 3217 3218 3219 3220 3221
	},
	{
		.ctl_name	= NET_IPV4_ROUTE_MTU_EXPIRES,
		.procname	= "mtu_expires",
		.data		= &ip_rt_mtu_expires,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3222 3223
		.proc_handler	= proc_dointvec_jiffies,
		.strategy	= sysctl_jiffies,
L
Linus Torvalds 已提交
3224 3225 3226 3227 3228 3229 3230
	},
	{
		.ctl_name	= NET_IPV4_ROUTE_MIN_PMTU,
		.procname	= "min_pmtu",
		.data		= &ip_rt_min_pmtu,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3231
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3232 3233 3234 3235 3236 3237 3238
	},
	{
		.ctl_name	= NET_IPV4_ROUTE_MIN_ADVMSS,
		.procname	= "min_adv_mss",
		.data		= &ip_rt_min_advmss,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3239
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
3240 3241 3242 3243 3244 3245 3246
	},
	{
		.ctl_name	= NET_IPV4_ROUTE_SECRET_INTERVAL,
		.procname	= "secret_interval",
		.data		= &ip_rt_secret_interval,
		.maxlen		= sizeof(int),
		.mode		= 0644,
A
Alexey Dobriyan 已提交
3247 3248
		.proc_handler	= ipv4_sysctl_rt_secret_interval,
		.strategy	= ipv4_sysctl_rt_secret_interval_strategy,
L
Linus Torvalds 已提交
3249 3250 3251
	},
	{ .ctl_name = 0 }
};
3252

A
Al Viro 已提交
3253 3254 3255 3256 3257
static struct ctl_table empty[1];

static struct ctl_table ipv4_skeleton[] =
{
	{ .procname = "route", .ctl_name = NET_IPV4_ROUTE,
H
Hugh Dickins 已提交
3258
	  .mode = 0555, .child = ipv4_route_table},
A
Al Viro 已提交
3259
	{ .procname = "neigh", .ctl_name = NET_IPV4_NEIGH,
H
Hugh Dickins 已提交
3260
	  .mode = 0555, .child = empty},
A
Al Viro 已提交
3261 3262 3263 3264
	{ }
};

static __net_initdata struct ctl_path ipv4_path[] = {
3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275
	{ .procname = "net", .ctl_name = CTL_NET, },
	{ .procname = "ipv4", .ctl_name = NET_IPV4, },
	{ },
};

static struct ctl_table ipv4_route_flush_table[] = {
	{
		.ctl_name 	= NET_IPV4_ROUTE_FLUSH,
		.procname	= "flush",
		.maxlen		= sizeof(int),
		.mode		= 0200,
A
Alexey Dobriyan 已提交
3276 3277
		.proc_handler	= ipv4_sysctl_rtcache_flush,
		.strategy	= ipv4_sysctl_rtcache_flush_strategy,
3278 3279 3280 3281
	},
	{ .ctl_name = 0 },
};

A
Al Viro 已提交
3282 3283 3284 3285 3286 3287 3288
static __net_initdata struct ctl_path ipv4_route_path[] = {
	{ .procname = "net", .ctl_name = CTL_NET, },
	{ .procname = "ipv4", .ctl_name = NET_IPV4, },
	{ .procname = "route", .ctl_name = NET_IPV4_ROUTE, },
	{ },
};

3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327
static __net_init int sysctl_route_net_init(struct net *net)
{
	struct ctl_table *tbl;

	tbl = ipv4_route_flush_table;
	if (net != &init_net) {
		tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
		if (tbl == NULL)
			goto err_dup;
	}
	tbl[0].extra1 = net;

	net->ipv4.route_hdr =
		register_net_sysctl_table(net, ipv4_route_path, tbl);
	if (net->ipv4.route_hdr == NULL)
		goto err_reg;
	return 0;

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

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

static __net_initdata struct pernet_operations sysctl_route_ops = {
	.init = sysctl_route_net_init,
	.exit = sysctl_route_net_exit,
};
L
Linus Torvalds 已提交
3328 3329
#endif

3330 3331 3332

static __net_init int rt_secret_timer_init(struct net *net)
{
3333 3334 3335 3336
	atomic_set(&net->ipv4.rt_genid,
			(int) ((num_physpages ^ (num_physpages>>8)) ^
			(jiffies ^ (jiffies >> 7))));

3337 3338 3339 3340
	net->ipv4.rt_secret_timer.function = rt_secret_rebuild;
	net->ipv4.rt_secret_timer.data = (unsigned long)net;
	init_timer_deferrable(&net->ipv4.rt_secret_timer);

3341 3342 3343 3344 3345 3346
	if (ip_rt_secret_interval) {
		net->ipv4.rt_secret_timer.expires =
			jiffies + net_random() % ip_rt_secret_interval +
			ip_rt_secret_interval;
		add_timer(&net->ipv4.rt_secret_timer);
	}
3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360
	return 0;
}

static __net_exit void rt_secret_timer_exit(struct net *net)
{
	del_timer_sync(&net->ipv4.rt_secret_timer);
}

static __net_initdata struct pernet_operations rt_secret_timer_ops = {
	.init = rt_secret_timer_init,
	.exit = rt_secret_timer_exit,
};


L
Linus Torvalds 已提交
3361
#ifdef CONFIG_NET_CLS_ROUTE
3362
struct ip_rt_acct *ip_rt_acct __read_mostly;
L
Linus Torvalds 已提交
3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376
#endif /* CONFIG_NET_CLS_ROUTE */

static __initdata unsigned long rhash_entries;
static int __init set_rhash_entries(char *str)
{
	if (!str)
		return 0;
	rhash_entries = simple_strtoul(str, &str, 0);
	return 1;
}
__setup("rhash_entries=", set_rhash_entries);

int __init ip_rt_init(void)
{
3377
	int rc = 0;
L
Linus Torvalds 已提交
3378 3379

#ifdef CONFIG_NET_CLS_ROUTE
3380
	ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
L
Linus Torvalds 已提交
3381 3382 3383 3384
	if (!ip_rt_acct)
		panic("IP: failed to allocate ip_rt_acct\n");
#endif

A
Alexey Dobriyan 已提交
3385 3386
	ipv4_dst_ops.kmem_cachep =
		kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
3387
				  SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
L
Linus Torvalds 已提交
3388

3389 3390
	ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;

3391 3392 3393 3394 3395
	rt_hash_table = (struct rt_hash_bucket *)
		alloc_large_system_hash("IP route cache",
					sizeof(struct rt_hash_bucket),
					rhash_entries,
					(num_physpages >= 128 * 1024) ?
3396
					15 : 17,
3397
					0,
3398 3399 3400
					&rt_hash_log,
					&rt_hash_mask,
					0);
3401 3402
	memset(rt_hash_table, 0, (rt_hash_mask + 1) * sizeof(struct rt_hash_bucket));
	rt_hash_lock_init();
L
Linus Torvalds 已提交
3403 3404 3405 3406 3407 3408 3409 3410 3411 3412

	ipv4_dst_ops.gc_thresh = (rt_hash_mask + 1);
	ip_rt_max_size = (rt_hash_mask + 1) * 16;

	devinet_init();
	ip_fib_init();

	/* All the timers, started at system startup tend
	   to synchronize. Perturb it a bit.
	 */
3413 3414
	schedule_delayed_work(&expires_work,
		net_random() % ip_rt_gc_interval + ip_rt_gc_interval);
L
Linus Torvalds 已提交
3415

3416 3417
	if (register_pernet_subsys(&rt_secret_timer_ops))
		printk(KERN_ERR "Unable to setup rt_secret_timer\n");
L
Linus Torvalds 已提交
3418

3419
	if (ip_rt_proc_init())
3420
		printk(KERN_ERR "Unable to create route proc files\n");
L
Linus Torvalds 已提交
3421 3422 3423 3424
#ifdef CONFIG_XFRM
	xfrm_init();
	xfrm4_init();
#endif
3425 3426
	rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL);

3427 3428 3429
#ifdef CONFIG_SYSCTL
	register_pernet_subsys(&sysctl_route_ops);
#endif
L
Linus Torvalds 已提交
3430 3431 3432
	return rc;
}

3433
#ifdef CONFIG_SYSCTL
A
Al Viro 已提交
3434 3435 3436 3437 3438 3439
/*
 * We really need to sanitize the damn ipv4 init order, then all
 * this nonsense will go away.
 */
void __init ip_static_sysctl_init(void)
{
A
Al Viro 已提交
3440
	register_sysctl_paths(ipv4_path, ipv4_skeleton);
A
Al Viro 已提交
3441
}
3442
#endif
A
Al Viro 已提交
3443

L
Linus Torvalds 已提交
3444 3445 3446
EXPORT_SYMBOL(__ip_select_ident);
EXPORT_SYMBOL(ip_route_input);
EXPORT_SYMBOL(ip_route_output_key);