projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
net: Abstract dst->neighbour accesses behind helpers.
[deliverable/linux.git] / net / ipv4 / route.c
CommitLineData
1da177e4
LT		 1/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * ROUTE - implementation of the IP router.
7 *
02c30a84 8 * Authors: Ross Biro
1da177e4
LT		 9 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
10 * Alan Cox, <gw4pts@gw4pts.ampr.org>
11 * Linus Torvalds, <Linus.Torvalds@helsinki.fi>
12 * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
13 *
14 * Fixes:
15 * Alan Cox : Verify area fixes.
16 * Alan Cox : cli() protects routing changes
17 * Rui Oliveira : ICMP routing table updates
18 * (rco@di.uminho.pt) Routing table insertion and update
19 * Linus Torvalds : Rewrote bits to be sensible
20 * Alan Cox : Added BSD route gw semantics
e905a9ed 21 * Alan Cox : Super /proc >4K
1da177e4
LT		 22 * Alan Cox : MTU in route table
23 * Alan Cox : MSS actually. Also added the window
24 * clamper.
25 * Sam Lantinga : Fixed route matching in rt_del()
26 * Alan Cox : Routing cache support.
27 * Alan Cox : Removed compatibility cruft.
28 * Alan Cox : RTF_REJECT support.
29 * Alan Cox : TCP irtt support.
30 * Jonathan Naylor : Added Metric support.
31 * Miquel van Smoorenburg : BSD API fixes.
32 * Miquel van Smoorenburg : Metrics.
33 * Alan Cox : Use __u32 properly
34 * Alan Cox : Aligned routing errors more closely with BSD
35 * our system is still very different.
36 * Alan Cox : Faster /proc handling
37 * Alexey Kuznetsov : Massive rework to support tree based routing,
38 * routing caches and better behaviour.
e905a9ed 39 *
1da177e4
LT		 40 * Olaf Erb : irtt wasn't being copied right.
41 * Bjorn Ekwall : Kerneld route support.
42 * Alan Cox : Multicast fixed (I hope)
43 * Pavel Krauz : Limited broadcast fixed
44 * Mike McLagan : Routing by source
45 * Alexey Kuznetsov : End of old history. Split to fib.c and
46 * route.c and rewritten from scratch.
47 * Andi Kleen : Load-limit warning messages.
48 * Vitaly E. Lavrov : Transparent proxy revived after year coma.
49 * Vitaly E. Lavrov : Race condition in ip_route_input_slow.
50 * Tobias Ringstrom : Uninitialized res.type in ip_route_output_slow.
51 * Vladimir V. Ivanov : IP rule info (flowid) is really useful.
52 * Marc Boucher : routing by fwmark
53 * Robert Olsson : Added rt_cache statistics
54 * Arnaldo C. Melo : Convert proc stuff to seq_file
bb1d23b0 55 * Eric Dumazet : hashed spinlocks and rt_check_expire() fixes.
cef2685e
IS		 56 * Ilia Sotnikov : Ignore TOS on PMTUD and Redirect
57 * Ilia Sotnikov : Removed TOS from hash calculations
1da177e4
LT		 58 *
59 * This program is free software; you can redistribute it and/or
60 * modify it under the terms of the GNU General Public License
61 * as published by the Free Software Foundation; either version
62 * 2 of the License, or (at your option) any later version.
63 */
64
1da177e4
LT		 65#include <linux/module.h>
66#include <asm/uaccess.h>
67#include <asm/system.h>
68#include <linux/bitops.h>
69#include <linux/types.h>
70#include <linux/kernel.h>
1da177e4 71#include <linux/mm.h>
424c4b70 72#include <linux/bootmem.h>
1da177e4
LT		 73#include <linux/string.h>
74#include <linux/socket.h>
75#include <linux/sockios.h>
76#include <linux/errno.h>
77#include <linux/in.h>
78#include <linux/inet.h>
79#include <linux/netdevice.h>
80#include <linux/proc_fs.h>
81#include <linux/init.h>
39c90ece 82#include <linux/workqueue.h>
1da177e4 83#include <linux/skbuff.h>
1da177e4
LT		 84#include <linux/inetdevice.h>
85#include <linux/igmp.h>
86#include <linux/pkt_sched.h>
87#include <linux/mroute.h>
88#include <linux/netfilter_ipv4.h>
89#include <linux/random.h>
90#include <linux/jhash.h>
91#include <linux/rcupdate.h>
92#include <linux/times.h>
5a0e3ad6 93#include <linux/slab.h>
352e512c 94#include <net/dst.h>
457c4cbc 95#include <net/net_namespace.h>
1da177e4
LT		 96#include <net/protocol.h>
97#include <net/ip.h>
98#include <net/route.h>
99#include <net/inetpeer.h>
100#include <net/sock.h>
101#include <net/ip_fib.h>
102#include <net/arp.h>
103#include <net/tcp.h>
104#include <net/icmp.h>
105#include <net/xfrm.h>
8d71740c 106#include <net/netevent.h>
63f3444f 107#include <net/rtnetlink.h>
1da177e4
LT		 108#ifdef CONFIG_SYSCTL
109#include <linux/sysctl.h>
110#endif
3769cffb 111#include <net/atmclip.h>
1da177e4 112
68a5e3dd
DM		 113#define RT_FL_TOS(oldflp4) \
114 ((u32)(oldflp4->flowi4_tos & (IPTOS_RT_MASK | RTO_ONLINK)))
1da177e4
LT		 115
116#define IP_MAX_MTU 0xFFF0
117
118#define RT_GC_TIMEOUT (300*HZ)
119
1da177e4 120static int ip_rt_max_size;
817bc4db
SH		 121static int ip_rt_gc_timeout __read_mostly = RT_GC_TIMEOUT;
122static int ip_rt_gc_interval __read_mostly = 60 * HZ;
123static int ip_rt_gc_min_interval __read_mostly = HZ / 2;
124static int ip_rt_redirect_number __read_mostly = 9;
125static int ip_rt_redirect_load __read_mostly = HZ / 50;
126static int ip_rt_redirect_silence __read_mostly = ((HZ / 50) << (9 + 1));
127static int ip_rt_error_cost __read_mostly = HZ;
128static int ip_rt_error_burst __read_mostly = 5 * HZ;
129static int ip_rt_gc_elasticity __read_mostly = 8;
130static int ip_rt_mtu_expires __read_mostly = 10 * 60 * HZ;
131static int ip_rt_min_pmtu __read_mostly = 512 + 20 + 20;
132static int ip_rt_min_advmss __read_mostly = 256;
1080d709 133static int rt_chain_length_max __read_mostly = 20;
1da177e4 134
1da177e4
LT		 135/*
136 * Interface to generic destination cache.
137 */
138
139static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
0dbaee3b 140static unsigned int ipv4_default_advmss(const struct dst_entry *dst);
d33e4553 141static unsigned int ipv4_default_mtu(const struct dst_entry *dst);
1da177e4 142static void ipv4_dst_destroy(struct dst_entry *dst);
1da177e4
LT		 143static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
144static void ipv4_link_failure(struct sk_buff *skb);
145static void ip_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
569d3645 146static int rt_garbage_collect(struct dst_ops *ops);
1da177e4 147
72cdd1d9
ED		 148static void ipv4_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
149 int how)
150{
151}
1da177e4 152
62fa8a84
DM		 153static u32 *ipv4_cow_metrics(struct dst_entry *dst, unsigned long old)
154{
06582540
DM		 155 struct rtable *rt = (struct rtable *) dst;
156 struct inet_peer *peer;
157 u32 *p = NULL;
158
159 if (!rt->peer)
a48eff12 160 rt_bind_peer(rt, rt->rt_dst, 1);
62fa8a84 161
06582540
DM		 162 peer = rt->peer;
163 if (peer) {
62fa8a84
DM		 164 u32 *old_p = __DST_METRICS_PTR(old);
165 unsigned long prev, new;
166
06582540
DM		 167 p = peer->metrics;
168 if (inet_metrics_new(peer))
169 memcpy(p, old_p, sizeof(u32) * RTAX_MAX);
62fa8a84
DM		 170
171 new = (unsigned long) p;
172 prev = cmpxchg(&dst->_metrics, old, new);
173
174 if (prev != old) {
62fa8a84
DM		 175 p = __DST_METRICS_PTR(prev);
176 if (prev & DST_METRICS_READ_ONLY)
177 p = NULL;
178 } else {
62fa8a84
DM		 179 if (rt->fi) {
180 fib_info_put(rt->fi);
181 rt->fi = NULL;
182 }
183 }
184 }
185 return p;
186}
187
1da177e4
LT		 188static struct dst_ops ipv4_dst_ops = {
189 .family = AF_INET,
09640e63 190 .protocol = cpu_to_be16(ETH_P_IP),
1da177e4
LT		 191 .gc = rt_garbage_collect,
192 .check = ipv4_dst_check,
0dbaee3b 193 .default_advmss = ipv4_default_advmss,
d33e4553 194 .default_mtu = ipv4_default_mtu,
62fa8a84 195 .cow_metrics = ipv4_cow_metrics,
1da177e4
LT		 196 .destroy = ipv4_dst_destroy,
197 .ifdown = ipv4_dst_ifdown,
198 .negative_advice = ipv4_negative_advice,
199 .link_failure = ipv4_link_failure,
200 .update_pmtu = ip_rt_update_pmtu,
1ac06e03 201 .local_out = __ip_local_out,
1da177e4
LT		 202};
203
204#define ECN_OR_COST(class) TC_PRIO_##class
205
4839c52b 206const __u8 ip_tos2prio[16] = {
1da177e4 207 TC_PRIO_BESTEFFORT,
4a2b9c37 208 ECN_OR_COST(BESTEFFORT),
1da177e4
LT		 209 TC_PRIO_BESTEFFORT,
210 ECN_OR_COST(BESTEFFORT),
211 TC_PRIO_BULK,
212 ECN_OR_COST(BULK),
213 TC_PRIO_BULK,
214 ECN_OR_COST(BULK),
215 TC_PRIO_INTERACTIVE,
216 ECN_OR_COST(INTERACTIVE),
217 TC_PRIO_INTERACTIVE,
218 ECN_OR_COST(INTERACTIVE),
219 TC_PRIO_INTERACTIVE_BULK,
220 ECN_OR_COST(INTERACTIVE_BULK),
221 TC_PRIO_INTERACTIVE_BULK,
222 ECN_OR_COST(INTERACTIVE_BULK)
223};
224
225
226/*
227 * Route cache.
228 */
229
230/* The locking scheme is rather straight forward:
231 *
232 * 1) Read-Copy Update protects the buckets of the central route hash.
233 * 2) Only writers remove entries, and they hold the lock
234 * as they look at rtable reference counts.
235 * 3) Only readers acquire references to rtable entries,
236 * they do so with atomic increments and with the
237 * lock held.
238 */
239
240struct rt_hash_bucket {
1c31720a 241 struct rtable __rcu *chain;
22c047cc 242};
1080d709 243
8a25d5de
IM		 244#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK) || \
245 defined(CONFIG_PROVE_LOCKING)
22c047cc
ED		 246/*
247 * Instead of using one spinlock for each rt_hash_bucket, we use a table of spinlocks
248 * The size of this table is a power of two and depends on the number of CPUS.
62051200 249 * (on lockdep we have a quite big spinlock_t, so keep the size down there)
22c047cc 250 */
62051200
IM		 251#ifdef CONFIG_LOCKDEP
252# define RT_HASH_LOCK_SZ 256
22c047cc 253#else
62051200
IM		 254# if NR_CPUS >= 32
255# define RT_HASH_LOCK_SZ 4096
256# elif NR_CPUS >= 16
257# define RT_HASH_LOCK_SZ 2048
258# elif NR_CPUS >= 8
259# define RT_HASH_LOCK_SZ 1024
260# elif NR_CPUS >= 4
261# define RT_HASH_LOCK_SZ 512
262# else
263# define RT_HASH_LOCK_SZ 256
264# endif
22c047cc
ED		 265#endif
266
267static spinlock_t *rt_hash_locks;
268# define rt_hash_lock_addr(slot) &rt_hash_locks[(slot) & (RT_HASH_LOCK_SZ - 1)]
1ff1cc20
PE		 269
270static __init void rt_hash_lock_init(void)
271{
272 int i;
273
274 rt_hash_locks = kmalloc(sizeof(spinlock_t) * RT_HASH_LOCK_SZ,
275 GFP_KERNEL);
276 if (!rt_hash_locks)
277 panic("IP: failed to allocate rt_hash_locks\n");
278
279 for (i = 0; i < RT_HASH_LOCK_SZ; i++)
280 spin_lock_init(&rt_hash_locks[i]);
281}
22c047cc
ED		 282#else
283# define rt_hash_lock_addr(slot) NULL
1ff1cc20
PE		 284
285static inline void rt_hash_lock_init(void)
286{
287}
22c047cc 288#endif
1da177e4 289
817bc4db
SH		 290static struct rt_hash_bucket *rt_hash_table __read_mostly;
291static unsigned rt_hash_mask __read_mostly;
292static unsigned int rt_hash_log __read_mostly;
1da177e4 293
2f970d83 294static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
27f39c73 295#define RT_CACHE_STAT_INC(field) __this_cpu_inc(rt_cache_stat.field)
1da177e4 296
b00180de 297static inline unsigned int rt_hash(__be32 daddr, __be32 saddr, int idx,
0eae88f3 298 int genid)
1da177e4 299{
0eae88f3 300 return jhash_3words((__force u32)daddr, (__force u32)saddr,
b00180de 301 idx, genid)
29e75252 302 & rt_hash_mask;
1da177e4
LT		 303}
304
e84f84f2
DL		 305static inline int rt_genid(struct net *net)
306{
307 return atomic_read(&net->ipv4.rt_genid);
308}
309
1da177e4
LT		 310#ifdef CONFIG_PROC_FS
311struct rt_cache_iter_state {
a75e936f 312 struct seq_net_private p;
1da177e4 313 int bucket;
29e75252 314 int genid;
1da177e4
LT		 315};
316
1218854a 317static struct rtable *rt_cache_get_first(struct seq_file *seq)
1da177e4 318{
1218854a 319 struct rt_cache_iter_state *st = seq->private;
1da177e4 320 struct rtable *r = NULL;
1da177e4
LT		 321
322 for (st->bucket = rt_hash_mask; st->bucket >= 0; --st->bucket) {
1c31720a 323 if (!rcu_dereference_raw(rt_hash_table[st->bucket].chain))
a6272665 324 continue;
1da177e4 325 rcu_read_lock_bh();
a898def2 326 r = rcu_dereference_bh(rt_hash_table[st->bucket].chain);
29e75252 327 while (r) {
d8d1f30b 328 if (dev_net(r->dst.dev) == seq_file_net(seq) &&
a75e936f 329 r->rt_genid == st->genid)
29e75252 330 return r;
d8d1f30b 331 r = rcu_dereference_bh(r->dst.rt_next);
29e75252 332 }
1da177e4
LT		 333 rcu_read_unlock_bh();
334 }
29e75252 335 return r;
1da177e4
LT		 336}
337
1218854a 338static struct rtable *__rt_cache_get_next(struct seq_file *seq,
642d6318 339 struct rtable *r)
1da177e4 340{
1218854a 341 struct rt_cache_iter_state *st = seq->private;
a6272665 342
1c31720a 343 r = rcu_dereference_bh(r->dst.rt_next);
1da177e4
LT		 344 while (!r) {
345 rcu_read_unlock_bh();
a6272665
ED		 346 do {
347 if (--st->bucket < 0)
348 return NULL;
1c31720a 349 } while (!rcu_dereference_raw(rt_hash_table[st->bucket].chain));
1da177e4 350 rcu_read_lock_bh();
1c31720a 351 r = rcu_dereference_bh(rt_hash_table[st->bucket].chain);
1da177e4 352 }
1c31720a 353 return r;
1da177e4
LT		 354}
355
1218854a 356static struct rtable *rt_cache_get_next(struct seq_file *seq,
642d6318
DL		 357 struct rtable *r)
358{
1218854a
YH		 359 struct rt_cache_iter_state *st = seq->private;
360 while ((r = __rt_cache_get_next(seq, r)) != NULL) {
d8d1f30b 361 if (dev_net(r->dst.dev) != seq_file_net(seq))
a75e936f 362 continue;
642d6318
DL		 363 if (r->rt_genid == st->genid)
364 break;
365 }
366 return r;
367}
368
1218854a 369static struct rtable *rt_cache_get_idx(struct seq_file *seq, loff_t pos)
1da177e4 370{
1218854a 371 struct rtable *r = rt_cache_get_first(seq);
1da177e4
LT		 372
373 if (r)
1218854a 374 while (pos && (r = rt_cache_get_next(seq, r)))
1da177e4
LT		 375 --pos;
376 return pos ? NULL : r;
377}
378
379static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
380{
29e75252 381 struct rt_cache_iter_state *st = seq->private;
29e75252 382 if (*pos)
1218854a 383 return rt_cache_get_idx(seq, *pos - 1);
e84f84f2 384 st->genid = rt_genid(seq_file_net(seq));
29e75252 385 return SEQ_START_TOKEN;
1da177e4
LT		 386}
387
388static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
389{
29e75252 390 struct rtable *r;
1da177e4
LT		 391
392 if (v == SEQ_START_TOKEN)
1218854a 393 r = rt_cache_get_first(seq);
1da177e4 394 else
1218854a 395 r = rt_cache_get_next(seq, v);
1da177e4
LT		 396 ++*pos;
397 return r;
398}
399
400static void rt_cache_seq_stop(struct seq_file *seq, void *v)
401{
402 if (v && v != SEQ_START_TOKEN)
403 rcu_read_unlock_bh();
404}
405
406static int rt_cache_seq_show(struct seq_file *seq, void *v)
407{
408 if (v == SEQ_START_TOKEN)
409 seq_printf(seq, "%-127s\n",
410 "Iface\tDestination\tGateway \tFlags\t\tRefCnt\tUse\t"
411 "Metric\tSource\t\tMTU\tWindow\tIRTT\tTOS\tHHRef\t"
412 "HHUptod\tSpecDst");
413 else {
414 struct rtable *r = v;
69cce1d1 415 struct neighbour *n;
5e659e4c 416 int len;
1da177e4 417
69cce1d1 418 n = dst_get_neighbour(&r->dst);
0eae88f3
ED		 419 seq_printf(seq, "%s\t%08X\t%08X\t%8X\t%d\t%u\t%d\t"
420 "%08X\t%d\t%u\t%u\t%02X\t%d\t%1d\t%08X%n",
d8d1f30b 421 r->dst.dev ? r->dst.dev->name : "*",
0eae88f3
ED		 422 (__force u32)r->rt_dst,
423 (__force u32)r->rt_gateway,
d8d1f30b
CG		 424 r->rt_flags, atomic_read(&r->dst.__refcnt),
425 r->dst.__use, 0, (__force u32)r->rt_src,
0dbaee3b 426 dst_metric_advmss(&r->dst) + 40,
d8d1f30b
CG		 427 dst_metric(&r->dst, RTAX_WINDOW),
428 (int)((dst_metric(&r->dst, RTAX_RTT) >> 3) +
429 dst_metric(&r->dst, RTAX_RTTVAR)),
475949d8 430 r->rt_key_tos,
f6b72b62 431 -1,
69cce1d1 432 (n && (n->nud_state & NUD_CONNECTED)) ? 1 : 0,
5e659e4c
PE		 433 r->rt_spec_dst, &len);
434
435 seq_printf(seq, "%*s\n", 127 - len, "");
e905a9ed
YH		 436 }
437 return 0;
1da177e4
LT		 438}
439
f690808e 440static const struct seq_operations rt_cache_seq_ops = {
1da177e4
LT		 441 .start = rt_cache_seq_start,
442 .next = rt_cache_seq_next,
443 .stop = rt_cache_seq_stop,
444 .show = rt_cache_seq_show,
445};
446
447static int rt_cache_seq_open(struct inode *inode, struct file *file)
448{
a75e936f 449 return seq_open_net(inode, file, &rt_cache_seq_ops,
cf7732e4 450 sizeof(struct rt_cache_iter_state));
1da177e4
LT		 451}
452
9a32144e 453static const struct file_operations rt_cache_seq_fops = {
1da177e4
LT		 454 .owner = THIS_MODULE,
455 .open = rt_cache_seq_open,
456 .read = seq_read,
457 .llseek = seq_lseek,
a75e936f 458 .release = seq_release_net,
1da177e4
LT		 459};
460
461
462static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
463{
464 int cpu;
465
466 if (*pos == 0)
467 return SEQ_START_TOKEN;
468
0f23174a 469 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
1da177e4
LT		 470 if (!cpu_possible(cpu))
471 continue;
472 *pos = cpu+1;
2f970d83 473 return &per_cpu(rt_cache_stat, cpu);
1da177e4
LT		 474 }
475 return NULL;
476}
477
478static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
479{
480 int cpu;
481
0f23174a 482 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
1da177e4
LT		 483 if (!cpu_possible(cpu))
484 continue;
485 *pos = cpu+1;
2f970d83 486 return &per_cpu(rt_cache_stat, cpu);
1da177e4
LT		 487 }
488 return NULL;
e905a9ed 489
1da177e4
LT		 490}
491
492static void rt_cpu_seq_stop(struct seq_file *seq, void *v)
493{
494
495}
496
497static int rt_cpu_seq_show(struct seq_file *seq, void *v)
498{
499 struct rt_cache_stat *st = v;
500
501 if (v == SEQ_START_TOKEN) {
5bec0039 502 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");
1da177e4
LT		 503 return 0;
504 }
e905a9ed 505
1da177e4
LT		 506 seq_printf(seq,"%08x %08x %08x %08x %08x %08x %08x %08x "
507 " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
fc66f95c 508 dst_entries_get_slow(&ipv4_dst_ops),
1da177e4
LT		 509 st->in_hit,
510 st->in_slow_tot,
511 st->in_slow_mc,
512 st->in_no_route,
513 st->in_brd,
514 st->in_martian_dst,
515 st->in_martian_src,
516
517 st->out_hit,
518 st->out_slow_tot,
e905a9ed 519 st->out_slow_mc,
1da177e4
LT		 520
521 st->gc_total,
522 st->gc_ignored,
523 st->gc_goal_miss,
524 st->gc_dst_overflow,
525 st->in_hlist_search,
526 st->out_hlist_search
527 );
528 return 0;
529}
530
f690808e 531static const struct seq_operations rt_cpu_seq_ops = {
1da177e4
LT		 532 .start = rt_cpu_seq_start,
533 .next = rt_cpu_seq_next,
534 .stop = rt_cpu_seq_stop,
535 .show = rt_cpu_seq_show,
536};
537
538
539static int rt_cpu_seq_open(struct inode *inode, struct file *file)
540{
541 return seq_open(file, &rt_cpu_seq_ops);
542}
543
9a32144e 544static const struct file_operations rt_cpu_seq_fops = {
1da177e4
LT		 545 .owner = THIS_MODULE,
546 .open = rt_cpu_seq_open,
547 .read = seq_read,
548 .llseek = seq_lseek,
549 .release = seq_release,
550};
551
c7066f70 552#ifdef CONFIG_IP_ROUTE_CLASSID
a661c419 553static int rt_acct_proc_show(struct seq_file *m, void *v)
78c686e9 554{
a661c419
AD		 555 struct ip_rt_acct *dst, *src;
556 unsigned int i, j;
557
558 dst = kcalloc(256, sizeof(struct ip_rt_acct), GFP_KERNEL);
559 if (!dst)
560 return -ENOMEM;
561
562 for_each_possible_cpu(i) {
563 src = (struct ip_rt_acct *)per_cpu_ptr(ip_rt_acct, i);
564 for (j = 0; j < 256; j++) {
565 dst[j].o_bytes += src[j].o_bytes;
566 dst[j].o_packets += src[j].o_packets;
567 dst[j].i_bytes += src[j].i_bytes;
568 dst[j].i_packets += src[j].i_packets;
569 }
78c686e9
PE		 570 }
571
a661c419
AD		 572 seq_write(m, dst, 256 * sizeof(struct ip_rt_acct));
573 kfree(dst);
574 return 0;
575}
78c686e9 576
a661c419
AD		 577static int rt_acct_proc_open(struct inode *inode, struct file *file)
578{
579 return single_open(file, rt_acct_proc_show, NULL);
78c686e9 580}
a661c419
AD		 581
582static const struct file_operations rt_acct_proc_fops = {
583 .owner = THIS_MODULE,
584 .open = rt_acct_proc_open,
585 .read = seq_read,
586 .llseek = seq_lseek,
587 .release = single_release,
588};
78c686e9 589#endif
107f1634 590
73b38711 591static int __net_init ip_rt_do_proc_init(struct net *net)
107f1634
PE		 592{
593 struct proc_dir_entry *pde;
594
595 pde = proc_net_fops_create(net, "rt_cache", S_IRUGO,
596 &rt_cache_seq_fops);
597 if (!pde)
598 goto err1;
599
77020720
WC		 600 pde = proc_create("rt_cache", S_IRUGO,
601 net->proc_net_stat, &rt_cpu_seq_fops);
107f1634
PE		 602 if (!pde)
603 goto err2;
604
c7066f70 605#ifdef CONFIG_IP_ROUTE_CLASSID
a661c419 606 pde = proc_create("rt_acct", 0, net->proc_net, &rt_acct_proc_fops);
107f1634
PE		 607 if (!pde)
608 goto err3;
609#endif
610 return 0;
611
c7066f70 612#ifdef CONFIG_IP_ROUTE_CLASSID
107f1634
PE		 613err3:
614 remove_proc_entry("rt_cache", net->proc_net_stat);
615#endif
616err2:
617 remove_proc_entry("rt_cache", net->proc_net);
618err1:
619 return -ENOMEM;
620}
73b38711
DL		 621
622static void __net_exit ip_rt_do_proc_exit(struct net *net)
623{
624 remove_proc_entry("rt_cache", net->proc_net_stat);
625 remove_proc_entry("rt_cache", net->proc_net);
c7066f70 626#ifdef CONFIG_IP_ROUTE_CLASSID
73b38711 627 remove_proc_entry("rt_acct", net->proc_net);
0a931acf 628#endif
73b38711
DL		 629}
630
631static struct pernet_operations ip_rt_proc_ops __net_initdata = {
632 .init = ip_rt_do_proc_init,
633 .exit = ip_rt_do_proc_exit,
634};
635
636static int __init ip_rt_proc_init(void)
637{
638 return register_pernet_subsys(&ip_rt_proc_ops);
639}
640
107f1634 641#else
73b38711 642static inline int ip_rt_proc_init(void)
107f1634
PE		 643{
644 return 0;
645}
1da177e4 646#endif /* CONFIG_PROC_FS */
e905a9ed 647
5969f71d 648static inline void rt_free(struct rtable *rt)
1da177e4 649{
d8d1f30b 650 call_rcu_bh(&rt->dst.rcu_head, dst_rcu_free);
1da177e4
LT		 651}
652
5969f71d 653static inline void rt_drop(struct rtable *rt)
1da177e4 654{
1da177e4 655 ip_rt_put(rt);
d8d1f30b 656 call_rcu_bh(&rt->dst.rcu_head, dst_rcu_free);
1da177e4
LT		 657}
658
5969f71d 659static inline int rt_fast_clean(struct rtable *rth)
1da177e4
LT		 660{
661 /* Kill broadcast/multicast entries very aggresively, if they
662 collide in hash table with more useful entries */
663 return (rth->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST)) &&
c7537967 664 rt_is_input_route(rth) && rth->dst.rt_next;
1da177e4
LT		 665}
666
5969f71d 667static inline int rt_valuable(struct rtable *rth)
1da177e4
LT		 668{
669 return (rth->rt_flags & (RTCF_REDIRECTED | RTCF_NOTIFY)) ||
2c8cec5c 670 (rth->peer && rth->peer->pmtu_expires);
1da177e4
LT		 671}
672
673static int rt_may_expire(struct rtable *rth, unsigned long tmo1, unsigned long tmo2)
674{
675 unsigned long age;
676 int ret = 0;
677
d8d1f30b 678 if (atomic_read(&rth->dst.__refcnt))
1da177e4
LT		 679 goto out;
680
d8d1f30b 681 age = jiffies - rth->dst.lastuse;
1da177e4
LT		 682 if ((age <= tmo1 && !rt_fast_clean(rth)) ||
683 (age <= tmo2 && rt_valuable(rth)))
684 goto out;
685 ret = 1;
686out: return ret;
687}
688
689/* Bits of score are:
690 * 31: very valuable
691 * 30: not quite useless
692 * 29..0: usage counter
693 */
694static inline u32 rt_score(struct rtable *rt)
695{
d8d1f30b 696 u32 score = jiffies - rt->dst.lastuse;
1da177e4
LT		 697
698 score = ~score & ~(3<<30);
699
700 if (rt_valuable(rt))
701 score |= (1<<31);
702
c7537967 703 if (rt_is_output_route(rt) ||
1da177e4
LT		 704 !(rt->rt_flags & (RTCF_BROADCAST|RTCF_MULTICAST|RTCF_LOCAL)))
705 score |= (1<<30);
706
707 return score;
708}
709
1080d709
NH		 710static inline bool rt_caching(const struct net *net)
711{
712 return net->ipv4.current_rt_cache_rebuild_count <=
713 net->ipv4.sysctl_rt_cache_rebuild_count;
714}
715
5e2b61f7
DM		 716static inline bool compare_hash_inputs(const struct rtable *rt1,
717 const struct rtable *rt2)
1080d709 718{
5e2b61f7
DM		 719 return ((((__force u32)rt1->rt_key_dst ^ (__force u32)rt2->rt_key_dst) |
720 ((__force u32)rt1->rt_key_src ^ (__force u32)rt2->rt_key_src) |
721 (rt1->rt_iif ^ rt2->rt_iif)) == 0);
1080d709
NH		 722}
723
5e2b61f7 724static inline int compare_keys(struct rtable *rt1, struct rtable *rt2)
1da177e4 725{
5e2b61f7
DM		 726 return (((__force u32)rt1->rt_key_dst ^ (__force u32)rt2->rt_key_dst) |
727 ((__force u32)rt1->rt_key_src ^ (__force u32)rt2->rt_key_src) |
728 (rt1->rt_mark ^ rt2->rt_mark) |
475949d8 729 (rt1->rt_key_tos ^ rt2->rt_key_tos) |
5e2b61f7
DM		 730 (rt1->rt_oif ^ rt2->rt_oif) |
731 (rt1->rt_iif ^ rt2->rt_iif)) == 0;
1da177e4
LT		 732}
733
b5921910
DL		 734static inline int compare_netns(struct rtable *rt1, struct rtable *rt2)
735{
d8d1f30b 736 return net_eq(dev_net(rt1->dst.dev), dev_net(rt2->dst.dev));
b5921910
DL		 737}
738
e84f84f2
DL		 739static inline int rt_is_expired(struct rtable *rth)
740{
d8d1f30b 741 return rth->rt_genid != rt_genid(dev_net(rth->dst.dev));
e84f84f2
DL		 742}
743
beb659bd
ED		 744/*
745 * Perform a full scan of hash table and free all entries.
746 * Can be called by a softirq or a process.
747 * In the later case, we want to be reschedule if necessary
748 */
6561a3b1 749static void rt_do_flush(struct net *net, int process_context)
beb659bd
ED		 750{
751 unsigned int i;
752 struct rtable *rth, *next;
753
754 for (i = 0; i <= rt_hash_mask; i++) {
6561a3b1
DM		 755 struct rtable __rcu **pprev;
756 struct rtable *list;
757
beb659bd
ED		 758 if (process_context && need_resched())
759 cond_resched();
1c31720a 760 rth = rcu_dereference_raw(rt_hash_table[i].chain);
beb659bd
ED		 761 if (!rth)
762 continue;
763
764 spin_lock_bh(rt_hash_lock_addr(i));
32cb5b4e 765
6561a3b1
DM		 766 list = NULL;
767 pprev = &rt_hash_table[i].chain;
768 rth = rcu_dereference_protected(*pprev,
1c31720a 769 lockdep_is_held(rt_hash_lock_addr(i)));
32cb5b4e 770
6561a3b1
DM		 771 while (rth) {
772 next = rcu_dereference_protected(rth->dst.rt_next,
1c31720a 773 lockdep_is_held(rt_hash_lock_addr(i)));
6561a3b1
DM		 774
775 if (!net ||
776 net_eq(dev_net(rth->dst.dev), net)) {
777 rcu_assign_pointer(*pprev, next);
778 rcu_assign_pointer(rth->dst.rt_next, list);
779 list = rth;
32cb5b4e 780 } else {
6561a3b1 781 pprev = &rth->dst.rt_next;
32cb5b4e 782 }
6561a3b1 783 rth = next;
32cb5b4e 784 }
6561a3b1 785
beb659bd
ED		 786 spin_unlock_bh(rt_hash_lock_addr(i));
787
6561a3b1
DM		 788 for (; list; list = next) {
789 next = rcu_dereference_protected(list->dst.rt_next, 1);
790 rt_free(list);
beb659bd
ED		 791 }
792 }
793}
794
1080d709
NH		 795/*
796 * While freeing expired entries, we compute average chain length
797 * and standard deviation, using fixed-point arithmetic.
798 * This to have an estimation of rt_chain_length_max
799 * rt_chain_length_max = max(elasticity, AVG + 4*SD)
800 * We use 3 bits for frational part, and 29 (or 61) for magnitude.
801 */
802
803#define FRACT_BITS 3
804#define ONE (1UL << FRACT_BITS)
805
98376387
ED		 806/*
807 * Given a hash chain and an item in this hash chain,
808 * find if a previous entry has the same hash_inputs
809 * (but differs on tos, mark or oif)
810 * Returns 0 if an alias is found.
811 * Returns ONE if rth has no alias before itself.
812 */
813static int has_noalias(const struct rtable *head, const struct rtable *rth)
814{
815 const struct rtable *aux = head;
816
817 while (aux != rth) {
5e2b61f7 818 if (compare_hash_inputs(aux, rth))
98376387 819 return 0;
1c31720a 820 aux = rcu_dereference_protected(aux->dst.rt_next, 1);
98376387
ED		 821 }
822 return ONE;
823}
824
29e75252 825/*
25985edc 826 * Perturbation of rt_genid by a small quantity [1..256]
29e75252
ED		 827 * Using 8 bits of shuffling ensure we can call rt_cache_invalidate()
828 * many times (2^24) without giving recent rt_genid.
829 * Jenkins hash is strong enough that litle changes of rt_genid are OK.
1da177e4 830 */
86c657f6 831static void rt_cache_invalidate(struct net *net)
1da177e4 832{
29e75252 833 unsigned char shuffle;
1da177e4 834
29e75252 835 get_random_bytes(&shuffle, sizeof(shuffle));
e84f84f2 836 atomic_add(shuffle + 1U, &net->ipv4.rt_genid);
1da177e4
LT		 837}
838
29e75252
ED		 839/*
840 * delay < 0 : invalidate cache (fast : entries will be deleted later)
841 * delay >= 0 : invalidate & flush cache (can be long)
842 */
76e6ebfb 843void rt_cache_flush(struct net *net, int delay)
1da177e4 844{
86c657f6 845 rt_cache_invalidate(net);
29e75252 846 if (delay >= 0)
6561a3b1 847 rt_do_flush(net, !in_softirq());
1da177e4
LT		 848}
849
a5ee1551 850/* Flush previous cache invalidated entries from the cache */
6561a3b1 851void rt_cache_flush_batch(struct net *net)
a5ee1551 852{
6561a3b1 853 rt_do_flush(net, !in_softirq());
a5ee1551
EB		 854}
855
1080d709
NH		 856static void rt_emergency_hash_rebuild(struct net *net)
857{
3ee94372 858 if (net_ratelimit())
1080d709 859 printk(KERN_WARNING "Route hash chain too long!\n");
3ee94372 860 rt_cache_invalidate(net);
1080d709
NH		 861}
862
1da177e4
LT		 863/*
864 Short description of GC goals.
865
866 We want to build algorithm, which will keep routing cache
867 at some equilibrium point, when number of aged off entries
868 is kept approximately equal to newly generated ones.
869
870 Current expiration strength is variable "expire".
871 We try to adjust it dynamically, so that if networking
872 is idle expires is large enough to keep enough of warm entries,
873 and when load increases it reduces to limit cache size.
874 */
875
569d3645 876static int rt_garbage_collect(struct dst_ops *ops)
1da177e4
LT		 877{
878 static unsigned long expire = RT_GC_TIMEOUT;
879 static unsigned long last_gc;
880 static int rover;
881 static int equilibrium;
1c31720a
ED		 882 struct rtable *rth;
883 struct rtable __rcu **rthp;
1da177e4
LT		 884 unsigned long now = jiffies;
885 int goal;
fc66f95c 886 int entries = dst_entries_get_fast(&ipv4_dst_ops);
1da177e4
LT		 887
888 /*
889 * Garbage collection is pretty expensive,
890 * do not make it too frequently.
891 */
892
893 RT_CACHE_STAT_INC(gc_total);
894
895 if (now - last_gc < ip_rt_gc_min_interval &&
fc66f95c 896 entries < ip_rt_max_size) {
1da177e4
LT		 897 RT_CACHE_STAT_INC(gc_ignored);
898 goto out;
899 }
900
fc66f95c 901 entries = dst_entries_get_slow(&ipv4_dst_ops);
1da177e4 902 /* Calculate number of entries, which we want to expire now. */
fc66f95c 903 goal = entries - (ip_rt_gc_elasticity << rt_hash_log);
1da177e4
LT		 904 if (goal <= 0) {
905 if (equilibrium < ipv4_dst_ops.gc_thresh)
906 equilibrium = ipv4_dst_ops.gc_thresh;
fc66f95c 907 goal = entries - equilibrium;
1da177e4 908 if (goal > 0) {
b790cedd 909 equilibrium += min_t(unsigned int, goal >> 1, rt_hash_mask + 1);
fc66f95c 910 goal = entries - equilibrium;
1da177e4
LT		 911 }
912 } else {
913 /* We are in dangerous area. Try to reduce cache really
914 * aggressively.
915 */
b790cedd 916 goal = max_t(unsigned int, goal >> 1, rt_hash_mask + 1);
fc66f95c 917 equilibrium = entries - goal;
1da177e4
LT		 918 }
919
920 if (now - last_gc >= ip_rt_gc_min_interval)
921 last_gc = now;
922
923 if (goal <= 0) {
924 equilibrium += goal;
925 goto work_done;
926 }
927
928 do {
929 int i, k;
930
931 for (i = rt_hash_mask, k = rover; i >= 0; i--) {
932 unsigned long tmo = expire;
933
934 k = (k + 1) & rt_hash_mask;
935 rthp = &rt_hash_table[k].chain;
22c047cc 936 spin_lock_bh(rt_hash_lock_addr(k));
1c31720a
ED		 937 while ((rth = rcu_dereference_protected(*rthp,
938 lockdep_is_held(rt_hash_lock_addr(k)))) != NULL) {
e84f84f2 939 if (!rt_is_expired(rth) &&
29e75252 940 !rt_may_expire(rth, tmo, expire)) {
1da177e4 941 tmo >>= 1;
d8d1f30b 942 rthp = &rth->dst.rt_next;
1da177e4
LT		 943 continue;
944 }
d8d1f30b 945 *rthp = rth->dst.rt_next;
1da177e4
LT		 946 rt_free(rth);
947 goal--;
1da177e4 948 }
22c047cc 949 spin_unlock_bh(rt_hash_lock_addr(k));
1da177e4
LT		 950 if (goal <= 0)
951 break;
952 }
953 rover = k;
954
955 if (goal <= 0)
956 goto work_done;
957
958 /* Goal is not achieved. We stop process if:
959
960 - if expire reduced to zero. Otherwise, expire is halfed.
961 - if table is not full.
962 - if we are called from interrupt.
963 - jiffies check is just fallback/debug loop breaker.
964 We will not spin here for long time in any case.
965 */
966
967 RT_CACHE_STAT_INC(gc_goal_miss);
968
969 if (expire == 0)
970 break;
971
972 expire >>= 1;
1da177e4 973
fc66f95c 974 if (dst_entries_get_fast(&ipv4_dst_ops) < ip_rt_max_size)
1da177e4
LT		 975 goto out;
976 } while (!in_softirq() && time_before_eq(jiffies, now));
977
fc66f95c
ED		 978 if (dst_entries_get_fast(&ipv4_dst_ops) < ip_rt_max_size)
979 goto out;
980 if (dst_entries_get_slow(&ipv4_dst_ops) < ip_rt_max_size)
1da177e4
LT		 981 goto out;
982 if (net_ratelimit())
983 printk(KERN_WARNING "dst cache overflow\n");
984 RT_CACHE_STAT_INC(gc_dst_overflow);
985 return 1;
986
987work_done:
988 expire += ip_rt_gc_min_interval;
989 if (expire > ip_rt_gc_timeout ||
fc66f95c
ED		 990 dst_entries_get_fast(&ipv4_dst_ops) < ipv4_dst_ops.gc_thresh ||
991 dst_entries_get_slow(&ipv4_dst_ops) < ipv4_dst_ops.gc_thresh)
1da177e4 992 expire = ip_rt_gc_timeout;
1da177e4
LT		 993out: return 0;
994}
995
98376387
ED		 996/*
997 * Returns number of entries in a hash chain that have different hash_inputs
998 */
999static int slow_chain_length(const struct rtable *head)
1000{
1001 int length = 0;
1002 const struct rtable *rth = head;
1003
1004 while (rth) {
1005 length += has_noalias(head, rth);
1c31720a 1006 rth = rcu_dereference_protected(rth->dst.rt_next, 1);
98376387
ED		 1007 }
1008 return length >> FRACT_BITS;
1009}
1010
3769cffb
DM		 1011static int rt_bind_neighbour(struct rtable *rt)
1012{
1013 static const __be32 inaddr_any = 0;
1014 struct net_device *dev = rt->dst.dev;
1015 struct neigh_table *tbl = &arp_tbl;
1016 const __be32 *nexthop;
1017 struct neighbour *n;
1018
1019#if defined(CONFIG_ATM_CLIP) || defined(CONFIG_ATM_CLIP_MODULE)
1020 if (dev->type == ARPHRD_ATM)
1021 tbl = clip_tbl_hook;
1022#endif
1023 nexthop = &rt->rt_gateway;
1024 if (dev->flags & (IFF_LOOPBACK | IFF_POINTOPOINT))
1025 nexthop = &inaddr_any;
1026 n = ipv4_neigh_lookup(tbl, dev, nexthop);
1027 if (IS_ERR(n))
1028 return PTR_ERR(n);
69cce1d1 1029 dst_set_neighbour(&rt->dst, n);
3769cffb
DM		 1030
1031 return 0;
1032}
1033
b23dd4fe
DM		 1034static struct rtable *rt_intern_hash(unsigned hash, struct rtable *rt,
1035 struct sk_buff *skb, int ifindex)
1da177e4 1036{
1c31720a
ED		 1037 struct rtable *rth, *cand;
1038 struct rtable __rcu **rthp, **candp;
1da177e4 1039 unsigned long now;
1da177e4
LT		 1040 u32 min_score;
1041 int chain_length;
1042 int attempts = !in_softirq();
1043
1044restart:
1045 chain_length = 0;
1046 min_score = ~(u32)0;
1047 cand = NULL;
1048 candp = NULL;
1049 now = jiffies;
1050
d8d1f30b 1051 if (!rt_caching(dev_net(rt->dst.dev))) {
73e42897
NH		 1052 /*
1053 * If we're not caching, just tell the caller we
1054 * were successful and don't touch the route. The
1055 * caller hold the sole reference to the cache entry, and
1056 * it will be released when the caller is done with it.
1057 * If we drop it here, the callers have no way to resolve routes
1058 * when we're not caching. Instead, just point *rp at rt, so
1059 * the caller gets a single use out of the route
b6280b47
NH		 1060 * Note that we do rt_free on this new route entry, so that
1061 * once its refcount hits zero, we are still able to reap it
1062 * (Thanks Alexey)
27b75c95
ED		 1063 * Note: To avoid expensive rcu stuff for this uncached dst,
1064 * we set DST_NOCACHE so that dst_release() can free dst without
1065 * waiting a grace period.
73e42897 1066 */
b6280b47 1067
c7d4426a 1068 rt->dst.flags |= DST_NOCACHE;
c7537967 1069 if (rt->rt_type == RTN_UNICAST || rt_is_output_route(rt)) {
3769cffb 1070 int err = rt_bind_neighbour(rt);
b6280b47
NH		 1071 if (err) {
1072 if (net_ratelimit())
1073 printk(KERN_WARNING
1074 "Neighbour table failure & not caching routes.\n");
27b75c95 1075 ip_rt_put(rt);
b23dd4fe 1076 return ERR_PTR(err);
b6280b47
NH		 1077 }
1078 }
1079
b6280b47 1080 goto skip_hashing;
1080d709
NH		 1081 }
1082
1da177e4
LT		 1083 rthp = &rt_hash_table[hash].chain;
1084
22c047cc 1085 spin_lock_bh(rt_hash_lock_addr(hash));
1c31720a
ED		 1086 while ((rth = rcu_dereference_protected(*rthp,
1087 lockdep_is_held(rt_hash_lock_addr(hash)))) != NULL) {
e84f84f2 1088 if (rt_is_expired(rth)) {
d8d1f30b 1089 *rthp = rth->dst.rt_next;
29e75252
ED		 1090 rt_free(rth);
1091 continue;
1092 }
5e2b61f7 1093 if (compare_keys(rth, rt) && compare_netns(rth, rt)) {
1da177e4 1094 /* Put it first */
d8d1f30b 1095 *rthp = rth->dst.rt_next;
1da177e4
LT		 1096 /*
1097 * Since lookup is lockfree, the deletion
1098 * must be visible to another weakly ordered CPU before
1099 * the insertion at the start of the hash chain.
1100 */
d8d1f30b 1101 rcu_assign_pointer(rth->dst.rt_next,
1da177e4
LT		 1102 rt_hash_table[hash].chain);
1103 /*
1104 * Since lookup is lockfree, the update writes
1105 * must be ordered for consistency on SMP.
1106 */
1107 rcu_assign_pointer(rt_hash_table[hash].chain, rth);
1108
d8d1f30b 1109 dst_use(&rth->dst, now);
22c047cc 1110 spin_unlock_bh(rt_hash_lock_addr(hash));
1da177e4
LT		 1111
1112 rt_drop(rt);
b23dd4fe 1113 if (skb)
d8d1f30b 1114 skb_dst_set(skb, &rth->dst);
b23dd4fe 1115 return rth;
1da177e4
LT		 1116 }
1117
d8d1f30b 1118 if (!atomic_read(&rth->dst.__refcnt)) {
1da177e4
LT		 1119 u32 score = rt_score(rth);
1120
1121 if (score <= min_score) {
1122 cand = rth;
1123 candp = rthp;
1124 min_score = score;
1125 }
1126 }
1127
1128 chain_length++;
1129
d8d1f30b 1130 rthp = &rth->dst.rt_next;
1da177e4
LT		 1131 }
1132
1133 if (cand) {
1134 /* ip_rt_gc_elasticity used to be average length of chain
1135 * length, when exceeded gc becomes really aggressive.
1136 *
1137 * The second limit is less certain. At the moment it allows
1138 * only 2 entries per bucket. We will see.
1139 */
1140 if (chain_length > ip_rt_gc_elasticity) {
d8d1f30b 1141 *candp = cand->dst.rt_next;
1da177e4
LT		 1142 rt_free(cand);
1143 }
1080d709 1144 } else {
98376387
ED		 1145 if (chain_length > rt_chain_length_max &&
1146 slow_chain_length(rt_hash_table[hash].chain) > rt_chain_length_max) {
d8d1f30b 1147 struct net *net = dev_net(rt->dst.dev);
1080d709 1148 int num = ++net->ipv4.current_rt_cache_rebuild_count;
b35ecb5d 1149 if (!rt_caching(net)) {
1080d709 1150 printk(KERN_WARNING "%s: %d rebuilds is over limit, route caching disabled\n",
d8d1f30b 1151 rt->dst.dev->name, num);
1080d709 1152 }
b35ecb5d 1153 rt_emergency_hash_rebuild(net);
6a2bad70
PE		 1154 spin_unlock_bh(rt_hash_lock_addr(hash));
1155
5e2b61f7 1156 hash = rt_hash(rt->rt_key_dst, rt->rt_key_src,
6a2bad70
PE		 1157 ifindex, rt_genid(net));
1158 goto restart;
1080d709 1159 }
1da177e4
LT		 1160 }
1161
1162 /* Try to bind route to arp only if it is output
1163 route or unicast forwarding path.
1164 */
c7537967 1165 if (rt->rt_type == RTN_UNICAST || rt_is_output_route(rt)) {
3769cffb 1166 int err = rt_bind_neighbour(rt);
1da177e4 1167 if (err) {
22c047cc 1168 spin_unlock_bh(rt_hash_lock_addr(hash));
1da177e4
LT		 1169
1170 if (err != -ENOBUFS) {
1171 rt_drop(rt);
b23dd4fe 1172 return ERR_PTR(err);
1da177e4
LT		 1173 }
1174
1175 /* Neighbour tables are full and nothing
1176 can be released. Try to shrink route cache,
1177 it is most likely it holds some neighbour records.
1178 */
1179 if (attempts-- > 0) {
1180 int saved_elasticity = ip_rt_gc_elasticity;
1181 int saved_int = ip_rt_gc_min_interval;
1182 ip_rt_gc_elasticity = 1;
1183 ip_rt_gc_min_interval = 0;
569d3645 1184 rt_garbage_collect(&ipv4_dst_ops);
1da177e4
LT		 1185 ip_rt_gc_min_interval = saved_int;
1186 ip_rt_gc_elasticity = saved_elasticity;
1187 goto restart;
1188 }
1189
1190 if (net_ratelimit())
7e1b33e5 1191 printk(KERN_WARNING "ipv4: Neighbour table overflow.\n");
1da177e4 1192 rt_drop(rt);
b23dd4fe 1193 return ERR_PTR(-ENOBUFS);
1da177e4
LT		 1194 }
1195 }
1196
d8d1f30b 1197 rt->dst.rt_next = rt_hash_table[hash].chain;
1080d709 1198
00269b54
ED		 1199 /*
1200 * Since lookup is lockfree, we must make sure
25985edc 1201 * previous writes to rt are committed to memory
00269b54
ED		 1202 * before making rt visible to other CPUS.
1203 */
1ddbcb00 1204 rcu_assign_pointer(rt_hash_table[hash].chain, rt);
1080d709 1205
22c047cc 1206 spin_unlock_bh(rt_hash_lock_addr(hash));
73e42897 1207
b6280b47 1208skip_hashing:
b23dd4fe 1209 if (skb)
d8d1f30b 1210 skb_dst_set(skb, &rt->dst);
b23dd4fe 1211 return rt;
1da177e4
LT		 1212}
1213
6431cbc2
DM		 1214static atomic_t __rt_peer_genid = ATOMIC_INIT(0);
1215
1216static u32 rt_peer_genid(void)
1217{
1218 return atomic_read(&__rt_peer_genid);
1219}
1220
a48eff12 1221void rt_bind_peer(struct rtable *rt, __be32 daddr, int create)
1da177e4 1222{
1da177e4
LT		 1223 struct inet_peer *peer;
1224
a48eff12 1225 peer = inet_getpeer_v4(daddr, create);
1da177e4 1226
49e8ab03 1227 if (peer && cmpxchg(&rt->peer, NULL, peer) != NULL)
1da177e4 1228 inet_putpeer(peer);
6431cbc2
DM		 1229 else
1230 rt->rt_peer_genid = rt_peer_genid();
1da177e4
LT		 1231}
1232
1233/*
1234 * Peer allocation may fail only in serious out-of-memory conditions. However
1235 * we still can generate some output.
1236 * Random ID selection looks a bit dangerous because we have no chances to
1237 * select ID being unique in a reasonable period of time.
1238 * But broken packet identifier may be better than no packet at all.
1239 */
1240static void ip_select_fb_ident(struct iphdr *iph)
1241{
1242 static DEFINE_SPINLOCK(ip_fb_id_lock);
1243 static u32 ip_fallback_id;
1244 u32 salt;
1245
1246 spin_lock_bh(&ip_fb_id_lock);
e448515c 1247 salt = secure_ip_id((__force __be32)ip_fallback_id ^ iph->daddr);
1da177e4
LT		 1248 iph->id = htons(salt & 0xFFFF);
1249 ip_fallback_id = salt;
1250 spin_unlock_bh(&ip_fb_id_lock);
1251}
1252
1253void __ip_select_ident(struct iphdr *iph, struct dst_entry *dst, int more)
1254{
1255 struct rtable *rt = (struct rtable *) dst;
1256
1257 if (rt) {
1258 if (rt->peer == NULL)
a48eff12 1259 rt_bind_peer(rt, rt->rt_dst, 1);
1da177e4
LT		 1260
1261 /* If peer is attached to destination, it is never detached,
1262 so that we need not to grab a lock to dereference it.
1263 */
1264 if (rt->peer) {
1265 iph->id = htons(inet_getid(rt->peer, more));
1266 return;
1267 }
1268 } else
e905a9ed 1269 printk(KERN_DEBUG "rt_bind_peer(0) @%p\n",
9c2b3328 1270 __builtin_return_address(0));
1da177e4
LT		 1271
1272 ip_select_fb_ident(iph);
1273}
4bc2f18b 1274EXPORT_SYMBOL(__ip_select_ident);
1da177e4
LT		 1275
1276static void rt_del(unsigned hash, struct rtable *rt)
1277{
1c31720a
ED		 1278 struct rtable __rcu **rthp;
1279 struct rtable *aux;
1da177e4 1280
29e75252 1281 rthp = &rt_hash_table[hash].chain;
22c047cc 1282 spin_lock_bh(rt_hash_lock_addr(hash));
1da177e4 1283 ip_rt_put(rt);
1c31720a
ED		 1284 while ((aux = rcu_dereference_protected(*rthp,
1285 lockdep_is_held(rt_hash_lock_addr(hash)))) != NULL) {
e84f84f2 1286 if (aux == rt || rt_is_expired(aux)) {
d8d1f30b 1287 *rthp = aux->dst.rt_next;
29e75252
ED		 1288 rt_free(aux);
1289 continue;
1da177e4 1290 }
d8d1f30b 1291 rthp = &aux->dst.rt_next;
29e75252 1292 }
22c047cc 1293 spin_unlock_bh(rt_hash_lock_addr(hash));
1da177e4
LT		 1294}
1295
ed7865a4 1296/* called in rcu_read_lock() section */
f7655229
AV		 1297void ip_rt_redirect(__be32 old_gw, __be32 daddr, __be32 new_gw,
1298 __be32 saddr, struct net_device *dev)
1da177e4 1299{
ed7865a4 1300 struct in_device *in_dev = __in_dev_get_rcu(dev);
f39925db 1301 struct inet_peer *peer;
317805b8 1302 struct net *net;
1da177e4 1303
1da177e4
LT		 1304 if (!in_dev)
1305 return;
1306
c346dca1 1307 net = dev_net(dev);
9d4fb27d
JP		 1308 if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) ||
1309 ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw) ||
1310 ipv4_is_zeronet(new_gw))
1da177e4
LT		 1311 goto reject_redirect;
1312
1313 if (!IN_DEV_SHARED_MEDIA(in_dev)) {
1314 if (!inet_addr_onlink(in_dev, new_gw, old_gw))
1315 goto reject_redirect;
1316 if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
1317 goto reject_redirect;
1318 } else {
317805b8 1319 if (inet_addr_type(net, new_gw) != RTN_UNICAST)
1da177e4
LT		 1320 goto reject_redirect;
1321 }
1322
f39925db
DM		 1323 peer = inet_getpeer_v4(daddr, 1);
1324 if (peer) {
1325 peer->redirect_learned.a4 = new_gw;
e905a9ed 1326
f39925db 1327 inet_putpeer(peer);
1da177e4 1328
f39925db 1329 atomic_inc(&__rt_peer_genid);
1da177e4 1330 }
1da177e4
LT		 1331 return;
1332
1333reject_redirect:
1334#ifdef CONFIG_IP_ROUTE_VERBOSE
1335 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit())
673d57e7
HH		 1336 printk(KERN_INFO "Redirect from %pI4 on %s about %pI4 ignored.\n"
1337 " Advised path = %pI4 -> %pI4\n",
1338 &old_gw, dev->name, &new_gw,
1339 &saddr, &daddr);
1da177e4 1340#endif
ed7865a4 1341 ;
1da177e4
LT		 1342}
1343
fe6fe792
ED		 1344static bool peer_pmtu_expired(struct inet_peer *peer)
1345{
1346 unsigned long orig = ACCESS_ONCE(peer->pmtu_expires);
1347
1348 return orig &&
1349 time_after_eq(jiffies, orig) &&
1350 cmpxchg(&peer->pmtu_expires, orig, 0) == orig;
1351}
1352
1353static bool peer_pmtu_cleaned(struct inet_peer *peer)
1354{
1355 unsigned long orig = ACCESS_ONCE(peer->pmtu_expires);
1356
1357 return orig &&
1358 cmpxchg(&peer->pmtu_expires, orig, 0) == orig;
1359}
1360
1da177e4
LT		 1361static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
1362{
ee6b9673 1363 struct rtable *rt = (struct rtable *)dst;
1da177e4
LT		 1364 struct dst_entry *ret = dst;
1365
1366 if (rt) {
d11a4dc1 1367 if (dst->obsolete > 0) {
1da177e4
LT		 1368 ip_rt_put(rt);
1369 ret = NULL;
2c8cec5c 1370 } else if (rt->rt_flags & RTCF_REDIRECTED) {
5e2b61f7
DM		 1371 unsigned hash = rt_hash(rt->rt_key_dst, rt->rt_key_src,
1372 rt->rt_oif,
e84f84f2 1373 rt_genid(dev_net(dst->dev)));
1da177e4
LT		 1374 rt_del(hash, rt);
1375 ret = NULL;
fe6fe792
ED		 1376 } else if (rt->peer && peer_pmtu_expired(rt->peer)) {
1377 dst_metric_set(dst, RTAX_MTU, rt->peer->pmtu_orig);
1da177e4
LT		 1378 }
1379 }
1380 return ret;
1381}
1382
1383/*
1384 * Algorithm:
1385 * 1. The first ip_rt_redirect_number redirects are sent
1386 * with exponential backoff, then we stop sending them at all,
1387 * assuming that the host ignores our redirects.
1388 * 2. If we did not see packets requiring redirects
1389 * during ip_rt_redirect_silence, we assume that the host
1390 * forgot redirected route and start to send redirects again.
1391 *
1392 * This algorithm is much cheaper and more intelligent than dumb load limiting
1393 * in icmp.c.
1394 *
1395 * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
1396 * and "frag. need" (breaks PMTU discovery) in icmp.c.
1397 */
1398
1399void ip_rt_send_redirect(struct sk_buff *skb)
1400{
511c3f92 1401 struct rtable *rt = skb_rtable(skb);
30038fc6 1402 struct in_device *in_dev;
92d86829 1403 struct inet_peer *peer;
30038fc6 1404 int log_martians;
1da177e4 1405
30038fc6 1406 rcu_read_lock();
d8d1f30b 1407 in_dev = __in_dev_get_rcu(rt->dst.dev);
30038fc6
ED		 1408 if (!in_dev || !IN_DEV_TX_REDIRECTS(in_dev)) {
1409 rcu_read_unlock();
1da177e4 1410 return;
30038fc6
ED		 1411 }
1412 log_martians = IN_DEV_LOG_MARTIANS(in_dev);
1413 rcu_read_unlock();
1da177e4 1414
92d86829 1415 if (!rt->peer)
a48eff12 1416 rt_bind_peer(rt, rt->rt_dst, 1);
92d86829
DM		 1417 peer = rt->peer;
1418 if (!peer) {
1419 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, rt->rt_gateway);
1420 return;
1421 }
1422
1da177e4
LT		 1423 /* No redirected packets during ip_rt_redirect_silence;
1424 * reset the algorithm.
1425 */
92d86829
DM		 1426 if (time_after(jiffies, peer->rate_last + ip_rt_redirect_silence))
1427 peer->rate_tokens = 0;
1da177e4
LT		 1428
1429 /* Too many ignored redirects; do not send anything
d8d1f30b 1430 * set dst.rate_last to the last seen redirected packet.
1da177e4 1431 */
92d86829
DM		 1432 if (peer->rate_tokens >= ip_rt_redirect_number) {
1433 peer->rate_last = jiffies;
30038fc6 1434 return;
1da177e4
LT		 1435 }
1436
1437 /* Check for load limit; set rate_last to the latest sent
1438 * redirect.
1439 */
92d86829 1440 if (peer->rate_tokens == 0 ||
14fb8a76 1441 time_after(jiffies,
92d86829
DM		 1442 (peer->rate_last +
1443 (ip_rt_redirect_load << peer->rate_tokens)))) {
1da177e4 1444 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, rt->rt_gateway);
92d86829
DM		 1445 peer->rate_last = jiffies;
1446 ++peer->rate_tokens;
1da177e4 1447#ifdef CONFIG_IP_ROUTE_VERBOSE
30038fc6 1448 if (log_martians &&
92d86829 1449 peer->rate_tokens == ip_rt_redirect_number &&
1da177e4 1450 net_ratelimit())
673d57e7 1451 printk(KERN_WARNING "host %pI4/if%d ignores redirects for %pI4 to %pI4.\n",
c5be24ff 1452 &ip_hdr(skb)->saddr, rt->rt_iif,
673d57e7 1453 &rt->rt_dst, &rt->rt_gateway);
1da177e4
LT		 1454#endif
1455 }
1da177e4
LT		 1456}
1457
1458static int ip_error(struct sk_buff *skb)
1459{
511c3f92 1460 struct rtable *rt = skb_rtable(skb);
92d86829 1461 struct inet_peer *peer;
1da177e4 1462 unsigned long now;
92d86829 1463 bool send;
1da177e4
LT		 1464 int code;
1465
d8d1f30b 1466 switch (rt->dst.error) {
4500ebf8
JP		 1467 case EINVAL:
1468 default:
1469 goto out;
1470 case EHOSTUNREACH:
1471 code = ICMP_HOST_UNREACH;
1472 break;
1473 case ENETUNREACH:
1474 code = ICMP_NET_UNREACH;
1475 IP_INC_STATS_BH(dev_net(rt->dst.dev),
1476 IPSTATS_MIB_INNOROUTES);
1477 break;
1478 case EACCES:
1479 code = ICMP_PKT_FILTERED;
1480 break;
1da177e4
LT		 1481 }
1482
92d86829 1483 if (!rt->peer)
a48eff12 1484 rt_bind_peer(rt, rt->rt_dst, 1);
92d86829
DM		 1485 peer = rt->peer;
1486
1487 send = true;
1488 if (peer) {
1489 now = jiffies;
1490 peer->rate_tokens += now - peer->rate_last;
1491 if (peer->rate_tokens > ip_rt_error_burst)
1492 peer->rate_tokens = ip_rt_error_burst;
1493 peer->rate_last = now;
1494 if (peer->rate_tokens >= ip_rt_error_cost)
1495 peer->rate_tokens -= ip_rt_error_cost;
1496 else
1497 send = false;
1da177e4 1498 }
92d86829
DM		 1499 if (send)
1500 icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
1da177e4
LT		 1501
1502out: kfree_skb(skb);
1503 return 0;
e905a9ed 1504}
1da177e4
LT		 1505
1506/*
1507 * The last two values are not from the RFC but
1508 * are needed for AMPRnet AX.25 paths.
1509 */
1510
9b5b5cff 1511static const unsigned short mtu_plateau[] =
1da177e4
LT		 1512{32000, 17914, 8166, 4352, 2002, 1492, 576, 296, 216, 128 };
1513
5969f71d 1514static inline unsigned short guess_mtu(unsigned short old_mtu)
1da177e4
LT		 1515{
1516 int i;
e905a9ed 1517
1da177e4
LT		 1518 for (i = 0; i < ARRAY_SIZE(mtu_plateau); i++)
1519 if (old_mtu > mtu_plateau[i])
1520 return mtu_plateau[i];
1521 return 68;
1522}
1523
b71d1d42 1524unsigned short ip_rt_frag_needed(struct net *net, const struct iphdr *iph,
0010e465
TT		 1525 unsigned short new_mtu,
1526 struct net_device *dev)
1da177e4 1527{
1da177e4 1528 unsigned short old_mtu = ntohs(iph->tot_len);
1da177e4 1529 unsigned short est_mtu = 0;
2c8cec5c 1530 struct inet_peer *peer;
1da177e4 1531
2c8cec5c
DM		 1532 peer = inet_getpeer_v4(iph->daddr, 1);
1533 if (peer) {
1534 unsigned short mtu = new_mtu;
1da177e4 1535
2c8cec5c
DM		 1536 if (new_mtu < 68 || new_mtu >= old_mtu) {
1537 /* BSD 4.2 derived systems incorrectly adjust
1538 * tot_len by the IP header length, and report
1539 * a zero MTU in the ICMP message.
1540 */
1541 if (mtu == 0 &&
1542 old_mtu >= 68 + (iph->ihl << 2))
1543 old_mtu -= iph->ihl << 2;
1544 mtu = guess_mtu(old_mtu);
1545 }
0010e465 1546
2c8cec5c
DM		 1547 if (mtu < ip_rt_min_pmtu)
1548 mtu = ip_rt_min_pmtu;
1549 if (!peer->pmtu_expires || mtu < peer->pmtu_learned) {
46af3180
HS		 1550 unsigned long pmtu_expires;
1551
1552 pmtu_expires = jiffies + ip_rt_mtu_expires;
1553 if (!pmtu_expires)
1554 pmtu_expires = 1UL;
1555
2c8cec5c
DM		 1556 est_mtu = mtu;
1557 peer->pmtu_learned = mtu;
46af3180 1558 peer->pmtu_expires = pmtu_expires;
2c8cec5c 1559 }
1da177e4 1560
2c8cec5c 1561 inet_putpeer(peer);
1da177e4 1562
2c8cec5c 1563 atomic_inc(&__rt_peer_genid);
1da177e4
LT		 1564 }
1565 return est_mtu ? : new_mtu;
1566}
1567
2c8cec5c
DM		 1568static void check_peer_pmtu(struct dst_entry *dst, struct inet_peer *peer)
1569{
fe6fe792 1570 unsigned long expires = ACCESS_ONCE(peer->pmtu_expires);
2c8cec5c 1571
fe6fe792
ED		 1572 if (!expires)
1573 return;
46af3180 1574 if (time_before(jiffies, expires)) {
2c8cec5c
DM		 1575 u32 orig_dst_mtu = dst_mtu(dst);
1576 if (peer->pmtu_learned < orig_dst_mtu) {
1577 if (!peer->pmtu_orig)
1578 peer->pmtu_orig = dst_metric_raw(dst, RTAX_MTU);
1579 dst_metric_set(dst, RTAX_MTU, peer->pmtu_learned);
1580 }
1581 } else if (cmpxchg(&peer->pmtu_expires, expires, 0) == expires)
1582 dst_metric_set(dst, RTAX_MTU, peer->pmtu_orig);
1583}
1584
1da177e4
LT		 1585static void ip_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
1586{
2c8cec5c
DM		 1587 struct rtable *rt = (struct rtable *) dst;
1588 struct inet_peer *peer;
1589
1590 dst_confirm(dst);
1591
1592 if (!rt->peer)
a48eff12 1593 rt_bind_peer(rt, rt->rt_dst, 1);
2c8cec5c
DM		 1594 peer = rt->peer;
1595 if (peer) {
fe6fe792
ED		 1596 unsigned long pmtu_expires = ACCESS_ONCE(peer->pmtu_expires);
1597
2c8cec5c 1598 if (mtu < ip_rt_min_pmtu)
1da177e4 1599 mtu = ip_rt_min_pmtu;
fe6fe792 1600 if (!pmtu_expires || mtu < peer->pmtu_learned) {
46af3180
HS		 1601
1602 pmtu_expires = jiffies + ip_rt_mtu_expires;
1603 if (!pmtu_expires)
1604 pmtu_expires = 1UL;
1605
2c8cec5c 1606 peer->pmtu_learned = mtu;
46af3180 1607 peer->pmtu_expires = pmtu_expires;
2c8cec5c
DM		 1608
1609 atomic_inc(&__rt_peer_genid);
1610 rt->rt_peer_genid = rt_peer_genid();
1da177e4 1611 }
46af3180 1612 check_peer_pmtu(dst, peer);
1da177e4
LT		 1613 }
1614}
1615
f39925db
DM		 1616static int check_peer_redir(struct dst_entry *dst, struct inet_peer *peer)
1617{
1618 struct rtable *rt = (struct rtable *) dst;
1619 __be32 orig_gw = rt->rt_gateway;
69cce1d1 1620 struct neighbour *n;
f39925db
DM		 1621
1622 dst_confirm(&rt->dst);
1623
69cce1d1
DM		 1624 neigh_release(dst_get_neighbour(&rt->dst));
1625 dst_set_neighbour(&rt->dst, NULL);
f39925db
DM		 1626
1627 rt->rt_gateway = peer->redirect_learned.a4;
69cce1d1
DM		 1628 rt_bind_neighbour(rt);
1629 n = dst_get_neighbour(&rt->dst);
1630 if (!n || !(n->nud_state & NUD_VALID)) {
1631 if (n)
1632 neigh_event_send(n, NULL);
f39925db
DM		 1633 rt->rt_gateway = orig_gw;
1634 return -EAGAIN;
1635 } else {
1636 rt->rt_flags |= RTCF_REDIRECTED;
69cce1d1 1637 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, n);
f39925db
DM		 1638 }
1639 return 0;
1640}
1641
1da177e4
LT		 1642static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
1643{
6431cbc2
DM		 1644 struct rtable *rt = (struct rtable *) dst;
1645
1646 if (rt_is_expired(rt))
d11a4dc1 1647 return NULL;
6431cbc2 1648 if (rt->rt_peer_genid != rt_peer_genid()) {
2c8cec5c
DM		 1649 struct inet_peer *peer;
1650
6431cbc2 1651 if (!rt->peer)
a48eff12 1652 rt_bind_peer(rt, rt->rt_dst, 0);
6431cbc2 1653
2c8cec5c 1654 peer = rt->peer;
fe6fe792 1655 if (peer) {
2c8cec5c
DM		 1656 check_peer_pmtu(dst, peer);
1657
fe6fe792
ED		 1658 if (peer->redirect_learned.a4 &&
1659 peer->redirect_learned.a4 != rt->rt_gateway) {
1660 if (check_peer_redir(dst, peer))
1661 return NULL;
1662 }
f39925db
DM		 1663 }
1664
6431cbc2
DM		 1665 rt->rt_peer_genid = rt_peer_genid();
1666 }
d11a4dc1 1667 return dst;
1da177e4
LT		 1668}
1669
1670static void ipv4_dst_destroy(struct dst_entry *dst)
1671{
1672 struct rtable *rt = (struct rtable *) dst;
1673 struct inet_peer *peer = rt->peer;
1da177e4 1674
62fa8a84
DM		 1675 if (rt->fi) {
1676 fib_info_put(rt->fi);
1677 rt->fi = NULL;
1678 }
1da177e4
LT		 1679 if (peer) {
1680 rt->peer = NULL;
1681 inet_putpeer(peer);
1682 }
1da177e4
LT		 1683}
1684
1da177e4
LT		 1685
1686static void ipv4_link_failure(struct sk_buff *skb)
1687{
1688 struct rtable *rt;
1689
1690 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
1691
511c3f92 1692 rt = skb_rtable(skb);
fe6fe792
ED		 1693 if (rt && rt->peer && peer_pmtu_cleaned(rt->peer))
1694 dst_metric_set(&rt->dst, RTAX_MTU, rt->peer->pmtu_orig);
1da177e4
LT		 1695}
1696
1697static int ip_rt_bug(struct sk_buff *skb)
1698{
673d57e7
HH		 1699 printk(KERN_DEBUG "ip_rt_bug: %pI4 -> %pI4, %s\n",
1700 &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
1da177e4
LT		 1701 skb->dev ? skb->dev->name : "?");
1702 kfree_skb(skb);
c378a9c0 1703 WARN_ON(1);
1da177e4
LT		 1704 return 0;
1705}
1706
1707/*
1708 We do not cache source address of outgoing interface,
1709 because it is used only by IP RR, TS and SRR options,
1710 so that it out of fast path.
1711
1712 BTW remember: "addr" is allowed to be not aligned
1713 in IP options!
1714 */
1715
8e36360a 1716void ip_rt_get_source(u8 *addr, struct sk_buff *skb, struct rtable *rt)
1da177e4 1717{
a61ced5d 1718 __be32 src;
1da177e4 1719
c7537967 1720 if (rt_is_output_route(rt))
c5be24ff 1721 src = ip_hdr(skb)->saddr;
ebc0ffae 1722 else {
8e36360a
DM		 1723 struct fib_result res;
1724 struct flowi4 fl4;
1725 struct iphdr *iph;
1726
1727 iph = ip_hdr(skb);
1728
1729 memset(&fl4, 0, sizeof(fl4));
1730 fl4.daddr = iph->daddr;
1731 fl4.saddr = iph->saddr;
1732 fl4.flowi4_tos = iph->tos;
1733 fl4.flowi4_oif = rt->dst.dev->ifindex;
1734 fl4.flowi4_iif = skb->dev->ifindex;
1735 fl4.flowi4_mark = skb->mark;
5e2b61f7 1736
ebc0ffae 1737 rcu_read_lock();
68a5e3dd 1738 if (fib_lookup(dev_net(rt->dst.dev), &fl4, &res) == 0)
436c3b66 1739 src = FIB_RES_PREFSRC(dev_net(rt->dst.dev), res);
ebc0ffae
ED		 1740 else
1741 src = inet_select_addr(rt->dst.dev, rt->rt_gateway,
1da177e4 1742 RT_SCOPE_UNIVERSE);
ebc0ffae
ED		 1743 rcu_read_unlock();
1744 }
1da177e4
LT		 1745 memcpy(addr, &src, 4);
1746}
1747
c7066f70 1748#ifdef CONFIG_IP_ROUTE_CLASSID
1da177e4
LT		 1749static void set_class_tag(struct rtable *rt, u32 tag)
1750{
d8d1f30b
CG		 1751 if (!(rt->dst.tclassid & 0xFFFF))
1752 rt->dst.tclassid |= tag & 0xFFFF;
1753 if (!(rt->dst.tclassid & 0xFFFF0000))
1754 rt->dst.tclassid |= tag & 0xFFFF0000;
1da177e4
LT		 1755}
1756#endif
1757
0dbaee3b
DM		 1758static unsigned int ipv4_default_advmss(const struct dst_entry *dst)
1759{
1760 unsigned int advmss = dst_metric_raw(dst, RTAX_ADVMSS);
1761
1762 if (advmss == 0) {
1763 advmss = max_t(unsigned int, dst->dev->mtu - 40,
1764 ip_rt_min_advmss);
1765 if (advmss > 65535 - 40)
1766 advmss = 65535 - 40;
1767 }
1768 return advmss;
1769}
1770
d33e4553
DM		 1771static unsigned int ipv4_default_mtu(const struct dst_entry *dst)
1772{
1773 unsigned int mtu = dst->dev->mtu;
1774
1775 if (unlikely(dst_metric_locked(dst, RTAX_MTU))) {
1776 const struct rtable *rt = (const struct rtable *) dst;
1777
1778 if (rt->rt_gateway != rt->rt_dst && mtu > 576)
1779 mtu = 576;
1780 }
1781
1782 if (mtu > IP_MAX_MTU)
1783 mtu = IP_MAX_MTU;
1784
1785 return mtu;
1786}
1787
813b3b5d 1788static void rt_init_metrics(struct rtable *rt, const struct flowi4 *fl4,
5e2b61f7 1789 struct fib_info *fi)
a4daad6b 1790{
0131ba45
DM		 1791 struct inet_peer *peer;
1792 int create = 0;
a4daad6b 1793
0131ba45
DM		 1794 /* If a peer entry exists for this destination, we must hook
1795 * it up in order to get at cached metrics.
1796 */
813b3b5d 1797 if (fl4 && (fl4->flowi4_flags & FLOWI_FLAG_PRECOW_METRICS))
0131ba45
DM		 1798 create = 1;
1799
3c0afdca 1800 rt->peer = peer = inet_getpeer_v4(rt->rt_dst, create);
0131ba45 1801 if (peer) {
3c0afdca 1802 rt->rt_peer_genid = rt_peer_genid();
a4daad6b
DM		 1803 if (inet_metrics_new(peer))
1804 memcpy(peer->metrics, fi->fib_metrics,
1805 sizeof(u32) * RTAX_MAX);
1806 dst_init_metrics(&rt->dst, peer->metrics, false);
2c8cec5c 1807
fe6fe792 1808 check_peer_pmtu(&rt->dst, peer);
f39925db
DM		 1809 if (peer->redirect_learned.a4 &&
1810 peer->redirect_learned.a4 != rt->rt_gateway) {
1811 rt->rt_gateway = peer->redirect_learned.a4;
1812 rt->rt_flags |= RTCF_REDIRECTED;
1813 }
0131ba45
DM		 1814 } else {
1815 if (fi->fib_metrics != (u32 *) dst_default_metrics) {
1816 rt->fi = fi;
1817 atomic_inc(&fi->fib_clntref);
1818 }
1819 dst_init_metrics(&rt->dst, fi->fib_metrics, true);
a4daad6b
DM		 1820 }
1821}
1822
813b3b5d 1823static void rt_set_nexthop(struct rtable *rt, const struct flowi4 *fl4,
5e2b61f7 1824 const struct fib_result *res,
982721f3 1825 struct fib_info *fi, u16 type, u32 itag)
1da177e4 1826{
defb3519 1827 struct dst_entry *dst = &rt->dst;
1da177e4
LT		 1828
1829 if (fi) {
1830 if (FIB_RES_GW(*res) &&
1831 FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK)
1832 rt->rt_gateway = FIB_RES_GW(*res);
813b3b5d 1833 rt_init_metrics(rt, fl4, fi);
c7066f70 1834#ifdef CONFIG_IP_ROUTE_CLASSID
defb3519 1835 dst->tclassid = FIB_RES_NH(*res).nh_tclassid;
1da177e4 1836#endif
d33e4553 1837 }
defb3519 1838
defb3519
DM		 1839 if (dst_mtu(dst) > IP_MAX_MTU)
1840 dst_metric_set(dst, RTAX_MTU, IP_MAX_MTU);
0dbaee3b 1841 if (dst_metric_raw(dst, RTAX_ADVMSS) > 65535 - 40)
defb3519 1842 dst_metric_set(dst, RTAX_ADVMSS, 65535 - 40);
1da177e4 1843
c7066f70 1844#ifdef CONFIG_IP_ROUTE_CLASSID
1da177e4
LT		 1845#ifdef CONFIG_IP_MULTIPLE_TABLES
1846 set_class_tag(rt, fib_rules_tclass(res));
1847#endif
1848 set_class_tag(rt, itag);
1849#endif
1da177e4
LT		 1850}
1851
5c1e6aa3
DM		 1852static struct rtable *rt_dst_alloc(struct net_device *dev,
1853 bool nopolicy, bool noxfrm)
0c4dcd58 1854{
5c1e6aa3
DM		 1855 return dst_alloc(&ipv4_dst_ops, dev, 1, -1,
1856 DST_HOST |
1857 (nopolicy ? DST_NOPOLICY : 0) |
1858 (noxfrm ? DST_NOXFRM : 0));
0c4dcd58
DM		 1859}
1860
96d36220 1861/* called in rcu_read_lock() section */
9e12bb22 1862static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1da177e4
LT		 1863 u8 tos, struct net_device *dev, int our)
1864{
96d36220 1865 unsigned int hash;
1da177e4 1866 struct rtable *rth;
a61ced5d 1867 __be32 spec_dst;
96d36220 1868 struct in_device *in_dev = __in_dev_get_rcu(dev);
1da177e4 1869 u32 itag = 0;
b5f7e755 1870 int err;
1da177e4
LT		 1871
1872 /* Primary sanity checks. */
1873
1874 if (in_dev == NULL)
1875 return -EINVAL;
1876
1e637c74 1877 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
f97c1e0c 1878 ipv4_is_loopback(saddr) || skb->protocol != htons(ETH_P_IP))
1da177e4
LT		 1879 goto e_inval;
1880
f97c1e0c
JP		 1881 if (ipv4_is_zeronet(saddr)) {
1882 if (!ipv4_is_local_multicast(daddr))
1da177e4
LT		 1883 goto e_inval;
1884 spec_dst = inet_select_addr(dev, 0, RT_SCOPE_LINK);
b5f7e755 1885 } else {
5c04c819
MS		 1886 err = fib_validate_source(skb, saddr, 0, tos, 0, dev, &spec_dst,
1887 &itag);
b5f7e755
ED		 1888 if (err < 0)
1889 goto e_err;
1890 }
5c1e6aa3
DM		 1891 rth = rt_dst_alloc(init_net.loopback_dev,
1892 IN_DEV_CONF_GET(in_dev, NOPOLICY), false);
1da177e4
LT		 1893 if (!rth)
1894 goto e_nobufs;
1895
cf911662
DM		 1896#ifdef CONFIG_IP_ROUTE_CLASSID
1897 rth->dst.tclassid = itag;
1898#endif
d8d1f30b 1899 rth->dst.output = ip_rt_bug;
1da177e4 1900
5e2b61f7 1901 rth->rt_key_dst = daddr;
5e2b61f7 1902 rth->rt_key_src = saddr;
cf911662
DM		 1903 rth->rt_genid = rt_genid(dev_net(dev));
1904 rth->rt_flags = RTCF_MULTICAST;
1905 rth->rt_type = RTN_MULTICAST;
475949d8 1906 rth->rt_key_tos = tos;
cf911662 1907 rth->rt_dst = daddr;
1da177e4 1908 rth->rt_src = saddr;
1b86a58f 1909 rth->rt_route_iif = dev->ifindex;
5e2b61f7 1910 rth->rt_iif = dev->ifindex;
5e2b61f7 1911 rth->rt_oif = 0;
cf911662 1912 rth->rt_mark = skb->mark;
1da177e4
LT		 1913 rth->rt_gateway = daddr;
1914 rth->rt_spec_dst= spec_dst;
cf911662
DM		 1915 rth->rt_peer_genid = 0;
1916 rth->peer = NULL;
1917 rth->fi = NULL;
1da177e4 1918 if (our) {
d8d1f30b 1919 rth->dst.input= ip_local_deliver;
1da177e4
LT		 1920 rth->rt_flags |= RTCF_LOCAL;
1921 }
1922
1923#ifdef CONFIG_IP_MROUTE
f97c1e0c 1924 if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
d8d1f30b 1925 rth->dst.input = ip_mr_input;
1da177e4
LT		 1926#endif
1927 RT_CACHE_STAT_INC(in_slow_mc);
1928
e84f84f2 1929 hash = rt_hash(daddr, saddr, dev->ifindex, rt_genid(dev_net(dev)));
b23dd4fe 1930 rth = rt_intern_hash(hash, rth, skb, dev->ifindex);
9aa3c94c 1931 return IS_ERR(rth) ? PTR_ERR(rth) : 0;
1da177e4
LT		 1932
1933e_nobufs:
1da177e4 1934 return -ENOBUFS;
1da177e4 1935e_inval:
96d36220 1936 return -EINVAL;
b5f7e755 1937e_err:
b5f7e755 1938 return err;
1da177e4
LT		 1939}
1940
1941
1942static void ip_handle_martian_source(struct net_device *dev,
1943 struct in_device *in_dev,
1944 struct sk_buff *skb,
9e12bb22
AV		 1945 __be32 daddr,
1946 __be32 saddr)
1da177e4
LT		 1947{
1948 RT_CACHE_STAT_INC(in_martian_src);
1949#ifdef CONFIG_IP_ROUTE_VERBOSE
1950 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
1951 /*
1952 * RFC1812 recommendation, if source is martian,
1953 * the only hint is MAC header.
1954 */
673d57e7
HH		 1955 printk(KERN_WARNING "martian source %pI4 from %pI4, on dev %s\n",
1956 &daddr, &saddr, dev->name);
98e399f8 1957 if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
1da177e4 1958 int i;
98e399f8 1959 const unsigned char *p = skb_mac_header(skb);
1da177e4
LT		 1960 printk(KERN_WARNING "ll header: ");
1961 for (i = 0; i < dev->hard_header_len; i++, p++) {
1962 printk("%02x", *p);
1963 if (i < (dev->hard_header_len - 1))
1964 printk(":");
1965 }
1966 printk("\n");
1967 }
1968 }
1969#endif
1970}
1971
47360228 1972/* called in rcu_read_lock() section */
5969f71d 1973static int __mkroute_input(struct sk_buff *skb,
982721f3 1974 const struct fib_result *res,
5969f71d
SH		 1975 struct in_device *in_dev,
1976 __be32 daddr, __be32 saddr, u32 tos,
1977 struct rtable **result)
1da177e4 1978{
1da177e4
LT		 1979 struct rtable *rth;
1980 int err;
1981 struct in_device *out_dev;
47360228 1982 unsigned int flags = 0;
d9c9df8c
AV		 1983 __be32 spec_dst;
1984 u32 itag;
1da177e4
LT		 1985
1986 /* get a working reference to the output device */
47360228 1987 out_dev = __in_dev_get_rcu(FIB_RES_DEV(*res));
1da177e4
LT		 1988 if (out_dev == NULL) {
1989 if (net_ratelimit())
1990 printk(KERN_CRIT "Bug in ip_route_input" \
1991 "_slow(). Please, report\n");
1992 return -EINVAL;
1993 }
1994
1995
5c04c819
MS		 1996 err = fib_validate_source(skb, saddr, daddr, tos, FIB_RES_OIF(*res),
1997 in_dev->dev, &spec_dst, &itag);
1da177e4 1998 if (err < 0) {
e905a9ed 1999 ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
1da177e4 2000 saddr);
e905a9ed 2001
1da177e4
LT		 2002 goto cleanup;
2003 }
2004
2005 if (err)
2006 flags |= RTCF_DIRECTSRC;
2007
51b77cae 2008 if (out_dev == in_dev && err &&
1da177e4
LT		 2009 (IN_DEV_SHARED_MEDIA(out_dev) ||
2010 inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
2011 flags |= RTCF_DOREDIRECT;
2012
2013 if (skb->protocol != htons(ETH_P_IP)) {
2014 /* Not IP (i.e. ARP). Do not create route, if it is
2015 * invalid for proxy arp. DNAT routes are always valid.
65324144
JDB		 2016 *
2017 * Proxy arp feature have been extended to allow, ARP
2018 * replies back to the same interface, to support
2019 * Private VLAN switch technologies. See arp.c.
1da177e4 2020 */
65324144
JDB		 2021 if (out_dev == in_dev &&
2022 IN_DEV_PROXY_ARP_PVLAN(in_dev) == 0) {
1da177e4
LT		 2023 err = -EINVAL;
2024 goto cleanup;
2025 }
2026 }
2027
5c1e6aa3
DM		 2028 rth = rt_dst_alloc(out_dev->dev,
2029 IN_DEV_CONF_GET(in_dev, NOPOLICY),
0c4dcd58 2030 IN_DEV_CONF_GET(out_dev, NOXFRM));
1da177e4
LT		 2031 if (!rth) {
2032 err = -ENOBUFS;
2033 goto cleanup;
2034 }
2035
5e2b61f7 2036 rth->rt_key_dst = daddr;
5e2b61f7 2037 rth->rt_key_src = saddr;
cf911662
DM		 2038 rth->rt_genid = rt_genid(dev_net(rth->dst.dev));
2039 rth->rt_flags = flags;
2040 rth->rt_type = res->type;
475949d8 2041 rth->rt_key_tos = tos;
cf911662 2042 rth->rt_dst = daddr;
1da177e4 2043 rth->rt_src = saddr;
1b86a58f 2044 rth->rt_route_iif = in_dev->dev->ifindex;
5e2b61f7 2045 rth->rt_iif = in_dev->dev->ifindex;
5e2b61f7 2046 rth->rt_oif = 0;
cf911662
DM		 2047 rth->rt_mark = skb->mark;
2048 rth->rt_gateway = daddr;
1da177e4 2049 rth->rt_spec_dst= spec_dst;
cf911662
DM		 2050 rth->rt_peer_genid = 0;
2051 rth->peer = NULL;
2052 rth->fi = NULL;
1da177e4 2053
d8d1f30b
CG		 2054 rth->dst.input = ip_forward;
2055 rth->dst.output = ip_output;
1da177e4 2056
5e2b61f7 2057 rt_set_nexthop(rth, NULL, res, res->fi, res->type, itag);
1da177e4 2058
1da177e4
LT		 2059 *result = rth;
2060 err = 0;
2061 cleanup:
1da177e4 2062 return err;
e905a9ed 2063}
1da177e4 2064
5969f71d
SH		 2065static int ip_mkroute_input(struct sk_buff *skb,
2066 struct fib_result *res,
68a5e3dd 2067 const struct flowi4 *fl4,
5969f71d
SH		 2068 struct in_device *in_dev,
2069 __be32 daddr, __be32 saddr, u32 tos)
1da177e4 2070{
7abaa27c 2071 struct rtable* rth = NULL;
1da177e4
LT		 2072 int err;
2073 unsigned hash;
2074
2075#ifdef CONFIG_IP_ROUTE_MULTIPATH
ff3fccb3 2076 if (res->fi && res->fi->fib_nhs > 1)
1b7fe593 2077 fib_select_multipath(res);
1da177e4
LT		 2078#endif
2079
2080 /* create a routing cache entry */
2081 err = __mkroute_input(skb, res, in_dev, daddr, saddr, tos, &rth);
2082 if (err)
2083 return err;
1da177e4
LT		 2084
2085 /* put it into the cache */
68a5e3dd 2086 hash = rt_hash(daddr, saddr, fl4->flowi4_iif,
d8d1f30b 2087 rt_genid(dev_net(rth->dst.dev)));
68a5e3dd 2088 rth = rt_intern_hash(hash, rth, skb, fl4->flowi4_iif);
b23dd4fe
DM		 2089 if (IS_ERR(rth))
2090 return PTR_ERR(rth);
2091 return 0;
1da177e4
LT		 2092}
2093
1da177e4
LT		 2094/*
2095 * NOTE. We drop all the packets that has local source
2096 * addresses, because every properly looped back packet
2097 * must have correct destination already attached by output routine.
2098 *
2099 * Such approach solves two big problems:
2100 * 1. Not simplex devices are handled properly.
2101 * 2. IP spoofing attempts are filtered with 100% of guarantee.
ebc0ffae 2102 * called with rcu_read_lock()
1da177e4
LT		 2103 */
2104
9e12bb22 2105static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1da177e4
LT		 2106 u8 tos, struct net_device *dev)
2107{
2108 struct fib_result res;
96d36220 2109 struct in_device *in_dev = __in_dev_get_rcu(dev);
68a5e3dd 2110 struct flowi4 fl4;
1da177e4
LT		 2111 unsigned flags = 0;
2112 u32 itag = 0;
2113 struct rtable * rth;
2114 unsigned hash;
9e12bb22 2115 __be32 spec_dst;
1da177e4 2116 int err = -EINVAL;
c346dca1 2117 struct net * net = dev_net(dev);
1da177e4
LT		 2118
2119 /* IP on this device is disabled. */
2120
2121 if (!in_dev)
2122 goto out;
2123
2124 /* Check for the most weird martians, which can be not detected
2125 by fib_lookup.
2126 */
2127
1e637c74 2128 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
f97c1e0c 2129 ipv4_is_loopback(saddr))
1da177e4
LT		 2130 goto martian_source;
2131
27a954bd 2132 if (ipv4_is_lbcast(daddr) || (saddr == 0 && daddr == 0))
1da177e4
LT		 2133 goto brd_input;
2134
2135 /* Accept zero addresses only to limited broadcast;
2136 * I even do not know to fix it or not. Waiting for complains :-)
2137 */
f97c1e0c 2138 if (ipv4_is_zeronet(saddr))
1da177e4
LT		 2139 goto martian_source;
2140
27a954bd 2141 if (ipv4_is_zeronet(daddr) || ipv4_is_loopback(daddr))
1da177e4
LT		 2142 goto martian_destination;
2143
2144 /*
2145 * Now we are ready to route packet.
2146 */
68a5e3dd
DM		 2147 fl4.flowi4_oif = 0;
2148 fl4.flowi4_iif = dev->ifindex;
2149 fl4.flowi4_mark = skb->mark;
2150 fl4.flowi4_tos = tos;
2151 fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
2152 fl4.daddr = daddr;
2153 fl4.saddr = saddr;
2154 err = fib_lookup(net, &fl4, &res);
ebc0ffae 2155 if (err != 0) {
1da177e4 2156 if (!IN_DEV_FORWARD(in_dev))
2c2910a4 2157 goto e_hostunreach;
1da177e4
LT		 2158 goto no_route;
2159 }
1da177e4
LT		 2160
2161 RT_CACHE_STAT_INC(in_slow_tot);
2162
2163 if (res.type == RTN_BROADCAST)
2164 goto brd_input;
2165
2166 if (res.type == RTN_LOCAL) {
5c04c819 2167 err = fib_validate_source(skb, saddr, daddr, tos,
ebc0ffae 2168 net->loopback_dev->ifindex,
5c04c819 2169 dev, &spec_dst, &itag);
b5f7e755
ED		 2170 if (err < 0)
2171 goto martian_source_keep_err;
2172 if (err)
1da177e4
LT		 2173 flags |= RTCF_DIRECTSRC;
2174 spec_dst = daddr;
2175 goto local_input;
2176 }
2177
2178 if (!IN_DEV_FORWARD(in_dev))
2c2910a4 2179 goto e_hostunreach;
1da177e4
LT		 2180 if (res.type != RTN_UNICAST)
2181 goto martian_destination;
2182
68a5e3dd 2183 err = ip_mkroute_input(skb, &res, &fl4, in_dev, daddr, saddr, tos);
1da177e4
LT		 2184out: return err;
2185
2186brd_input:
2187 if (skb->protocol != htons(ETH_P_IP))
2188 goto e_inval;
2189
f97c1e0c 2190 if (ipv4_is_zeronet(saddr))
1da177e4
LT		 2191 spec_dst = inet_select_addr(dev, 0, RT_SCOPE_LINK);
2192 else {
5c04c819
MS		 2193 err = fib_validate_source(skb, saddr, 0, tos, 0, dev, &spec_dst,
2194 &itag);
1da177e4 2195 if (err < 0)
b5f7e755 2196 goto martian_source_keep_err;
1da177e4
LT		 2197 if (err)
2198 flags |= RTCF_DIRECTSRC;
2199 }
2200 flags |= RTCF_BROADCAST;
2201 res.type = RTN_BROADCAST;
2202 RT_CACHE_STAT_INC(in_brd);
2203
2204local_input:
5c1e6aa3
DM		 2205 rth = rt_dst_alloc(net->loopback_dev,
2206 IN_DEV_CONF_GET(in_dev, NOPOLICY), false);
1da177e4
LT		 2207 if (!rth)
2208 goto e_nobufs;
2209
cf911662 2210 rth->dst.input= ip_local_deliver;
d8d1f30b 2211 rth->dst.output= ip_rt_bug;
cf911662
DM		 2212#ifdef CONFIG_IP_ROUTE_CLASSID
2213 rth->dst.tclassid = itag;
2214#endif
1da177e4 2215
5e2b61f7 2216 rth->rt_key_dst = daddr;
5e2b61f7 2217 rth->rt_key_src = saddr;
cf911662
DM		 2218 rth->rt_genid = rt_genid(net);
2219 rth->rt_flags = flags|RTCF_LOCAL;
2220 rth->rt_type = res.type;
475949d8 2221 rth->rt_key_tos = tos;
cf911662 2222 rth->rt_dst = daddr;
1da177e4 2223 rth->rt_src = saddr;
c7066f70 2224#ifdef CONFIG_IP_ROUTE_CLASSID
d8d1f30b 2225 rth->dst.tclassid = itag;
1da177e4 2226#endif
1b86a58f 2227 rth->rt_route_iif = dev->ifindex;
5e2b61f7 2228 rth->rt_iif = dev->ifindex;
cf911662
DM		 2229 rth->rt_oif = 0;
2230 rth->rt_mark = skb->mark;
1da177e4
LT		 2231 rth->rt_gateway = daddr;
2232 rth->rt_spec_dst= spec_dst;
cf911662
DM		 2233 rth->rt_peer_genid = 0;
2234 rth->peer = NULL;
2235 rth->fi = NULL;
1da177e4 2236 if (res.type == RTN_UNREACHABLE) {
d8d1f30b
CG		 2237 rth->dst.input= ip_error;
2238 rth->dst.error= -err;
1da177e4
LT		 2239 rth->rt_flags &= ~RTCF_LOCAL;
2240 }
68a5e3dd
DM		 2241 hash = rt_hash(daddr, saddr, fl4.flowi4_iif, rt_genid(net));
2242 rth = rt_intern_hash(hash, rth, skb, fl4.flowi4_iif);
b23dd4fe
DM		 2243 err = 0;
2244 if (IS_ERR(rth))
2245 err = PTR_ERR(rth);
ebc0ffae 2246 goto out;
1da177e4
LT		 2247
2248no_route:
2249 RT_CACHE_STAT_INC(in_no_route);
2250 spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
2251 res.type = RTN_UNREACHABLE;
7f53878d
MC		 2252 if (err == -ESRCH)
2253 err = -ENETUNREACH;
1da177e4
LT		 2254 goto local_input;
2255
2256 /*
2257 * Do not cache martian addresses: they should be logged (RFC1812)
2258 */
2259martian_destination:
2260 RT_CACHE_STAT_INC(in_martian_dst);
2261#ifdef CONFIG_IP_ROUTE_VERBOSE
2262 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit())
673d57e7
HH		 2263 printk(KERN_WARNING "martian destination %pI4 from %pI4, dev %s\n",
2264 &daddr, &saddr, dev->name);
1da177e4 2265#endif
2c2910a4
DE		 2266
2267e_hostunreach:
e905a9ed 2268 err = -EHOSTUNREACH;
ebc0ffae 2269 goto out;
2c2910a4 2270
1da177e4
LT		 2271e_inval:
2272 err = -EINVAL;
ebc0ffae 2273 goto out;
1da177e4
LT		 2274
2275e_nobufs:
2276 err = -ENOBUFS;
ebc0ffae 2277 goto out;
1da177e4
LT		 2278
2279martian_source:
b5f7e755
ED		 2280 err = -EINVAL;
2281martian_source_keep_err:
1da177e4 2282 ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
ebc0ffae 2283 goto out;
1da177e4
LT		 2284}
2285
407eadd9
ED		 2286int ip_route_input_common(struct sk_buff *skb, __be32 daddr, __be32 saddr,
2287 u8 tos, struct net_device *dev, bool noref)
1da177e4
LT		 2288{
2289 struct rtable * rth;
2290 unsigned hash;
2291 int iif = dev->ifindex;
b5921910 2292 struct net *net;
96d36220 2293 int res;
1da177e4 2294
c346dca1 2295 net = dev_net(dev);
1080d709 2296
96d36220
ED		 2297 rcu_read_lock();
2298
1080d709
NH		 2299 if (!rt_caching(net))
2300 goto skip_cache;
2301
1da177e4 2302 tos &= IPTOS_RT_MASK;
e84f84f2 2303 hash = rt_hash(daddr, saddr, iif, rt_genid(net));
1da177e4 2304
1da177e4 2305 for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
d8d1f30b 2306 rth = rcu_dereference(rth->dst.rt_next)) {
5e2b61f7
DM		 2307 if ((((__force u32)rth->rt_key_dst ^ (__force u32)daddr) |
2308 ((__force u32)rth->rt_key_src ^ (__force u32)saddr) |
2309 (rth->rt_iif ^ iif) |
2310 rth->rt_oif |
475949d8 2311 (rth->rt_key_tos ^ tos)) == 0 &&
5e2b61f7 2312 rth->rt_mark == skb->mark &&
d8d1f30b 2313 net_eq(dev_net(rth->dst.dev), net) &&
e84f84f2 2314 !rt_is_expired(rth)) {
407eadd9 2315 if (noref) {
d8d1f30b
CG		 2316 dst_use_noref(&rth->dst, jiffies);
2317 skb_dst_set_noref(skb, &rth->dst);
407eadd9 2318 } else {
d8d1f30b
CG		 2319 dst_use(&rth->dst, jiffies);
2320 skb_dst_set(skb, &rth->dst);
407eadd9 2321 }
1da177e4
LT		 2322 RT_CACHE_STAT_INC(in_hit);
2323 rcu_read_unlock();
1da177e4
LT		 2324 return 0;
2325 }
2326 RT_CACHE_STAT_INC(in_hlist_search);
2327 }
1da177e4 2328
1080d709 2329skip_cache:
1da177e4
LT		 2330 /* Multicast recognition logic is moved from route cache to here.
2331 The problem was that too many Ethernet cards have broken/missing
2332 hardware multicast filters :-( As result the host on multicasting
2333 network acquires a lot of useless route cache entries, sort of
2334 SDR messages from all the world. Now we try to get rid of them.
2335 Really, provided software IP multicast filter is organized
2336 reasonably (at least, hashed), it does not result in a slowdown
2337 comparing with route cache reject entries.
2338 Note, that multicast routers are not affected, because
2339 route cache entry is created eventually.
2340 */
f97c1e0c 2341 if (ipv4_is_multicast(daddr)) {
96d36220 2342 struct in_device *in_dev = __in_dev_get_rcu(dev);
1da177e4 2343
96d36220 2344 if (in_dev) {
dbdd9a52
DM		 2345 int our = ip_check_mc_rcu(in_dev, daddr, saddr,
2346 ip_hdr(skb)->protocol);
1da177e4
LT		 2347 if (our
2348#ifdef CONFIG_IP_MROUTE
9d4fb27d
JP		 2349 ||
2350 (!ipv4_is_local_multicast(daddr) &&
2351 IN_DEV_MFORWARD(in_dev))
1da177e4 2352#endif
9d4fb27d 2353 ) {
96d36220
ED		 2354 int res = ip_route_input_mc(skb, daddr, saddr,
2355 tos, dev, our);
1da177e4 2356 rcu_read_unlock();
96d36220 2357 return res;
1da177e4
LT		 2358 }
2359 }
2360 rcu_read_unlock();
2361 return -EINVAL;
2362 }
96d36220
ED		 2363 res = ip_route_input_slow(skb, daddr, saddr, tos, dev);
2364 rcu_read_unlock();
2365 return res;
1da177e4 2366}
407eadd9 2367EXPORT_SYMBOL(ip_route_input_common);
1da177e4 2368
ebc0ffae 2369/* called with rcu_read_lock() */
982721f3 2370static struct rtable *__mkroute_output(const struct fib_result *res,
68a5e3dd 2371 const struct flowi4 *fl4,
813b3b5d
DM		 2372 __be32 orig_daddr, __be32 orig_saddr,
2373 int orig_oif, struct net_device *dev_out,
5ada5527 2374 unsigned int flags)
1da177e4 2375{
982721f3 2376 struct fib_info *fi = res->fi;
813b3b5d 2377 u32 tos = RT_FL_TOS(fl4);
5ada5527 2378 struct in_device *in_dev;
982721f3 2379 u16 type = res->type;
5ada5527 2380 struct rtable *rth;
1da177e4 2381
68a5e3dd 2382 if (ipv4_is_loopback(fl4->saddr) && !(dev_out->flags & IFF_LOOPBACK))
5ada5527 2383 return ERR_PTR(-EINVAL);
1da177e4 2384
68a5e3dd 2385 if (ipv4_is_lbcast(fl4->daddr))
982721f3 2386 type = RTN_BROADCAST;
68a5e3dd 2387 else if (ipv4_is_multicast(fl4->daddr))
982721f3 2388 type = RTN_MULTICAST;
68a5e3dd 2389 else if (ipv4_is_zeronet(fl4->daddr))
5ada5527 2390 return ERR_PTR(-EINVAL);
1da177e4
LT		 2391
2392 if (dev_out->flags & IFF_LOOPBACK)
2393 flags |= RTCF_LOCAL;
2394
dd28d1a0 2395 in_dev = __in_dev_get_rcu(dev_out);
ebc0ffae 2396 if (!in_dev)
5ada5527 2397 return ERR_PTR(-EINVAL);
ebc0ffae 2398
982721f3 2399 if (type == RTN_BROADCAST) {
1da177e4 2400 flags |= RTCF_BROADCAST | RTCF_LOCAL;
982721f3
DM		 2401 fi = NULL;
2402 } else if (type == RTN_MULTICAST) {
dd28d1a0 2403 flags |= RTCF_MULTICAST | RTCF_LOCAL;
813b3b5d
DM		 2404 if (!ip_check_mc_rcu(in_dev, fl4->daddr, fl4->saddr,
2405 fl4->flowi4_proto))
1da177e4
LT		 2406 flags &= ~RTCF_LOCAL;
2407 /* If multicast route do not exist use
dd28d1a0
ED		 2408 * default one, but do not gateway in this case.
2409 * Yes, it is hack.
1da177e4 2410 */
982721f3
DM		 2411 if (fi && res->prefixlen < 4)
2412 fi = NULL;
1da177e4
LT		 2413 }
2414
5c1e6aa3
DM		 2415 rth = rt_dst_alloc(dev_out,
2416 IN_DEV_CONF_GET(in_dev, NOPOLICY),
0c4dcd58 2417 IN_DEV_CONF_GET(in_dev, NOXFRM));
8391d07b 2418 if (!rth)
5ada5527 2419 return ERR_PTR(-ENOBUFS);
8391d07b 2420
cf911662
DM		 2421 rth->dst.output = ip_output;
2422
813b3b5d
DM		 2423 rth->rt_key_dst = orig_daddr;
2424 rth->rt_key_src = orig_saddr;
cf911662
DM		 2425 rth->rt_genid = rt_genid(dev_net(dev_out));
2426 rth->rt_flags = flags;
2427 rth->rt_type = type;
475949d8 2428 rth->rt_key_tos = tos;
68a5e3dd
DM		 2429 rth->rt_dst = fl4->daddr;
2430 rth->rt_src = fl4->saddr;
1b86a58f 2431 rth->rt_route_iif = 0;
813b3b5d
DM		 2432 rth->rt_iif = orig_oif ? : dev_out->ifindex;
2433 rth->rt_oif = orig_oif;
2434 rth->rt_mark = fl4->flowi4_mark;
68a5e3dd
DM		 2435 rth->rt_gateway = fl4->daddr;
2436 rth->rt_spec_dst= fl4->saddr;
cf911662
DM		 2437 rth->rt_peer_genid = 0;
2438 rth->peer = NULL;
2439 rth->fi = NULL;
1da177e4
LT		 2440
2441 RT_CACHE_STAT_INC(out_slow_tot);
2442
2443 if (flags & RTCF_LOCAL) {
d8d1f30b 2444 rth->dst.input = ip_local_deliver;
68a5e3dd 2445 rth->rt_spec_dst = fl4->daddr;
1da177e4
LT		 2446 }
2447 if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
68a5e3dd 2448 rth->rt_spec_dst = fl4->saddr;
e905a9ed 2449 if (flags & RTCF_LOCAL &&
1da177e4 2450 !(dev_out->flags & IFF_LOOPBACK)) {
d8d1f30b 2451 rth->dst.output = ip_mc_output;
1da177e4
LT		 2452 RT_CACHE_STAT_INC(out_slow_mc);
2453 }
2454#ifdef CONFIG_IP_MROUTE
982721f3 2455 if (type == RTN_MULTICAST) {
1da177e4 2456 if (IN_DEV_MFORWARD(in_dev) &&
813b3b5d 2457 !ipv4_is_local_multicast(fl4->daddr)) {
d8d1f30b
CG		 2458 rth->dst.input = ip_mr_input;
2459 rth->dst.output = ip_mc_output;
1da177e4
LT		 2460 }
2461 }
2462#endif
2463 }
2464
813b3b5d 2465 rt_set_nexthop(rth, fl4, res, fi, type, 0);
1da177e4 2466
5ada5527 2467 return rth;
1da177e4
LT		 2468}
2469
1da177e4
LT		 2470/*
2471 * Major route resolver routine.
0197aa38 2472 * called with rcu_read_lock();
1da177e4
LT		 2473 */
2474
813b3b5d 2475static struct rtable *ip_route_output_slow(struct net *net, struct flowi4 *fl4)
1da177e4 2476{
1da177e4 2477 struct net_device *dev_out = NULL;
813b3b5d
DM		 2478 u32 tos = RT_FL_TOS(fl4);
2479 unsigned int flags = 0;
2480 struct fib_result res;
5ada5527 2481 struct rtable *rth;
813b3b5d
DM		 2482 __be32 orig_daddr;
2483 __be32 orig_saddr;
2484 int orig_oif;
1da177e4
LT		 2485
2486 res.fi = NULL;
2487#ifdef CONFIG_IP_MULTIPLE_TABLES
2488 res.r = NULL;
2489#endif
2490
813b3b5d
DM		 2491 orig_daddr = fl4->daddr;
2492 orig_saddr = fl4->saddr;
2493 orig_oif = fl4->flowi4_oif;
2494
2495 fl4->flowi4_iif = net->loopback_dev->ifindex;
2496 fl4->flowi4_tos = tos & IPTOS_RT_MASK;
2497 fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
2498 RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);
44713b67 2499
010c2708 2500 rcu_read_lock();
813b3b5d 2501 if (fl4->saddr) {
b23dd4fe 2502 rth = ERR_PTR(-EINVAL);
813b3b5d
DM		 2503 if (ipv4_is_multicast(fl4->saddr) ||
2504 ipv4_is_lbcast(fl4->saddr) ||
2505 ipv4_is_zeronet(fl4->saddr))
1da177e4
LT		 2506 goto out;
2507
1da177e4
LT		 2508 /* I removed check for oif == dev_out->oif here.
2509 It was wrong for two reasons:
1ab35276
DL		 2510 1. ip_dev_find(net, saddr) can return wrong iface, if saddr
2511 is assigned to multiple interfaces.
1da177e4
LT		 2512 2. Moreover, we are allowed to send packets with saddr
2513 of another iface. --ANK
2514 */
2515
813b3b5d
DM		 2516 if (fl4->flowi4_oif == 0 &&
2517 (ipv4_is_multicast(fl4->daddr) ||
2518 ipv4_is_lbcast(fl4->daddr))) {
a210d01a 2519 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
813b3b5d 2520 dev_out = __ip_dev_find(net, fl4->saddr, false);
a210d01a
JA		 2521 if (dev_out == NULL)
2522 goto out;
2523
1da177e4
LT		 2524 /* Special hack: user can direct multicasts
2525 and limited broadcast via necessary interface
2526 without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
2527 This hack is not just for fun, it allows
2528 vic,vat and friends to work.
2529 They bind socket to loopback, set ttl to zero
2530 and expect that it will work.
2531 From the viewpoint of routing cache they are broken,
2532 because we are not allowed to build multicast path
2533 with loopback source addr (look, routing cache
2534 cannot know, that ttl is zero, so that packet
2535 will not leave this host and route is valid).
2536 Luckily, this hack is good workaround.
2537 */
2538
813b3b5d 2539 fl4->flowi4_oif = dev_out->ifindex;
1da177e4
LT		 2540 goto make_route;
2541 }
a210d01a 2542
813b3b5d 2543 if (!(fl4->flowi4_flags & FLOWI_FLAG_ANYSRC)) {
a210d01a 2544 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
813b3b5d 2545 if (!__ip_dev_find(net, fl4->saddr, false))
a210d01a 2546 goto out;
a210d01a 2547 }
1da177e4
LT		 2548 }
2549
2550
813b3b5d
DM		 2551 if (fl4->flowi4_oif) {
2552 dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);
b23dd4fe 2553 rth = ERR_PTR(-ENODEV);
1da177e4
LT		 2554 if (dev_out == NULL)
2555 goto out;
e5ed6399
HX		 2556
2557 /* RACE: Check return value of inet_select_addr instead. */
fc75fc83 2558 if (!(dev_out->flags & IFF_UP) || !__in_dev_get_rcu(dev_out)) {
b23dd4fe 2559 rth = ERR_PTR(-ENETUNREACH);
fc75fc83
ED		 2560 goto out;
2561 }
813b3b5d
DM		 2562 if (ipv4_is_local_multicast(fl4->daddr) ||
2563 ipv4_is_lbcast(fl4->daddr)) {
2564 if (!fl4->saddr)
2565 fl4->saddr = inet_select_addr(dev_out, 0,
2566 RT_SCOPE_LINK);
1da177e4
LT		 2567 goto make_route;
2568 }
813b3b5d
DM		 2569 if (fl4->saddr) {
2570 if (ipv4_is_multicast(fl4->daddr))
2571 fl4->saddr = inet_select_addr(dev_out, 0,
2572 fl4->flowi4_scope);
2573 else if (!fl4->daddr)
2574 fl4->saddr = inet_select_addr(dev_out, 0,
2575 RT_SCOPE_HOST);
1da177e4
LT		 2576 }
2577 }
2578
813b3b5d
DM		 2579 if (!fl4->daddr) {
2580 fl4->daddr = fl4->saddr;
2581 if (!fl4->daddr)
2582 fl4->daddr = fl4->saddr = htonl(INADDR_LOOPBACK);
b40afd0e 2583 dev_out = net->loopback_dev;
813b3b5d 2584 fl4->flowi4_oif = net->loopback_dev->ifindex;
1da177e4
LT		 2585 res.type = RTN_LOCAL;
2586 flags |= RTCF_LOCAL;
2587 goto make_route;
2588 }
2589
813b3b5d 2590 if (fib_lookup(net, fl4, &res)) {
1da177e4 2591 res.fi = NULL;
813b3b5d 2592 if (fl4->flowi4_oif) {
1da177e4
LT		 2593 /* Apparently, routing tables are wrong. Assume,
2594 that the destination is on link.
2595
2596 WHY? DW.
2597 Because we are allowed to send to iface
2598 even if it has NO routes and NO assigned
2599 addresses. When oif is specified, routing
2600 tables are looked up with only one purpose:
2601 to catch if destination is gatewayed, rather than
2602 direct. Moreover, if MSG_DONTROUTE is set,
2603 we send packet, ignoring both routing tables
2604 and ifaddr state. --ANK
2605
2606
2607 We could make it even if oif is unknown,
2608 likely IPv6, but we do not.
2609 */
2610
813b3b5d
DM		 2611 if (fl4->saddr == 0)
2612 fl4->saddr = inet_select_addr(dev_out, 0,
2613 RT_SCOPE_LINK);
1da177e4
LT		 2614 res.type = RTN_UNICAST;
2615 goto make_route;
2616 }
b23dd4fe 2617 rth = ERR_PTR(-ENETUNREACH);
1da177e4
LT		 2618 goto out;
2619 }
1da177e4
LT		 2620
2621 if (res.type == RTN_LOCAL) {
813b3b5d 2622 if (!fl4->saddr) {
9fc3bbb4 2623 if (res.fi->fib_prefsrc)
813b3b5d 2624 fl4->saddr = res.fi->fib_prefsrc;
9fc3bbb4 2625 else
813b3b5d 2626 fl4->saddr = fl4->daddr;
9fc3bbb4 2627 }
b40afd0e 2628 dev_out = net->loopback_dev;
813b3b5d 2629 fl4->flowi4_oif = dev_out->ifindex;
1da177e4
LT		 2630 res.fi = NULL;
2631 flags |= RTCF_LOCAL;
2632 goto make_route;
2633 }
2634
2635#ifdef CONFIG_IP_ROUTE_MULTIPATH
813b3b5d 2636 if (res.fi->fib_nhs > 1 && fl4->flowi4_oif == 0)
1b7fe593 2637 fib_select_multipath(&res);
1da177e4
LT		 2638 else
2639#endif
21d8c49e
DM		 2640 if (!res.prefixlen &&
2641 res.table->tb_num_default > 1 &&
813b3b5d 2642 res.type == RTN_UNICAST && !fl4->flowi4_oif)
0c838ff1 2643 fib_select_default(&res);
1da177e4 2644
813b3b5d
DM		 2645 if (!fl4->saddr)
2646 fl4->saddr = FIB_RES_PREFSRC(net, res);
1da177e4 2647
1da177e4 2648 dev_out = FIB_RES_DEV(res);
813b3b5d 2649 fl4->flowi4_oif = dev_out->ifindex;
1da177e4
LT		 2650
2651
2652make_route:
813b3b5d
DM		 2653 rth = __mkroute_output(&res, fl4, orig_daddr, orig_saddr, orig_oif,
2654 dev_out, flags);
b23dd4fe 2655 if (!IS_ERR(rth)) {
5ada5527
DM		 2656 unsigned int hash;
2657
813b3b5d 2658 hash = rt_hash(orig_daddr, orig_saddr, orig_oif,
5ada5527 2659 rt_genid(dev_net(dev_out)));
813b3b5d 2660 rth = rt_intern_hash(hash, rth, NULL, orig_oif);
5ada5527 2661 }
1da177e4 2662
010c2708
DM		 2663out:
2664 rcu_read_unlock();
b23dd4fe 2665 return rth;
1da177e4
LT		 2666}
2667
813b3b5d 2668struct rtable *__ip_route_output_key(struct net *net, struct flowi4 *flp4)
1da177e4 2669{
1da177e4 2670 struct rtable *rth;
010c2708 2671 unsigned int hash;
1da177e4 2672
1080d709
NH		 2673 if (!rt_caching(net))
2674 goto slow_output;
2675
9d6ec938 2676 hash = rt_hash(flp4->daddr, flp4->saddr, flp4->flowi4_oif, rt_genid(net));
1da177e4
LT		 2677
2678 rcu_read_lock_bh();
a898def2 2679 for (rth = rcu_dereference_bh(rt_hash_table[hash].chain); rth;
d8d1f30b 2680 rth = rcu_dereference_bh(rth->dst.rt_next)) {
9d6ec938
DM		 2681 if (rth->rt_key_dst == flp4->daddr &&
2682 rth->rt_key_src == flp4->saddr &&
c7537967 2683 rt_is_output_route(rth) &&
9d6ec938
DM		 2684 rth->rt_oif == flp4->flowi4_oif &&
2685 rth->rt_mark == flp4->flowi4_mark &&
475949d8 2686 !((rth->rt_key_tos ^ flp4->flowi4_tos) &
b5921910 2687 (IPTOS_RT_MASK | RTO_ONLINK)) &&
d8d1f30b 2688 net_eq(dev_net(rth->dst.dev), net) &&
e84f84f2 2689 !rt_is_expired(rth)) {
d8d1f30b 2690 dst_use(&rth->dst, jiffies);
1da177e4
LT		 2691 RT_CACHE_STAT_INC(out_hit);
2692 rcu_read_unlock_bh();
56157872
DM		 2693 if (!flp4->saddr)
2694 flp4->saddr = rth->rt_src;
2695 if (!flp4->daddr)
2696 flp4->daddr = rth->rt_dst;
b23dd4fe 2697 return rth;
1da177e4
LT		 2698 }
2699 RT_CACHE_STAT_INC(out_hlist_search);
2700 }
2701 rcu_read_unlock_bh();
2702
1080d709 2703slow_output:
9d6ec938 2704 return ip_route_output_slow(net, flp4);
1da177e4 2705}
d8c97a94
ACM		 2706EXPORT_SYMBOL_GPL(__ip_route_output_key);
2707
ae2688d5
JW		 2708static struct dst_entry *ipv4_blackhole_dst_check(struct dst_entry *dst, u32 cookie)
2709{
2710 return NULL;
2711}
2712
ec831ea7
RD		 2713static unsigned int ipv4_blackhole_default_mtu(const struct dst_entry *dst)
2714{
2715 return 0;
2716}
2717
14e50e57
DM		 2718static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu)
2719{
2720}
2721
0972ddb2
HB		 2722static u32 *ipv4_rt_blackhole_cow_metrics(struct dst_entry *dst,
2723 unsigned long old)
2724{
2725 return NULL;
2726}
2727
14e50e57
DM		 2728static struct dst_ops ipv4_dst_blackhole_ops = {
2729 .family = AF_INET,
09640e63 2730 .protocol = cpu_to_be16(ETH_P_IP),
14e50e57 2731 .destroy = ipv4_dst_destroy,
ae2688d5 2732 .check = ipv4_blackhole_dst_check,
ec831ea7 2733 .default_mtu = ipv4_blackhole_default_mtu,
214f45c9 2734 .default_advmss = ipv4_default_advmss,
14e50e57 2735 .update_pmtu = ipv4_rt_blackhole_update_pmtu,
0972ddb2 2736 .cow_metrics = ipv4_rt_blackhole_cow_metrics,
14e50e57
DM		 2737};
2738
2774c131 2739struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig)
14e50e57 2740{
5c1e6aa3 2741 struct rtable *rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, 0, 0);
2774c131 2742 struct rtable *ort = (struct rtable *) dst_orig;
14e50e57
DM		 2743
2744 if (rt) {
d8d1f30b 2745 struct dst_entry *new = &rt->dst;
14e50e57 2746
14e50e57 2747 new->__use = 1;
352e512c
HX		 2748 new->input = dst_discard;
2749 new->output = dst_discard;
defb3519 2750 dst_copy_metrics(new, &ort->dst);
14e50e57 2751
d8d1f30b 2752 new->dev = ort->dst.dev;
14e50e57
DM		 2753 if (new->dev)
2754 dev_hold(new->dev);
2755
5e2b61f7
DM		 2756 rt->rt_key_dst = ort->rt_key_dst;
2757 rt->rt_key_src = ort->rt_key_src;
475949d8 2758 rt->rt_key_tos = ort->rt_key_tos;
1b86a58f 2759 rt->rt_route_iif = ort->rt_route_iif;
5e2b61f7
DM		 2760 rt->rt_iif = ort->rt_iif;
2761 rt->rt_oif = ort->rt_oif;
2762 rt->rt_mark = ort->rt_mark;
14e50e57 2763
e84f84f2 2764 rt->rt_genid = rt_genid(net);
14e50e57
DM		 2765 rt->rt_flags = ort->rt_flags;
2766 rt->rt_type = ort->rt_type;
2767 rt->rt_dst = ort->rt_dst;
2768 rt->rt_src = ort->rt_src;
14e50e57
DM		 2769 rt->rt_gateway = ort->rt_gateway;
2770 rt->rt_spec_dst = ort->rt_spec_dst;
2771 rt->peer = ort->peer;
2772 if (rt->peer)
2773 atomic_inc(&rt->peer->refcnt);
62fa8a84
DM		 2774 rt->fi = ort->fi;
2775 if (rt->fi)
2776 atomic_inc(&rt->fi->fib_clntref);
14e50e57
DM		 2777
2778 dst_free(new);
2779 }
2780
2774c131
DM		 2781 dst_release(dst_orig);
2782
2783 return rt ? &rt->dst : ERR_PTR(-ENOMEM);
14e50e57
DM		 2784}
2785
9d6ec938 2786struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4,
b23dd4fe 2787 struct sock *sk)
1da177e4 2788{
9d6ec938 2789 struct rtable *rt = __ip_route_output_key(net, flp4);
1da177e4 2790
b23dd4fe
DM		 2791 if (IS_ERR(rt))
2792 return rt;
1da177e4 2793
56157872 2794 if (flp4->flowi4_proto)
9d6ec938
DM		 2795 rt = (struct rtable *) xfrm_lookup(net, &rt->dst,
2796 flowi4_to_flowi(flp4),
2797 sk, 0);
1da177e4 2798
b23dd4fe 2799 return rt;
1da177e4 2800}
d8c97a94
ACM		 2801EXPORT_SYMBOL_GPL(ip_route_output_flow);
2802
4feb88e5
BT		 2803static int rt_fill_info(struct net *net,
2804 struct sk_buff *skb, u32 pid, u32 seq, int event,
b6544c0b 2805 int nowait, unsigned int flags)
1da177e4 2806{
511c3f92 2807 struct rtable *rt = skb_rtable(skb);
1da177e4 2808 struct rtmsg *r;
be403ea1 2809 struct nlmsghdr *nlh;
fe6fe792
ED		 2810 long expires = 0;
2811 const struct inet_peer *peer = rt->peer;
e3703b3d 2812 u32 id = 0, ts = 0, tsage = 0, error;
be403ea1
TG		 2813
2814 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*r), flags);
2815 if (nlh == NULL)
26932566 2816 return -EMSGSIZE;
be403ea1
TG		 2817
2818 r = nlmsg_data(nlh);
1da177e4
LT		 2819 r->rtm_family = AF_INET;
2820 r->rtm_dst_len = 32;
2821 r->rtm_src_len = 0;
475949d8 2822 r->rtm_tos = rt->rt_key_tos;
1da177e4 2823 r->rtm_table = RT_TABLE_MAIN;
be403ea1 2824 NLA_PUT_U32(skb, RTA_TABLE, RT_TABLE_MAIN);
1da177e4
LT		 2825 r->rtm_type = rt->rt_type;
2826 r->rtm_scope = RT_SCOPE_UNIVERSE;
2827 r->rtm_protocol = RTPROT_UNSPEC;
2828 r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
2829 if (rt->rt_flags & RTCF_NOTIFY)
2830 r->rtm_flags |= RTM_F_NOTIFY;
be403ea1 2831
17fb2c64 2832 NLA_PUT_BE32(skb, RTA_DST, rt->rt_dst);
be403ea1 2833
5e2b61f7 2834 if (rt->rt_key_src) {
1da177e4 2835 r->rtm_src_len = 32;
5e2b61f7 2836 NLA_PUT_BE32(skb, RTA_SRC, rt->rt_key_src);
1da177e4 2837 }
d8d1f30b
CG		 2838 if (rt->dst.dev)
2839 NLA_PUT_U32(skb, RTA_OIF, rt->dst.dev->ifindex);
c7066f70 2840#ifdef CONFIG_IP_ROUTE_CLASSID
d8d1f30b
CG		 2841 if (rt->dst.tclassid)
2842 NLA_PUT_U32(skb, RTA_FLOW, rt->dst.tclassid);
1da177e4 2843#endif
c7537967 2844 if (rt_is_input_route(rt))
17fb2c64 2845 NLA_PUT_BE32(skb, RTA_PREFSRC, rt->rt_spec_dst);
5e2b61f7 2846 else if (rt->rt_src != rt->rt_key_src)
17fb2c64 2847 NLA_PUT_BE32(skb, RTA_PREFSRC, rt->rt_src);
be403ea1 2848
1da177e4 2849 if (rt->rt_dst != rt->rt_gateway)
17fb2c64 2850 NLA_PUT_BE32(skb, RTA_GATEWAY, rt->rt_gateway);
be403ea1 2851
defb3519 2852 if (rtnetlink_put_metrics(skb, dst_metrics_ptr(&rt->dst)) < 0)
be403ea1
TG		 2853 goto nla_put_failure;
2854
5e2b61f7
DM		 2855 if (rt->rt_mark)
2856 NLA_PUT_BE32(skb, RTA_MARK, rt->rt_mark);
963bfeee 2857
d8d1f30b 2858 error = rt->dst.error;
fe6fe792 2859 if (peer) {
317fe0e6 2860 inet_peer_refcheck(rt->peer);
fe6fe792
ED		 2861 id = atomic_read(&peer->ip_id_count) & 0xffff;
2862 if (peer->tcp_ts_stamp) {
2863 ts = peer->tcp_ts;
2864 tsage = get_seconds() - peer->tcp_ts_stamp;
1da177e4 2865 }
fe6fe792
ED		 2866 expires = ACCESS_ONCE(peer->pmtu_expires);
2867 if (expires)
2868 expires -= jiffies;
1da177e4 2869 }
be403ea1 2870
c7537967 2871 if (rt_is_input_route(rt)) {
1da177e4 2872#ifdef CONFIG_IP_MROUTE
e448515c 2873 __be32 dst = rt->rt_dst;
1da177e4 2874
f97c1e0c 2875 if (ipv4_is_multicast(dst) && !ipv4_is_local_multicast(dst) &&
4feb88e5 2876 IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
9a1b9496
DM		 2877 int err = ipmr_get_route(net, skb,
2878 rt->rt_src, rt->rt_dst,
2879 r, nowait);
1da177e4
LT		 2880 if (err <= 0) {
2881 if (!nowait) {
2882 if (err == 0)
2883 return 0;
be403ea1 2884 goto nla_put_failure;
1da177e4
LT		 2885 } else {
2886 if (err == -EMSGSIZE)
be403ea1 2887 goto nla_put_failure;
e3703b3d 2888 error = err;
1da177e4
LT		 2889 }
2890 }
2891 } else
2892#endif
5e2b61f7 2893 NLA_PUT_U32(skb, RTA_IIF, rt->rt_iif);
1da177e4
LT		 2894 }
2895
d8d1f30b 2896 if (rtnl_put_cacheinfo(skb, &rt->dst, id, ts, tsage,
e3703b3d
TG		 2897 expires, error) < 0)
2898 goto nla_put_failure;
be403ea1
TG		 2899
2900 return nlmsg_end(skb, nlh);
1da177e4 2901
be403ea1 2902nla_put_failure:
26932566
PM		 2903 nlmsg_cancel(skb, nlh);
2904 return -EMSGSIZE;
1da177e4
LT		 2905}
2906
63f3444f 2907static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
1da177e4 2908{
3b1e0a65 2909 struct net *net = sock_net(in_skb->sk);
d889ce3b
TG		 2910 struct rtmsg *rtm;
2911 struct nlattr *tb[RTA_MAX+1];
1da177e4 2912 struct rtable *rt = NULL;
9e12bb22
AV		 2913 __be32 dst = 0;
2914 __be32 src = 0;
2915 u32 iif;
d889ce3b 2916 int err;
963bfeee 2917 int mark;
1da177e4
LT		 2918 struct sk_buff *skb;
2919
d889ce3b
TG		 2920 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv4_policy);
2921 if (err < 0)
2922 goto errout;
2923
2924 rtm = nlmsg_data(nlh);
2925
1da177e4 2926 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
d889ce3b
TG		 2927 if (skb == NULL) {
2928 err = -ENOBUFS;
2929 goto errout;
2930 }
1da177e4
LT		 2931
2932 /* Reserve room for dummy headers, this skb can pass
2933 through good chunk of routing engine.
2934 */
459a98ed 2935 skb_reset_mac_header(skb);
c1d2bbe1 2936 skb_reset_network_header(skb);
d2c962b8
SH		 2937
2938 /* Bugfix: need to give ip_route_input enough of an IP header to not gag. */
eddc9ec5 2939 ip_hdr(skb)->protocol = IPPROTO_ICMP;
1da177e4
LT		 2940 skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));
2941
17fb2c64
AV		 2942 src = tb[RTA_SRC] ? nla_get_be32(tb[RTA_SRC]) : 0;
2943 dst = tb[RTA_DST] ? nla_get_be32(tb[RTA_DST]) : 0;
d889ce3b 2944 iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
963bfeee 2945 mark = tb[RTA_MARK] ? nla_get_u32(tb[RTA_MARK]) : 0;
1da177e4
LT		 2946
2947 if (iif) {
d889ce3b
TG		 2948 struct net_device *dev;
2949
1937504d 2950 dev = __dev_get_by_index(net, iif);
d889ce3b
TG		 2951 if (dev == NULL) {
2952 err = -ENODEV;
2953 goto errout_free;
2954 }
2955
1da177e4
LT		 2956 skb->protocol = htons(ETH_P_IP);
2957 skb->dev = dev;
963bfeee 2958 skb->mark = mark;
1da177e4
LT		 2959 local_bh_disable();
2960 err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
2961 local_bh_enable();
d889ce3b 2962
511c3f92 2963 rt = skb_rtable(skb);
d8d1f30b
CG		 2964 if (err == 0 && rt->dst.error)
2965 err = -rt->dst.error;
1da177e4 2966 } else {
68a5e3dd
DM		 2967 struct flowi4 fl4 = {
2968 .daddr = dst,
2969 .saddr = src,
2970 .flowi4_tos = rtm->rtm_tos,
2971 .flowi4_oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0,
2972 .flowi4_mark = mark,
d889ce3b 2973 };
9d6ec938 2974 rt = ip_route_output_key(net, &fl4);
b23dd4fe
DM		 2975
2976 err = 0;
2977 if (IS_ERR(rt))
2978 err = PTR_ERR(rt);
1da177e4 2979 }
d889ce3b 2980
1da177e4 2981 if (err)
d889ce3b 2982 goto errout_free;
1da177e4 2983
d8d1f30b 2984 skb_dst_set(skb, &rt->dst);
1da177e4
LT		 2985 if (rtm->rtm_flags & RTM_F_NOTIFY)
2986 rt->rt_flags |= RTCF_NOTIFY;
2987
4feb88e5 2988 err = rt_fill_info(net, skb, NETLINK_CB(in_skb).pid, nlh->nlmsg_seq,
1937504d 2989 RTM_NEWROUTE, 0, 0);
d889ce3b
TG		 2990 if (err <= 0)
2991 goto errout_free;
1da177e4 2992
1937504d 2993 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).pid);
d889ce3b 2994errout:
2942e900 2995 return err;
1da177e4 2996
d889ce3b 2997errout_free:
1da177e4 2998 kfree_skb(skb);
d889ce3b 2999 goto errout;
1da177e4
LT		 3000}
3001
3002int ip_rt_dump(struct sk_buff *skb, struct netlink_callback *cb)
3003{
3004 struct rtable *rt;
3005 int h, s_h;
3006 int idx, s_idx;
1937504d
DL		 3007 struct net *net;
3008
3b1e0a65 3009 net = sock_net(skb->sk);
1da177e4
LT		 3010
3011 s_h = cb->args[0];
d8c92830
ED		 3012 if (s_h < 0)
3013 s_h = 0;
1da177e4 3014 s_idx = idx = cb->args[1];
a6272665
ED		 3015 for (h = s_h; h <= rt_hash_mask; h++, s_idx = 0) {
3016 if (!rt_hash_table[h].chain)
3017 continue;
1da177e4 3018 rcu_read_lock_bh();
a898def2 3019 for (rt = rcu_dereference_bh(rt_hash_table[h].chain), idx = 0; rt;
d8d1f30b
CG		 3020 rt = rcu_dereference_bh(rt->dst.rt_next), idx++) {
3021 if (!net_eq(dev_net(rt->dst.dev), net) || idx < s_idx)
1da177e4 3022 continue;
e84f84f2 3023 if (rt_is_expired(rt))
29e75252 3024 continue;
d8d1f30b 3025 skb_dst_set_noref(skb, &rt->dst);
4feb88e5 3026 if (rt_fill_info(net, skb, NETLINK_CB(cb->skb).pid,
e905a9ed 3027 cb->nlh->nlmsg_seq, RTM_NEWROUTE,
b6544c0b 3028 1, NLM_F_MULTI) <= 0) {
adf30907 3029 skb_dst_drop(skb);
1da177e4
LT		 3030 rcu_read_unlock_bh();
3031 goto done;
3032 }
adf30907 3033 skb_dst_drop(skb);
1da177e4
LT		 3034 }
3035 rcu_read_unlock_bh();
3036 }
3037
3038done:
3039 cb->args[0] = h;
3040 cb->args[1] = idx;
3041 return skb->len;
3042}
3043
3044void ip_rt_multicast_event(struct in_device *in_dev)
3045{
76e6ebfb 3046 rt_cache_flush(dev_net(in_dev->dev), 0);
1da177e4
LT		 3047}
3048
3049#ifdef CONFIG_SYSCTL
81c684d1 3050static int ipv4_sysctl_rtcache_flush(ctl_table *__ctl, int write,
8d65af78 3051 void __user *buffer,
1da177e4
LT		 3052 size_t *lenp, loff_t *ppos)
3053{
3054 if (write) {
639e104f 3055 int flush_delay;
81c684d1 3056 ctl_table ctl;
39a23e75 3057 struct net *net;
639e104f 3058
81c684d1
DL		 3059 memcpy(&ctl, __ctl, sizeof(ctl));
3060 ctl.data = &flush_delay;
8d65af78 3061 proc_dointvec(&ctl, write, buffer, lenp, ppos);
639e104f 3062
81c684d1 3063 net = (struct net *)__ctl->extra1;
39a23e75 3064 rt_cache_flush(net, flush_delay);
1da177e4 3065 return 0;
e905a9ed 3066 }
1da177e4
LT		 3067
3068 return -EINVAL;
3069}
3070
eeb61f71 3071static ctl_table ipv4_route_table[] = {
1da177e4 3072 {
1da177e4
LT		 3073 .procname = "gc_thresh",
3074 .data = &ipv4_dst_ops.gc_thresh,
3075 .maxlen = sizeof(int),
3076 .mode = 0644,
6d9f239a 3077 .proc_handler = proc_dointvec,
1da177e4
LT		 3078 },
3079 {
1da177e4
LT		 3080 .procname = "max_size",
3081 .data = &ip_rt_max_size,
3082 .maxlen = sizeof(int),
3083 .mode = 0644,
6d9f239a 3084 .proc_handler = proc_dointvec,
1da177e4
LT		 3085 },
3086 {
3087 /* Deprecated. Use gc_min_interval_ms */
e905a9ed 3088
1da177e4
LT		 3089 .procname = "gc_min_interval",
3090 .data = &ip_rt_gc_min_interval,
3091 .maxlen = sizeof(int),
3092 .mode = 0644,
6d9f239a 3093 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 3094 },
3095 {
1da177e4
LT		 3096 .procname = "gc_min_interval_ms",
3097 .data = &ip_rt_gc_min_interval,
3098 .maxlen = sizeof(int),
3099 .mode = 0644,
6d9f239a 3100 .proc_handler = proc_dointvec_ms_jiffies,
1da177e4
LT		 3101 },
3102 {
1da177e4
LT		 3103 .procname = "gc_timeout",
3104 .data = &ip_rt_gc_timeout,
3105 .maxlen = sizeof(int),
3106 .mode = 0644,
6d9f239a 3107 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 3108 },
3109 {
1da177e4
LT		 3110 .procname = "gc_interval",
3111 .data = &ip_rt_gc_interval,
3112 .maxlen = sizeof(int),
3113 .mode = 0644,
6d9f239a 3114 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 3115 },
3116 {
1da177e4
LT		 3117 .procname = "redirect_load",
3118 .data = &ip_rt_redirect_load,
3119 .maxlen = sizeof(int),
3120 .mode = 0644,
6d9f239a 3121 .proc_handler = proc_dointvec,
1da177e4
LT		 3122 },
3123 {
1da177e4
LT		 3124 .procname = "redirect_number",
3125 .data = &ip_rt_redirect_number,
3126 .maxlen = sizeof(int),
3127 .mode = 0644,
6d9f239a 3128 .proc_handler = proc_dointvec,
1da177e4
LT		 3129 },
3130 {
1da177e4
LT		 3131 .procname = "redirect_silence",
3132 .data = &ip_rt_redirect_silence,
3133 .maxlen = sizeof(int),
3134 .mode = 0644,
6d9f239a 3135 .proc_handler = proc_dointvec,
1da177e4
LT		 3136 },
3137 {
1da177e4
LT		 3138 .procname = "error_cost",
3139 .data = &ip_rt_error_cost,
3140 .maxlen = sizeof(int),
3141 .mode = 0644,
6d9f239a 3142 .proc_handler = proc_dointvec,
1da177e4
LT		 3143 },
3144 {
1da177e4
LT		 3145 .procname = "error_burst",
3146 .data = &ip_rt_error_burst,
3147 .maxlen = sizeof(int),
3148 .mode = 0644,
6d9f239a 3149 .proc_handler = proc_dointvec,
1da177e4
LT		 3150 },
3151 {
1da177e4
LT		 3152 .procname = "gc_elasticity",
3153 .data = &ip_rt_gc_elasticity,
3154 .maxlen = sizeof(int),
3155 .mode = 0644,
6d9f239a 3156 .proc_handler = proc_dointvec,
1da177e4
LT		 3157 },
3158 {
1da177e4
LT		 3159 .procname = "mtu_expires",
3160 .data = &ip_rt_mtu_expires,
3161 .maxlen = sizeof(int),
3162 .mode = 0644,
6d9f239a 3163 .proc_handler = proc_dointvec_jiffies,
1da177e4
LT		 3164 },
3165 {
1da177e4
LT		 3166 .procname = "min_pmtu",
3167 .data = &ip_rt_min_pmtu,
3168 .maxlen = sizeof(int),
3169 .mode = 0644,
6d9f239a 3170 .proc_handler = proc_dointvec,
1da177e4
LT		 3171 },
3172 {
1da177e4
LT		 3173 .procname = "min_adv_mss",
3174 .data = &ip_rt_min_advmss,
3175 .maxlen = sizeof(int),
3176 .mode = 0644,
6d9f239a 3177 .proc_handler = proc_dointvec,
1da177e4 3178 },
f8572d8f 3179 { }
1da177e4 3180};
39a23e75 3181
2f4520d3
AV		 3182static struct ctl_table empty[1];
3183
3184static struct ctl_table ipv4_skeleton[] =
3185{
f8572d8f 3186 { .procname = "route",
d994af0d 3187 .mode = 0555, .child = ipv4_route_table},
f8572d8f 3188 { .procname = "neigh",
d994af0d 3189 .mode = 0555, .child = empty},
2f4520d3
AV		 3190 { }
3191};
3192
3193static __net_initdata struct ctl_path ipv4_path[] = {
f8572d8f
EB		 3194 { .procname = "net", },
3195 { .procname = "ipv4", },
39a23e75
DL		 3196 { },
3197};
3198
39a23e75
DL		 3199static struct ctl_table ipv4_route_flush_table[] = {
3200 {
39a23e75
DL		 3201 .procname = "flush",
3202 .maxlen = sizeof(int),
3203 .mode = 0200,
6d9f239a 3204 .proc_handler = ipv4_sysctl_rtcache_flush,
39a23e75 3205 },
f8572d8f 3206 { },
39a23e75
DL		 3207};
3208
2f4520d3 3209static __net_initdata struct ctl_path ipv4_route_path[] = {
f8572d8f
EB		 3210 { .procname = "net", },
3211 { .procname = "ipv4", },
3212 { .procname = "route", },
2f4520d3
AV		 3213 { },
3214};
3215
39a23e75
DL		 3216static __net_init int sysctl_route_net_init(struct net *net)
3217{
3218 struct ctl_table *tbl;
3219
3220 tbl = ipv4_route_flush_table;
09ad9bc7 3221 if (!net_eq(net, &init_net)) {
39a23e75
DL		 3222 tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
3223 if (tbl == NULL)
3224 goto err_dup;
3225 }
3226 tbl[0].extra1 = net;
3227
3228 net->ipv4.route_hdr =
3229 register_net_sysctl_table(net, ipv4_route_path, tbl);
3230 if (net->ipv4.route_hdr == NULL)
3231 goto err_reg;
3232 return 0;
3233
3234err_reg:
3235 if (tbl != ipv4_route_flush_table)
3236 kfree(tbl);
3237err_dup:
3238 return -ENOMEM;
3239}
3240
3241static __net_exit void sysctl_route_net_exit(struct net *net)
3242{
3243 struct ctl_table *tbl;
3244
3245 tbl = net->ipv4.route_hdr->ctl_table_arg;
3246 unregister_net_sysctl_table(net->ipv4.route_hdr);
3247 BUG_ON(tbl == ipv4_route_flush_table);
3248 kfree(tbl);
3249}
3250
3251static __net_initdata struct pernet_operations sysctl_route_ops = {
3252 .init = sysctl_route_net_init,
3253 .exit = sysctl_route_net_exit,
3254};
1da177e4
LT		 3255#endif
3256
3ee94372 3257static __net_init int rt_genid_init(struct net *net)
9f5e97e5 3258{
3ee94372
NH		 3259 get_random_bytes(&net->ipv4.rt_genid,
3260 sizeof(net->ipv4.rt_genid));
436c3b66
DM		 3261 get_random_bytes(&net->ipv4.dev_addr_genid,
3262 sizeof(net->ipv4.dev_addr_genid));
9f5e97e5
DL		 3263 return 0;
3264}
3265
3ee94372
NH		 3266static __net_initdata struct pernet_operations rt_genid_ops = {
3267 .init = rt_genid_init,
9f5e97e5
DL		 3268};
3269
3270
c7066f70 3271#ifdef CONFIG_IP_ROUTE_CLASSID
7d720c3e 3272struct ip_rt_acct __percpu *ip_rt_acct __read_mostly;
c7066f70 3273#endif /* CONFIG_IP_ROUTE_CLASSID */
1da177e4
LT		 3274
3275static __initdata unsigned long rhash_entries;
3276static int __init set_rhash_entries(char *str)
3277{
3278 if (!str)
3279 return 0;
3280 rhash_entries = simple_strtoul(str, &str, 0);
3281 return 1;
3282}
3283__setup("rhash_entries=", set_rhash_entries);
3284
3285int __init ip_rt_init(void)
3286{
424c4b70 3287 int rc = 0;
1da177e4 3288
c7066f70 3289#ifdef CONFIG_IP_ROUTE_CLASSID
0dcec8c2 3290 ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
1da177e4
LT		 3291 if (!ip_rt_acct)
3292 panic("IP: failed to allocate ip_rt_acct\n");
1da177e4
LT		 3293#endif
3294
e5d679f3
AD		 3295 ipv4_dst_ops.kmem_cachep =
3296 kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
20c2df83 3297 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
1da177e4 3298
14e50e57
DM		 3299 ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
3300
fc66f95c
ED		 3301 if (dst_entries_init(&ipv4_dst_ops) < 0)
3302 panic("IP: failed to allocate ipv4_dst_ops counter\n");
3303
3304 if (dst_entries_init(&ipv4_dst_blackhole_ops) < 0)
3305 panic("IP: failed to allocate ipv4_dst_blackhole_ops counter\n");
3306
424c4b70
ED		 3307 rt_hash_table = (struct rt_hash_bucket *)
3308 alloc_large_system_hash("IP route cache",
3309 sizeof(struct rt_hash_bucket),
3310 rhash_entries,
4481374c 3311 (totalram_pages >= 128 * 1024) ?
18955cfc 3312 15 : 17,
8d1502de 3313 0,
424c4b70
ED		 3314 &rt_hash_log,
3315 &rt_hash_mask,
c9503e0f 3316 rhash_entries ? 0 : 512 * 1024);
22c047cc
ED		 3317 memset(rt_hash_table, 0, (rt_hash_mask + 1) * sizeof(struct rt_hash_bucket));
3318 rt_hash_lock_init();
1da177e4
LT		 3319
3320 ipv4_dst_ops.gc_thresh = (rt_hash_mask + 1);
3321 ip_rt_max_size = (rt_hash_mask + 1) * 16;
3322
1da177e4
LT		 3323 devinet_init();
3324 ip_fib_init();
3325
73b38711 3326 if (ip_rt_proc_init())
107f1634 3327 printk(KERN_ERR "Unable to create route proc files\n");
1da177e4
LT		 3328#ifdef CONFIG_XFRM
3329 xfrm_init();
a33bc5c1 3330 xfrm4_init(ip_rt_max_size);
1da177e4 3331#endif
c7ac8679 3332 rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL, NULL);
63f3444f 3333
39a23e75
DL		 3334#ifdef CONFIG_SYSCTL
3335 register_pernet_subsys(&sysctl_route_ops);
3336#endif
3ee94372 3337 register_pernet_subsys(&rt_genid_ops);
1da177e4
LT		 3338 return rc;
3339}
3340
a1bc6eb4 3341#ifdef CONFIG_SYSCTL
eeb61f71
AV		 3342/*
3343 * We really need to sanitize the damn ipv4 init order, then all
3344 * this nonsense will go away.
3345 */
3346void __init ip_static_sysctl_init(void)
3347{
2f4520d3 3348 register_sysctl_paths(ipv4_path, ipv4_skeleton);
eeb61f71 3349}
a1bc6eb4 3350#endif
Linux kernel - Deliverables
This page took 1.292754 seconds and 5 git commands to generate.