blob: c4c60e9f068acc221cb47079178df40299e3ef20 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 *
Jesper Juhl02c30a82005-05-05 16:16:16 -07008 * Authors: Ross Biro
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * 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
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090021 * Alan Cox : Super /proc >4K
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 * 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.
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090039 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 * 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
Eric Dumazetbb1d23b2005-07-05 15:00:32 -070055 * Eric Dumazet : hashed spinlocks and rt_check_expire() fixes.
Ilia Sotnikovcef26852006-03-25 01:38:55 -080056 * Ilia Sotnikov : Ignore TOS on PMTUD and Redirect
57 * Ilia Sotnikov : Removed TOS from hash calculations
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 *
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070065#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070071#include <linux/mm.h>
Eric Dumazet424c4b72005-07-05 14:58:19 -070072#include <linux/bootmem.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070073#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>
Eric Dumazet39c90ec2007-09-15 10:55:54 -070082#include <linux/workqueue.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070083#include <linux/skbuff.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070084#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>
Herbert Xu352e5122007-11-13 21:34:06 -080093#include <net/dst.h>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020094#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070095#include <net/protocol.h>
96#include <net/ip.h>
97#include <net/route.h>
98#include <net/inetpeer.h>
99#include <net/sock.h>
100#include <net/ip_fib.h>
101#include <net/arp.h>
102#include <net/tcp.h>
103#include <net/icmp.h>
104#include <net/xfrm.h>
Tom Tucker8d717402006-07-30 20:43:36 -0700105#include <net/netevent.h>
Thomas Graf63f34442007-03-22 11:55:17 -0700106#include <net/rtnetlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107#ifdef CONFIG_SYSCTL
108#include <linux/sysctl.h>
109#endif
110
111#define RT_FL_TOS(oldflp) \
112 ((u32)(oldflp->fl4_tos & (IPTOS_RT_MASK | RTO_ONLINK)))
113
114#define IP_MAX_MTU 0xFFF0
115
116#define RT_GC_TIMEOUT (300*HZ)
117
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118static int ip_rt_max_size;
Stephen Hemminger817bc4d2008-03-22 17:43:59 -0700119static int ip_rt_gc_timeout __read_mostly = RT_GC_TIMEOUT;
120static int ip_rt_gc_interval __read_mostly = 60 * HZ;
121static int ip_rt_gc_min_interval __read_mostly = HZ / 2;
122static int ip_rt_redirect_number __read_mostly = 9;
123static int ip_rt_redirect_load __read_mostly = HZ / 50;
124static int ip_rt_redirect_silence __read_mostly = ((HZ / 50) << (9 + 1));
125static int ip_rt_error_cost __read_mostly = HZ;
126static int ip_rt_error_burst __read_mostly = 5 * HZ;
127static int ip_rt_gc_elasticity __read_mostly = 8;
128static int ip_rt_mtu_expires __read_mostly = 10 * 60 * HZ;
129static int ip_rt_min_pmtu __read_mostly = 512 + 20 + 20;
130static int ip_rt_min_advmss __read_mostly = 256;
131static int ip_rt_secret_interval __read_mostly = 10 * 60 * HZ;
Neil Horman1080d702008-10-27 12:28:25 -0700132static int rt_chain_length_max __read_mostly = 20;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
Eric Dumazetbeb659b2007-11-19 22:43:37 -0800134static void rt_worker_func(struct work_struct *work);
135static DECLARE_DELAYED_WORK(expires_work, rt_worker_func);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136
137/*
138 * Interface to generic destination cache.
139 */
140
141static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
142static void ipv4_dst_destroy(struct dst_entry *dst);
143static void ipv4_dst_ifdown(struct dst_entry *dst,
144 struct net_device *dev, int how);
145static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
146static void ipv4_link_failure(struct sk_buff *skb);
147static void ip_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
Daniel Lezcano569d3642008-01-18 03:56:57 -0800148static int rt_garbage_collect(struct dst_ops *ops);
Neil Horman1080d702008-10-27 12:28:25 -0700149static void rt_emergency_hash_rebuild(struct net *net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150
151
152static struct dst_ops ipv4_dst_ops = {
153 .family = AF_INET,
Harvey Harrison09640e62009-02-01 00:45:17 -0800154 .protocol = cpu_to_be16(ETH_P_IP),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 .gc = rt_garbage_collect,
156 .check = ipv4_dst_check,
157 .destroy = ipv4_dst_destroy,
158 .ifdown = ipv4_dst_ifdown,
159 .negative_advice = ipv4_negative_advice,
160 .link_failure = ipv4_link_failure,
161 .update_pmtu = ip_rt_update_pmtu,
Herbert Xu1ac06e02008-05-20 14:32:14 -0700162 .local_out = __ip_local_out,
Eric Dumazete2422972008-01-30 20:07:45 -0800163 .entries = ATOMIC_INIT(0),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164};
165
166#define ECN_OR_COST(class) TC_PRIO_##class
167
Philippe De Muyter4839c522007-07-09 15:32:57 -0700168const __u8 ip_tos2prio[16] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 TC_PRIO_BESTEFFORT,
170 ECN_OR_COST(FILLER),
171 TC_PRIO_BESTEFFORT,
172 ECN_OR_COST(BESTEFFORT),
173 TC_PRIO_BULK,
174 ECN_OR_COST(BULK),
175 TC_PRIO_BULK,
176 ECN_OR_COST(BULK),
177 TC_PRIO_INTERACTIVE,
178 ECN_OR_COST(INTERACTIVE),
179 TC_PRIO_INTERACTIVE,
180 ECN_OR_COST(INTERACTIVE),
181 TC_PRIO_INTERACTIVE_BULK,
182 ECN_OR_COST(INTERACTIVE_BULK),
183 TC_PRIO_INTERACTIVE_BULK,
184 ECN_OR_COST(INTERACTIVE_BULK)
185};
186
187
188/*
189 * Route cache.
190 */
191
192/* The locking scheme is rather straight forward:
193 *
194 * 1) Read-Copy Update protects the buckets of the central route hash.
195 * 2) Only writers remove entries, and they hold the lock
196 * as they look at rtable reference counts.
197 * 3) Only readers acquire references to rtable entries,
198 * they do so with atomic increments and with the
199 * lock held.
200 */
201
202struct rt_hash_bucket {
203 struct rtable *chain;
Eric Dumazet22c047c2005-07-05 14:55:24 -0700204};
Neil Horman1080d702008-10-27 12:28:25 -0700205
Ingo Molnar8a25d5d2006-07-03 00:24:54 -0700206#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK) || \
207 defined(CONFIG_PROVE_LOCKING)
Eric Dumazet22c047c2005-07-05 14:55:24 -0700208/*
209 * Instead of using one spinlock for each rt_hash_bucket, we use a table of spinlocks
210 * The size of this table is a power of two and depends on the number of CPUS.
Ingo Molnar62051202006-07-03 00:24:59 -0700211 * (on lockdep we have a quite big spinlock_t, so keep the size down there)
Eric Dumazet22c047c2005-07-05 14:55:24 -0700212 */
Ingo Molnar62051202006-07-03 00:24:59 -0700213#ifdef CONFIG_LOCKDEP
214# define RT_HASH_LOCK_SZ 256
Eric Dumazet22c047c2005-07-05 14:55:24 -0700215#else
Ingo Molnar62051202006-07-03 00:24:59 -0700216# if NR_CPUS >= 32
217# define RT_HASH_LOCK_SZ 4096
218# elif NR_CPUS >= 16
219# define RT_HASH_LOCK_SZ 2048
220# elif NR_CPUS >= 8
221# define RT_HASH_LOCK_SZ 1024
222# elif NR_CPUS >= 4
223# define RT_HASH_LOCK_SZ 512
224# else
225# define RT_HASH_LOCK_SZ 256
226# endif
Eric Dumazet22c047c2005-07-05 14:55:24 -0700227#endif
228
229static spinlock_t *rt_hash_locks;
230# define rt_hash_lock_addr(slot) &rt_hash_locks[(slot) & (RT_HASH_LOCK_SZ - 1)]
Pavel Emelyanov1ff1cc22007-12-05 21:15:05 -0800231
232static __init void rt_hash_lock_init(void)
233{
234 int i;
235
236 rt_hash_locks = kmalloc(sizeof(spinlock_t) * RT_HASH_LOCK_SZ,
237 GFP_KERNEL);
238 if (!rt_hash_locks)
239 panic("IP: failed to allocate rt_hash_locks\n");
240
241 for (i = 0; i < RT_HASH_LOCK_SZ; i++)
242 spin_lock_init(&rt_hash_locks[i]);
243}
Eric Dumazet22c047c2005-07-05 14:55:24 -0700244#else
245# define rt_hash_lock_addr(slot) NULL
Pavel Emelyanov1ff1cc22007-12-05 21:15:05 -0800246
247static inline void rt_hash_lock_init(void)
248{
249}
Eric Dumazet22c047c2005-07-05 14:55:24 -0700250#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
Stephen Hemminger817bc4d2008-03-22 17:43:59 -0700252static struct rt_hash_bucket *rt_hash_table __read_mostly;
253static unsigned rt_hash_mask __read_mostly;
254static unsigned int rt_hash_log __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
Eric Dumazet2f970d82006-01-17 02:54:36 -0800256static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
Andrew Mortondbd29152006-01-17 21:58:01 -0800257#define RT_CACHE_STAT_INC(field) \
Paul Mackerrasbfe5d832006-06-25 05:47:14 -0700258 (__raw_get_cpu_var(rt_cache_stat).field++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Denis V. Lunevb00180d2008-07-05 19:04:09 -0700260static inline unsigned int rt_hash(__be32 daddr, __be32 saddr, int idx,
261 int genid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262{
Stephen Hemminger1294fc42008-04-10 01:54:01 -0700263 return jhash_3words((__force u32)(__be32)(daddr),
264 (__force u32)(__be32)(saddr),
Denis V. Lunevb00180d2008-07-05 19:04:09 -0700265 idx, genid)
Eric Dumazet29e75252008-01-31 17:05:09 -0800266 & rt_hash_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267}
268
Denis V. Luneve84f84f2008-07-05 19:04:32 -0700269static inline int rt_genid(struct net *net)
270{
271 return atomic_read(&net->ipv4.rt_genid);
272}
273
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274#ifdef CONFIG_PROC_FS
275struct rt_cache_iter_state {
Denis V. Luneva75e9362008-02-28 20:50:55 -0800276 struct seq_net_private p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 int bucket;
Eric Dumazet29e75252008-01-31 17:05:09 -0800278 int genid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279};
280
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +0900281static struct rtable *rt_cache_get_first(struct seq_file *seq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282{
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +0900283 struct rt_cache_iter_state *st = seq->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 struct rtable *r = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285
286 for (st->bucket = rt_hash_mask; st->bucket >= 0; --st->bucket) {
Eric Dumazeta6272662008-08-28 01:11:25 -0700287 if (!rt_hash_table[st->bucket].chain)
288 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 rcu_read_lock_bh();
Eric Dumazet29e75252008-01-31 17:05:09 -0800290 r = rcu_dereference(rt_hash_table[st->bucket].chain);
291 while (r) {
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +0900292 if (dev_net(r->u.dst.dev) == seq_file_net(seq) &&
Denis V. Luneva75e9362008-02-28 20:50:55 -0800293 r->rt_genid == st->genid)
Eric Dumazet29e75252008-01-31 17:05:09 -0800294 return r;
295 r = rcu_dereference(r->u.dst.rt_next);
296 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 rcu_read_unlock_bh();
298 }
Eric Dumazet29e75252008-01-31 17:05:09 -0800299 return r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300}
301
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +0900302static struct rtable *__rt_cache_get_next(struct seq_file *seq,
Denis V. Lunev642d6312008-02-28 20:50:33 -0800303 struct rtable *r)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304{
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +0900305 struct rt_cache_iter_state *st = seq->private;
Eric Dumazeta6272662008-08-28 01:11:25 -0700306
Eric Dumazet093c2ca2007-02-09 16:19:26 -0800307 r = r->u.dst.rt_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 while (!r) {
309 rcu_read_unlock_bh();
Eric Dumazeta6272662008-08-28 01:11:25 -0700310 do {
311 if (--st->bucket < 0)
312 return NULL;
313 } while (!rt_hash_table[st->bucket].chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 rcu_read_lock_bh();
315 r = rt_hash_table[st->bucket].chain;
316 }
Eric Dumazet0bccead2008-01-10 03:55:57 -0800317 return rcu_dereference(r);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318}
319
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +0900320static struct rtable *rt_cache_get_next(struct seq_file *seq,
Denis V. Lunev642d6312008-02-28 20:50:33 -0800321 struct rtable *r)
322{
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +0900323 struct rt_cache_iter_state *st = seq->private;
324 while ((r = __rt_cache_get_next(seq, r)) != NULL) {
325 if (dev_net(r->u.dst.dev) != seq_file_net(seq))
Denis V. Luneva75e9362008-02-28 20:50:55 -0800326 continue;
Denis V. Lunev642d6312008-02-28 20:50:33 -0800327 if (r->rt_genid == st->genid)
328 break;
329 }
330 return r;
331}
332
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +0900333static struct rtable *rt_cache_get_idx(struct seq_file *seq, loff_t pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334{
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +0900335 struct rtable *r = rt_cache_get_first(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
337 if (r)
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +0900338 while (pos && (r = rt_cache_get_next(seq, r)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 --pos;
340 return pos ? NULL : r;
341}
342
343static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
344{
Eric Dumazet29e75252008-01-31 17:05:09 -0800345 struct rt_cache_iter_state *st = seq->private;
Eric Dumazet29e75252008-01-31 17:05:09 -0800346 if (*pos)
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +0900347 return rt_cache_get_idx(seq, *pos - 1);
Denis V. Luneve84f84f2008-07-05 19:04:32 -0700348 st->genid = rt_genid(seq_file_net(seq));
Eric Dumazet29e75252008-01-31 17:05:09 -0800349 return SEQ_START_TOKEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350}
351
352static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
353{
Eric Dumazet29e75252008-01-31 17:05:09 -0800354 struct rtable *r;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
356 if (v == SEQ_START_TOKEN)
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +0900357 r = rt_cache_get_first(seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 else
YOSHIFUJI Hideaki12188542008-03-26 02:36:06 +0900359 r = rt_cache_get_next(seq, v);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 ++*pos;
361 return r;
362}
363
364static void rt_cache_seq_stop(struct seq_file *seq, void *v)
365{
366 if (v && v != SEQ_START_TOKEN)
367 rcu_read_unlock_bh();
368}
369
370static int rt_cache_seq_show(struct seq_file *seq, void *v)
371{
372 if (v == SEQ_START_TOKEN)
373 seq_printf(seq, "%-127s\n",
374 "Iface\tDestination\tGateway \tFlags\t\tRefCnt\tUse\t"
375 "Metric\tSource\t\tMTU\tWindow\tIRTT\tTOS\tHHRef\t"
376 "HHUptod\tSpecDst");
377 else {
378 struct rtable *r = v;
Pavel Emelyanov5e659e42008-04-24 01:02:16 -0700379 int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380
Pavel Emelyanov5e659e42008-04-24 01:02:16 -0700381 seq_printf(seq, "%s\t%08lX\t%08lX\t%8X\t%d\t%u\t%d\t"
382 "%08lX\t%d\t%u\t%u\t%02X\t%d\t%1d\t%08X%n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 r->u.dst.dev ? r->u.dst.dev->name : "*",
384 (unsigned long)r->rt_dst, (unsigned long)r->rt_gateway,
385 r->rt_flags, atomic_read(&r->u.dst.__refcnt),
386 r->u.dst.__use, 0, (unsigned long)r->rt_src,
387 (dst_metric(&r->u.dst, RTAX_ADVMSS) ?
388 (int)dst_metric(&r->u.dst, RTAX_ADVMSS) + 40 : 0),
389 dst_metric(&r->u.dst, RTAX_WINDOW),
390 (int)((dst_metric(&r->u.dst, RTAX_RTT) >> 3) +
391 dst_metric(&r->u.dst, RTAX_RTTVAR)),
392 r->fl.fl4_tos,
393 r->u.dst.hh ? atomic_read(&r->u.dst.hh->hh_refcnt) : -1,
394 r->u.dst.hh ? (r->u.dst.hh->hh_output ==
395 dev_queue_xmit) : 0,
Pavel Emelyanov5e659e42008-04-24 01:02:16 -0700396 r->rt_spec_dst, &len);
397
398 seq_printf(seq, "%*s\n", 127 - len, "");
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900399 }
400 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401}
402
Stephen Hemmingerf6908082007-03-12 14:34:29 -0700403static const struct seq_operations rt_cache_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 .start = rt_cache_seq_start,
405 .next = rt_cache_seq_next,
406 .stop = rt_cache_seq_stop,
407 .show = rt_cache_seq_show,
408};
409
410static int rt_cache_seq_open(struct inode *inode, struct file *file)
411{
Denis V. Luneva75e9362008-02-28 20:50:55 -0800412 return seq_open_net(inode, file, &rt_cache_seq_ops,
Pavel Emelyanovcf7732e2007-10-10 02:29:29 -0700413 sizeof(struct rt_cache_iter_state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414}
415
Arjan van de Ven9a321442007-02-12 00:55:35 -0800416static const struct file_operations rt_cache_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 .owner = THIS_MODULE,
418 .open = rt_cache_seq_open,
419 .read = seq_read,
420 .llseek = seq_lseek,
Denis V. Luneva75e9362008-02-28 20:50:55 -0800421 .release = seq_release_net,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422};
423
424
425static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
426{
427 int cpu;
428
429 if (*pos == 0)
430 return SEQ_START_TOKEN;
431
Rusty Russell0f231742008-12-29 12:23:42 +0000432 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 if (!cpu_possible(cpu))
434 continue;
435 *pos = cpu+1;
Eric Dumazet2f970d82006-01-17 02:54:36 -0800436 return &per_cpu(rt_cache_stat, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 }
438 return NULL;
439}
440
441static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
442{
443 int cpu;
444
Rusty Russell0f231742008-12-29 12:23:42 +0000445 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 if (!cpu_possible(cpu))
447 continue;
448 *pos = cpu+1;
Eric Dumazet2f970d82006-01-17 02:54:36 -0800449 return &per_cpu(rt_cache_stat, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 }
451 return NULL;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900452
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453}
454
455static void rt_cpu_seq_stop(struct seq_file *seq, void *v)
456{
457
458}
459
460static int rt_cpu_seq_show(struct seq_file *seq, void *v)
461{
462 struct rt_cache_stat *st = v;
463
464 if (v == SEQ_START_TOKEN) {
Olaf Rempel5bec0032005-04-28 12:16:08 -0700465 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");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 return 0;
467 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900468
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 seq_printf(seq,"%08x %08x %08x %08x %08x %08x %08x %08x "
470 " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
471 atomic_read(&ipv4_dst_ops.entries),
472 st->in_hit,
473 st->in_slow_tot,
474 st->in_slow_mc,
475 st->in_no_route,
476 st->in_brd,
477 st->in_martian_dst,
478 st->in_martian_src,
479
480 st->out_hit,
481 st->out_slow_tot,
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900482 st->out_slow_mc,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
484 st->gc_total,
485 st->gc_ignored,
486 st->gc_goal_miss,
487 st->gc_dst_overflow,
488 st->in_hlist_search,
489 st->out_hlist_search
490 );
491 return 0;
492}
493
Stephen Hemmingerf6908082007-03-12 14:34:29 -0700494static const struct seq_operations rt_cpu_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 .start = rt_cpu_seq_start,
496 .next = rt_cpu_seq_next,
497 .stop = rt_cpu_seq_stop,
498 .show = rt_cpu_seq_show,
499};
500
501
502static int rt_cpu_seq_open(struct inode *inode, struct file *file)
503{
504 return seq_open(file, &rt_cpu_seq_ops);
505}
506
Arjan van de Ven9a321442007-02-12 00:55:35 -0800507static const struct file_operations rt_cpu_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 .owner = THIS_MODULE,
509 .open = rt_cpu_seq_open,
510 .read = seq_read,
511 .llseek = seq_lseek,
512 .release = seq_release,
513};
514
Pavel Emelyanov78c686e2007-12-05 21:13:48 -0800515#ifdef CONFIG_NET_CLS_ROUTE
516static int ip_rt_acct_read(char *buffer, char **start, off_t offset,
517 int length, int *eof, void *data)
518{
519 unsigned int i;
520
521 if ((offset & 3) || (length & 3))
522 return -EIO;
523
524 if (offset >= sizeof(struct ip_rt_acct) * 256) {
525 *eof = 1;
526 return 0;
527 }
528
529 if (offset + length >= sizeof(struct ip_rt_acct) * 256) {
530 length = sizeof(struct ip_rt_acct) * 256 - offset;
531 *eof = 1;
532 }
533
534 offset /= sizeof(u32);
535
536 if (length > 0) {
537 u32 *dst = (u32 *) buffer;
538
539 *start = buffer;
540 memset(dst, 0, length);
541
542 for_each_possible_cpu(i) {
543 unsigned int j;
544 u32 *src;
545
546 src = ((u32 *) per_cpu_ptr(ip_rt_acct, i)) + offset;
547 for (j = 0; j < length/4; j++)
548 dst[j] += src[j];
549 }
550 }
551 return length;
552}
553#endif
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800554
Denis V. Lunev73b38712008-02-28 20:51:18 -0800555static int __net_init ip_rt_do_proc_init(struct net *net)
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800556{
557 struct proc_dir_entry *pde;
558
559 pde = proc_net_fops_create(net, "rt_cache", S_IRUGO,
560 &rt_cache_seq_fops);
561 if (!pde)
562 goto err1;
563
Wang Chen77020722008-02-28 14:14:25 -0800564 pde = proc_create("rt_cache", S_IRUGO,
565 net->proc_net_stat, &rt_cpu_seq_fops);
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800566 if (!pde)
567 goto err2;
568
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800569#ifdef CONFIG_NET_CLS_ROUTE
570 pde = create_proc_read_entry("rt_acct", 0, net->proc_net,
571 ip_rt_acct_read, NULL);
572 if (!pde)
573 goto err3;
574#endif
575 return 0;
576
577#ifdef CONFIG_NET_CLS_ROUTE
578err3:
579 remove_proc_entry("rt_cache", net->proc_net_stat);
580#endif
581err2:
582 remove_proc_entry("rt_cache", net->proc_net);
583err1:
584 return -ENOMEM;
585}
Denis V. Lunev73b38712008-02-28 20:51:18 -0800586
587static void __net_exit ip_rt_do_proc_exit(struct net *net)
588{
589 remove_proc_entry("rt_cache", net->proc_net_stat);
590 remove_proc_entry("rt_cache", net->proc_net);
591 remove_proc_entry("rt_acct", net->proc_net);
592}
593
594static struct pernet_operations ip_rt_proc_ops __net_initdata = {
595 .init = ip_rt_do_proc_init,
596 .exit = ip_rt_do_proc_exit,
597};
598
599static int __init ip_rt_proc_init(void)
600{
601 return register_pernet_subsys(&ip_rt_proc_ops);
602}
603
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800604#else
Denis V. Lunev73b38712008-02-28 20:51:18 -0800605static inline int ip_rt_proc_init(void)
Pavel Emelyanov107f1632007-12-05 21:14:28 -0800606{
607 return 0;
608}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609#endif /* CONFIG_PROC_FS */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900610
Stephen Hemminger5969f712008-04-10 01:52:09 -0700611static inline void rt_free(struct rtable *rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 call_rcu_bh(&rt->u.dst.rcu_head, dst_rcu_free);
614}
615
Stephen Hemminger5969f712008-04-10 01:52:09 -0700616static inline void rt_drop(struct rtable *rt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 ip_rt_put(rt);
619 call_rcu_bh(&rt->u.dst.rcu_head, dst_rcu_free);
620}
621
Stephen Hemminger5969f712008-04-10 01:52:09 -0700622static inline int rt_fast_clean(struct rtable *rth)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623{
624 /* Kill broadcast/multicast entries very aggresively, if they
625 collide in hash table with more useful entries */
626 return (rth->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST)) &&
Eric Dumazet093c2ca2007-02-09 16:19:26 -0800627 rth->fl.iif && rth->u.dst.rt_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628}
629
Stephen Hemminger5969f712008-04-10 01:52:09 -0700630static inline int rt_valuable(struct rtable *rth)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631{
632 return (rth->rt_flags & (RTCF_REDIRECTED | RTCF_NOTIFY)) ||
633 rth->u.dst.expires;
634}
635
636static int rt_may_expire(struct rtable *rth, unsigned long tmo1, unsigned long tmo2)
637{
638 unsigned long age;
639 int ret = 0;
640
641 if (atomic_read(&rth->u.dst.__refcnt))
642 goto out;
643
644 ret = 1;
645 if (rth->u.dst.expires &&
646 time_after_eq(jiffies, rth->u.dst.expires))
647 goto out;
648
649 age = jiffies - rth->u.dst.lastuse;
650 ret = 0;
651 if ((age <= tmo1 && !rt_fast_clean(rth)) ||
652 (age <= tmo2 && rt_valuable(rth)))
653 goto out;
654 ret = 1;
655out: return ret;
656}
657
658/* Bits of score are:
659 * 31: very valuable
660 * 30: not quite useless
661 * 29..0: usage counter
662 */
663static inline u32 rt_score(struct rtable *rt)
664{
665 u32 score = jiffies - rt->u.dst.lastuse;
666
667 score = ~score & ~(3<<30);
668
669 if (rt_valuable(rt))
670 score |= (1<<31);
671
672 if (!rt->fl.iif ||
673 !(rt->rt_flags & (RTCF_BROADCAST|RTCF_MULTICAST|RTCF_LOCAL)))
674 score |= (1<<30);
675
676 return score;
677}
678
Neil Horman1080d702008-10-27 12:28:25 -0700679static inline bool rt_caching(const struct net *net)
680{
681 return net->ipv4.current_rt_cache_rebuild_count <=
682 net->ipv4.sysctl_rt_cache_rebuild_count;
683}
684
685static inline bool compare_hash_inputs(const struct flowi *fl1,
686 const struct flowi *fl2)
687{
688 return (__force u32)(((fl1->nl_u.ip4_u.daddr ^ fl2->nl_u.ip4_u.daddr) |
689 (fl1->nl_u.ip4_u.saddr ^ fl2->nl_u.ip4_u.saddr) |
690 (fl1->iif ^ fl2->iif)) == 0);
691}
692
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693static inline int compare_keys(struct flowi *fl1, struct flowi *fl2)
694{
Al Viro714e85b2006-11-14 20:51:49 -0800695 return ((__force u32)((fl1->nl_u.ip4_u.daddr ^ fl2->nl_u.ip4_u.daddr) |
696 (fl1->nl_u.ip4_u.saddr ^ fl2->nl_u.ip4_u.saddr)) |
Thomas Graf47dcf0c2006-11-09 15:20:38 -0800697 (fl1->mark ^ fl2->mark) |
David S. Miller8238b212006-10-12 00:49:15 -0700698 (*(u16 *)&fl1->nl_u.ip4_u.tos ^
699 *(u16 *)&fl2->nl_u.ip4_u.tos) |
700 (fl1->oif ^ fl2->oif) |
701 (fl1->iif ^ fl2->iif)) == 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702}
703
Denis V. Lunevb5921912008-01-22 23:50:25 -0800704static inline int compare_netns(struct rtable *rt1, struct rtable *rt2)
705{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900706 return dev_net(rt1->u.dst.dev) == dev_net(rt2->u.dst.dev);
Denis V. Lunevb5921912008-01-22 23:50:25 -0800707}
708
Denis V. Luneve84f84f2008-07-05 19:04:32 -0700709static inline int rt_is_expired(struct rtable *rth)
710{
711 return rth->rt_genid != rt_genid(dev_net(rth->u.dst.dev));
712}
713
Eric Dumazetbeb659b2007-11-19 22:43:37 -0800714/*
715 * Perform a full scan of hash table and free all entries.
716 * Can be called by a softirq or a process.
717 * In the later case, we want to be reschedule if necessary
718 */
719static void rt_do_flush(int process_context)
720{
721 unsigned int i;
722 struct rtable *rth, *next;
Denis V. Lunev32cb5b42008-07-05 19:06:12 -0700723 struct rtable * tail;
Eric Dumazetbeb659b2007-11-19 22:43:37 -0800724
725 for (i = 0; i <= rt_hash_mask; i++) {
726 if (process_context && need_resched())
727 cond_resched();
728 rth = rt_hash_table[i].chain;
729 if (!rth)
730 continue;
731
732 spin_lock_bh(rt_hash_lock_addr(i));
Denis V. Lunev32cb5b42008-07-05 19:06:12 -0700733#ifdef CONFIG_NET_NS
734 {
735 struct rtable ** prev, * p;
736
737 rth = rt_hash_table[i].chain;
738
739 /* defer releasing the head of the list after spin_unlock */
740 for (tail = rth; tail; tail = tail->u.dst.rt_next)
741 if (!rt_is_expired(tail))
742 break;
743 if (rth != tail)
744 rt_hash_table[i].chain = tail;
745
746 /* call rt_free on entries after the tail requiring flush */
747 prev = &rt_hash_table[i].chain;
748 for (p = *prev; p; p = next) {
749 next = p->u.dst.rt_next;
750 if (!rt_is_expired(p)) {
751 prev = &p->u.dst.rt_next;
752 } else {
753 *prev = next;
754 rt_free(p);
755 }
756 }
757 }
758#else
Eric Dumazetbeb659b2007-11-19 22:43:37 -0800759 rth = rt_hash_table[i].chain;
760 rt_hash_table[i].chain = NULL;
Denis V. Lunev32cb5b42008-07-05 19:06:12 -0700761 tail = NULL;
762#endif
Eric Dumazetbeb659b2007-11-19 22:43:37 -0800763 spin_unlock_bh(rt_hash_lock_addr(i));
764
Denis V. Lunev32cb5b42008-07-05 19:06:12 -0700765 for (; rth != tail; rth = next) {
Eric Dumazetbeb659b2007-11-19 22:43:37 -0800766 next = rth->u.dst.rt_next;
767 rt_free(rth);
768 }
769 }
770}
771
Neil Horman1080d702008-10-27 12:28:25 -0700772/*
773 * While freeing expired entries, we compute average chain length
774 * and standard deviation, using fixed-point arithmetic.
775 * This to have an estimation of rt_chain_length_max
776 * rt_chain_length_max = max(elasticity, AVG + 4*SD)
777 * We use 3 bits for frational part, and 29 (or 61) for magnitude.
778 */
779
780#define FRACT_BITS 3
781#define ONE (1UL << FRACT_BITS)
782
Eric Dumazetbeb659b2007-11-19 22:43:37 -0800783static void rt_check_expire(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784{
Eric Dumazetbb1d23b2005-07-05 15:00:32 -0700785 static unsigned int rover;
786 unsigned int i = rover, goal;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 struct rtable *rth, **rthp;
Neil Horman1080d702008-10-27 12:28:25 -0700788 unsigned long length = 0, samples = 0;
789 unsigned long sum = 0, sum2 = 0;
Eric Dumazetbb1d23b2005-07-05 15:00:32 -0700790 u64 mult;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791
Eric Dumazetbb1d23b2005-07-05 15:00:32 -0700792 mult = ((u64)ip_rt_gc_interval) << rt_hash_log;
793 if (ip_rt_gc_timeout > 1)
794 do_div(mult, ip_rt_gc_timeout);
795 goal = (unsigned int)mult;
Eric Dumazet39c90ec2007-09-15 10:55:54 -0700796 if (goal > rt_hash_mask)
797 goal = rt_hash_mask + 1;
Neil Horman1080d702008-10-27 12:28:25 -0700798 length = 0;
Eric Dumazetbb1d23b2005-07-05 15:00:32 -0700799 for (; goal > 0; goal--) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 unsigned long tmo = ip_rt_gc_timeout;
801
802 i = (i + 1) & rt_hash_mask;
803 rthp = &rt_hash_table[i].chain;
804
Eric Dumazetd90bf5a2007-11-14 16:14:05 -0800805 if (need_resched())
806 cond_resched();
807
Neil Horman1080d702008-10-27 12:28:25 -0700808 samples++;
809
Stephen Hemmingercfcabdc2007-10-09 01:59:42 -0700810 if (*rthp == NULL)
Eric Dumazetbb1d23b2005-07-05 15:00:32 -0700811 continue;
Eric Dumazet39c90ec2007-09-15 10:55:54 -0700812 spin_lock_bh(rt_hash_lock_addr(i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 while ((rth = *rthp) != NULL) {
Denis V. Luneve84f84f2008-07-05 19:04:32 -0700814 if (rt_is_expired(rth)) {
Eric Dumazet29e75252008-01-31 17:05:09 -0800815 *rthp = rth->u.dst.rt_next;
816 rt_free(rth);
817 continue;
818 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 if (rth->u.dst.expires) {
820 /* Entry is expired even if it is in use */
Eric Dumazet39c90ec2007-09-15 10:55:54 -0700821 if (time_before_eq(jiffies, rth->u.dst.expires)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 tmo >>= 1;
Eric Dumazet093c2ca2007-02-09 16:19:26 -0800823 rthp = &rth->u.dst.rt_next;
Neil Horman1080d702008-10-27 12:28:25 -0700824 /*
825 * Only bump our length if the hash
826 * inputs on entries n and n+1 are not
827 * the same, we only count entries on
828 * a chain with equal hash inputs once
829 * so that entries for different QOS
830 * levels, and other non-hash input
831 * attributes don't unfairly skew
832 * the length computation
833 */
834 if ((*rthp == NULL) ||
835 !compare_hash_inputs(&(*rthp)->fl,
836 &rth->fl))
837 length += ONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 continue;
839 }
840 } else if (!rt_may_expire(rth, tmo, ip_rt_gc_timeout)) {
841 tmo >>= 1;
Eric Dumazet093c2ca2007-02-09 16:19:26 -0800842 rthp = &rth->u.dst.rt_next;
Neil Horman1080d702008-10-27 12:28:25 -0700843 if ((*rthp == NULL) ||
844 !compare_hash_inputs(&(*rthp)->fl,
845 &rth->fl))
846 length += ONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 continue;
848 }
849
850 /* Cleanup aged off entries. */
Eric Dumazet093c2ca2007-02-09 16:19:26 -0800851 *rthp = rth->u.dst.rt_next;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900852 rt_free(rth);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 }
Eric Dumazet39c90ec2007-09-15 10:55:54 -0700854 spin_unlock_bh(rt_hash_lock_addr(i));
Neil Horman1080d702008-10-27 12:28:25 -0700855 sum += length;
856 sum2 += length*length;
857 }
858 if (samples) {
859 unsigned long avg = sum / samples;
860 unsigned long sd = int_sqrt(sum2 / samples - avg*avg);
861 rt_chain_length_max = max_t(unsigned long,
862 ip_rt_gc_elasticity,
863 (avg + 4*sd) >> FRACT_BITS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 }
865 rover = i;
Eric Dumazetbeb659b2007-11-19 22:43:37 -0800866}
867
868/*
869 * rt_worker_func() is run in process context.
Eric Dumazet29e75252008-01-31 17:05:09 -0800870 * we call rt_check_expire() to scan part of the hash table
Eric Dumazetbeb659b2007-11-19 22:43:37 -0800871 */
872static void rt_worker_func(struct work_struct *work)
873{
Eric Dumazet29e75252008-01-31 17:05:09 -0800874 rt_check_expire();
Eric Dumazet39c90ec2007-09-15 10:55:54 -0700875 schedule_delayed_work(&expires_work, ip_rt_gc_interval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876}
877
Eric Dumazet29e75252008-01-31 17:05:09 -0800878/*
879 * Pertubation of rt_genid by a small quantity [1..256]
880 * Using 8 bits of shuffling ensure we can call rt_cache_invalidate()
881 * many times (2^24) without giving recent rt_genid.
882 * Jenkins hash is strong enough that litle changes of rt_genid are OK.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 */
Denis V. Lunev86c657f2008-07-05 19:03:31 -0700884static void rt_cache_invalidate(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885{
Eric Dumazet29e75252008-01-31 17:05:09 -0800886 unsigned char shuffle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887
Eric Dumazet29e75252008-01-31 17:05:09 -0800888 get_random_bytes(&shuffle, sizeof(shuffle));
Denis V. Luneve84f84f2008-07-05 19:04:32 -0700889 atomic_add(shuffle + 1U, &net->ipv4.rt_genid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890}
891
Eric Dumazetbeb659b2007-11-19 22:43:37 -0800892/*
Eric Dumazet29e75252008-01-31 17:05:09 -0800893 * delay < 0 : invalidate cache (fast : entries will be deleted later)
894 * delay >= 0 : invalidate & flush cache (can be long)
895 */
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -0700896void rt_cache_flush(struct net *net, int delay)
Eric Dumazet29e75252008-01-31 17:05:09 -0800897{
Denis V. Lunev86c657f2008-07-05 19:03:31 -0700898 rt_cache_invalidate(net);
Eric Dumazet29e75252008-01-31 17:05:09 -0800899 if (delay >= 0)
900 rt_do_flush(!in_softirq());
901}
902
903/*
904 * We change rt_genid and let gc do the cleanup
Eric Dumazetbeb659b2007-11-19 22:43:37 -0800905 */
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -0700906static void rt_secret_rebuild(unsigned long __net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907{
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -0700908 struct net *net = (struct net *)__net;
Denis V. Lunev86c657f2008-07-05 19:03:31 -0700909 rt_cache_invalidate(net);
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -0700910 mod_timer(&net->ipv4.rt_secret_timer, jiffies + ip_rt_secret_interval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911}
912
Neil Horman1080d702008-10-27 12:28:25 -0700913static void rt_secret_rebuild_oneshot(struct net *net)
914{
915 del_timer_sync(&net->ipv4.rt_secret_timer);
916 rt_cache_invalidate(net);
917 if (ip_rt_secret_interval) {
918 net->ipv4.rt_secret_timer.expires += ip_rt_secret_interval;
919 add_timer(&net->ipv4.rt_secret_timer);
920 }
921}
922
923static void rt_emergency_hash_rebuild(struct net *net)
924{
925 if (net_ratelimit()) {
926 printk(KERN_WARNING "Route hash chain too long!\n");
927 printk(KERN_WARNING "Adjust your secret_interval!\n");
928 }
929
930 rt_secret_rebuild_oneshot(net);
931}
932
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933/*
934 Short description of GC goals.
935
936 We want to build algorithm, which will keep routing cache
937 at some equilibrium point, when number of aged off entries
938 is kept approximately equal to newly generated ones.
939
940 Current expiration strength is variable "expire".
941 We try to adjust it dynamically, so that if networking
942 is idle expires is large enough to keep enough of warm entries,
943 and when load increases it reduces to limit cache size.
944 */
945
Daniel Lezcano569d3642008-01-18 03:56:57 -0800946static int rt_garbage_collect(struct dst_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947{
948 static unsigned long expire = RT_GC_TIMEOUT;
949 static unsigned long last_gc;
950 static int rover;
951 static int equilibrium;
952 struct rtable *rth, **rthp;
953 unsigned long now = jiffies;
954 int goal;
955
956 /*
957 * Garbage collection is pretty expensive,
958 * do not make it too frequently.
959 */
960
961 RT_CACHE_STAT_INC(gc_total);
962
963 if (now - last_gc < ip_rt_gc_min_interval &&
964 atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size) {
965 RT_CACHE_STAT_INC(gc_ignored);
966 goto out;
967 }
968
969 /* Calculate number of entries, which we want to expire now. */
970 goal = atomic_read(&ipv4_dst_ops.entries) -
971 (ip_rt_gc_elasticity << rt_hash_log);
972 if (goal <= 0) {
973 if (equilibrium < ipv4_dst_ops.gc_thresh)
974 equilibrium = ipv4_dst_ops.gc_thresh;
975 goal = atomic_read(&ipv4_dst_ops.entries) - equilibrium;
976 if (goal > 0) {
Eric Dumazetb790ced2007-12-21 01:49:07 -0800977 equilibrium += min_t(unsigned int, goal >> 1, rt_hash_mask + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 goal = atomic_read(&ipv4_dst_ops.entries) - equilibrium;
979 }
980 } else {
981 /* We are in dangerous area. Try to reduce cache really
982 * aggressively.
983 */
Eric Dumazetb790ced2007-12-21 01:49:07 -0800984 goal = max_t(unsigned int, goal >> 1, rt_hash_mask + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 equilibrium = atomic_read(&ipv4_dst_ops.entries) - goal;
986 }
987
988 if (now - last_gc >= ip_rt_gc_min_interval)
989 last_gc = now;
990
991 if (goal <= 0) {
992 equilibrium += goal;
993 goto work_done;
994 }
995
996 do {
997 int i, k;
998
999 for (i = rt_hash_mask, k = rover; i >= 0; i--) {
1000 unsigned long tmo = expire;
1001
1002 k = (k + 1) & rt_hash_mask;
1003 rthp = &rt_hash_table[k].chain;
Eric Dumazet22c047c2005-07-05 14:55:24 -07001004 spin_lock_bh(rt_hash_lock_addr(k));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 while ((rth = *rthp) != NULL) {
Denis V. Luneve84f84f2008-07-05 19:04:32 -07001006 if (!rt_is_expired(rth) &&
Eric Dumazet29e75252008-01-31 17:05:09 -08001007 !rt_may_expire(rth, tmo, expire)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 tmo >>= 1;
Eric Dumazet093c2ca2007-02-09 16:19:26 -08001009 rthp = &rth->u.dst.rt_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 continue;
1011 }
Eric Dumazet093c2ca2007-02-09 16:19:26 -08001012 *rthp = rth->u.dst.rt_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 rt_free(rth);
1014 goal--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 }
Eric Dumazet22c047c2005-07-05 14:55:24 -07001016 spin_unlock_bh(rt_hash_lock_addr(k));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 if (goal <= 0)
1018 break;
1019 }
1020 rover = k;
1021
1022 if (goal <= 0)
1023 goto work_done;
1024
1025 /* Goal is not achieved. We stop process if:
1026
1027 - if expire reduced to zero. Otherwise, expire is halfed.
1028 - if table is not full.
1029 - if we are called from interrupt.
1030 - jiffies check is just fallback/debug loop breaker.
1031 We will not spin here for long time in any case.
1032 */
1033
1034 RT_CACHE_STAT_INC(gc_goal_miss);
1035
1036 if (expire == 0)
1037 break;
1038
1039 expire >>= 1;
1040#if RT_CACHE_DEBUG >= 2
1041 printk(KERN_DEBUG "expire>> %u %d %d %d\n", expire,
1042 atomic_read(&ipv4_dst_ops.entries), goal, i);
1043#endif
1044
1045 if (atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size)
1046 goto out;
1047 } while (!in_softirq() && time_before_eq(jiffies, now));
1048
1049 if (atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size)
1050 goto out;
1051 if (net_ratelimit())
1052 printk(KERN_WARNING "dst cache overflow\n");
1053 RT_CACHE_STAT_INC(gc_dst_overflow);
1054 return 1;
1055
1056work_done:
1057 expire += ip_rt_gc_min_interval;
1058 if (expire > ip_rt_gc_timeout ||
1059 atomic_read(&ipv4_dst_ops.entries) < ipv4_dst_ops.gc_thresh)
1060 expire = ip_rt_gc_timeout;
1061#if RT_CACHE_DEBUG >= 2
1062 printk(KERN_DEBUG "expire++ %u %d %d %d\n", expire,
1063 atomic_read(&ipv4_dst_ops.entries), goal, rover);
1064#endif
1065out: return 0;
1066}
1067
1068static int rt_intern_hash(unsigned hash, struct rtable *rt, struct rtable **rp)
1069{
1070 struct rtable *rth, **rthp;
Neil Horman1080d702008-10-27 12:28:25 -07001071 struct rtable *rthi;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 unsigned long now;
1073 struct rtable *cand, **candp;
1074 u32 min_score;
1075 int chain_length;
1076 int attempts = !in_softirq();
1077
1078restart:
1079 chain_length = 0;
1080 min_score = ~(u32)0;
1081 cand = NULL;
1082 candp = NULL;
1083 now = jiffies;
1084
Neil Horman1080d702008-10-27 12:28:25 -07001085 if (!rt_caching(dev_net(rt->u.dst.dev))) {
1086 rt_drop(rt);
1087 return 0;
1088 }
1089
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 rthp = &rt_hash_table[hash].chain;
Neil Horman1080d702008-10-27 12:28:25 -07001091 rthi = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092
Eric Dumazet22c047c2005-07-05 14:55:24 -07001093 spin_lock_bh(rt_hash_lock_addr(hash));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 while ((rth = *rthp) != NULL) {
Denis V. Luneve84f84f2008-07-05 19:04:32 -07001095 if (rt_is_expired(rth)) {
Eric Dumazet29e75252008-01-31 17:05:09 -08001096 *rthp = rth->u.dst.rt_next;
1097 rt_free(rth);
1098 continue;
1099 }
Denis V. Lunevb5921912008-01-22 23:50:25 -08001100 if (compare_keys(&rth->fl, &rt->fl) && compare_netns(rth, rt)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 /* Put it first */
Eric Dumazet093c2ca2007-02-09 16:19:26 -08001102 *rthp = rth->u.dst.rt_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 /*
1104 * Since lookup is lockfree, the deletion
1105 * must be visible to another weakly ordered CPU before
1106 * the insertion at the start of the hash chain.
1107 */
Eric Dumazet093c2ca2007-02-09 16:19:26 -08001108 rcu_assign_pointer(rth->u.dst.rt_next,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 rt_hash_table[hash].chain);
1110 /*
1111 * Since lookup is lockfree, the update writes
1112 * must be ordered for consistency on SMP.
1113 */
1114 rcu_assign_pointer(rt_hash_table[hash].chain, rth);
1115
Pavel Emelyanov03f49f32007-11-10 21:28:34 -08001116 dst_use(&rth->u.dst, now);
Eric Dumazet22c047c2005-07-05 14:55:24 -07001117 spin_unlock_bh(rt_hash_lock_addr(hash));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118
1119 rt_drop(rt);
1120 *rp = rth;
1121 return 0;
1122 }
1123
1124 if (!atomic_read(&rth->u.dst.__refcnt)) {
1125 u32 score = rt_score(rth);
1126
1127 if (score <= min_score) {
1128 cand = rth;
1129 candp = rthp;
1130 min_score = score;
1131 }
1132 }
1133
1134 chain_length++;
1135
Eric Dumazet093c2ca2007-02-09 16:19:26 -08001136 rthp = &rth->u.dst.rt_next;
Neil Horman1080d702008-10-27 12:28:25 -07001137
1138 /*
1139 * check to see if the next entry in the chain
1140 * contains the same hash input values as rt. If it does
1141 * This is where we will insert into the list, instead of
1142 * at the head. This groups entries that differ by aspects not
1143 * relvant to the hash function together, which we use to adjust
1144 * our chain length
1145 */
1146 if (*rthp && compare_hash_inputs(&(*rthp)->fl, &rt->fl))
1147 rthi = rth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 }
1149
1150 if (cand) {
1151 /* ip_rt_gc_elasticity used to be average length of chain
1152 * length, when exceeded gc becomes really aggressive.
1153 *
1154 * The second limit is less certain. At the moment it allows
1155 * only 2 entries per bucket. We will see.
1156 */
1157 if (chain_length > ip_rt_gc_elasticity) {
Eric Dumazet093c2ca2007-02-09 16:19:26 -08001158 *candp = cand->u.dst.rt_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 rt_free(cand);
1160 }
Neil Horman1080d702008-10-27 12:28:25 -07001161 } else {
1162 if (chain_length > rt_chain_length_max) {
1163 struct net *net = dev_net(rt->u.dst.dev);
1164 int num = ++net->ipv4.current_rt_cache_rebuild_count;
1165 if (!rt_caching(dev_net(rt->u.dst.dev))) {
1166 printk(KERN_WARNING "%s: %d rebuilds is over limit, route caching disabled\n",
1167 rt->u.dst.dev->name, num);
1168 }
1169 rt_emergency_hash_rebuild(dev_net(rt->u.dst.dev));
1170 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 }
1172
1173 /* Try to bind route to arp only if it is output
1174 route or unicast forwarding path.
1175 */
1176 if (rt->rt_type == RTN_UNICAST || rt->fl.iif == 0) {
1177 int err = arp_bind_neighbour(&rt->u.dst);
1178 if (err) {
Eric Dumazet22c047c2005-07-05 14:55:24 -07001179 spin_unlock_bh(rt_hash_lock_addr(hash));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180
1181 if (err != -ENOBUFS) {
1182 rt_drop(rt);
1183 return err;
1184 }
1185
1186 /* Neighbour tables are full and nothing
1187 can be released. Try to shrink route cache,
1188 it is most likely it holds some neighbour records.
1189 */
1190 if (attempts-- > 0) {
1191 int saved_elasticity = ip_rt_gc_elasticity;
1192 int saved_int = ip_rt_gc_min_interval;
1193 ip_rt_gc_elasticity = 1;
1194 ip_rt_gc_min_interval = 0;
Daniel Lezcano569d3642008-01-18 03:56:57 -08001195 rt_garbage_collect(&ipv4_dst_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 ip_rt_gc_min_interval = saved_int;
1197 ip_rt_gc_elasticity = saved_elasticity;
1198 goto restart;
1199 }
1200
1201 if (net_ratelimit())
1202 printk(KERN_WARNING "Neighbour table overflow.\n");
1203 rt_drop(rt);
1204 return -ENOBUFS;
1205 }
1206 }
1207
Neil Horman1080d702008-10-27 12:28:25 -07001208 if (rthi)
1209 rt->u.dst.rt_next = rthi->u.dst.rt_next;
1210 else
1211 rt->u.dst.rt_next = rt_hash_table[hash].chain;
1212
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213#if RT_CACHE_DEBUG >= 2
Eric Dumazet093c2ca2007-02-09 16:19:26 -08001214 if (rt->u.dst.rt_next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 struct rtable *trt;
Harvey Harrison673d57e2008-10-31 00:53:57 -07001216 printk(KERN_DEBUG "rt_cache @%02x: %pI4", hash, &rt->rt_dst);
Eric Dumazet093c2ca2007-02-09 16:19:26 -08001217 for (trt = rt->u.dst.rt_next; trt; trt = trt->u.dst.rt_next)
Harvey Harrison673d57e2008-10-31 00:53:57 -07001218 printk(" . %pI4", &trt->rt_dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 printk("\n");
1220 }
1221#endif
Eric Dumazet00269b52008-10-16 14:18:29 -07001222 /*
1223 * Since lookup is lockfree, we must make sure
1224 * previous writes to rt are comitted to memory
1225 * before making rt visible to other CPUS.
1226 */
Neil Horman1080d702008-10-27 12:28:25 -07001227 if (rthi)
1228 rcu_assign_pointer(rthi->u.dst.rt_next, rt);
1229 else
1230 rcu_assign_pointer(rt_hash_table[hash].chain, rt);
1231
Eric Dumazet22c047c2005-07-05 14:55:24 -07001232 spin_unlock_bh(rt_hash_lock_addr(hash));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 *rp = rt;
1234 return 0;
1235}
1236
1237void rt_bind_peer(struct rtable *rt, int create)
1238{
1239 static DEFINE_SPINLOCK(rt_peer_lock);
1240 struct inet_peer *peer;
1241
1242 peer = inet_getpeer(rt->rt_dst, create);
1243
1244 spin_lock_bh(&rt_peer_lock);
1245 if (rt->peer == NULL) {
1246 rt->peer = peer;
1247 peer = NULL;
1248 }
1249 spin_unlock_bh(&rt_peer_lock);
1250 if (peer)
1251 inet_putpeer(peer);
1252}
1253
1254/*
1255 * Peer allocation may fail only in serious out-of-memory conditions. However
1256 * we still can generate some output.
1257 * Random ID selection looks a bit dangerous because we have no chances to
1258 * select ID being unique in a reasonable period of time.
1259 * But broken packet identifier may be better than no packet at all.
1260 */
1261static void ip_select_fb_ident(struct iphdr *iph)
1262{
1263 static DEFINE_SPINLOCK(ip_fb_id_lock);
1264 static u32 ip_fallback_id;
1265 u32 salt;
1266
1267 spin_lock_bh(&ip_fb_id_lock);
Al Viroe4485152006-09-26 22:15:01 -07001268 salt = secure_ip_id((__force __be32)ip_fallback_id ^ iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 iph->id = htons(salt & 0xFFFF);
1270 ip_fallback_id = salt;
1271 spin_unlock_bh(&ip_fb_id_lock);
1272}
1273
1274void __ip_select_ident(struct iphdr *iph, struct dst_entry *dst, int more)
1275{
1276 struct rtable *rt = (struct rtable *) dst;
1277
1278 if (rt) {
1279 if (rt->peer == NULL)
1280 rt_bind_peer(rt, 1);
1281
1282 /* If peer is attached to destination, it is never detached,
1283 so that we need not to grab a lock to dereference it.
1284 */
1285 if (rt->peer) {
1286 iph->id = htons(inet_getid(rt->peer, more));
1287 return;
1288 }
1289 } else
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001290 printk(KERN_DEBUG "rt_bind_peer(0) @%p\n",
Stephen Hemminger9c2b3322005-04-19 22:39:42 -07001291 __builtin_return_address(0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292
1293 ip_select_fb_ident(iph);
1294}
1295
1296static void rt_del(unsigned hash, struct rtable *rt)
1297{
Eric Dumazet29e75252008-01-31 17:05:09 -08001298 struct rtable **rthp, *aux;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299
Eric Dumazet29e75252008-01-31 17:05:09 -08001300 rthp = &rt_hash_table[hash].chain;
Eric Dumazet22c047c2005-07-05 14:55:24 -07001301 spin_lock_bh(rt_hash_lock_addr(hash));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 ip_rt_put(rt);
Eric Dumazet29e75252008-01-31 17:05:09 -08001303 while ((aux = *rthp) != NULL) {
Denis V. Luneve84f84f2008-07-05 19:04:32 -07001304 if (aux == rt || rt_is_expired(aux)) {
Eric Dumazet29e75252008-01-31 17:05:09 -08001305 *rthp = aux->u.dst.rt_next;
1306 rt_free(aux);
1307 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 }
Eric Dumazet29e75252008-01-31 17:05:09 -08001309 rthp = &aux->u.dst.rt_next;
1310 }
Eric Dumazet22c047c2005-07-05 14:55:24 -07001311 spin_unlock_bh(rt_hash_lock_addr(hash));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312}
1313
Al Virof7655222006-09-26 21:25:43 -07001314void ip_rt_redirect(__be32 old_gw, __be32 daddr, __be32 new_gw,
1315 __be32 saddr, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316{
1317 int i, k;
1318 struct in_device *in_dev = in_dev_get(dev);
1319 struct rtable *rth, **rthp;
Al Virof7655222006-09-26 21:25:43 -07001320 __be32 skeys[2] = { saddr, 0 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 int ikeys[2] = { dev->ifindex, 0 };
Tom Tucker8d717402006-07-30 20:43:36 -07001322 struct netevent_redirect netevent;
Denis V. Lunev317805b2008-02-28 20:50:06 -08001323 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 if (!in_dev)
1326 return;
1327
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001328 net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev)
Jan Engelhardt1e637c72008-01-21 03:18:08 -08001330 || ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw)
Joe Perchesf97c1e02007-12-16 13:45:43 -08001331 || ipv4_is_zeronet(new_gw))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 goto reject_redirect;
1333
Neil Horman1080d702008-10-27 12:28:25 -07001334 if (!rt_caching(net))
1335 goto reject_redirect;
1336
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 if (!IN_DEV_SHARED_MEDIA(in_dev)) {
1338 if (!inet_addr_onlink(in_dev, new_gw, old_gw))
1339 goto reject_redirect;
1340 if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
1341 goto reject_redirect;
1342 } else {
Denis V. Lunev317805b2008-02-28 20:50:06 -08001343 if (inet_addr_type(net, new_gw) != RTN_UNICAST)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 goto reject_redirect;
1345 }
1346
1347 for (i = 0; i < 2; i++) {
1348 for (k = 0; k < 2; k++) {
Denis V. Lunevb00180d2008-07-05 19:04:09 -07001349 unsigned hash = rt_hash(daddr, skeys[i], ikeys[k],
Denis V. Luneve84f84f2008-07-05 19:04:32 -07001350 rt_genid(net));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351
1352 rthp=&rt_hash_table[hash].chain;
1353
1354 rcu_read_lock();
1355 while ((rth = rcu_dereference(*rthp)) != NULL) {
1356 struct rtable *rt;
1357
1358 if (rth->fl.fl4_dst != daddr ||
1359 rth->fl.fl4_src != skeys[i] ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 rth->fl.oif != ikeys[k] ||
Eric Dumazet29e75252008-01-31 17:05:09 -08001361 rth->fl.iif != 0 ||
Denis V. Luneve84f84f2008-07-05 19:04:32 -07001362 rt_is_expired(rth) ||
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09001363 !net_eq(dev_net(rth->u.dst.dev), net)) {
Eric Dumazet093c2ca2007-02-09 16:19:26 -08001364 rthp = &rth->u.dst.rt_next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 continue;
1366 }
1367
1368 if (rth->rt_dst != daddr ||
1369 rth->rt_src != saddr ||
1370 rth->u.dst.error ||
1371 rth->rt_gateway != old_gw ||
1372 rth->u.dst.dev != dev)
1373 break;
1374
1375 dst_hold(&rth->u.dst);
1376 rcu_read_unlock();
1377
1378 rt = dst_alloc(&ipv4_dst_ops);
1379 if (rt == NULL) {
1380 ip_rt_put(rth);
1381 in_dev_put(in_dev);
1382 return;
1383 }
1384
1385 /* Copy all the information. */
1386 *rt = *rth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 rt->u.dst.__use = 1;
1388 atomic_set(&rt->u.dst.__refcnt, 1);
1389 rt->u.dst.child = NULL;
1390 if (rt->u.dst.dev)
1391 dev_hold(rt->u.dst.dev);
1392 if (rt->idev)
1393 in_dev_hold(rt->idev);
1394 rt->u.dst.obsolete = 0;
1395 rt->u.dst.lastuse = jiffies;
1396 rt->u.dst.path = &rt->u.dst;
1397 rt->u.dst.neighbour = NULL;
1398 rt->u.dst.hh = NULL;
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -07001399#ifdef CONFIG_XFRM
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 rt->u.dst.xfrm = NULL;
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -07001401#endif
Denis V. Luneve84f84f2008-07-05 19:04:32 -07001402 rt->rt_genid = rt_genid(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 rt->rt_flags |= RTCF_REDIRECTED;
1404
1405 /* Gateway is different ... */
1406 rt->rt_gateway = new_gw;
1407
1408 /* Redirect received -> path was valid */
1409 dst_confirm(&rth->u.dst);
1410
1411 if (rt->peer)
1412 atomic_inc(&rt->peer->refcnt);
1413
1414 if (arp_bind_neighbour(&rt->u.dst) ||
1415 !(rt->u.dst.neighbour->nud_state &
1416 NUD_VALID)) {
1417 if (rt->u.dst.neighbour)
1418 neigh_event_send(rt->u.dst.neighbour, NULL);
1419 ip_rt_put(rth);
1420 rt_drop(rt);
1421 goto do_next;
1422 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001423
Tom Tucker8d717402006-07-30 20:43:36 -07001424 netevent.old = &rth->u.dst;
1425 netevent.new = &rt->u.dst;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001426 call_netevent_notifiers(NETEVENT_REDIRECT,
1427 &netevent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428
1429 rt_del(hash, rth);
1430 if (!rt_intern_hash(hash, rt, &rt))
1431 ip_rt_put(rt);
1432 goto do_next;
1433 }
1434 rcu_read_unlock();
1435 do_next:
1436 ;
1437 }
1438 }
1439 in_dev_put(in_dev);
1440 return;
1441
1442reject_redirect:
1443#ifdef CONFIG_IP_ROUTE_VERBOSE
1444 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit())
Harvey Harrison673d57e2008-10-31 00:53:57 -07001445 printk(KERN_INFO "Redirect from %pI4 on %s about %pI4 ignored.\n"
1446 " Advised path = %pI4 -> %pI4\n",
1447 &old_gw, dev->name, &new_gw,
1448 &saddr, &daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449#endif
1450 in_dev_put(in_dev);
1451}
1452
1453static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
1454{
Eric Dumazetee6b9672008-03-05 18:30:47 -08001455 struct rtable *rt = (struct rtable *)dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 struct dst_entry *ret = dst;
1457
1458 if (rt) {
1459 if (dst->obsolete) {
1460 ip_rt_put(rt);
1461 ret = NULL;
1462 } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
1463 rt->u.dst.expires) {
Al Viro8c7bc842006-09-26 21:26:19 -07001464 unsigned hash = rt_hash(rt->fl.fl4_dst, rt->fl.fl4_src,
Denis V. Lunevb00180d2008-07-05 19:04:09 -07001465 rt->fl.oif,
Denis V. Luneve84f84f2008-07-05 19:04:32 -07001466 rt_genid(dev_net(dst->dev)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467#if RT_CACHE_DEBUG >= 1
Harvey Harrison673d57e2008-10-31 00:53:57 -07001468 printk(KERN_DEBUG "ipv4_negative_advice: redirect to %pI4/%02x dropped\n",
1469 &rt->rt_dst, rt->fl.fl4_tos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470#endif
1471 rt_del(hash, rt);
1472 ret = NULL;
1473 }
1474 }
1475 return ret;
1476}
1477
1478/*
1479 * Algorithm:
1480 * 1. The first ip_rt_redirect_number redirects are sent
1481 * with exponential backoff, then we stop sending them at all,
1482 * assuming that the host ignores our redirects.
1483 * 2. If we did not see packets requiring redirects
1484 * during ip_rt_redirect_silence, we assume that the host
1485 * forgot redirected route and start to send redirects again.
1486 *
1487 * This algorithm is much cheaper and more intelligent than dumb load limiting
1488 * in icmp.c.
1489 *
1490 * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
1491 * and "frag. need" (breaks PMTU discovery) in icmp.c.
1492 */
1493
1494void ip_rt_send_redirect(struct sk_buff *skb)
1495{
Eric Dumazetee6b9672008-03-05 18:30:47 -08001496 struct rtable *rt = skb->rtable;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 struct in_device *in_dev = in_dev_get(rt->u.dst.dev);
1498
1499 if (!in_dev)
1500 return;
1501
1502 if (!IN_DEV_TX_REDIRECTS(in_dev))
1503 goto out;
1504
1505 /* No redirected packets during ip_rt_redirect_silence;
1506 * reset the algorithm.
1507 */
1508 if (time_after(jiffies, rt->u.dst.rate_last + ip_rt_redirect_silence))
1509 rt->u.dst.rate_tokens = 0;
1510
1511 /* Too many ignored redirects; do not send anything
1512 * set u.dst.rate_last to the last seen redirected packet.
1513 */
1514 if (rt->u.dst.rate_tokens >= ip_rt_redirect_number) {
1515 rt->u.dst.rate_last = jiffies;
1516 goto out;
1517 }
1518
1519 /* Check for load limit; set rate_last to the latest sent
1520 * redirect.
1521 */
Li Yewang14fb8a72006-12-18 00:26:35 -08001522 if (rt->u.dst.rate_tokens == 0 ||
1523 time_after(jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524 (rt->u.dst.rate_last +
1525 (ip_rt_redirect_load << rt->u.dst.rate_tokens)))) {
1526 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, rt->rt_gateway);
1527 rt->u.dst.rate_last = jiffies;
1528 ++rt->u.dst.rate_tokens;
1529#ifdef CONFIG_IP_ROUTE_VERBOSE
1530 if (IN_DEV_LOG_MARTIANS(in_dev) &&
1531 rt->u.dst.rate_tokens == ip_rt_redirect_number &&
1532 net_ratelimit())
Harvey Harrison673d57e2008-10-31 00:53:57 -07001533 printk(KERN_WARNING "host %pI4/if%d ignores redirects for %pI4 to %pI4.\n",
1534 &rt->rt_src, rt->rt_iif,
1535 &rt->rt_dst, &rt->rt_gateway);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536#endif
1537 }
1538out:
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001539 in_dev_put(in_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540}
1541
1542static int ip_error(struct sk_buff *skb)
1543{
Eric Dumazetee6b9672008-03-05 18:30:47 -08001544 struct rtable *rt = skb->rtable;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 unsigned long now;
1546 int code;
1547
1548 switch (rt->u.dst.error) {
1549 case EINVAL:
1550 default:
1551 goto out;
1552 case EHOSTUNREACH:
1553 code = ICMP_HOST_UNREACH;
1554 break;
1555 case ENETUNREACH:
1556 code = ICMP_NET_UNREACH;
Pavel Emelyanov7c73a6f2008-07-16 20:20:11 -07001557 IP_INC_STATS_BH(dev_net(rt->u.dst.dev),
1558 IPSTATS_MIB_INNOROUTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 break;
1560 case EACCES:
1561 code = ICMP_PKT_FILTERED;
1562 break;
1563 }
1564
1565 now = jiffies;
1566 rt->u.dst.rate_tokens += now - rt->u.dst.rate_last;
1567 if (rt->u.dst.rate_tokens > ip_rt_error_burst)
1568 rt->u.dst.rate_tokens = ip_rt_error_burst;
1569 rt->u.dst.rate_last = now;
1570 if (rt->u.dst.rate_tokens >= ip_rt_error_cost) {
1571 rt->u.dst.rate_tokens -= ip_rt_error_cost;
1572 icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
1573 }
1574
1575out: kfree_skb(skb);
1576 return 0;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001577}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578
1579/*
1580 * The last two values are not from the RFC but
1581 * are needed for AMPRnet AX.25 paths.
1582 */
1583
Arjan van de Ven9b5b5cf2005-11-29 16:21:38 -08001584static const unsigned short mtu_plateau[] =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585{32000, 17914, 8166, 4352, 2002, 1492, 576, 296, 216, 128 };
1586
Stephen Hemminger5969f712008-04-10 01:52:09 -07001587static inline unsigned short guess_mtu(unsigned short old_mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588{
1589 int i;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001590
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 for (i = 0; i < ARRAY_SIZE(mtu_plateau); i++)
1592 if (old_mtu > mtu_plateau[i])
1593 return mtu_plateau[i];
1594 return 68;
1595}
1596
Denis V. Lunevb5921912008-01-22 23:50:25 -08001597unsigned short ip_rt_frag_needed(struct net *net, struct iphdr *iph,
Timo Teras0010e462008-04-29 03:32:25 -07001598 unsigned short new_mtu,
1599 struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600{
Timo Teras0010e462008-04-29 03:32:25 -07001601 int i, k;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 unsigned short old_mtu = ntohs(iph->tot_len);
1603 struct rtable *rth;
Timo Teras0010e462008-04-29 03:32:25 -07001604 int ikeys[2] = { dev->ifindex, 0 };
Al Viroe4485152006-09-26 22:15:01 -07001605 __be32 skeys[2] = { iph->saddr, 0, };
1606 __be32 daddr = iph->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607 unsigned short est_mtu = 0;
1608
1609 if (ipv4_config.no_pmtu_disc)
1610 return 0;
1611
Timo Teras0010e462008-04-29 03:32:25 -07001612 for (k = 0; k < 2; k++) {
1613 for (i = 0; i < 2; i++) {
Denis V. Lunevb00180d2008-07-05 19:04:09 -07001614 unsigned hash = rt_hash(daddr, skeys[i], ikeys[k],
Denis V. Luneve84f84f2008-07-05 19:04:32 -07001615 rt_genid(net));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616
Timo Teras0010e462008-04-29 03:32:25 -07001617 rcu_read_lock();
1618 for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
1619 rth = rcu_dereference(rth->u.dst.rt_next)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 unsigned short mtu = new_mtu;
1621
Timo Teras0010e462008-04-29 03:32:25 -07001622 if (rth->fl.fl4_dst != daddr ||
1623 rth->fl.fl4_src != skeys[i] ||
1624 rth->rt_dst != daddr ||
1625 rth->rt_src != iph->saddr ||
1626 rth->fl.oif != ikeys[k] ||
1627 rth->fl.iif != 0 ||
1628 dst_metric_locked(&rth->u.dst, RTAX_MTU) ||
1629 !net_eq(dev_net(rth->u.dst.dev), net) ||
Hugh Dickins6c3b8fc2008-07-26 17:51:06 -07001630 rt_is_expired(rth))
Timo Teras0010e462008-04-29 03:32:25 -07001631 continue;
1632
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 if (new_mtu < 68 || new_mtu >= old_mtu) {
1634
1635 /* BSD 4.2 compatibility hack :-( */
1636 if (mtu == 0 &&
Rami Rosen6d273f82008-08-06 02:33:49 -07001637 old_mtu >= dst_mtu(&rth->u.dst) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638 old_mtu >= 68 + (iph->ihl << 2))
1639 old_mtu -= iph->ihl << 2;
1640
1641 mtu = guess_mtu(old_mtu);
1642 }
Rami Rosen6d273f82008-08-06 02:33:49 -07001643 if (mtu <= dst_mtu(&rth->u.dst)) {
1644 if (mtu < dst_mtu(&rth->u.dst)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 dst_confirm(&rth->u.dst);
1646 if (mtu < ip_rt_min_pmtu) {
1647 mtu = ip_rt_min_pmtu;
1648 rth->u.dst.metrics[RTAX_LOCK-1] |=
1649 (1 << RTAX_MTU);
1650 }
1651 rth->u.dst.metrics[RTAX_MTU-1] = mtu;
1652 dst_set_expires(&rth->u.dst,
1653 ip_rt_mtu_expires);
1654 }
1655 est_mtu = mtu;
1656 }
1657 }
Timo Teras0010e462008-04-29 03:32:25 -07001658 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 }
1661 return est_mtu ? : new_mtu;
1662}
1663
1664static void ip_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
1665{
Rami Rosen6d273f82008-08-06 02:33:49 -07001666 if (dst_mtu(dst) > mtu && mtu >= 68 &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 !(dst_metric_locked(dst, RTAX_MTU))) {
1668 if (mtu < ip_rt_min_pmtu) {
1669 mtu = ip_rt_min_pmtu;
1670 dst->metrics[RTAX_LOCK-1] |= (1 << RTAX_MTU);
1671 }
1672 dst->metrics[RTAX_MTU-1] = mtu;
1673 dst_set_expires(dst, ip_rt_mtu_expires);
Tom Tucker8d717402006-07-30 20:43:36 -07001674 call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 }
1676}
1677
1678static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
1679{
1680 return NULL;
1681}
1682
1683static void ipv4_dst_destroy(struct dst_entry *dst)
1684{
1685 struct rtable *rt = (struct rtable *) dst;
1686 struct inet_peer *peer = rt->peer;
1687 struct in_device *idev = rt->idev;
1688
1689 if (peer) {
1690 rt->peer = NULL;
1691 inet_putpeer(peer);
1692 }
1693
1694 if (idev) {
1695 rt->idev = NULL;
1696 in_dev_put(idev);
1697 }
1698}
1699
1700static void ipv4_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
1701 int how)
1702{
1703 struct rtable *rt = (struct rtable *) dst;
1704 struct in_device *idev = rt->idev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001705 if (dev != dev_net(dev)->loopback_dev && idev && idev->dev == dev) {
Denis V. Lunev5a3e55d2007-12-07 00:38:10 -08001706 struct in_device *loopback_idev =
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001707 in_dev_get(dev_net(dev)->loopback_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708 if (loopback_idev) {
1709 rt->idev = loopback_idev;
1710 in_dev_put(idev);
1711 }
1712 }
1713}
1714
1715static void ipv4_link_failure(struct sk_buff *skb)
1716{
1717 struct rtable *rt;
1718
1719 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
1720
Eric Dumazetee6b9672008-03-05 18:30:47 -08001721 rt = skb->rtable;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 if (rt)
1723 dst_set_expires(&rt->u.dst, 0);
1724}
1725
1726static int ip_rt_bug(struct sk_buff *skb)
1727{
Harvey Harrison673d57e2008-10-31 00:53:57 -07001728 printk(KERN_DEBUG "ip_rt_bug: %pI4 -> %pI4, %s\n",
1729 &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 skb->dev ? skb->dev->name : "?");
1731 kfree_skb(skb);
1732 return 0;
1733}
1734
1735/*
1736 We do not cache source address of outgoing interface,
1737 because it is used only by IP RR, TS and SRR options,
1738 so that it out of fast path.
1739
1740 BTW remember: "addr" is allowed to be not aligned
1741 in IP options!
1742 */
1743
1744void ip_rt_get_source(u8 *addr, struct rtable *rt)
1745{
Al Viroa61ced52006-09-26 21:27:54 -07001746 __be32 src;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 struct fib_result res;
1748
1749 if (rt->fl.iif == 0)
1750 src = rt->rt_src;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001751 else if (fib_lookup(dev_net(rt->u.dst.dev), &rt->fl, &res) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 src = FIB_RES_PREFSRC(res);
1753 fib_res_put(&res);
1754 } else
1755 src = inet_select_addr(rt->u.dst.dev, rt->rt_gateway,
1756 RT_SCOPE_UNIVERSE);
1757 memcpy(addr, &src, 4);
1758}
1759
1760#ifdef CONFIG_NET_CLS_ROUTE
1761static void set_class_tag(struct rtable *rt, u32 tag)
1762{
1763 if (!(rt->u.dst.tclassid & 0xFFFF))
1764 rt->u.dst.tclassid |= tag & 0xFFFF;
1765 if (!(rt->u.dst.tclassid & 0xFFFF0000))
1766 rt->u.dst.tclassid |= tag & 0xFFFF0000;
1767}
1768#endif
1769
1770static void rt_set_nexthop(struct rtable *rt, struct fib_result *res, u32 itag)
1771{
1772 struct fib_info *fi = res->fi;
1773
1774 if (fi) {
1775 if (FIB_RES_GW(*res) &&
1776 FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK)
1777 rt->rt_gateway = FIB_RES_GW(*res);
1778 memcpy(rt->u.dst.metrics, fi->fib_metrics,
1779 sizeof(rt->u.dst.metrics));
1780 if (fi->fib_mtu == 0) {
1781 rt->u.dst.metrics[RTAX_MTU-1] = rt->u.dst.dev->mtu;
Satoru SATOH0bbeafd2008-05-04 22:12:43 -07001782 if (dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 rt->rt_gateway != rt->rt_dst &&
1784 rt->u.dst.dev->mtu > 576)
1785 rt->u.dst.metrics[RTAX_MTU-1] = 576;
1786 }
1787#ifdef CONFIG_NET_CLS_ROUTE
1788 rt->u.dst.tclassid = FIB_RES_NH(*res).nh_tclassid;
1789#endif
1790 } else
1791 rt->u.dst.metrics[RTAX_MTU-1]= rt->u.dst.dev->mtu;
1792
Satoru SATOH5ffc02a2008-05-04 22:14:42 -07001793 if (dst_metric(&rt->u.dst, RTAX_HOPLIMIT) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = sysctl_ip_default_ttl;
Rami Rosen6d273f82008-08-06 02:33:49 -07001795 if (dst_mtu(&rt->u.dst) > IP_MAX_MTU)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 rt->u.dst.metrics[RTAX_MTU-1] = IP_MAX_MTU;
Satoru SATOH5ffc02a2008-05-04 22:14:42 -07001797 if (dst_metric(&rt->u.dst, RTAX_ADVMSS) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 rt->u.dst.metrics[RTAX_ADVMSS-1] = max_t(unsigned int, rt->u.dst.dev->mtu - 40,
1799 ip_rt_min_advmss);
Satoru SATOH5ffc02a2008-05-04 22:14:42 -07001800 if (dst_metric(&rt->u.dst, RTAX_ADVMSS) > 65535 - 40)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 rt->u.dst.metrics[RTAX_ADVMSS-1] = 65535 - 40;
1802
1803#ifdef CONFIG_NET_CLS_ROUTE
1804#ifdef CONFIG_IP_MULTIPLE_TABLES
1805 set_class_tag(rt, fib_rules_tclass(res));
1806#endif
1807 set_class_tag(rt, itag);
1808#endif
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001809 rt->rt_type = res->type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810}
1811
Al Viro9e12bb22006-09-26 21:25:20 -07001812static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 u8 tos, struct net_device *dev, int our)
1814{
1815 unsigned hash;
1816 struct rtable *rth;
Al Viroa61ced52006-09-26 21:27:54 -07001817 __be32 spec_dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818 struct in_device *in_dev = in_dev_get(dev);
1819 u32 itag = 0;
1820
1821 /* Primary sanity checks. */
1822
1823 if (in_dev == NULL)
1824 return -EINVAL;
1825
Jan Engelhardt1e637c72008-01-21 03:18:08 -08001826 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
Joe Perchesf97c1e02007-12-16 13:45:43 -08001827 ipv4_is_loopback(saddr) || skb->protocol != htons(ETH_P_IP))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 goto e_inval;
1829
Joe Perchesf97c1e02007-12-16 13:45:43 -08001830 if (ipv4_is_zeronet(saddr)) {
1831 if (!ipv4_is_local_multicast(daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 goto e_inval;
1833 spec_dst = inet_select_addr(dev, 0, RT_SCOPE_LINK);
1834 } else if (fib_validate_source(saddr, 0, tos, 0,
1835 dev, &spec_dst, &itag) < 0)
1836 goto e_inval;
1837
1838 rth = dst_alloc(&ipv4_dst_ops);
1839 if (!rth)
1840 goto e_nobufs;
1841
1842 rth->u.dst.output= ip_rt_bug;
1843
1844 atomic_set(&rth->u.dst.__refcnt, 1);
1845 rth->u.dst.flags= DST_HOST;
Herbert Xu42f811b2007-06-04 23:34:44 -07001846 if (IN_DEV_CONF_GET(in_dev, NOPOLICY))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847 rth->u.dst.flags |= DST_NOPOLICY;
1848 rth->fl.fl4_dst = daddr;
1849 rth->rt_dst = daddr;
1850 rth->fl.fl4_tos = tos;
Thomas Graf47dcf0c2006-11-09 15:20:38 -08001851 rth->fl.mark = skb->mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 rth->fl.fl4_src = saddr;
1853 rth->rt_src = saddr;
1854#ifdef CONFIG_NET_CLS_ROUTE
1855 rth->u.dst.tclassid = itag;
1856#endif
1857 rth->rt_iif =
1858 rth->fl.iif = dev->ifindex;
Eric W. Biederman2774c7a2007-09-26 22:10:56 -07001859 rth->u.dst.dev = init_net.loopback_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 dev_hold(rth->u.dst.dev);
1861 rth->idev = in_dev_get(rth->u.dst.dev);
1862 rth->fl.oif = 0;
1863 rth->rt_gateway = daddr;
1864 rth->rt_spec_dst= spec_dst;
Denis V. Luneve84f84f2008-07-05 19:04:32 -07001865 rth->rt_genid = rt_genid(dev_net(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 rth->rt_flags = RTCF_MULTICAST;
Eric Dumazet29e75252008-01-31 17:05:09 -08001867 rth->rt_type = RTN_MULTICAST;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868 if (our) {
1869 rth->u.dst.input= ip_local_deliver;
1870 rth->rt_flags |= RTCF_LOCAL;
1871 }
1872
1873#ifdef CONFIG_IP_MROUTE
Joe Perchesf97c1e02007-12-16 13:45:43 -08001874 if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 rth->u.dst.input = ip_mr_input;
1876#endif
1877 RT_CACHE_STAT_INC(in_slow_mc);
1878
1879 in_dev_put(in_dev);
Denis V. Luneve84f84f2008-07-05 19:04:32 -07001880 hash = rt_hash(daddr, saddr, dev->ifindex, rt_genid(dev_net(dev)));
Eric Dumazetee6b9672008-03-05 18:30:47 -08001881 return rt_intern_hash(hash, rth, &skb->rtable);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882
1883e_nobufs:
1884 in_dev_put(in_dev);
1885 return -ENOBUFS;
1886
1887e_inval:
1888 in_dev_put(in_dev);
1889 return -EINVAL;
1890}
1891
1892
1893static void ip_handle_martian_source(struct net_device *dev,
1894 struct in_device *in_dev,
1895 struct sk_buff *skb,
Al Viro9e12bb22006-09-26 21:25:20 -07001896 __be32 daddr,
1897 __be32 saddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898{
1899 RT_CACHE_STAT_INC(in_martian_src);
1900#ifdef CONFIG_IP_ROUTE_VERBOSE
1901 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
1902 /*
1903 * RFC1812 recommendation, if source is martian,
1904 * the only hint is MAC header.
1905 */
Harvey Harrison673d57e2008-10-31 00:53:57 -07001906 printk(KERN_WARNING "martian source %pI4 from %pI4, on dev %s\n",
1907 &daddr, &saddr, dev->name);
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001908 if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 int i;
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -07001910 const unsigned char *p = skb_mac_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911 printk(KERN_WARNING "ll header: ");
1912 for (i = 0; i < dev->hard_header_len; i++, p++) {
1913 printk("%02x", *p);
1914 if (i < (dev->hard_header_len - 1))
1915 printk(":");
1916 }
1917 printk("\n");
1918 }
1919 }
1920#endif
1921}
1922
Stephen Hemminger5969f712008-04-10 01:52:09 -07001923static int __mkroute_input(struct sk_buff *skb,
1924 struct fib_result *res,
1925 struct in_device *in_dev,
1926 __be32 daddr, __be32 saddr, u32 tos,
1927 struct rtable **result)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928{
1929
1930 struct rtable *rth;
1931 int err;
1932 struct in_device *out_dev;
1933 unsigned flags = 0;
Al Virod9c9df82006-09-26 21:28:14 -07001934 __be32 spec_dst;
1935 u32 itag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936
1937 /* get a working reference to the output device */
1938 out_dev = in_dev_get(FIB_RES_DEV(*res));
1939 if (out_dev == NULL) {
1940 if (net_ratelimit())
1941 printk(KERN_CRIT "Bug in ip_route_input" \
1942 "_slow(). Please, report\n");
1943 return -EINVAL;
1944 }
1945
1946
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001947 err = fib_validate_source(saddr, daddr, tos, FIB_RES_OIF(*res),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 in_dev->dev, &spec_dst, &itag);
1949 if (err < 0) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001950 ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 saddr);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001952
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953 err = -EINVAL;
1954 goto cleanup;
1955 }
1956
1957 if (err)
1958 flags |= RTCF_DIRECTSRC;
1959
Thomas Graf51b77ca2008-06-03 16:36:01 -07001960 if (out_dev == in_dev && err &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961 (IN_DEV_SHARED_MEDIA(out_dev) ||
1962 inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
1963 flags |= RTCF_DOREDIRECT;
1964
1965 if (skb->protocol != htons(ETH_P_IP)) {
1966 /* Not IP (i.e. ARP). Do not create route, if it is
1967 * invalid for proxy arp. DNAT routes are always valid.
1968 */
Rami Rosencb7928a2008-01-09 00:18:24 -08001969 if (out_dev == in_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 err = -EINVAL;
1971 goto cleanup;
1972 }
1973 }
1974
1975
1976 rth = dst_alloc(&ipv4_dst_ops);
1977 if (!rth) {
1978 err = -ENOBUFS;
1979 goto cleanup;
1980 }
1981
Julian Anastasovce723d82005-09-08 13:34:47 -07001982 atomic_set(&rth->u.dst.__refcnt, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 rth->u.dst.flags= DST_HOST;
Herbert Xu42f811b2007-06-04 23:34:44 -07001984 if (IN_DEV_CONF_GET(in_dev, NOPOLICY))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985 rth->u.dst.flags |= DST_NOPOLICY;
Herbert Xu42f811b2007-06-04 23:34:44 -07001986 if (IN_DEV_CONF_GET(out_dev, NOXFRM))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 rth->u.dst.flags |= DST_NOXFRM;
1988 rth->fl.fl4_dst = daddr;
1989 rth->rt_dst = daddr;
1990 rth->fl.fl4_tos = tos;
Thomas Graf47dcf0c2006-11-09 15:20:38 -08001991 rth->fl.mark = skb->mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992 rth->fl.fl4_src = saddr;
1993 rth->rt_src = saddr;
1994 rth->rt_gateway = daddr;
1995 rth->rt_iif =
1996 rth->fl.iif = in_dev->dev->ifindex;
1997 rth->u.dst.dev = (out_dev)->dev;
1998 dev_hold(rth->u.dst.dev);
1999 rth->idev = in_dev_get(rth->u.dst.dev);
2000 rth->fl.oif = 0;
2001 rth->rt_spec_dst= spec_dst;
2002
2003 rth->u.dst.input = ip_forward;
2004 rth->u.dst.output = ip_output;
Denis V. Luneve84f84f2008-07-05 19:04:32 -07002005 rth->rt_genid = rt_genid(dev_net(rth->u.dst.dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006
2007 rt_set_nexthop(rth, res, itag);
2008
2009 rth->rt_flags = flags;
2010
2011 *result = rth;
2012 err = 0;
2013 cleanup:
2014 /* release the working reference to the output device */
2015 in_dev_put(out_dev);
2016 return err;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002017}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018
Stephen Hemminger5969f712008-04-10 01:52:09 -07002019static int ip_mkroute_input(struct sk_buff *skb,
2020 struct fib_result *res,
2021 const struct flowi *fl,
2022 struct in_device *in_dev,
2023 __be32 daddr, __be32 saddr, u32 tos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024{
Chuck Short7abaa272005-06-22 22:10:23 -07002025 struct rtable* rth = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026 int err;
2027 unsigned hash;
2028
2029#ifdef CONFIG_IP_ROUTE_MULTIPATH
2030 if (res->fi && res->fi->fib_nhs > 1 && fl->oif == 0)
2031 fib_select_multipath(fl, res);
2032#endif
2033
2034 /* create a routing cache entry */
2035 err = __mkroute_input(skb, res, in_dev, daddr, saddr, tos, &rth);
2036 if (err)
2037 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038
2039 /* put it into the cache */
Denis V. Luneve84f84f2008-07-05 19:04:32 -07002040 hash = rt_hash(daddr, saddr, fl->iif,
2041 rt_genid(dev_net(rth->u.dst.dev)));
Eric Dumazetee6b9672008-03-05 18:30:47 -08002042 return rt_intern_hash(hash, rth, &skb->rtable);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043}
2044
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045/*
2046 * NOTE. We drop all the packets that has local source
2047 * addresses, because every properly looped back packet
2048 * must have correct destination already attached by output routine.
2049 *
2050 * Such approach solves two big problems:
2051 * 1. Not simplex devices are handled properly.
2052 * 2. IP spoofing attempts are filtered with 100% of guarantee.
2053 */
2054
Al Viro9e12bb22006-09-26 21:25:20 -07002055static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056 u8 tos, struct net_device *dev)
2057{
2058 struct fib_result res;
2059 struct in_device *in_dev = in_dev_get(dev);
2060 struct flowi fl = { .nl_u = { .ip4_u =
2061 { .daddr = daddr,
2062 .saddr = saddr,
2063 .tos = tos,
2064 .scope = RT_SCOPE_UNIVERSE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065 } },
Thomas Graf47dcf0c2006-11-09 15:20:38 -08002066 .mark = skb->mark,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067 .iif = dev->ifindex };
2068 unsigned flags = 0;
2069 u32 itag = 0;
2070 struct rtable * rth;
2071 unsigned hash;
Al Viro9e12bb22006-09-26 21:25:20 -07002072 __be32 spec_dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073 int err = -EINVAL;
2074 int free_res = 0;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002075 struct net * net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076
2077 /* IP on this device is disabled. */
2078
2079 if (!in_dev)
2080 goto out;
2081
2082 /* Check for the most weird martians, which can be not detected
2083 by fib_lookup.
2084 */
2085
Jan Engelhardt1e637c72008-01-21 03:18:08 -08002086 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
Joe Perchesf97c1e02007-12-16 13:45:43 -08002087 ipv4_is_loopback(saddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 goto martian_source;
2089
Al Viroe4485152006-09-26 22:15:01 -07002090 if (daddr == htonl(0xFFFFFFFF) || (saddr == 0 && daddr == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091 goto brd_input;
2092
2093 /* Accept zero addresses only to limited broadcast;
2094 * I even do not know to fix it or not. Waiting for complains :-)
2095 */
Joe Perchesf97c1e02007-12-16 13:45:43 -08002096 if (ipv4_is_zeronet(saddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 goto martian_source;
2098
Jan Engelhardt1e637c72008-01-21 03:18:08 -08002099 if (ipv4_is_lbcast(daddr) || ipv4_is_zeronet(daddr) ||
Joe Perchesf97c1e02007-12-16 13:45:43 -08002100 ipv4_is_loopback(daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101 goto martian_destination;
2102
2103 /*
2104 * Now we are ready to route packet.
2105 */
Denis V. Lunev84a885f2008-01-21 17:34:35 -08002106 if ((err = fib_lookup(net, &fl, &res)) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107 if (!IN_DEV_FORWARD(in_dev))
Dietmar Eggemann2c2910a2005-06-28 13:06:23 -07002108 goto e_hostunreach;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 goto no_route;
2110 }
2111 free_res = 1;
2112
2113 RT_CACHE_STAT_INC(in_slow_tot);
2114
2115 if (res.type == RTN_BROADCAST)
2116 goto brd_input;
2117
2118 if (res.type == RTN_LOCAL) {
2119 int result;
2120 result = fib_validate_source(saddr, daddr, tos,
Denis V. Lunev84a885f2008-01-21 17:34:35 -08002121 net->loopback_dev->ifindex,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122 dev, &spec_dst, &itag);
2123 if (result < 0)
2124 goto martian_source;
2125 if (result)
2126 flags |= RTCF_DIRECTSRC;
2127 spec_dst = daddr;
2128 goto local_input;
2129 }
2130
2131 if (!IN_DEV_FORWARD(in_dev))
Dietmar Eggemann2c2910a2005-06-28 13:06:23 -07002132 goto e_hostunreach;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133 if (res.type != RTN_UNICAST)
2134 goto martian_destination;
2135
2136 err = ip_mkroute_input(skb, &res, &fl, in_dev, daddr, saddr, tos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137done:
2138 in_dev_put(in_dev);
2139 if (free_res)
2140 fib_res_put(&res);
2141out: return err;
2142
2143brd_input:
2144 if (skb->protocol != htons(ETH_P_IP))
2145 goto e_inval;
2146
Joe Perchesf97c1e02007-12-16 13:45:43 -08002147 if (ipv4_is_zeronet(saddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148 spec_dst = inet_select_addr(dev, 0, RT_SCOPE_LINK);
2149 else {
2150 err = fib_validate_source(saddr, 0, tos, 0, dev, &spec_dst,
2151 &itag);
2152 if (err < 0)
2153 goto martian_source;
2154 if (err)
2155 flags |= RTCF_DIRECTSRC;
2156 }
2157 flags |= RTCF_BROADCAST;
2158 res.type = RTN_BROADCAST;
2159 RT_CACHE_STAT_INC(in_brd);
2160
2161local_input:
2162 rth = dst_alloc(&ipv4_dst_ops);
2163 if (!rth)
2164 goto e_nobufs;
2165
2166 rth->u.dst.output= ip_rt_bug;
Denis V. Luneve84f84f2008-07-05 19:04:32 -07002167 rth->rt_genid = rt_genid(net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168
2169 atomic_set(&rth->u.dst.__refcnt, 1);
2170 rth->u.dst.flags= DST_HOST;
Herbert Xu42f811b2007-06-04 23:34:44 -07002171 if (IN_DEV_CONF_GET(in_dev, NOPOLICY))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172 rth->u.dst.flags |= DST_NOPOLICY;
2173 rth->fl.fl4_dst = daddr;
2174 rth->rt_dst = daddr;
2175 rth->fl.fl4_tos = tos;
Thomas Graf47dcf0c2006-11-09 15:20:38 -08002176 rth->fl.mark = skb->mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 rth->fl.fl4_src = saddr;
2178 rth->rt_src = saddr;
2179#ifdef CONFIG_NET_CLS_ROUTE
2180 rth->u.dst.tclassid = itag;
2181#endif
2182 rth->rt_iif =
2183 rth->fl.iif = dev->ifindex;
Denis V. Lunev84a885f2008-01-21 17:34:35 -08002184 rth->u.dst.dev = net->loopback_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185 dev_hold(rth->u.dst.dev);
2186 rth->idev = in_dev_get(rth->u.dst.dev);
2187 rth->rt_gateway = daddr;
2188 rth->rt_spec_dst= spec_dst;
2189 rth->u.dst.input= ip_local_deliver;
2190 rth->rt_flags = flags|RTCF_LOCAL;
2191 if (res.type == RTN_UNREACHABLE) {
2192 rth->u.dst.input= ip_error;
2193 rth->u.dst.error= -err;
2194 rth->rt_flags &= ~RTCF_LOCAL;
2195 }
2196 rth->rt_type = res.type;
Denis V. Luneve84f84f2008-07-05 19:04:32 -07002197 hash = rt_hash(daddr, saddr, fl.iif, rt_genid(net));
Eric Dumazetee6b9672008-03-05 18:30:47 -08002198 err = rt_intern_hash(hash, rth, &skb->rtable);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199 goto done;
2200
2201no_route:
2202 RT_CACHE_STAT_INC(in_no_route);
2203 spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
2204 res.type = RTN_UNREACHABLE;
Mitsuru Chinen7f538782007-12-07 01:07:24 -08002205 if (err == -ESRCH)
2206 err = -ENETUNREACH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207 goto local_input;
2208
2209 /*
2210 * Do not cache martian addresses: they should be logged (RFC1812)
2211 */
2212martian_destination:
2213 RT_CACHE_STAT_INC(in_martian_dst);
2214#ifdef CONFIG_IP_ROUTE_VERBOSE
2215 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit())
Harvey Harrison673d57e2008-10-31 00:53:57 -07002216 printk(KERN_WARNING "martian destination %pI4 from %pI4, dev %s\n",
2217 &daddr, &saddr, dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002218#endif
Dietmar Eggemann2c2910a2005-06-28 13:06:23 -07002219
2220e_hostunreach:
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002221 err = -EHOSTUNREACH;
2222 goto done;
Dietmar Eggemann2c2910a2005-06-28 13:06:23 -07002223
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224e_inval:
2225 err = -EINVAL;
2226 goto done;
2227
2228e_nobufs:
2229 err = -ENOBUFS;
2230 goto done;
2231
2232martian_source:
2233 ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
2234 goto e_inval;
2235}
2236
Al Viro9e12bb22006-09-26 21:25:20 -07002237int ip_route_input(struct sk_buff *skb, __be32 daddr, __be32 saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238 u8 tos, struct net_device *dev)
2239{
2240 struct rtable * rth;
2241 unsigned hash;
2242 int iif = dev->ifindex;
Denis V. Lunevb5921912008-01-22 23:50:25 -08002243 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09002245 net = dev_net(dev);
Neil Horman1080d702008-10-27 12:28:25 -07002246
2247 if (!rt_caching(net))
2248 goto skip_cache;
2249
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250 tos &= IPTOS_RT_MASK;
Denis V. Luneve84f84f2008-07-05 19:04:32 -07002251 hash = rt_hash(daddr, saddr, iif, rt_genid(net));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252
2253 rcu_read_lock();
2254 for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
Eric Dumazet093c2ca2007-02-09 16:19:26 -08002255 rth = rcu_dereference(rth->u.dst.rt_next)) {
Stephen Hemmingerc0b8c322008-04-10 04:00:28 -07002256 if (((rth->fl.fl4_dst ^ daddr) |
2257 (rth->fl.fl4_src ^ saddr) |
2258 (rth->fl.iif ^ iif) |
2259 rth->fl.oif |
2260 (rth->fl.fl4_tos ^ tos)) == 0 &&
Thomas Graf47dcf0c2006-11-09 15:20:38 -08002261 rth->fl.mark == skb->mark &&
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002262 net_eq(dev_net(rth->u.dst.dev), net) &&
Denis V. Luneve84f84f2008-07-05 19:04:32 -07002263 !rt_is_expired(rth)) {
Pavel Emelyanov03f49f32007-11-10 21:28:34 -08002264 dst_use(&rth->u.dst, jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265 RT_CACHE_STAT_INC(in_hit);
2266 rcu_read_unlock();
Eric Dumazetee6b9672008-03-05 18:30:47 -08002267 skb->rtable = rth;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002268 return 0;
2269 }
2270 RT_CACHE_STAT_INC(in_hlist_search);
2271 }
2272 rcu_read_unlock();
2273
Neil Horman1080d702008-10-27 12:28:25 -07002274skip_cache:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275 /* Multicast recognition logic is moved from route cache to here.
2276 The problem was that too many Ethernet cards have broken/missing
2277 hardware multicast filters :-( As result the host on multicasting
2278 network acquires a lot of useless route cache entries, sort of
2279 SDR messages from all the world. Now we try to get rid of them.
2280 Really, provided software IP multicast filter is organized
2281 reasonably (at least, hashed), it does not result in a slowdown
2282 comparing with route cache reject entries.
2283 Note, that multicast routers are not affected, because
2284 route cache entry is created eventually.
2285 */
Joe Perchesf97c1e02007-12-16 13:45:43 -08002286 if (ipv4_is_multicast(daddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287 struct in_device *in_dev;
2288
2289 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -07002290 if ((in_dev = __in_dev_get_rcu(dev)) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291 int our = ip_check_mc(in_dev, daddr, saddr,
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07002292 ip_hdr(skb)->protocol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293 if (our
2294#ifdef CONFIG_IP_MROUTE
Joe Perchesf97c1e02007-12-16 13:45:43 -08002295 || (!ipv4_is_local_multicast(daddr) &&
2296 IN_DEV_MFORWARD(in_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297#endif
2298 ) {
2299 rcu_read_unlock();
2300 return ip_route_input_mc(skb, daddr, saddr,
2301 tos, dev, our);
2302 }
2303 }
2304 rcu_read_unlock();
2305 return -EINVAL;
2306 }
2307 return ip_route_input_slow(skb, daddr, saddr, tos, dev);
2308}
2309
Stephen Hemminger5969f712008-04-10 01:52:09 -07002310static int __mkroute_output(struct rtable **result,
2311 struct fib_result *res,
2312 const struct flowi *fl,
2313 const struct flowi *oldflp,
2314 struct net_device *dev_out,
2315 unsigned flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316{
2317 struct rtable *rth;
2318 struct in_device *in_dev;
2319 u32 tos = RT_FL_TOS(oldflp);
2320 int err = 0;
2321
Joe Perchesf97c1e02007-12-16 13:45:43 -08002322 if (ipv4_is_loopback(fl->fl4_src) && !(dev_out->flags&IFF_LOOPBACK))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002323 return -EINVAL;
2324
Al Viroe4485152006-09-26 22:15:01 -07002325 if (fl->fl4_dst == htonl(0xFFFFFFFF))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 res->type = RTN_BROADCAST;
Joe Perchesf97c1e02007-12-16 13:45:43 -08002327 else if (ipv4_is_multicast(fl->fl4_dst))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328 res->type = RTN_MULTICAST;
Jan Engelhardt1e637c72008-01-21 03:18:08 -08002329 else if (ipv4_is_lbcast(fl->fl4_dst) || ipv4_is_zeronet(fl->fl4_dst))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330 return -EINVAL;
2331
2332 if (dev_out->flags & IFF_LOOPBACK)
2333 flags |= RTCF_LOCAL;
2334
2335 /* get work reference to inet device */
2336 in_dev = in_dev_get(dev_out);
2337 if (!in_dev)
2338 return -EINVAL;
2339
2340 if (res->type == RTN_BROADCAST) {
2341 flags |= RTCF_BROADCAST | RTCF_LOCAL;
2342 if (res->fi) {
2343 fib_info_put(res->fi);
2344 res->fi = NULL;
2345 }
2346 } else if (res->type == RTN_MULTICAST) {
2347 flags |= RTCF_MULTICAST|RTCF_LOCAL;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002348 if (!ip_check_mc(in_dev, oldflp->fl4_dst, oldflp->fl4_src,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349 oldflp->proto))
2350 flags &= ~RTCF_LOCAL;
2351 /* If multicast route do not exist use
2352 default one, but do not gateway in this case.
2353 Yes, it is hack.
2354 */
2355 if (res->fi && res->prefixlen < 4) {
2356 fib_info_put(res->fi);
2357 res->fi = NULL;
2358 }
2359 }
2360
2361
2362 rth = dst_alloc(&ipv4_dst_ops);
2363 if (!rth) {
2364 err = -ENOBUFS;
2365 goto cleanup;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002366 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002367
Julian Anastasovce723d82005-09-08 13:34:47 -07002368 atomic_set(&rth->u.dst.__refcnt, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369 rth->u.dst.flags= DST_HOST;
Herbert Xu42f811b2007-06-04 23:34:44 -07002370 if (IN_DEV_CONF_GET(in_dev, NOXFRM))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371 rth->u.dst.flags |= DST_NOXFRM;
Herbert Xu42f811b2007-06-04 23:34:44 -07002372 if (IN_DEV_CONF_GET(in_dev, NOPOLICY))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373 rth->u.dst.flags |= DST_NOPOLICY;
2374
2375 rth->fl.fl4_dst = oldflp->fl4_dst;
2376 rth->fl.fl4_tos = tos;
2377 rth->fl.fl4_src = oldflp->fl4_src;
2378 rth->fl.oif = oldflp->oif;
Thomas Graf47dcf0c2006-11-09 15:20:38 -08002379 rth->fl.mark = oldflp->mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380 rth->rt_dst = fl->fl4_dst;
2381 rth->rt_src = fl->fl4_src;
2382 rth->rt_iif = oldflp->oif ? : dev_out->ifindex;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002383 /* get references to the devices that are to be hold by the routing
Linus Torvalds1da177e2005-04-16 15:20:36 -07002384 cache entry */
2385 rth->u.dst.dev = dev_out;
2386 dev_hold(dev_out);
2387 rth->idev = in_dev_get(dev_out);
2388 rth->rt_gateway = fl->fl4_dst;
2389 rth->rt_spec_dst= fl->fl4_src;
2390
2391 rth->u.dst.output=ip_output;
Denis V. Luneve84f84f2008-07-05 19:04:32 -07002392 rth->rt_genid = rt_genid(dev_net(dev_out));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393
2394 RT_CACHE_STAT_INC(out_slow_tot);
2395
2396 if (flags & RTCF_LOCAL) {
2397 rth->u.dst.input = ip_local_deliver;
2398 rth->rt_spec_dst = fl->fl4_dst;
2399 }
2400 if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
2401 rth->rt_spec_dst = fl->fl4_src;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002402 if (flags & RTCF_LOCAL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403 !(dev_out->flags & IFF_LOOPBACK)) {
2404 rth->u.dst.output = ip_mc_output;
2405 RT_CACHE_STAT_INC(out_slow_mc);
2406 }
2407#ifdef CONFIG_IP_MROUTE
2408 if (res->type == RTN_MULTICAST) {
2409 if (IN_DEV_MFORWARD(in_dev) &&
Joe Perchesf97c1e02007-12-16 13:45:43 -08002410 !ipv4_is_local_multicast(oldflp->fl4_dst)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002411 rth->u.dst.input = ip_mr_input;
2412 rth->u.dst.output = ip_mc_output;
2413 }
2414 }
2415#endif
2416 }
2417
2418 rt_set_nexthop(rth, res, 0);
2419
2420 rth->rt_flags = flags;
2421
2422 *result = rth;
2423 cleanup:
2424 /* release work reference to inet device */
2425 in_dev_put(in_dev);
2426
2427 return err;
2428}
2429
Stephen Hemminger5969f712008-04-10 01:52:09 -07002430static int ip_mkroute_output(struct rtable **rp,
2431 struct fib_result *res,
2432 const struct flowi *fl,
2433 const struct flowi *oldflp,
2434 struct net_device *dev_out,
2435 unsigned flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436{
Chuck Short7abaa272005-06-22 22:10:23 -07002437 struct rtable *rth = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438 int err = __mkroute_output(&rth, res, fl, oldflp, dev_out, flags);
2439 unsigned hash;
2440 if (err == 0) {
Denis V. Lunevb00180d2008-07-05 19:04:09 -07002441 hash = rt_hash(oldflp->fl4_dst, oldflp->fl4_src, oldflp->oif,
Denis V. Luneve84f84f2008-07-05 19:04:32 -07002442 rt_genid(dev_net(dev_out)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002443 err = rt_intern_hash(hash, rth, rp);
2444 }
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002445
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446 return err;
2447}
2448
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449/*
2450 * Major route resolver routine.
2451 */
2452
Denis V. Lunevb40afd02008-01-22 22:06:19 -08002453static int ip_route_output_slow(struct net *net, struct rtable **rp,
2454 const struct flowi *oldflp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002455{
2456 u32 tos = RT_FL_TOS(oldflp);
2457 struct flowi fl = { .nl_u = { .ip4_u =
2458 { .daddr = oldflp->fl4_dst,
2459 .saddr = oldflp->fl4_src,
2460 .tos = tos & IPTOS_RT_MASK,
2461 .scope = ((tos & RTO_ONLINK) ?
2462 RT_SCOPE_LINK :
2463 RT_SCOPE_UNIVERSE),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002464 } },
Thomas Graf47dcf0c2006-11-09 15:20:38 -08002465 .mark = oldflp->mark,
Denis V. Lunevb40afd02008-01-22 22:06:19 -08002466 .iif = net->loopback_dev->ifindex,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467 .oif = oldflp->oif };
2468 struct fib_result res;
2469 unsigned flags = 0;
2470 struct net_device *dev_out = NULL;
2471 int free_res = 0;
2472 int err;
2473
2474
2475 res.fi = NULL;
2476#ifdef CONFIG_IP_MULTIPLE_TABLES
2477 res.r = NULL;
2478#endif
2479
2480 if (oldflp->fl4_src) {
2481 err = -EINVAL;
Joe Perchesf97c1e02007-12-16 13:45:43 -08002482 if (ipv4_is_multicast(oldflp->fl4_src) ||
Jan Engelhardt1e637c72008-01-21 03:18:08 -08002483 ipv4_is_lbcast(oldflp->fl4_src) ||
Joe Perchesf97c1e02007-12-16 13:45:43 -08002484 ipv4_is_zeronet(oldflp->fl4_src))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002485 goto out;
2486
Linus Torvalds1da177e2005-04-16 15:20:36 -07002487 /* I removed check for oif == dev_out->oif here.
2488 It was wrong for two reasons:
Denis V. Lunev1ab35272008-01-22 22:04:30 -08002489 1. ip_dev_find(net, saddr) can return wrong iface, if saddr
2490 is assigned to multiple interfaces.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491 2. Moreover, we are allowed to send packets with saddr
2492 of another iface. --ANK
2493 */
2494
David S. Millerf6c5d732007-05-18 02:07:50 -07002495 if (oldflp->oif == 0
Joe Perchesf97c1e02007-12-16 13:45:43 -08002496 && (ipv4_is_multicast(oldflp->fl4_dst) ||
2497 oldflp->fl4_dst == htonl(0xFFFFFFFF))) {
Julian Anastasova210d012008-10-01 07:28:28 -07002498 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2499 dev_out = ip_dev_find(net, oldflp->fl4_src);
2500 if (dev_out == NULL)
2501 goto out;
2502
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503 /* Special hack: user can direct multicasts
2504 and limited broadcast via necessary interface
2505 without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
2506 This hack is not just for fun, it allows
2507 vic,vat and friends to work.
2508 They bind socket to loopback, set ttl to zero
2509 and expect that it will work.
2510 From the viewpoint of routing cache they are broken,
2511 because we are not allowed to build multicast path
2512 with loopback source addr (look, routing cache
2513 cannot know, that ttl is zero, so that packet
2514 will not leave this host and route is valid).
2515 Luckily, this hack is good workaround.
2516 */
2517
2518 fl.oif = dev_out->ifindex;
2519 goto make_route;
2520 }
Julian Anastasova210d012008-10-01 07:28:28 -07002521
2522 if (!(oldflp->flags & FLOWI_FLAG_ANYSRC)) {
2523 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2524 dev_out = ip_dev_find(net, oldflp->fl4_src);
2525 if (dev_out == NULL)
2526 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527 dev_put(dev_out);
Julian Anastasova210d012008-10-01 07:28:28 -07002528 dev_out = NULL;
2529 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002530 }
2531
2532
2533 if (oldflp->oif) {
Denis V. Lunevb40afd02008-01-22 22:06:19 -08002534 dev_out = dev_get_by_index(net, oldflp->oif);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002535 err = -ENODEV;
2536 if (dev_out == NULL)
2537 goto out;
Herbert Xue5ed6392005-10-03 14:35:55 -07002538
2539 /* RACE: Check return value of inet_select_addr instead. */
2540 if (__in_dev_get_rtnl(dev_out) == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002541 dev_put(dev_out);
2542 goto out; /* Wrong error code */
2543 }
2544
Joe Perchesf97c1e02007-12-16 13:45:43 -08002545 if (ipv4_is_local_multicast(oldflp->fl4_dst) ||
2546 oldflp->fl4_dst == htonl(0xFFFFFFFF)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002547 if (!fl.fl4_src)
2548 fl.fl4_src = inet_select_addr(dev_out, 0,
2549 RT_SCOPE_LINK);
2550 goto make_route;
2551 }
2552 if (!fl.fl4_src) {
Joe Perchesf97c1e02007-12-16 13:45:43 -08002553 if (ipv4_is_multicast(oldflp->fl4_dst))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002554 fl.fl4_src = inet_select_addr(dev_out, 0,
2555 fl.fl4_scope);
2556 else if (!oldflp->fl4_dst)
2557 fl.fl4_src = inet_select_addr(dev_out, 0,
2558 RT_SCOPE_HOST);
2559 }
2560 }
2561
2562 if (!fl.fl4_dst) {
2563 fl.fl4_dst = fl.fl4_src;
2564 if (!fl.fl4_dst)
2565 fl.fl4_dst = fl.fl4_src = htonl(INADDR_LOOPBACK);
2566 if (dev_out)
2567 dev_put(dev_out);
Denis V. Lunevb40afd02008-01-22 22:06:19 -08002568 dev_out = net->loopback_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002569 dev_hold(dev_out);
Denis V. Lunevb40afd02008-01-22 22:06:19 -08002570 fl.oif = net->loopback_dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002571 res.type = RTN_LOCAL;
2572 flags |= RTCF_LOCAL;
2573 goto make_route;
2574 }
2575
Denis V. Lunevb40afd02008-01-22 22:06:19 -08002576 if (fib_lookup(net, &fl, &res)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577 res.fi = NULL;
2578 if (oldflp->oif) {
2579 /* Apparently, routing tables are wrong. Assume,
2580 that the destination is on link.
2581
2582 WHY? DW.
2583 Because we are allowed to send to iface
2584 even if it has NO routes and NO assigned
2585 addresses. When oif is specified, routing
2586 tables are looked up with only one purpose:
2587 to catch if destination is gatewayed, rather than
2588 direct. Moreover, if MSG_DONTROUTE is set,
2589 we send packet, ignoring both routing tables
2590 and ifaddr state. --ANK
2591
2592
2593 We could make it even if oif is unknown,
2594 likely IPv6, but we do not.
2595 */
2596
2597 if (fl.fl4_src == 0)
2598 fl.fl4_src = inet_select_addr(dev_out, 0,
2599 RT_SCOPE_LINK);
2600 res.type = RTN_UNICAST;
2601 goto make_route;
2602 }
2603 if (dev_out)
2604 dev_put(dev_out);
2605 err = -ENETUNREACH;
2606 goto out;
2607 }
2608 free_res = 1;
2609
2610 if (res.type == RTN_LOCAL) {
2611 if (!fl.fl4_src)
2612 fl.fl4_src = fl.fl4_dst;
2613 if (dev_out)
2614 dev_put(dev_out);
Denis V. Lunevb40afd02008-01-22 22:06:19 -08002615 dev_out = net->loopback_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002616 dev_hold(dev_out);
2617 fl.oif = dev_out->ifindex;
2618 if (res.fi)
2619 fib_info_put(res.fi);
2620 res.fi = NULL;
2621 flags |= RTCF_LOCAL;
2622 goto make_route;
2623 }
2624
2625#ifdef CONFIG_IP_ROUTE_MULTIPATH
2626 if (res.fi->fib_nhs > 1 && fl.oif == 0)
2627 fib_select_multipath(&fl, &res);
2628 else
2629#endif
2630 if (!res.prefixlen && res.type == RTN_UNICAST && !fl.oif)
Denis V. Lunevb40afd02008-01-22 22:06:19 -08002631 fib_select_default(net, &fl, &res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632
2633 if (!fl.fl4_src)
2634 fl.fl4_src = FIB_RES_PREFSRC(res);
2635
2636 if (dev_out)
2637 dev_put(dev_out);
2638 dev_out = FIB_RES_DEV(res);
2639 dev_hold(dev_out);
2640 fl.oif = dev_out->ifindex;
2641
2642
2643make_route:
2644 err = ip_mkroute_output(rp, &res, &fl, oldflp, dev_out, flags);
2645
2646
2647 if (free_res)
2648 fib_res_put(&res);
2649 if (dev_out)
2650 dev_put(dev_out);
2651out: return err;
2652}
2653
Denis V. Lunev611c1832008-01-22 22:06:48 -08002654int __ip_route_output_key(struct net *net, struct rtable **rp,
2655 const struct flowi *flp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002656{
2657 unsigned hash;
2658 struct rtable *rth;
2659
Neil Horman1080d702008-10-27 12:28:25 -07002660 if (!rt_caching(net))
2661 goto slow_output;
2662
Denis V. Luneve84f84f2008-07-05 19:04:32 -07002663 hash = rt_hash(flp->fl4_dst, flp->fl4_src, flp->oif, rt_genid(net));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664
2665 rcu_read_lock_bh();
2666 for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
Eric Dumazet093c2ca2007-02-09 16:19:26 -08002667 rth = rcu_dereference(rth->u.dst.rt_next)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002668 if (rth->fl.fl4_dst == flp->fl4_dst &&
2669 rth->fl.fl4_src == flp->fl4_src &&
2670 rth->fl.iif == 0 &&
2671 rth->fl.oif == flp->oif &&
Thomas Graf47dcf0c2006-11-09 15:20:38 -08002672 rth->fl.mark == flp->mark &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002673 !((rth->fl.fl4_tos ^ flp->fl4_tos) &
Denis V. Lunevb5921912008-01-22 23:50:25 -08002674 (IPTOS_RT_MASK | RTO_ONLINK)) &&
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002675 net_eq(dev_net(rth->u.dst.dev), net) &&
Denis V. Luneve84f84f2008-07-05 19:04:32 -07002676 !rt_is_expired(rth)) {
Pavel Emelyanov03f49f32007-11-10 21:28:34 -08002677 dst_use(&rth->u.dst, jiffies);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002678 RT_CACHE_STAT_INC(out_hit);
2679 rcu_read_unlock_bh();
2680 *rp = rth;
2681 return 0;
2682 }
2683 RT_CACHE_STAT_INC(out_hlist_search);
2684 }
2685 rcu_read_unlock_bh();
2686
Neil Horman1080d702008-10-27 12:28:25 -07002687slow_output:
Denis V. Lunev611c1832008-01-22 22:06:48 -08002688 return ip_route_output_slow(net, rp, flp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002689}
2690
Arnaldo Carvalho de Melod8c97a92005-08-09 20:12:12 -07002691EXPORT_SYMBOL_GPL(__ip_route_output_key);
2692
David S. Miller14e50e52007-05-24 18:17:54 -07002693static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu)
2694{
2695}
2696
2697static struct dst_ops ipv4_dst_blackhole_ops = {
2698 .family = AF_INET,
Harvey Harrison09640e62009-02-01 00:45:17 -08002699 .protocol = cpu_to_be16(ETH_P_IP),
David S. Miller14e50e52007-05-24 18:17:54 -07002700 .destroy = ipv4_dst_destroy,
2701 .check = ipv4_dst_check,
2702 .update_pmtu = ipv4_rt_blackhole_update_pmtu,
Eric Dumazete2422972008-01-30 20:07:45 -08002703 .entries = ATOMIC_INIT(0),
David S. Miller14e50e52007-05-24 18:17:54 -07002704};
2705
2706
Denis V. Luneve84f84f2008-07-05 19:04:32 -07002707static int ipv4_dst_blackhole(struct net *net, struct rtable **rp, struct flowi *flp)
David S. Miller14e50e52007-05-24 18:17:54 -07002708{
2709 struct rtable *ort = *rp;
2710 struct rtable *rt = (struct rtable *)
2711 dst_alloc(&ipv4_dst_blackhole_ops);
2712
2713 if (rt) {
2714 struct dst_entry *new = &rt->u.dst;
2715
2716 atomic_set(&new->__refcnt, 1);
2717 new->__use = 1;
Herbert Xu352e5122007-11-13 21:34:06 -08002718 new->input = dst_discard;
2719 new->output = dst_discard;
David S. Miller14e50e52007-05-24 18:17:54 -07002720 memcpy(new->metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32));
2721
2722 new->dev = ort->u.dst.dev;
2723 if (new->dev)
2724 dev_hold(new->dev);
2725
2726 rt->fl = ort->fl;
2727
2728 rt->idev = ort->idev;
2729 if (rt->idev)
2730 in_dev_hold(rt->idev);
Denis V. Luneve84f84f2008-07-05 19:04:32 -07002731 rt->rt_genid = rt_genid(net);
David S. Miller14e50e52007-05-24 18:17:54 -07002732 rt->rt_flags = ort->rt_flags;
2733 rt->rt_type = ort->rt_type;
2734 rt->rt_dst = ort->rt_dst;
2735 rt->rt_src = ort->rt_src;
2736 rt->rt_iif = ort->rt_iif;
2737 rt->rt_gateway = ort->rt_gateway;
2738 rt->rt_spec_dst = ort->rt_spec_dst;
2739 rt->peer = ort->peer;
2740 if (rt->peer)
2741 atomic_inc(&rt->peer->refcnt);
2742
2743 dst_free(new);
2744 }
2745
2746 dst_release(&(*rp)->u.dst);
2747 *rp = rt;
2748 return (rt ? 0 : -ENOMEM);
2749}
2750
Denis V. Lunevf1b050b2008-01-22 22:07:10 -08002751int ip_route_output_flow(struct net *net, struct rtable **rp, struct flowi *flp,
2752 struct sock *sk, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002753{
2754 int err;
2755
Denis V. Lunevf1b050b2008-01-22 22:07:10 -08002756 if ((err = __ip_route_output_key(net, rp, flp)) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002757 return err;
2758
2759 if (flp->proto) {
2760 if (!flp->fl4_src)
2761 flp->fl4_src = (*rp)->rt_src;
2762 if (!flp->fl4_dst)
2763 flp->fl4_dst = (*rp)->rt_dst;
Alexey Dobriyan52479b62008-11-25 17:35:18 -08002764 err = __xfrm_lookup(net, (struct dst_entry **)rp, flp, sk,
Herbert Xubb728452007-12-12 18:48:58 -08002765 flags ? XFRM_LOOKUP_WAIT : 0);
David S. Miller14e50e52007-05-24 18:17:54 -07002766 if (err == -EREMOTE)
Denis V. Luneve84f84f2008-07-05 19:04:32 -07002767 err = ipv4_dst_blackhole(net, rp, flp);
David S. Miller14e50e52007-05-24 18:17:54 -07002768
2769 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770 }
2771
2772 return 0;
2773}
2774
Arnaldo Carvalho de Melod8c97a92005-08-09 20:12:12 -07002775EXPORT_SYMBOL_GPL(ip_route_output_flow);
2776
Denis V. Lunevf2063512008-01-22 22:07:34 -08002777int ip_route_output_key(struct net *net, struct rtable **rp, struct flowi *flp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778{
Denis V. Lunevf2063512008-01-22 22:07:34 -08002779 return ip_route_output_flow(net, rp, flp, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780}
2781
Benjamin Thery4feb88e2009-01-22 04:56:23 +00002782static int rt_fill_info(struct net *net,
2783 struct sk_buff *skb, u32 pid, u32 seq, int event,
Jamal Hadi Salimb6544c02005-06-18 22:54:12 -07002784 int nowait, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002785{
Eric Dumazetee6b9672008-03-05 18:30:47 -08002786 struct rtable *rt = skb->rtable;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002787 struct rtmsg *r;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002788 struct nlmsghdr *nlh;
Thomas Grafe3703b32006-11-27 09:27:07 -08002789 long expires;
2790 u32 id = 0, ts = 0, tsage = 0, error;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002791
2792 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*r), flags);
2793 if (nlh == NULL)
Patrick McHardy26932562007-01-31 23:16:40 -08002794 return -EMSGSIZE;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002795
2796 r = nlmsg_data(nlh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797 r->rtm_family = AF_INET;
2798 r->rtm_dst_len = 32;
2799 r->rtm_src_len = 0;
2800 r->rtm_tos = rt->fl.fl4_tos;
2801 r->rtm_table = RT_TABLE_MAIN;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002802 NLA_PUT_U32(skb, RTA_TABLE, RT_TABLE_MAIN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002803 r->rtm_type = rt->rt_type;
2804 r->rtm_scope = RT_SCOPE_UNIVERSE;
2805 r->rtm_protocol = RTPROT_UNSPEC;
2806 r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
2807 if (rt->rt_flags & RTCF_NOTIFY)
2808 r->rtm_flags |= RTM_F_NOTIFY;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002809
Al Viro17fb2c62006-09-26 22:15:25 -07002810 NLA_PUT_BE32(skb, RTA_DST, rt->rt_dst);
Thomas Grafbe403ea2006-08-17 18:15:17 -07002811
Linus Torvalds1da177e2005-04-16 15:20:36 -07002812 if (rt->fl.fl4_src) {
2813 r->rtm_src_len = 32;
Al Viro17fb2c62006-09-26 22:15:25 -07002814 NLA_PUT_BE32(skb, RTA_SRC, rt->fl.fl4_src);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815 }
2816 if (rt->u.dst.dev)
Thomas Grafbe403ea2006-08-17 18:15:17 -07002817 NLA_PUT_U32(skb, RTA_OIF, rt->u.dst.dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818#ifdef CONFIG_NET_CLS_ROUTE
2819 if (rt->u.dst.tclassid)
Thomas Grafbe403ea2006-08-17 18:15:17 -07002820 NLA_PUT_U32(skb, RTA_FLOW, rt->u.dst.tclassid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822 if (rt->fl.iif)
Al Viro17fb2c62006-09-26 22:15:25 -07002823 NLA_PUT_BE32(skb, RTA_PREFSRC, rt->rt_spec_dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002824 else if (rt->rt_src != rt->fl.fl4_src)
Al Viro17fb2c62006-09-26 22:15:25 -07002825 NLA_PUT_BE32(skb, RTA_PREFSRC, rt->rt_src);
Thomas Grafbe403ea2006-08-17 18:15:17 -07002826
Linus Torvalds1da177e2005-04-16 15:20:36 -07002827 if (rt->rt_dst != rt->rt_gateway)
Al Viro17fb2c62006-09-26 22:15:25 -07002828 NLA_PUT_BE32(skb, RTA_GATEWAY, rt->rt_gateway);
Thomas Grafbe403ea2006-08-17 18:15:17 -07002829
Linus Torvalds1da177e2005-04-16 15:20:36 -07002830 if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
Thomas Grafbe403ea2006-08-17 18:15:17 -07002831 goto nla_put_failure;
2832
Thomas Grafe3703b32006-11-27 09:27:07 -08002833 error = rt->u.dst.error;
2834 expires = rt->u.dst.expires ? rt->u.dst.expires - jiffies : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002835 if (rt->peer) {
Thomas Grafe3703b32006-11-27 09:27:07 -08002836 id = rt->peer->ip_id_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002837 if (rt->peer->tcp_ts_stamp) {
Thomas Grafe3703b32006-11-27 09:27:07 -08002838 ts = rt->peer->tcp_ts;
James Morris9d729f72007-03-04 16:12:44 -08002839 tsage = get_seconds() - rt->peer->tcp_ts_stamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002840 }
2841 }
Thomas Grafbe403ea2006-08-17 18:15:17 -07002842
Linus Torvalds1da177e2005-04-16 15:20:36 -07002843 if (rt->fl.iif) {
2844#ifdef CONFIG_IP_MROUTE
Al Viroe4485152006-09-26 22:15:01 -07002845 __be32 dst = rt->rt_dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002846
Joe Perchesf97c1e02007-12-16 13:45:43 -08002847 if (ipv4_is_multicast(dst) && !ipv4_is_local_multicast(dst) &&
Benjamin Thery4feb88e2009-01-22 04:56:23 +00002848 IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
2849 int err = ipmr_get_route(net, skb, r, nowait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850 if (err <= 0) {
2851 if (!nowait) {
2852 if (err == 0)
2853 return 0;
Thomas Grafbe403ea2006-08-17 18:15:17 -07002854 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855 } else {
2856 if (err == -EMSGSIZE)
Thomas Grafbe403ea2006-08-17 18:15:17 -07002857 goto nla_put_failure;
Thomas Grafe3703b32006-11-27 09:27:07 -08002858 error = err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002859 }
2860 }
2861 } else
2862#endif
Thomas Grafbe403ea2006-08-17 18:15:17 -07002863 NLA_PUT_U32(skb, RTA_IIF, rt->fl.iif);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002864 }
2865
Thomas Grafe3703b32006-11-27 09:27:07 -08002866 if (rtnl_put_cacheinfo(skb, &rt->u.dst, id, ts, tsage,
2867 expires, error) < 0)
2868 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002869
Thomas Grafbe403ea2006-08-17 18:15:17 -07002870 return nlmsg_end(skb, nlh);
2871
2872nla_put_failure:
Patrick McHardy26932562007-01-31 23:16:40 -08002873 nlmsg_cancel(skb, nlh);
2874 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002875}
2876
Thomas Graf63f34442007-03-22 11:55:17 -07002877static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09002879 struct net *net = sock_net(in_skb->sk);
Thomas Grafd889ce32006-08-17 18:15:44 -07002880 struct rtmsg *rtm;
2881 struct nlattr *tb[RTA_MAX+1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002882 struct rtable *rt = NULL;
Al Viro9e12bb22006-09-26 21:25:20 -07002883 __be32 dst = 0;
2884 __be32 src = 0;
2885 u32 iif;
Thomas Grafd889ce32006-08-17 18:15:44 -07002886 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887 struct sk_buff *skb;
2888
Thomas Grafd889ce32006-08-17 18:15:44 -07002889 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv4_policy);
2890 if (err < 0)
2891 goto errout;
2892
2893 rtm = nlmsg_data(nlh);
2894
Linus Torvalds1da177e2005-04-16 15:20:36 -07002895 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
Thomas Grafd889ce32006-08-17 18:15:44 -07002896 if (skb == NULL) {
2897 err = -ENOBUFS;
2898 goto errout;
2899 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002900
2901 /* Reserve room for dummy headers, this skb can pass
2902 through good chunk of routing engine.
2903 */
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07002904 skb_reset_mac_header(skb);
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -07002905 skb_reset_network_header(skb);
Stephen Hemmingerd2c962b2006-04-17 17:27:11 -07002906
2907 /* Bugfix: need to give ip_route_input enough of an IP header to not gag. */
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07002908 ip_hdr(skb)->protocol = IPPROTO_ICMP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002909 skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));
2910
Al Viro17fb2c62006-09-26 22:15:25 -07002911 src = tb[RTA_SRC] ? nla_get_be32(tb[RTA_SRC]) : 0;
2912 dst = tb[RTA_DST] ? nla_get_be32(tb[RTA_DST]) : 0;
Thomas Grafd889ce32006-08-17 18:15:44 -07002913 iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002914
2915 if (iif) {
Thomas Grafd889ce32006-08-17 18:15:44 -07002916 struct net_device *dev;
2917
Denis V. Lunev19375042008-02-28 20:52:04 -08002918 dev = __dev_get_by_index(net, iif);
Thomas Grafd889ce32006-08-17 18:15:44 -07002919 if (dev == NULL) {
2920 err = -ENODEV;
2921 goto errout_free;
2922 }
2923
Linus Torvalds1da177e2005-04-16 15:20:36 -07002924 skb->protocol = htons(ETH_P_IP);
2925 skb->dev = dev;
2926 local_bh_disable();
2927 err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
2928 local_bh_enable();
Thomas Grafd889ce32006-08-17 18:15:44 -07002929
Eric Dumazetee6b9672008-03-05 18:30:47 -08002930 rt = skb->rtable;
Thomas Grafd889ce32006-08-17 18:15:44 -07002931 if (err == 0 && rt->u.dst.error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002932 err = -rt->u.dst.error;
2933 } else {
Thomas Grafd889ce32006-08-17 18:15:44 -07002934 struct flowi fl = {
2935 .nl_u = {
2936 .ip4_u = {
2937 .daddr = dst,
2938 .saddr = src,
2939 .tos = rtm->rtm_tos,
2940 },
2941 },
2942 .oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0,
2943 };
Denis V. Lunev19375042008-02-28 20:52:04 -08002944 err = ip_route_output_key(net, &rt, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002945 }
Thomas Grafd889ce32006-08-17 18:15:44 -07002946
Linus Torvalds1da177e2005-04-16 15:20:36 -07002947 if (err)
Thomas Grafd889ce32006-08-17 18:15:44 -07002948 goto errout_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949
Eric Dumazetee6b9672008-03-05 18:30:47 -08002950 skb->rtable = rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002951 if (rtm->rtm_flags & RTM_F_NOTIFY)
2952 rt->rt_flags |= RTCF_NOTIFY;
2953
Benjamin Thery4feb88e2009-01-22 04:56:23 +00002954 err = rt_fill_info(net, skb, NETLINK_CB(in_skb).pid, nlh->nlmsg_seq,
Denis V. Lunev19375042008-02-28 20:52:04 -08002955 RTM_NEWROUTE, 0, 0);
Thomas Grafd889ce32006-08-17 18:15:44 -07002956 if (err <= 0)
2957 goto errout_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002958
Denis V. Lunev19375042008-02-28 20:52:04 -08002959 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).pid);
Thomas Grafd889ce32006-08-17 18:15:44 -07002960errout:
Thomas Graf2942e902006-08-15 00:30:25 -07002961 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002962
Thomas Grafd889ce32006-08-17 18:15:44 -07002963errout_free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002964 kfree_skb(skb);
Thomas Grafd889ce32006-08-17 18:15:44 -07002965 goto errout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002966}
2967
2968int ip_rt_dump(struct sk_buff *skb, struct netlink_callback *cb)
2969{
2970 struct rtable *rt;
2971 int h, s_h;
2972 int idx, s_idx;
Denis V. Lunev19375042008-02-28 20:52:04 -08002973 struct net *net;
2974
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09002975 net = sock_net(skb->sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002976
2977 s_h = cb->args[0];
Eric Dumazetd8c92832008-01-07 21:52:14 -08002978 if (s_h < 0)
2979 s_h = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002980 s_idx = idx = cb->args[1];
Eric Dumazeta6272662008-08-28 01:11:25 -07002981 for (h = s_h; h <= rt_hash_mask; h++, s_idx = 0) {
2982 if (!rt_hash_table[h].chain)
2983 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984 rcu_read_lock_bh();
2985 for (rt = rcu_dereference(rt_hash_table[h].chain), idx = 0; rt;
Eric Dumazet093c2ca2007-02-09 16:19:26 -08002986 rt = rcu_dereference(rt->u.dst.rt_next), idx++) {
YOSHIFUJI Hideaki878628f2008-03-26 03:57:35 +09002987 if (!net_eq(dev_net(rt->u.dst.dev), net) || idx < s_idx)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002988 continue;
Denis V. Luneve84f84f2008-07-05 19:04:32 -07002989 if (rt_is_expired(rt))
Eric Dumazet29e75252008-01-31 17:05:09 -08002990 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002991 skb->dst = dst_clone(&rt->u.dst);
Benjamin Thery4feb88e2009-01-22 04:56:23 +00002992 if (rt_fill_info(net, skb, NETLINK_CB(cb->skb).pid,
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002993 cb->nlh->nlmsg_seq, RTM_NEWROUTE,
Jamal Hadi Salimb6544c02005-06-18 22:54:12 -07002994 1, NLM_F_MULTI) <= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002995 dst_release(xchg(&skb->dst, NULL));
2996 rcu_read_unlock_bh();
2997 goto done;
2998 }
2999 dst_release(xchg(&skb->dst, NULL));
3000 }
3001 rcu_read_unlock_bh();
3002 }
3003
3004done:
3005 cb->args[0] = h;
3006 cb->args[1] = idx;
3007 return skb->len;
3008}
3009
3010void ip_rt_multicast_event(struct in_device *in_dev)
3011{
Denis V. Lunev76e6ebf2008-07-05 19:00:44 -07003012 rt_cache_flush(dev_net(in_dev->dev), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003013}
3014
3015#ifdef CONFIG_SYSCTL
Denis V. Lunev81c684d2008-07-08 03:05:28 -07003016static int ipv4_sysctl_rtcache_flush(ctl_table *__ctl, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003017 struct file *filp, void __user *buffer,
3018 size_t *lenp, loff_t *ppos)
3019{
3020 if (write) {
Denis V. Lunev639e1042008-07-05 19:02:06 -07003021 int flush_delay;
Denis V. Lunev81c684d2008-07-08 03:05:28 -07003022 ctl_table ctl;
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003023 struct net *net;
Denis V. Lunev639e1042008-07-05 19:02:06 -07003024
Denis V. Lunev81c684d2008-07-08 03:05:28 -07003025 memcpy(&ctl, __ctl, sizeof(ctl));
3026 ctl.data = &flush_delay;
3027 proc_dointvec(&ctl, write, filp, buffer, lenp, ppos);
Denis V. Lunev639e1042008-07-05 19:02:06 -07003028
Denis V. Lunev81c684d2008-07-08 03:05:28 -07003029 net = (struct net *)__ctl->extra1;
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003030 rt_cache_flush(net, flush_delay);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003031 return 0;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09003032 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003033
3034 return -EINVAL;
3035}
3036
3037static int ipv4_sysctl_rtcache_flush_strategy(ctl_table *table,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003038 void __user *oldval,
3039 size_t __user *oldlenp,
3040 void __user *newval,
Alexey Dobriyan1f29bcd2006-12-10 02:19:10 -08003041 size_t newlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003042{
3043 int delay;
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003044 struct net *net;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003045 if (newlen != sizeof(int))
3046 return -EINVAL;
3047 if (get_user(delay, (int __user *)newval))
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09003048 return -EFAULT;
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003049 net = (struct net *)table->extra1;
3050 rt_cache_flush(net, delay);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003051 return 0;
3052}
3053
Herbert Xuc6153b52008-08-15 13:44:31 -07003054static void rt_secret_reschedule(int old)
3055{
3056 struct net *net;
3057 int new = ip_rt_secret_interval;
3058 int diff = new - old;
3059
3060 if (!diff)
3061 return;
3062
3063 rtnl_lock();
3064 for_each_net(net) {
3065 int deleted = del_timer_sync(&net->ipv4.rt_secret_timer);
3066
3067 if (!new)
3068 continue;
3069
3070 if (deleted) {
3071 long time = net->ipv4.rt_secret_timer.expires - jiffies;
3072
3073 if (time <= 0 || (time += diff) <= 0)
3074 time = 0;
3075
3076 net->ipv4.rt_secret_timer.expires = time;
3077 } else
3078 net->ipv4.rt_secret_timer.expires = new;
3079
3080 net->ipv4.rt_secret_timer.expires += jiffies;
3081 add_timer(&net->ipv4.rt_secret_timer);
3082 }
3083 rtnl_unlock();
3084}
3085
3086static int ipv4_sysctl_rt_secret_interval(ctl_table *ctl, int write,
3087 struct file *filp,
3088 void __user *buffer, size_t *lenp,
3089 loff_t *ppos)
3090{
3091 int old = ip_rt_secret_interval;
3092 int ret = proc_dointvec_jiffies(ctl, write, filp, buffer, lenp, ppos);
3093
3094 rt_secret_reschedule(old);
3095
3096 return ret;
3097}
3098
3099static int ipv4_sysctl_rt_secret_interval_strategy(ctl_table *table,
Herbert Xuc6153b52008-08-15 13:44:31 -07003100 void __user *oldval,
3101 size_t __user *oldlenp,
3102 void __user *newval,
3103 size_t newlen)
3104{
3105 int old = ip_rt_secret_interval;
Alexey Dobriyanf221e722008-10-15 22:04:23 -07003106 int ret = sysctl_jiffies(table, oldval, oldlenp, newval, newlen);
Herbert Xuc6153b52008-08-15 13:44:31 -07003107
3108 rt_secret_reschedule(old);
3109
3110 return ret;
3111}
3112
Al Viroeeb61f72008-07-27 08:59:33 +01003113static ctl_table ipv4_route_table[] = {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09003114 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003115 .ctl_name = NET_IPV4_ROUTE_GC_THRESH,
3116 .procname = "gc_thresh",
3117 .data = &ipv4_dst_ops.gc_thresh,
3118 .maxlen = sizeof(int),
3119 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003120 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003121 },
3122 {
3123 .ctl_name = NET_IPV4_ROUTE_MAX_SIZE,
3124 .procname = "max_size",
3125 .data = &ip_rt_max_size,
3126 .maxlen = sizeof(int),
3127 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003128 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003129 },
3130 {
3131 /* Deprecated. Use gc_min_interval_ms */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09003132
Linus Torvalds1da177e2005-04-16 15:20:36 -07003133 .ctl_name = NET_IPV4_ROUTE_GC_MIN_INTERVAL,
3134 .procname = "gc_min_interval",
3135 .data = &ip_rt_gc_min_interval,
3136 .maxlen = sizeof(int),
3137 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003138 .proc_handler = proc_dointvec_jiffies,
3139 .strategy = sysctl_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003140 },
3141 {
3142 .ctl_name = NET_IPV4_ROUTE_GC_MIN_INTERVAL_MS,
3143 .procname = "gc_min_interval_ms",
3144 .data = &ip_rt_gc_min_interval,
3145 .maxlen = sizeof(int),
3146 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003147 .proc_handler = proc_dointvec_ms_jiffies,
3148 .strategy = sysctl_ms_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003149 },
3150 {
3151 .ctl_name = NET_IPV4_ROUTE_GC_TIMEOUT,
3152 .procname = "gc_timeout",
3153 .data = &ip_rt_gc_timeout,
3154 .maxlen = sizeof(int),
3155 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003156 .proc_handler = proc_dointvec_jiffies,
3157 .strategy = sysctl_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003158 },
3159 {
3160 .ctl_name = NET_IPV4_ROUTE_GC_INTERVAL,
3161 .procname = "gc_interval",
3162 .data = &ip_rt_gc_interval,
3163 .maxlen = sizeof(int),
3164 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003165 .proc_handler = proc_dointvec_jiffies,
3166 .strategy = sysctl_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003167 },
3168 {
3169 .ctl_name = NET_IPV4_ROUTE_REDIRECT_LOAD,
3170 .procname = "redirect_load",
3171 .data = &ip_rt_redirect_load,
3172 .maxlen = sizeof(int),
3173 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003174 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003175 },
3176 {
3177 .ctl_name = NET_IPV4_ROUTE_REDIRECT_NUMBER,
3178 .procname = "redirect_number",
3179 .data = &ip_rt_redirect_number,
3180 .maxlen = sizeof(int),
3181 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003182 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003183 },
3184 {
3185 .ctl_name = NET_IPV4_ROUTE_REDIRECT_SILENCE,
3186 .procname = "redirect_silence",
3187 .data = &ip_rt_redirect_silence,
3188 .maxlen = sizeof(int),
3189 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003190 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003191 },
3192 {
3193 .ctl_name = NET_IPV4_ROUTE_ERROR_COST,
3194 .procname = "error_cost",
3195 .data = &ip_rt_error_cost,
3196 .maxlen = sizeof(int),
3197 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003198 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003199 },
3200 {
3201 .ctl_name = NET_IPV4_ROUTE_ERROR_BURST,
3202 .procname = "error_burst",
3203 .data = &ip_rt_error_burst,
3204 .maxlen = sizeof(int),
3205 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003206 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003207 },
3208 {
3209 .ctl_name = NET_IPV4_ROUTE_GC_ELASTICITY,
3210 .procname = "gc_elasticity",
3211 .data = &ip_rt_gc_elasticity,
3212 .maxlen = sizeof(int),
3213 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003214 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003215 },
3216 {
3217 .ctl_name = NET_IPV4_ROUTE_MTU_EXPIRES,
3218 .procname = "mtu_expires",
3219 .data = &ip_rt_mtu_expires,
3220 .maxlen = sizeof(int),
3221 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003222 .proc_handler = proc_dointvec_jiffies,
3223 .strategy = sysctl_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003224 },
3225 {
3226 .ctl_name = NET_IPV4_ROUTE_MIN_PMTU,
3227 .procname = "min_pmtu",
3228 .data = &ip_rt_min_pmtu,
3229 .maxlen = sizeof(int),
3230 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003231 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003232 },
3233 {
3234 .ctl_name = NET_IPV4_ROUTE_MIN_ADVMSS,
3235 .procname = "min_adv_mss",
3236 .data = &ip_rt_min_advmss,
3237 .maxlen = sizeof(int),
3238 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003239 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003240 },
3241 {
3242 .ctl_name = NET_IPV4_ROUTE_SECRET_INTERVAL,
3243 .procname = "secret_interval",
3244 .data = &ip_rt_secret_interval,
3245 .maxlen = sizeof(int),
3246 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003247 .proc_handler = ipv4_sysctl_rt_secret_interval,
3248 .strategy = ipv4_sysctl_rt_secret_interval_strategy,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003249 },
3250 { .ctl_name = 0 }
3251};
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003252
Al Viro2f4520d2008-08-25 15:17:44 -07003253static struct ctl_table empty[1];
3254
3255static struct ctl_table ipv4_skeleton[] =
3256{
3257 { .procname = "route", .ctl_name = NET_IPV4_ROUTE,
Hugh Dickinsd994af02008-08-27 02:35:18 -07003258 .mode = 0555, .child = ipv4_route_table},
Al Viro2f4520d2008-08-25 15:17:44 -07003259 { .procname = "neigh", .ctl_name = NET_IPV4_NEIGH,
Hugh Dickinsd994af02008-08-27 02:35:18 -07003260 .mode = 0555, .child = empty},
Al Viro2f4520d2008-08-25 15:17:44 -07003261 { }
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003262};
3263
Al Viro2f4520d2008-08-25 15:17:44 -07003264static __net_initdata struct ctl_path ipv4_path[] = {
3265 { .procname = "net", .ctl_name = CTL_NET, },
3266 { .procname = "ipv4", .ctl_name = NET_IPV4, },
3267 { },
3268};
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003269
3270static struct ctl_table ipv4_route_flush_table[] = {
3271 {
3272 .ctl_name = NET_IPV4_ROUTE_FLUSH,
3273 .procname = "flush",
3274 .maxlen = sizeof(int),
3275 .mode = 0200,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08003276 .proc_handler = ipv4_sysctl_rtcache_flush,
3277 .strategy = ipv4_sysctl_rtcache_flush_strategy,
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003278 },
3279 { .ctl_name = 0 },
3280};
3281
Al Viro2f4520d2008-08-25 15:17:44 -07003282static __net_initdata struct ctl_path ipv4_route_path[] = {
3283 { .procname = "net", .ctl_name = CTL_NET, },
3284 { .procname = "ipv4", .ctl_name = NET_IPV4, },
3285 { .procname = "route", .ctl_name = NET_IPV4_ROUTE, },
3286 { },
3287};
3288
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003289static __net_init int sysctl_route_net_init(struct net *net)
3290{
3291 struct ctl_table *tbl;
3292
3293 tbl = ipv4_route_flush_table;
3294 if (net != &init_net) {
3295 tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
3296 if (tbl == NULL)
3297 goto err_dup;
3298 }
3299 tbl[0].extra1 = net;
3300
3301 net->ipv4.route_hdr =
3302 register_net_sysctl_table(net, ipv4_route_path, tbl);
3303 if (net->ipv4.route_hdr == NULL)
3304 goto err_reg;
3305 return 0;
3306
3307err_reg:
3308 if (tbl != ipv4_route_flush_table)
3309 kfree(tbl);
3310err_dup:
3311 return -ENOMEM;
3312}
3313
3314static __net_exit void sysctl_route_net_exit(struct net *net)
3315{
3316 struct ctl_table *tbl;
3317
3318 tbl = net->ipv4.route_hdr->ctl_table_arg;
3319 unregister_net_sysctl_table(net->ipv4.route_hdr);
3320 BUG_ON(tbl == ipv4_route_flush_table);
3321 kfree(tbl);
3322}
3323
3324static __net_initdata struct pernet_operations sysctl_route_ops = {
3325 .init = sysctl_route_net_init,
3326 .exit = sysctl_route_net_exit,
3327};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003328#endif
3329
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07003330
3331static __net_init int rt_secret_timer_init(struct net *net)
3332{
Denis V. Luneve84f84f2008-07-05 19:04:32 -07003333 atomic_set(&net->ipv4.rt_genid,
3334 (int) ((num_physpages ^ (num_physpages>>8)) ^
3335 (jiffies ^ (jiffies >> 7))));
3336
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07003337 net->ipv4.rt_secret_timer.function = rt_secret_rebuild;
3338 net->ipv4.rt_secret_timer.data = (unsigned long)net;
3339 init_timer_deferrable(&net->ipv4.rt_secret_timer);
3340
Herbert Xuc6153b52008-08-15 13:44:31 -07003341 if (ip_rt_secret_interval) {
3342 net->ipv4.rt_secret_timer.expires =
3343 jiffies + net_random() % ip_rt_secret_interval +
3344 ip_rt_secret_interval;
3345 add_timer(&net->ipv4.rt_secret_timer);
3346 }
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07003347 return 0;
3348}
3349
3350static __net_exit void rt_secret_timer_exit(struct net *net)
3351{
3352 del_timer_sync(&net->ipv4.rt_secret_timer);
3353}
3354
3355static __net_initdata struct pernet_operations rt_secret_timer_ops = {
3356 .init = rt_secret_timer_init,
3357 .exit = rt_secret_timer_exit,
3358};
3359
3360
Linus Torvalds1da177e2005-04-16 15:20:36 -07003361#ifdef CONFIG_NET_CLS_ROUTE
Eric Dumazet8dbde282007-11-16 03:32:10 -08003362struct ip_rt_acct *ip_rt_acct __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003363#endif /* CONFIG_NET_CLS_ROUTE */
3364
3365static __initdata unsigned long rhash_entries;
3366static int __init set_rhash_entries(char *str)
3367{
3368 if (!str)
3369 return 0;
3370 rhash_entries = simple_strtoul(str, &str, 0);
3371 return 1;
3372}
3373__setup("rhash_entries=", set_rhash_entries);
3374
3375int __init ip_rt_init(void)
3376{
Eric Dumazet424c4b72005-07-05 14:58:19 -07003377 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003378
Linus Torvalds1da177e2005-04-16 15:20:36 -07003379#ifdef CONFIG_NET_CLS_ROUTE
Ingo Molnar0dcec8c2009-02-25 14:07:33 +01003380 ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003381 if (!ip_rt_acct)
3382 panic("IP: failed to allocate ip_rt_acct\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003383#endif
3384
Alexey Dobriyane5d679f2006-08-26 19:25:52 -07003385 ipv4_dst_ops.kmem_cachep =
3386 kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
Paul Mundt20c2df82007-07-20 10:11:58 +09003387 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003388
David S. Miller14e50e52007-05-24 18:17:54 -07003389 ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
3390
Eric Dumazet424c4b72005-07-05 14:58:19 -07003391 rt_hash_table = (struct rt_hash_bucket *)
3392 alloc_large_system_hash("IP route cache",
3393 sizeof(struct rt_hash_bucket),
3394 rhash_entries,
3395 (num_physpages >= 128 * 1024) ?
Mike Stroyan18955cf2005-11-29 16:12:55 -08003396 15 : 17,
Kirill Korotaev8d1502d2006-08-07 20:44:22 -07003397 0,
Eric Dumazet424c4b72005-07-05 14:58:19 -07003398 &rt_hash_log,
3399 &rt_hash_mask,
Anton Blanchardc9503e02009-04-27 05:42:24 -07003400 rhash_entries ? 0 : 512 * 1024);
Eric Dumazet22c047c2005-07-05 14:55:24 -07003401 memset(rt_hash_table, 0, (rt_hash_mask + 1) * sizeof(struct rt_hash_bucket));
3402 rt_hash_lock_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003403
3404 ipv4_dst_ops.gc_thresh = (rt_hash_mask + 1);
3405 ip_rt_max_size = (rt_hash_mask + 1) * 16;
3406
Linus Torvalds1da177e2005-04-16 15:20:36 -07003407 devinet_init();
3408 ip_fib_init();
3409
Linus Torvalds1da177e2005-04-16 15:20:36 -07003410 /* All the timers, started at system startup tend
3411 to synchronize. Perturb it a bit.
3412 */
Eric Dumazet39c90ec2007-09-15 10:55:54 -07003413 schedule_delayed_work(&expires_work,
3414 net_random() % ip_rt_gc_interval + ip_rt_gc_interval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003415
Denis V. Lunev9f5e97e2008-07-05 19:02:59 -07003416 if (register_pernet_subsys(&rt_secret_timer_ops))
3417 printk(KERN_ERR "Unable to setup rt_secret_timer\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003418
Denis V. Lunev73b38712008-02-28 20:51:18 -08003419 if (ip_rt_proc_init())
Pavel Emelyanov107f1632007-12-05 21:14:28 -08003420 printk(KERN_ERR "Unable to create route proc files\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003421#ifdef CONFIG_XFRM
3422 xfrm_init();
3423 xfrm4_init();
3424#endif
Thomas Graf63f34442007-03-22 11:55:17 -07003425 rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL);
3426
Denis V. Lunev39a23e72008-07-05 19:02:33 -07003427#ifdef CONFIG_SYSCTL
3428 register_pernet_subsys(&sysctl_route_ops);
3429#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003430 return rc;
3431}
3432
Al Viroa1bc6eb2008-07-30 06:32:52 -04003433#ifdef CONFIG_SYSCTL
Al Viroeeb61f72008-07-27 08:59:33 +01003434/*
3435 * We really need to sanitize the damn ipv4 init order, then all
3436 * this nonsense will go away.
3437 */
3438void __init ip_static_sysctl_init(void)
3439{
Al Viro2f4520d2008-08-25 15:17:44 -07003440 register_sysctl_paths(ipv4_path, ipv4_skeleton);
Al Viroeeb61f72008-07-27 08:59:33 +01003441}
Al Viroa1bc6eb2008-07-30 06:32:52 -04003442#endif
Al Viroeeb61f72008-07-27 08:59:33 +01003443
Linus Torvalds1da177e2005-04-16 15:20:36 -07003444EXPORT_SYMBOL(__ip_select_ident);
3445EXPORT_SYMBOL(ip_route_input);
3446EXPORT_SYMBOL(ip_route_output_key);