]> bbs.cooldavid.org Git - net-next-2.6.git/blame_incremental - net/ipv4/route.c
git://bbs.cooldavid.org / net-next-2.6.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
net: Move rx skb_orphan call to where needed
[net-next-2.6.git] / net / ipv4 / route.c
... / ...
CommitLineData
1/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * ROUTE - implementation of the IP router.
7 *
8 * Authors: Ross Biro
9 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
10 * Alan Cox, <gw4pts@gw4pts.ampr.org>
11 * Linus Torvalds, <Linus.Torvalds@helsinki.fi>
12 * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
13 *
14 * Fixes:
15 * Alan Cox : Verify area fixes.
16 * Alan Cox : cli() protects routing changes
17 * Rui Oliveira : ICMP routing table updates
18 * (rco@di.uminho.pt) Routing table insertion and update
19 * Linus Torvalds : Rewrote bits to be sensible
20 * Alan Cox : Added BSD route gw semantics
21 * Alan Cox : Super /proc >4K
22 * Alan Cox : MTU in route table
23 * Alan Cox : MSS actually. Also added the window
24 * clamper.
25 * Sam Lantinga : Fixed route matching in rt_del()
26 * Alan Cox : Routing cache support.
27 * Alan Cox : Removed compatibility cruft.
28 * Alan Cox : RTF_REJECT support.
29 * Alan Cox : TCP irtt support.
30 * Jonathan Naylor : Added Metric support.
31 * Miquel van Smoorenburg : BSD API fixes.
32 * Miquel van Smoorenburg : Metrics.
33 * Alan Cox : Use __u32 properly
34 * Alan Cox : Aligned routing errors more closely with BSD
35 * our system is still very different.
36 * Alan Cox : Faster /proc handling
37 * Alexey Kuznetsov : Massive rework to support tree based routing,
38 * routing caches and better behaviour.
39 *
40 * Olaf Erb : irtt wasn't being copied right.
41 * Bjorn Ekwall : Kerneld route support.
42 * Alan Cox : Multicast fixed (I hope)
43 * Pavel Krauz : Limited broadcast fixed
44 * Mike McLagan : Routing by source
45 * Alexey Kuznetsov : End of old history. Split to fib.c and
46 * route.c and rewritten from scratch.
47 * Andi Kleen : Load-limit warning messages.
48 * Vitaly E. Lavrov : Transparent proxy revived after year coma.
49 * Vitaly E. Lavrov : Race condition in ip_route_input_slow.
50 * Tobias Ringstrom : Uninitialized res.type in ip_route_output_slow.
51 * Vladimir V. Ivanov : IP rule info (flowid) is really useful.
52 * Marc Boucher : routing by fwmark
53 * Robert Olsson : Added rt_cache statistics
54 * Arnaldo C. Melo : Convert proc stuff to seq_file
55 * Eric Dumazet : hashed spinlocks and rt_check_expire() fixes.
56 * Ilia Sotnikov : Ignore TOS on PMTUD and Redirect
57 * Ilia Sotnikov : Removed TOS from hash calculations
58 *
59 * This program is free software; you can redistribute it and/or
60 * modify it under the terms of the GNU General Public License
61 * as published by the Free Software Foundation; either version
62 * 2 of the License, or (at your option) any later version.
63 */
64
65#include <linux/module.h>
66#include <asm/uaccess.h>
67#include <asm/system.h>
68#include <linux/bitops.h>
69#include <linux/types.h>
70#include <linux/kernel.h>
71#include <linux/mm.h>
72#include <linux/bootmem.h>
73#include <linux/string.h>
74#include <linux/socket.h>
75#include <linux/sockios.h>
76#include <linux/errno.h>
77#include <linux/in.h>
78#include <linux/inet.h>
79#include <linux/netdevice.h>
80#include <linux/proc_fs.h>
81#include <linux/init.h>
82#include <linux/workqueue.h>
83#include <linux/skbuff.h>
84#include <linux/inetdevice.h>
85#include <linux/igmp.h>
86#include <linux/pkt_sched.h>
87#include <linux/mroute.h>
88#include <linux/netfilter_ipv4.h>
89#include <linux/random.h>
90#include <linux/jhash.h>
91#include <linux/rcupdate.h>
92#include <linux/times.h>
93#include <net/dst.h>
94#include <net/net_namespace.h>
95#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>
105#include <net/netevent.h>
106#include <net/rtnetlink.h>
107#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
118static int ip_rt_max_size;
119static 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;
132static int rt_chain_length_max __read_mostly = 20;
133
134static struct delayed_work expires_work;
135static unsigned long expires_ljiffies;
136
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);
148static int rt_garbage_collect(struct dst_ops *ops);
149static void rt_emergency_hash_rebuild(struct net *net);
150
151
152static struct dst_ops ipv4_dst_ops = {
153 .family = AF_INET,
154 .protocol = cpu_to_be16(ETH_P_IP),
155 .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,
162 .local_out = __ip_local_out,
163 .entries = ATOMIC_INIT(0),
164};
165
166#define ECN_OR_COST(class) TC_PRIO_##class
167
168const __u8 ip_tos2prio[16] = {
169 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;
204};
205
206#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK) || \
207 defined(CONFIG_PROVE_LOCKING)
208/*
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.
211 * (on lockdep we have a quite big spinlock_t, so keep the size down there)
212 */
213#ifdef CONFIG_LOCKDEP
214# define RT_HASH_LOCK_SZ 256
215#else
216# 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
227#endif
228
229static spinlock_t *rt_hash_locks;
230# define rt_hash_lock_addr(slot) &rt_hash_locks[(slot) & (RT_HASH_LOCK_SZ - 1)]
231
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}
244#else
245# define rt_hash_lock_addr(slot) NULL
246
247static inline void rt_hash_lock_init(void)
248{
249}
250#endif
251
252static struct rt_hash_bucket *rt_hash_table __read_mostly;
253static unsigned rt_hash_mask __read_mostly;
254static unsigned int rt_hash_log __read_mostly;
255
256static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
257#define RT_CACHE_STAT_INC(field) \
258 (__raw_get_cpu_var(rt_cache_stat).field++)
259
260static inline unsigned int rt_hash(__be32 daddr, __be32 saddr, int idx,
261 int genid)
262{
263 return jhash_3words((__force u32)(__be32)(daddr),
264 (__force u32)(__be32)(saddr),
265 idx, genid)
266 & rt_hash_mask;
267}
268
269static inline int rt_genid(struct net *net)
270{
271 return atomic_read(&net->ipv4.rt_genid);
272}
273
274#ifdef CONFIG_PROC_FS
275struct rt_cache_iter_state {
276 struct seq_net_private p;
277 int bucket;
278 int genid;
279};
280
281static struct rtable *rt_cache_get_first(struct seq_file *seq)
282{
283 struct rt_cache_iter_state *st = seq->private;
284 struct rtable *r = NULL;
285
286 for (st->bucket = rt_hash_mask; st->bucket >= 0; --st->bucket) {
287 if (!rt_hash_table[st->bucket].chain)
288 continue;
289 rcu_read_lock_bh();
290 r = rcu_dereference(rt_hash_table[st->bucket].chain);
291 while (r) {
292 if (dev_net(r->u.dst.dev) == seq_file_net(seq) &&
293 r->rt_genid == st->genid)
294 return r;
295 r = rcu_dereference(r->u.dst.rt_next);
296 }
297 rcu_read_unlock_bh();
298 }
299 return r;
300}
301
302static struct rtable *__rt_cache_get_next(struct seq_file *seq,
303 struct rtable *r)
304{
305 struct rt_cache_iter_state *st = seq->private;
306
307 r = r->u.dst.rt_next;
308 while (!r) {
309 rcu_read_unlock_bh();
310 do {
311 if (--st->bucket < 0)
312 return NULL;
313 } while (!rt_hash_table[st->bucket].chain);
314 rcu_read_lock_bh();
315 r = rt_hash_table[st->bucket].chain;
316 }
317 return rcu_dereference(r);
318}
319
320static struct rtable *rt_cache_get_next(struct seq_file *seq,
321 struct rtable *r)
322{
323 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))
326 continue;
327 if (r->rt_genid == st->genid)
328 break;
329 }
330 return r;
331}
332
333static struct rtable *rt_cache_get_idx(struct seq_file *seq, loff_t pos)
334{
335 struct rtable *r = rt_cache_get_first(seq);
336
337 if (r)
338 while (pos && (r = rt_cache_get_next(seq, r)))
339 --pos;
340 return pos ? NULL : r;
341}
342
343static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
344{
345 struct rt_cache_iter_state *st = seq->private;
346 if (*pos)
347 return rt_cache_get_idx(seq, *pos - 1);
348 st->genid = rt_genid(seq_file_net(seq));
349 return SEQ_START_TOKEN;
350}
351
352static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
353{
354 struct rtable *r;
355
356 if (v == SEQ_START_TOKEN)
357 r = rt_cache_get_first(seq);
358 else
359 r = rt_cache_get_next(seq, v);
360 ++*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;
379 int len;
380
381 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",
383 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,
396 r->rt_spec_dst, &len);
397
398 seq_printf(seq, "%*s\n", 127 - len, "");
399 }
400 return 0;
401}
402
403static const struct seq_operations rt_cache_seq_ops = {
404 .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{
412 return seq_open_net(inode, file, &rt_cache_seq_ops,
413 sizeof(struct rt_cache_iter_state));
414}
415
416static const struct file_operations rt_cache_seq_fops = {
417 .owner = THIS_MODULE,
418 .open = rt_cache_seq_open,
419 .read = seq_read,
420 .llseek = seq_lseek,
421 .release = seq_release_net,
422};
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
432 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
433 if (!cpu_possible(cpu))
434 continue;
435 *pos = cpu+1;
436 return &per_cpu(rt_cache_stat, cpu);
437 }
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
445 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
446 if (!cpu_possible(cpu))
447 continue;
448 *pos = cpu+1;
449 return &per_cpu(rt_cache_stat, cpu);
450 }
451 return NULL;
452
453}
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) {
465 seq_printf(seq, "entries in_hit in_slow_tot in_slow_mc in_no_route in_brd in_martian_dst in_martian_src out_hit out_slow_tot out_slow_mc gc_total gc_ignored gc_goal_miss gc_dst_overflow in_hlist_search out_hlist_search\n");
466 return 0;
467 }
468
469 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,
482 st->out_slow_mc,
483
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
494static const struct seq_operations rt_cpu_seq_ops = {
495 .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
507static const struct file_operations rt_cpu_seq_fops = {
508 .owner = THIS_MODULE,
509 .open = rt_cpu_seq_open,
510 .read = seq_read,
511 .llseek = seq_lseek,
512 .release = seq_release,
513};
514
515#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
554
555static int __net_init ip_rt_do_proc_init(struct net *net)
556{
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
564 pde = proc_create("rt_cache", S_IRUGO,
565 net->proc_net_stat, &rt_cpu_seq_fops);
566 if (!pde)
567 goto err2;
568
569#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}
586
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
604#else
605static inline int ip_rt_proc_init(void)
606{
607 return 0;
608}
609#endif /* CONFIG_PROC_FS */
610
611static inline void rt_free(struct rtable *rt)
612{
613 call_rcu_bh(&rt->u.dst.rcu_head, dst_rcu_free);
614}
615
616static inline void rt_drop(struct rtable *rt)
617{
618 ip_rt_put(rt);
619 call_rcu_bh(&rt->u.dst.rcu_head, dst_rcu_free);
620}
621
622static inline int rt_fast_clean(struct rtable *rth)
623{
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)) &&
627 rth->fl.iif && rth->u.dst.rt_next;
628}
629
630static inline int rt_valuable(struct rtable *rth)
631{
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
679static 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
693static inline int compare_keys(struct flowi *fl1, struct flowi *fl2)
694{
695 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)) |
697 (fl1->mark ^ fl2->mark) |
698 (*(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;
702}
703
704static inline int compare_netns(struct rtable *rt1, struct rtable *rt2)
705{
706 return dev_net(rt1->u.dst.dev) == dev_net(rt2->u.dst.dev);
707}
708
709static inline int rt_is_expired(struct rtable *rth)
710{
711 return rth->rt_genid != rt_genid(dev_net(rth->u.dst.dev));
712}
713
714/*
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;
723 struct rtable * tail;
724
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));
733#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
759 rth = rt_hash_table[i].chain;
760 rt_hash_table[i].chain = NULL;
761 tail = NULL;
762#endif
763 spin_unlock_bh(rt_hash_lock_addr(i));
764
765 for (; rth != tail; rth = next) {
766 next = rth->u.dst.rt_next;
767 rt_free(rth);
768 }
769 }
770}
771
772/*
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
783static void rt_check_expire(void)
784{
785 static unsigned int rover;
786 unsigned int i = rover, goal;
787 struct rtable *rth, *aux, **rthp;
788 unsigned long samples = 0;
789 unsigned long sum = 0, sum2 = 0;
790 unsigned long delta;
791 u64 mult;
792
793 delta = jiffies - expires_ljiffies;
794 expires_ljiffies = jiffies;
795 mult = ((u64)delta) << rt_hash_log;
796 if (ip_rt_gc_timeout > 1)
797 do_div(mult, ip_rt_gc_timeout);
798 goal = (unsigned int)mult;
799 if (goal > rt_hash_mask)
800 goal = rt_hash_mask + 1;
801 for (; goal > 0; goal--) {
802 unsigned long tmo = ip_rt_gc_timeout;
803 unsigned long length;
804
805 i = (i + 1) & rt_hash_mask;
806 rthp = &rt_hash_table[i].chain;
807
808 if (need_resched())
809 cond_resched();
810
811 samples++;
812
813 if (*rthp == NULL)
814 continue;
815 length = 0;
816 spin_lock_bh(rt_hash_lock_addr(i));
817 while ((rth = *rthp) != NULL) {
818 prefetch(rth->u.dst.rt_next);
819 if (rt_is_expired(rth)) {
820 *rthp = rth->u.dst.rt_next;
821 rt_free(rth);
822 continue;
823 }
824 if (rth->u.dst.expires) {
825 /* Entry is expired even if it is in use */
826 if (time_before_eq(jiffies, rth->u.dst.expires)) {
827nofree:
828 tmo >>= 1;
829 rthp = &rth->u.dst.rt_next;
830 /*
831 * We only count entries on
832 * a chain with equal hash inputs once
833 * so that entries for different QOS
834 * levels, and other non-hash input
835 * attributes don't unfairly skew
836 * the length computation
837 */
838 for (aux = rt_hash_table[i].chain;;) {
839 if (aux == rth) {
840 length += ONE;
841 break;
842 }
843 if (compare_hash_inputs(&aux->fl, &rth->fl))
844 break;
845 aux = aux->u.dst.rt_next;
846 }
847 continue;
848 }
849 } else if (!rt_may_expire(rth, tmo, ip_rt_gc_timeout))
850 goto nofree;
851
852 /* Cleanup aged off entries. */
853 *rthp = rth->u.dst.rt_next;
854 rt_free(rth);
855 }
856 spin_unlock_bh(rt_hash_lock_addr(i));
857 sum += length;
858 sum2 += length*length;
859 }
860 if (samples) {
861 unsigned long avg = sum / samples;
862 unsigned long sd = int_sqrt(sum2 / samples - avg*avg);
863 rt_chain_length_max = max_t(unsigned long,
864 ip_rt_gc_elasticity,
865 (avg + 4*sd) >> FRACT_BITS);
866 }
867 rover = i;
868}
869
870/*
871 * rt_worker_func() is run in process context.
872 * we call rt_check_expire() to scan part of the hash table
873 */
874static void rt_worker_func(struct work_struct *work)
875{
876 rt_check_expire();
877 schedule_delayed_work(&expires_work, ip_rt_gc_interval);
878}
879
880/*
881 * Pertubation of rt_genid by a small quantity [1..256]
882 * Using 8 bits of shuffling ensure we can call rt_cache_invalidate()
883 * many times (2^24) without giving recent rt_genid.
884 * Jenkins hash is strong enough that litle changes of rt_genid are OK.
885 */
886static void rt_cache_invalidate(struct net *net)
887{
888 unsigned char shuffle;
889
890 get_random_bytes(&shuffle, sizeof(shuffle));
891 atomic_add(shuffle + 1U, &net->ipv4.rt_genid);
892}
893
894/*
895 * delay < 0 : invalidate cache (fast : entries will be deleted later)
896 * delay >= 0 : invalidate & flush cache (can be long)
897 */
898void rt_cache_flush(struct net *net, int delay)
899{
900 rt_cache_invalidate(net);
901 if (delay >= 0)
902 rt_do_flush(!in_softirq());
903}
904
905/*
906 * We change rt_genid and let gc do the cleanup
907 */
908static void rt_secret_rebuild(unsigned long __net)
909{
910 struct net *net = (struct net *)__net;
911 rt_cache_invalidate(net);
912 mod_timer(&net->ipv4.rt_secret_timer, jiffies + ip_rt_secret_interval);
913}
914
915static void rt_secret_rebuild_oneshot(struct net *net)
916{
917 del_timer_sync(&net->ipv4.rt_secret_timer);
918 rt_cache_invalidate(net);
919 if (ip_rt_secret_interval) {
920 net->ipv4.rt_secret_timer.expires += ip_rt_secret_interval;
921 add_timer(&net->ipv4.rt_secret_timer);
922 }
923}
924
925static void rt_emergency_hash_rebuild(struct net *net)
926{
927 if (net_ratelimit()) {
928 printk(KERN_WARNING "Route hash chain too long!\n");
929 printk(KERN_WARNING "Adjust your secret_interval!\n");
930 }
931
932 rt_secret_rebuild_oneshot(net);
933}
934
935/*
936 Short description of GC goals.
937
938 We want to build algorithm, which will keep routing cache
939 at some equilibrium point, when number of aged off entries
940 is kept approximately equal to newly generated ones.
941
942 Current expiration strength is variable "expire".
943 We try to adjust it dynamically, so that if networking
944 is idle expires is large enough to keep enough of warm entries,
945 and when load increases it reduces to limit cache size.
946 */
947
948static int rt_garbage_collect(struct dst_ops *ops)
949{
950 static unsigned long expire = RT_GC_TIMEOUT;
951 static unsigned long last_gc;
952 static int rover;
953 static int equilibrium;
954 struct rtable *rth, **rthp;
955 unsigned long now = jiffies;
956 int goal;
957
958 /*
959 * Garbage collection is pretty expensive,
960 * do not make it too frequently.
961 */
962
963 RT_CACHE_STAT_INC(gc_total);
964
965 if (now - last_gc < ip_rt_gc_min_interval &&
966 atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size) {
967 RT_CACHE_STAT_INC(gc_ignored);
968 goto out;
969 }
970
971 /* Calculate number of entries, which we want to expire now. */
972 goal = atomic_read(&ipv4_dst_ops.entries) -
973 (ip_rt_gc_elasticity << rt_hash_log);
974 if (goal <= 0) {
975 if (equilibrium < ipv4_dst_ops.gc_thresh)
976 equilibrium = ipv4_dst_ops.gc_thresh;
977 goal = atomic_read(&ipv4_dst_ops.entries) - equilibrium;
978 if (goal > 0) {
979 equilibrium += min_t(unsigned int, goal >> 1, rt_hash_mask + 1);
980 goal = atomic_read(&ipv4_dst_ops.entries) - equilibrium;
981 }
982 } else {
983 /* We are in dangerous area. Try to reduce cache really
984 * aggressively.
985 */
986 goal = max_t(unsigned int, goal >> 1, rt_hash_mask + 1);
987 equilibrium = atomic_read(&ipv4_dst_ops.entries) - goal;
988 }
989
990 if (now - last_gc >= ip_rt_gc_min_interval)
991 last_gc = now;
992
993 if (goal <= 0) {
994 equilibrium += goal;
995 goto work_done;
996 }
997
998 do {
999 int i, k;
1000
1001 for (i = rt_hash_mask, k = rover; i >= 0; i--) {
1002 unsigned long tmo = expire;
1003
1004 k = (k + 1) & rt_hash_mask;
1005 rthp = &rt_hash_table[k].chain;
1006 spin_lock_bh(rt_hash_lock_addr(k));
1007 while ((rth = *rthp) != NULL) {
1008 if (!rt_is_expired(rth) &&
1009 !rt_may_expire(rth, tmo, expire)) {
1010 tmo >>= 1;
1011 rthp = &rth->u.dst.rt_next;
1012 continue;
1013 }
1014 *rthp = rth->u.dst.rt_next;
1015 rt_free(rth);
1016 goal--;
1017 }
1018 spin_unlock_bh(rt_hash_lock_addr(k));
1019 if (goal <= 0)
1020 break;
1021 }
1022 rover = k;
1023
1024 if (goal <= 0)
1025 goto work_done;
1026
1027 /* Goal is not achieved. We stop process if:
1028
1029 - if expire reduced to zero. Otherwise, expire is halfed.
1030 - if table is not full.
1031 - if we are called from interrupt.
1032 - jiffies check is just fallback/debug loop breaker.
1033 We will not spin here for long time in any case.
1034 */
1035
1036 RT_CACHE_STAT_INC(gc_goal_miss);
1037
1038 if (expire == 0)
1039 break;
1040
1041 expire >>= 1;
1042#if RT_CACHE_DEBUG >= 2
1043 printk(KERN_DEBUG "expire>> %u %d %d %d\n", expire,
1044 atomic_read(&ipv4_dst_ops.entries), goal, i);
1045#endif
1046
1047 if (atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size)
1048 goto out;
1049 } while (!in_softirq() && time_before_eq(jiffies, now));
1050
1051 if (atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size)
1052 goto out;
1053 if (net_ratelimit())
1054 printk(KERN_WARNING "dst cache overflow\n");
1055 RT_CACHE_STAT_INC(gc_dst_overflow);
1056 return 1;
1057
1058work_done:
1059 expire += ip_rt_gc_min_interval;
1060 if (expire > ip_rt_gc_timeout ||
1061 atomic_read(&ipv4_dst_ops.entries) < ipv4_dst_ops.gc_thresh)
1062 expire = ip_rt_gc_timeout;
1063#if RT_CACHE_DEBUG >= 2
1064 printk(KERN_DEBUG "expire++ %u %d %d %d\n", expire,
1065 atomic_read(&ipv4_dst_ops.entries), goal, rover);
1066#endif
1067out: return 0;
1068}
1069
1070static int rt_intern_hash(unsigned hash, struct rtable *rt,
1071 struct rtable **rp, struct sk_buff *skb)
1072{
1073 struct rtable *rth, **rthp;
1074 unsigned long now;
1075 struct rtable *cand, **candp;
1076 u32 min_score;
1077 int chain_length;
1078 int attempts = !in_softirq();
1079
1080restart:
1081 chain_length = 0;
1082 min_score = ~(u32)0;
1083 cand = NULL;
1084 candp = NULL;
1085 now = jiffies;
1086
1087 if (!rt_caching(dev_net(rt->u.dst.dev))) {
1088 /*
1089 * If we're not caching, just tell the caller we
1090 * were successful and don't touch the route. The
1091 * caller hold the sole reference to the cache entry, and
1092 * it will be released when the caller is done with it.
1093 * If we drop it here, the callers have no way to resolve routes
1094 * when we're not caching. Instead, just point *rp at rt, so
1095 * the caller gets a single use out of the route
1096 */
1097 goto report_and_exit;
1098 }
1099
1100 rthp = &rt_hash_table[hash].chain;
1101
1102 spin_lock_bh(rt_hash_lock_addr(hash));
1103 while ((rth = *rthp) != NULL) {
1104 if (rt_is_expired(rth)) {
1105 *rthp = rth->u.dst.rt_next;
1106 rt_free(rth);
1107 continue;
1108 }
1109 if (compare_keys(&rth->fl, &rt->fl) && compare_netns(rth, rt)) {
1110 /* Put it first */
1111 *rthp = rth->u.dst.rt_next;
1112 /*
1113 * Since lookup is lockfree, the deletion
1114 * must be visible to another weakly ordered CPU before
1115 * the insertion at the start of the hash chain.
1116 */
1117 rcu_assign_pointer(rth->u.dst.rt_next,
1118 rt_hash_table[hash].chain);
1119 /*
1120 * Since lookup is lockfree, the update writes
1121 * must be ordered for consistency on SMP.
1122 */
1123 rcu_assign_pointer(rt_hash_table[hash].chain, rth);
1124
1125 dst_use(&rth->u.dst, now);
1126 spin_unlock_bh(rt_hash_lock_addr(hash));
1127
1128 rt_drop(rt);
1129 if (rp)
1130 *rp = rth;
1131 else
1132 skb_dst_set(skb, &rth->u.dst);
1133 return 0;
1134 }
1135
1136 if (!atomic_read(&rth->u.dst.__refcnt)) {
1137 u32 score = rt_score(rth);
1138
1139 if (score <= min_score) {
1140 cand = rth;
1141 candp = rthp;
1142 min_score = score;
1143 }
1144 }
1145
1146 chain_length++;
1147
1148 rthp = &rth->u.dst.rt_next;
1149 }
1150
1151 if (cand) {
1152 /* ip_rt_gc_elasticity used to be average length of chain
1153 * length, when exceeded gc becomes really aggressive.
1154 *
1155 * The second limit is less certain. At the moment it allows
1156 * only 2 entries per bucket. We will see.
1157 */
1158 if (chain_length > ip_rt_gc_elasticity) {
1159 *candp = cand->u.dst.rt_next;
1160 rt_free(cand);
1161 }
1162 } else {
1163 if (chain_length > rt_chain_length_max) {
1164 struct net *net = dev_net(rt->u.dst.dev);
1165 int num = ++net->ipv4.current_rt_cache_rebuild_count;
1166 if (!rt_caching(dev_net(rt->u.dst.dev))) {
1167 printk(KERN_WARNING "%s: %d rebuilds is over limit, route caching disabled\n",
1168 rt->u.dst.dev->name, num);
1169 }
1170 rt_emergency_hash_rebuild(dev_net(rt->u.dst.dev));
1171 }
1172 }
1173
1174 /* Try to bind route to arp only if it is output
1175 route or unicast forwarding path.
1176 */
1177 if (rt->rt_type == RTN_UNICAST || rt->fl.iif == 0) {
1178 int err = arp_bind_neighbour(&rt->u.dst);
1179 if (err) {
1180 spin_unlock_bh(rt_hash_lock_addr(hash));
1181
1182 if (err != -ENOBUFS) {
1183 rt_drop(rt);
1184 return err;
1185 }
1186
1187 /* Neighbour tables are full and nothing
1188 can be released. Try to shrink route cache,
1189 it is most likely it holds some neighbour records.
1190 */
1191 if (attempts-- > 0) {
1192 int saved_elasticity = ip_rt_gc_elasticity;
1193 int saved_int = ip_rt_gc_min_interval;
1194 ip_rt_gc_elasticity = 1;
1195 ip_rt_gc_min_interval = 0;
1196 rt_garbage_collect(&ipv4_dst_ops);
1197 ip_rt_gc_min_interval = saved_int;
1198 ip_rt_gc_elasticity = saved_elasticity;
1199 goto restart;
1200 }
1201
1202 if (net_ratelimit())
1203 printk(KERN_WARNING "Neighbour table overflow.\n");
1204 rt_drop(rt);
1205 return -ENOBUFS;
1206 }
1207 }
1208
1209 rt->u.dst.rt_next = rt_hash_table[hash].chain;
1210
1211#if RT_CACHE_DEBUG >= 2
1212 if (rt->u.dst.rt_next) {
1213 struct rtable *trt;
1214 printk(KERN_DEBUG "rt_cache @%02x: %pI4", hash, &rt->rt_dst);
1215 for (trt = rt->u.dst.rt_next; trt; trt = trt->u.dst.rt_next)
1216 printk(" . %pI4", &trt->rt_dst);
1217 printk("\n");
1218 }
1219#endif
1220 /*
1221 * Since lookup is lockfree, we must make sure
1222 * previous writes to rt are comitted to memory
1223 * before making rt visible to other CPUS.
1224 */
1225 rcu_assign_pointer(rt_hash_table[hash].chain, rt);
1226
1227 spin_unlock_bh(rt_hash_lock_addr(hash));
1228
1229report_and_exit:
1230 if (rp)
1231 *rp = rt;
1232 else
1233 skb_dst_set(skb, &rt->u.dst);
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);
1268 salt = secure_ip_id((__force __be32)ip_fallback_id ^ iph->daddr);
1269 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
1290 printk(KERN_DEBUG "rt_bind_peer(0) @%p\n",
1291 __builtin_return_address(0));
1292
1293 ip_select_fb_ident(iph);
1294}
1295
1296static void rt_del(unsigned hash, struct rtable *rt)
1297{
1298 struct rtable **rthp, *aux;
1299
1300 rthp = &rt_hash_table[hash].chain;
1301 spin_lock_bh(rt_hash_lock_addr(hash));
1302 ip_rt_put(rt);
1303 while ((aux = *rthp) != NULL) {
1304 if (aux == rt || rt_is_expired(aux)) {
1305 *rthp = aux->u.dst.rt_next;
1306 rt_free(aux);
1307 continue;
1308 }
1309 rthp = &aux->u.dst.rt_next;
1310 }
1311 spin_unlock_bh(rt_hash_lock_addr(hash));
1312}
1313
1314void ip_rt_redirect(__be32 old_gw, __be32 daddr, __be32 new_gw,
1315 __be32 saddr, struct net_device *dev)
1316{
1317 int i, k;
1318 struct in_device *in_dev = in_dev_get(dev);
1319 struct rtable *rth, **rthp;
1320 __be32 skeys[2] = { saddr, 0 };
1321 int ikeys[2] = { dev->ifindex, 0 };
1322 struct netevent_redirect netevent;
1323 struct net *net;
1324
1325 if (!in_dev)
1326 return;
1327
1328 net = dev_net(dev);
1329 if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev)
1330 || ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw)
1331 || ipv4_is_zeronet(new_gw))
1332 goto reject_redirect;
1333
1334 if (!rt_caching(net))
1335 goto reject_redirect;
1336
1337 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 {
1343 if (inet_addr_type(net, new_gw) != RTN_UNICAST)
1344 goto reject_redirect;
1345 }
1346
1347 for (i = 0; i < 2; i++) {
1348 for (k = 0; k < 2; k++) {
1349 unsigned hash = rt_hash(daddr, skeys[i], ikeys[k],
1350 rt_genid(net));
1351
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] ||
1360 rth->fl.oif != ikeys[k] ||
1361 rth->fl.iif != 0 ||
1362 rt_is_expired(rth) ||
1363 !net_eq(dev_net(rth->u.dst.dev), net)) {
1364 rthp = &rth->u.dst.rt_next;
1365 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;
1387 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;
1399#ifdef CONFIG_XFRM
1400 rt->u.dst.xfrm = NULL;
1401#endif
1402 rt->rt_genid = rt_genid(net);
1403 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 }
1423
1424 netevent.old = &rth->u.dst;
1425 netevent.new = &rt->u.dst;
1426 call_netevent_notifiers(NETEVENT_REDIRECT,
1427 &netevent);
1428
1429 rt_del(hash, rth);
1430 if (!rt_intern_hash(hash, rt, &rt, NULL))
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())
1445 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);
1449#endif
1450 in_dev_put(in_dev);
1451}
1452
1453static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
1454{
1455 struct rtable *rt = (struct rtable *)dst;
1456 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) {
1464 unsigned hash = rt_hash(rt->fl.fl4_dst, rt->fl.fl4_src,
1465 rt->fl.oif,
1466 rt_genid(dev_net(dst->dev)));
1467#if RT_CACHE_DEBUG >= 1
1468 printk(KERN_DEBUG "ipv4_negative_advice: redirect to %pI4/%02x dropped\n",
1469 &rt->rt_dst, rt->fl.fl4_tos);
1470#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{
1496 struct rtable *rt = skb_rtable(skb);
1497 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 */
1522 if (rt->u.dst.rate_tokens == 0 ||
1523 time_after(jiffies,
1524 (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())
1533 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);
1536#endif
1537 }
1538out:
1539 in_dev_put(in_dev);
1540}
1541
1542static int ip_error(struct sk_buff *skb)
1543{
1544 struct rtable *rt = skb_rtable(skb);
1545 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;
1557 IP_INC_STATS_BH(dev_net(rt->u.dst.dev),
1558 IPSTATS_MIB_INNOROUTES);
1559 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;
1577}
1578
1579/*
1580 * The last two values are not from the RFC but
1581 * are needed for AMPRnet AX.25 paths.
1582 */
1583
1584static const unsigned short mtu_plateau[] =
1585{32000, 17914, 8166, 4352, 2002, 1492, 576, 296, 216, 128 };
1586
1587static inline unsigned short guess_mtu(unsigned short old_mtu)
1588{
1589 int i;
1590
1591 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
1597unsigned short ip_rt_frag_needed(struct net *net, struct iphdr *iph,
1598 unsigned short new_mtu,
1599 struct net_device *dev)
1600{
1601 int i, k;
1602 unsigned short old_mtu = ntohs(iph->tot_len);
1603 struct rtable *rth;
1604 int ikeys[2] = { dev->ifindex, 0 };
1605 __be32 skeys[2] = { iph->saddr, 0, };
1606 __be32 daddr = iph->daddr;
1607 unsigned short est_mtu = 0;
1608
1609 if (ipv4_config.no_pmtu_disc)
1610 return 0;
1611
1612 for (k = 0; k < 2; k++) {
1613 for (i = 0; i < 2; i++) {
1614 unsigned hash = rt_hash(daddr, skeys[i], ikeys[k],
1615 rt_genid(net));
1616
1617 rcu_read_lock();
1618 for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
1619 rth = rcu_dereference(rth->u.dst.rt_next)) {
1620 unsigned short mtu = new_mtu;
1621
1622 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) ||
1630 rt_is_expired(rth))
1631 continue;
1632
1633 if (new_mtu < 68 || new_mtu >= old_mtu) {
1634
1635 /* BSD 4.2 compatibility hack :-( */
1636 if (mtu == 0 &&
1637 old_mtu >= dst_mtu(&rth->u.dst) &&
1638 old_mtu >= 68 + (iph->ihl << 2))
1639 old_mtu -= iph->ihl << 2;
1640
1641 mtu = guess_mtu(old_mtu);
1642 }
1643 if (mtu <= dst_mtu(&rth->u.dst)) {
1644 if (mtu < dst_mtu(&rth->u.dst)) {
1645 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 }
1658 rcu_read_unlock();
1659 }
1660 }
1661 return est_mtu ? : new_mtu;
1662}
1663
1664static void ip_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
1665{
1666 if (dst_mtu(dst) > mtu && mtu >= 68 &&
1667 !(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);
1674 call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst);
1675 }
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;
1705 if (dev != dev_net(dev)->loopback_dev && idev && idev->dev == dev) {
1706 struct in_device *loopback_idev =
1707 in_dev_get(dev_net(dev)->loopback_dev);
1708 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
1721 rt = skb_rtable(skb);
1722 if (rt)
1723 dst_set_expires(&rt->u.dst, 0);
1724}
1725
1726static int ip_rt_bug(struct sk_buff *skb)
1727{
1728 printk(KERN_DEBUG "ip_rt_bug: %pI4 -> %pI4, %s\n",
1729 &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
1730 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{
1746 __be32 src;
1747 struct fib_result res;
1748
1749 if (rt->fl.iif == 0)
1750 src = rt->rt_src;
1751 else if (fib_lookup(dev_net(rt->u.dst.dev), &rt->fl, &res) == 0) {
1752 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;
1782 if (dst_metric_locked(&rt->u.dst, RTAX_MTU) &&
1783 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
1793 if (dst_metric(&rt->u.dst, RTAX_HOPLIMIT) == 0)
1794 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = sysctl_ip_default_ttl;
1795 if (dst_mtu(&rt->u.dst) > IP_MAX_MTU)
1796 rt->u.dst.metrics[RTAX_MTU-1] = IP_MAX_MTU;
1797 if (dst_metric(&rt->u.dst, RTAX_ADVMSS) == 0)
1798 rt->u.dst.metrics[RTAX_ADVMSS-1] = max_t(unsigned int, rt->u.dst.dev->mtu - 40,
1799 ip_rt_min_advmss);
1800 if (dst_metric(&rt->u.dst, RTAX_ADVMSS) > 65535 - 40)
1801 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
1809 rt->rt_type = res->type;
1810}
1811
1812static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1813 u8 tos, struct net_device *dev, int our)
1814{
1815 unsigned hash;
1816 struct rtable *rth;
1817 __be32 spec_dst;
1818 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
1826 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
1827 ipv4_is_loopback(saddr) || skb->protocol != htons(ETH_P_IP))
1828 goto e_inval;
1829
1830 if (ipv4_is_zeronet(saddr)) {
1831 if (!ipv4_is_local_multicast(daddr))
1832 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;
1846 if (IN_DEV_CONF_GET(in_dev, NOPOLICY))
1847 rth->u.dst.flags |= DST_NOPOLICY;
1848 rth->fl.fl4_dst = daddr;
1849 rth->rt_dst = daddr;
1850 rth->fl.fl4_tos = tos;
1851 rth->fl.mark = skb->mark;
1852 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;
1859 rth->u.dst.dev = init_net.loopback_dev;
1860 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;
1865 rth->rt_genid = rt_genid(dev_net(dev));
1866 rth->rt_flags = RTCF_MULTICAST;
1867 rth->rt_type = RTN_MULTICAST;
1868 if (our) {
1869 rth->u.dst.input= ip_local_deliver;
1870 rth->rt_flags |= RTCF_LOCAL;
1871 }
1872
1873#ifdef CONFIG_IP_MROUTE
1874 if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
1875 rth->u.dst.input = ip_mr_input;
1876#endif
1877 RT_CACHE_STAT_INC(in_slow_mc);
1878
1879 in_dev_put(in_dev);
1880 hash = rt_hash(daddr, saddr, dev->ifindex, rt_genid(dev_net(dev)));
1881 return rt_intern_hash(hash, rth, NULL, skb);
1882
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,
1896 __be32 daddr,
1897 __be32 saddr)
1898{
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 */
1906 printk(KERN_WARNING "martian source %pI4 from %pI4, on dev %s\n",
1907 &daddr, &saddr, dev->name);
1908 if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
1909 int i;
1910 const unsigned char *p = skb_mac_header(skb);
1911 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
1923static 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)
1928{
1929
1930 struct rtable *rth;
1931 int err;
1932 struct in_device *out_dev;
1933 unsigned flags = 0;
1934 __be32 spec_dst;
1935 u32 itag;
1936
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
1947 err = fib_validate_source(saddr, daddr, tos, FIB_RES_OIF(*res),
1948 in_dev->dev, &spec_dst, &itag);
1949 if (err < 0) {
1950 ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
1951 saddr);
1952
1953 err = -EINVAL;
1954 goto cleanup;
1955 }
1956
1957 if (err)
1958 flags |= RTCF_DIRECTSRC;
1959
1960 if (out_dev == in_dev && err &&
1961 (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 */
1969 if (out_dev == in_dev) {
1970 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
1982 atomic_set(&rth->u.dst.__refcnt, 1);
1983 rth->u.dst.flags= DST_HOST;
1984 if (IN_DEV_CONF_GET(in_dev, NOPOLICY))
1985 rth->u.dst.flags |= DST_NOPOLICY;
1986 if (IN_DEV_CONF_GET(out_dev, NOXFRM))
1987 rth->u.dst.flags |= DST_NOXFRM;
1988 rth->fl.fl4_dst = daddr;
1989 rth->rt_dst = daddr;
1990 rth->fl.fl4_tos = tos;
1991 rth->fl.mark = skb->mark;
1992 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;
2005 rth->rt_genid = rt_genid(dev_net(rth->u.dst.dev));
2006
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;
2017}
2018
2019static 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)
2024{
2025 struct rtable* rth = NULL;
2026 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;
2038
2039 /* put it into the cache */
2040 hash = rt_hash(daddr, saddr, fl->iif,
2041 rt_genid(dev_net(rth->u.dst.dev)));
2042 return rt_intern_hash(hash, rth, NULL, skb);
2043}
2044
2045/*
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
2055static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
2056 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,
2065 } },
2066 .mark = skb->mark,
2067 .iif = dev->ifindex };
2068 unsigned flags = 0;
2069 u32 itag = 0;
2070 struct rtable * rth;
2071 unsigned hash;
2072 __be32 spec_dst;
2073 int err = -EINVAL;
2074 int free_res = 0;
2075 struct net * net = dev_net(dev);
2076
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
2086 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
2087 ipv4_is_loopback(saddr))
2088 goto martian_source;
2089
2090 if (daddr == htonl(0xFFFFFFFF) || (saddr == 0 && daddr == 0))
2091 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 */
2096 if (ipv4_is_zeronet(saddr))
2097 goto martian_source;
2098
2099 if (ipv4_is_lbcast(daddr) || ipv4_is_zeronet(daddr) ||
2100 ipv4_is_loopback(daddr))
2101 goto martian_destination;
2102
2103 /*
2104 * Now we are ready to route packet.
2105 */
2106 if ((err = fib_lookup(net, &fl, &res)) != 0) {
2107 if (!IN_DEV_FORWARD(in_dev))
2108 goto e_hostunreach;
2109 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,
2121 net->loopback_dev->ifindex,
2122 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))
2132 goto e_hostunreach;
2133 if (res.type != RTN_UNICAST)
2134 goto martian_destination;
2135
2136 err = ip_mkroute_input(skb, &res, &fl, in_dev, daddr, saddr, tos);
2137done:
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
2147 if (ipv4_is_zeronet(saddr))
2148 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;
2167 rth->rt_genid = rt_genid(net);
2168
2169 atomic_set(&rth->u.dst.__refcnt, 1);
2170 rth->u.dst.flags= DST_HOST;
2171 if (IN_DEV_CONF_GET(in_dev, NOPOLICY))
2172 rth->u.dst.flags |= DST_NOPOLICY;
2173 rth->fl.fl4_dst = daddr;
2174 rth->rt_dst = daddr;
2175 rth->fl.fl4_tos = tos;
2176 rth->fl.mark = skb->mark;
2177 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;
2184 rth->u.dst.dev = net->loopback_dev;
2185 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;
2197 hash = rt_hash(daddr, saddr, fl.iif, rt_genid(net));
2198 err = rt_intern_hash(hash, rth, NULL, skb);
2199 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;
2205 if (err == -ESRCH)
2206 err = -ENETUNREACH;
2207 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())
2216 printk(KERN_WARNING "martian destination %pI4 from %pI4, dev %s\n",
2217 &daddr, &saddr, dev->name);
2218#endif
2219
2220e_hostunreach:
2221 err = -EHOSTUNREACH;
2222 goto done;
2223
2224e_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
2237int ip_route_input(struct sk_buff *skb, __be32 daddr, __be32 saddr,
2238 u8 tos, struct net_device *dev)
2239{
2240 struct rtable * rth;
2241 unsigned hash;
2242 int iif = dev->ifindex;
2243 struct net *net;
2244
2245 net = dev_net(dev);
2246
2247 if (!rt_caching(net))
2248 goto skip_cache;
2249
2250 tos &= IPTOS_RT_MASK;
2251 hash = rt_hash(daddr, saddr, iif, rt_genid(net));
2252
2253 rcu_read_lock();
2254 for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
2255 rth = rcu_dereference(rth->u.dst.rt_next)) {
2256 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 &&
2261 rth->fl.mark == skb->mark &&
2262 net_eq(dev_net(rth->u.dst.dev), net) &&
2263 !rt_is_expired(rth)) {
2264 dst_use(&rth->u.dst, jiffies);
2265 RT_CACHE_STAT_INC(in_hit);
2266 rcu_read_unlock();
2267 skb_dst_set(skb, &rth->u.dst);
2268 return 0;
2269 }
2270 RT_CACHE_STAT_INC(in_hlist_search);
2271 }
2272 rcu_read_unlock();
2273
2274skip_cache:
2275 /* 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 */
2286 if (ipv4_is_multicast(daddr)) {
2287 struct in_device *in_dev;
2288
2289 rcu_read_lock();
2290 if ((in_dev = __in_dev_get_rcu(dev)) != NULL) {
2291 int our = ip_check_mc(in_dev, daddr, saddr,
2292 ip_hdr(skb)->protocol);
2293 if (our
2294#ifdef CONFIG_IP_MROUTE
2295 || (!ipv4_is_local_multicast(daddr) &&
2296 IN_DEV_MFORWARD(in_dev))
2297#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
2310static 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)
2316{
2317 struct rtable *rth;
2318 struct in_device *in_dev;
2319 u32 tos = RT_FL_TOS(oldflp);
2320 int err = 0;
2321
2322 if (ipv4_is_loopback(fl->fl4_src) && !(dev_out->flags&IFF_LOOPBACK))
2323 return -EINVAL;
2324
2325 if (fl->fl4_dst == htonl(0xFFFFFFFF))
2326 res->type = RTN_BROADCAST;
2327 else if (ipv4_is_multicast(fl->fl4_dst))
2328 res->type = RTN_MULTICAST;
2329 else if (ipv4_is_lbcast(fl->fl4_dst) || ipv4_is_zeronet(fl->fl4_dst))
2330 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;
2348 if (!ip_check_mc(in_dev, oldflp->fl4_dst, oldflp->fl4_src,
2349 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;
2366 }
2367
2368 atomic_set(&rth->u.dst.__refcnt, 1);
2369 rth->u.dst.flags= DST_HOST;
2370 if (IN_DEV_CONF_GET(in_dev, NOXFRM))
2371 rth->u.dst.flags |= DST_NOXFRM;
2372 if (IN_DEV_CONF_GET(in_dev, NOPOLICY))
2373 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;
2379 rth->fl.mark = oldflp->mark;
2380 rth->rt_dst = fl->fl4_dst;
2381 rth->rt_src = fl->fl4_src;
2382 rth->rt_iif = oldflp->oif ? : dev_out->ifindex;
2383 /* get references to the devices that are to be hold by the routing
2384 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;
2392 rth->rt_genid = rt_genid(dev_net(dev_out));
2393
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;
2402 if (flags & RTCF_LOCAL &&
2403 !(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) &&
2410 !ipv4_is_local_multicast(oldflp->fl4_dst)) {
2411 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
2430static 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)
2436{
2437 struct rtable *rth = NULL;
2438 int err = __mkroute_output(&rth, res, fl, oldflp, dev_out, flags);
2439 unsigned hash;
2440 if (err == 0) {
2441 hash = rt_hash(oldflp->fl4_dst, oldflp->fl4_src, oldflp->oif,
2442 rt_genid(dev_net(dev_out)));
2443 err = rt_intern_hash(hash, rth, rp, NULL);
2444 }
2445
2446 return err;
2447}
2448
2449/*
2450 * Major route resolver routine.
2451 */
2452
2453static int ip_route_output_slow(struct net *net, struct rtable **rp,
2454 const struct flowi *oldflp)
2455{
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),
2464 } },
2465 .mark = oldflp->mark,
2466 .iif = net->loopback_dev->ifindex,
2467 .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;
2482 if (ipv4_is_multicast(oldflp->fl4_src) ||
2483 ipv4_is_lbcast(oldflp->fl4_src) ||
2484 ipv4_is_zeronet(oldflp->fl4_src))
2485 goto out;
2486
2487 /* I removed check for oif == dev_out->oif here.
2488 It was wrong for two reasons:
2489 1. ip_dev_find(net, saddr) can return wrong iface, if saddr
2490 is assigned to multiple interfaces.
2491 2. Moreover, we are allowed to send packets with saddr
2492 of another iface. --ANK
2493 */
2494
2495 if (oldflp->oif == 0
2496 && (ipv4_is_multicast(oldflp->fl4_dst) ||
2497 oldflp->fl4_dst == htonl(0xFFFFFFFF))) {
2498 /* 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
2503 /* 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 }
2521
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;
2527 dev_put(dev_out);
2528 dev_out = NULL;
2529 }
2530 }
2531
2532
2533 if (oldflp->oif) {
2534 dev_out = dev_get_by_index(net, oldflp->oif);
2535 err = -ENODEV;
2536 if (dev_out == NULL)
2537 goto out;
2538
2539 /* RACE: Check return value of inet_select_addr instead. */
2540 if (__in_dev_get_rtnl(dev_out) == NULL) {
2541 dev_put(dev_out);
2542 goto out; /* Wrong error code */
2543 }
2544
2545 if (ipv4_is_local_multicast(oldflp->fl4_dst) ||
2546 oldflp->fl4_dst == htonl(0xFFFFFFFF)) {
2547 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) {
2553 if (ipv4_is_multicast(oldflp->fl4_dst))
2554 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);
2568 dev_out = net->loopback_dev;
2569 dev_hold(dev_out);
2570 fl.oif = net->loopback_dev->ifindex;
2571 res.type = RTN_LOCAL;
2572 flags |= RTCF_LOCAL;
2573 goto make_route;
2574 }
2575
2576 if (fib_lookup(net, &fl, &res)) {
2577 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);
2615 dev_out = net->loopback_dev;
2616 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)
2631 fib_select_default(net, &fl, &res);
2632
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
2654int __ip_route_output_key(struct net *net, struct rtable **rp,
2655 const struct flowi *flp)
2656{
2657 unsigned hash;
2658 struct rtable *rth;
2659
2660 if (!rt_caching(net))
2661 goto slow_output;
2662
2663 hash = rt_hash(flp->fl4_dst, flp->fl4_src, flp->oif, rt_genid(net));
2664
2665 rcu_read_lock_bh();
2666 for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
2667 rth = rcu_dereference(rth->u.dst.rt_next)) {
2668 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 &&
2672 rth->fl.mark == flp->mark &&
2673 !((rth->fl.fl4_tos ^ flp->fl4_tos) &
2674 (IPTOS_RT_MASK | RTO_ONLINK)) &&
2675 net_eq(dev_net(rth->u.dst.dev), net) &&
2676 !rt_is_expired(rth)) {
2677 dst_use(&rth->u.dst, jiffies);
2678 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
2687slow_output:
2688 return ip_route_output_slow(net, rp, flp);
2689}
2690
2691EXPORT_SYMBOL_GPL(__ip_route_output_key);
2692
2693static 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,
2699 .protocol = cpu_to_be16(ETH_P_IP),
2700 .destroy = ipv4_dst_destroy,
2701 .check = ipv4_dst_check,
2702 .update_pmtu = ipv4_rt_blackhole_update_pmtu,
2703 .entries = ATOMIC_INIT(0),
2704};
2705
2706
2707static int ipv4_dst_blackhole(struct net *net, struct rtable **rp, struct flowi *flp)
2708{
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;
2718 new->input = dst_discard;
2719 new->output = dst_discard;
2720 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);
2731 rt->rt_genid = rt_genid(net);
2732 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
2751int ip_route_output_flow(struct net *net, struct rtable **rp, struct flowi *flp,
2752 struct sock *sk, int flags)
2753{
2754 int err;
2755
2756 if ((err = __ip_route_output_key(net, rp, flp)) != 0)
2757 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;
2764 err = __xfrm_lookup(net, (struct dst_entry **)rp, flp, sk,
2765 flags ? XFRM_LOOKUP_WAIT : 0);
2766 if (err == -EREMOTE)
2767 err = ipv4_dst_blackhole(net, rp, flp);
2768
2769 return err;
2770 }
2771
2772 return 0;
2773}
2774
2775EXPORT_SYMBOL_GPL(ip_route_output_flow);
2776
2777int ip_route_output_key(struct net *net, struct rtable **rp, struct flowi *flp)
2778{
2779 return ip_route_output_flow(net, rp, flp, NULL, 0);
2780}
2781
2782static int rt_fill_info(struct net *net,
2783 struct sk_buff *skb, u32 pid, u32 seq, int event,
2784 int nowait, unsigned int flags)
2785{
2786 struct rtable *rt = skb_rtable(skb);
2787 struct rtmsg *r;
2788 struct nlmsghdr *nlh;
2789 long expires;
2790 u32 id = 0, ts = 0, tsage = 0, error;
2791
2792 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*r), flags);
2793 if (nlh == NULL)
2794 return -EMSGSIZE;
2795
2796 r = nlmsg_data(nlh);
2797 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;
2802 NLA_PUT_U32(skb, RTA_TABLE, RT_TABLE_MAIN);
2803 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;
2809
2810 NLA_PUT_BE32(skb, RTA_DST, rt->rt_dst);
2811
2812 if (rt->fl.fl4_src) {
2813 r->rtm_src_len = 32;
2814 NLA_PUT_BE32(skb, RTA_SRC, rt->fl.fl4_src);
2815 }
2816 if (rt->u.dst.dev)
2817 NLA_PUT_U32(skb, RTA_OIF, rt->u.dst.dev->ifindex);
2818#ifdef CONFIG_NET_CLS_ROUTE
2819 if (rt->u.dst.tclassid)
2820 NLA_PUT_U32(skb, RTA_FLOW, rt->u.dst.tclassid);
2821#endif
2822 if (rt->fl.iif)
2823 NLA_PUT_BE32(skb, RTA_PREFSRC, rt->rt_spec_dst);
2824 else if (rt->rt_src != rt->fl.fl4_src)
2825 NLA_PUT_BE32(skb, RTA_PREFSRC, rt->rt_src);
2826
2827 if (rt->rt_dst != rt->rt_gateway)
2828 NLA_PUT_BE32(skb, RTA_GATEWAY, rt->rt_gateway);
2829
2830 if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
2831 goto nla_put_failure;
2832
2833 error = rt->u.dst.error;
2834 expires = rt->u.dst.expires ? rt->u.dst.expires - jiffies : 0;
2835 if (rt->peer) {
2836 id = rt->peer->ip_id_count;
2837 if (rt->peer->tcp_ts_stamp) {
2838 ts = rt->peer->tcp_ts;
2839 tsage = get_seconds() - rt->peer->tcp_ts_stamp;
2840 }
2841 }
2842
2843 if (rt->fl.iif) {
2844#ifdef CONFIG_IP_MROUTE
2845 __be32 dst = rt->rt_dst;
2846
2847 if (ipv4_is_multicast(dst) && !ipv4_is_local_multicast(dst) &&
2848 IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
2849 int err = ipmr_get_route(net, skb, r, nowait);
2850 if (err <= 0) {
2851 if (!nowait) {
2852 if (err == 0)
2853 return 0;
2854 goto nla_put_failure;
2855 } else {
2856 if (err == -EMSGSIZE)
2857 goto nla_put_failure;
2858 error = err;
2859 }
2860 }
2861 } else
2862#endif
2863 NLA_PUT_U32(skb, RTA_IIF, rt->fl.iif);
2864 }
2865
2866 if (rtnl_put_cacheinfo(skb, &rt->u.dst, id, ts, tsage,
2867 expires, error) < 0)
2868 goto nla_put_failure;
2869
2870 return nlmsg_end(skb, nlh);
2871
2872nla_put_failure:
2873 nlmsg_cancel(skb, nlh);
2874 return -EMSGSIZE;
2875}
2876
2877static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
2878{
2879 struct net *net = sock_net(in_skb->sk);
2880 struct rtmsg *rtm;
2881 struct nlattr *tb[RTA_MAX+1];
2882 struct rtable *rt = NULL;
2883 __be32 dst = 0;
2884 __be32 src = 0;
2885 u32 iif;
2886 int err;
2887 struct sk_buff *skb;
2888
2889 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
2895 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2896 if (skb == NULL) {
2897 err = -ENOBUFS;
2898 goto errout;
2899 }
2900
2901 /* Reserve room for dummy headers, this skb can pass
2902 through good chunk of routing engine.
2903 */
2904 skb_reset_mac_header(skb);
2905 skb_reset_network_header(skb);
2906
2907 /* Bugfix: need to give ip_route_input enough of an IP header to not gag. */
2908 ip_hdr(skb)->protocol = IPPROTO_ICMP;
2909 skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));
2910
2911 src = tb[RTA_SRC] ? nla_get_be32(tb[RTA_SRC]) : 0;
2912 dst = tb[RTA_DST] ? nla_get_be32(tb[RTA_DST]) : 0;
2913 iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
2914
2915 if (iif) {
2916 struct net_device *dev;
2917
2918 dev = __dev_get_by_index(net, iif);
2919 if (dev == NULL) {
2920 err = -ENODEV;
2921 goto errout_free;
2922 }
2923
2924 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();
2929
2930 rt = skb_rtable(skb);
2931 if (err == 0 && rt->u.dst.error)
2932 err = -rt->u.dst.error;
2933 } else {
2934 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 };
2944 err = ip_route_output_key(net, &rt, &fl);
2945 }
2946
2947 if (err)
2948 goto errout_free;
2949
2950 skb_dst_set(skb, &rt->u.dst);
2951 if (rtm->rtm_flags & RTM_F_NOTIFY)
2952 rt->rt_flags |= RTCF_NOTIFY;
2953
2954 err = rt_fill_info(net, skb, NETLINK_CB(in_skb).pid, nlh->nlmsg_seq,
2955 RTM_NEWROUTE, 0, 0);
2956 if (err <= 0)
2957 goto errout_free;
2958
2959 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).pid);
2960errout:
2961 return err;
2962
2963errout_free:
2964 kfree_skb(skb);
2965 goto errout;
2966}
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;
2973 struct net *net;
2974
2975 net = sock_net(skb->sk);
2976
2977 s_h = cb->args[0];
2978 if (s_h < 0)
2979 s_h = 0;
2980 s_idx = idx = cb->args[1];
2981 for (h = s_h; h <= rt_hash_mask; h++, s_idx = 0) {
2982 if (!rt_hash_table[h].chain)
2983 continue;
2984 rcu_read_lock_bh();
2985 for (rt = rcu_dereference(rt_hash_table[h].chain), idx = 0; rt;
2986 rt = rcu_dereference(rt->u.dst.rt_next), idx++) {
2987 if (!net_eq(dev_net(rt->u.dst.dev), net) || idx < s_idx)
2988 continue;
2989 if (rt_is_expired(rt))
2990 continue;
2991 skb_dst_set(skb, dst_clone(&rt->u.dst));
2992 if (rt_fill_info(net, skb, NETLINK_CB(cb->skb).pid,
2993 cb->nlh->nlmsg_seq, RTM_NEWROUTE,
2994 1, NLM_F_MULTI) <= 0) {
2995 skb_dst_drop(skb);
2996 rcu_read_unlock_bh();
2997 goto done;
2998 }
2999 skb_dst_drop(skb);
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{
3012 rt_cache_flush(dev_net(in_dev->dev), 0);
3013}
3014
3015#ifdef CONFIG_SYSCTL
3016static int ipv4_sysctl_rtcache_flush(ctl_table *__ctl, int write,
3017 struct file *filp, void __user *buffer,
3018 size_t *lenp, loff_t *ppos)
3019{
3020 if (write) {
3021 int flush_delay;
3022 ctl_table ctl;
3023 struct net *net;
3024
3025 memcpy(&ctl, __ctl, sizeof(ctl));
3026 ctl.data = &flush_delay;
3027 proc_dointvec(&ctl, write, filp, buffer, lenp, ppos);
3028
3029 net = (struct net *)__ctl->extra1;
3030 rt_cache_flush(net, flush_delay);
3031 return 0;
3032 }
3033
3034 return -EINVAL;
3035}
3036
3037static int ipv4_sysctl_rtcache_flush_strategy(ctl_table *table,
3038 void __user *oldval,
3039 size_t __user *oldlenp,
3040 void __user *newval,
3041 size_t newlen)
3042{
3043 int delay;
3044 struct net *net;
3045 if (newlen != sizeof(int))
3046 return -EINVAL;
3047 if (get_user(delay, (int __user *)newval))
3048 return -EFAULT;
3049 net = (struct net *)table->extra1;
3050 rt_cache_flush(net, delay);
3051 return 0;
3052}
3053
3054static 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,
3100 void __user *oldval,
3101 size_t __user *oldlenp,
3102 void __user *newval,
3103 size_t newlen)
3104{
3105 int old = ip_rt_secret_interval;
3106 int ret = sysctl_jiffies(table, oldval, oldlenp, newval, newlen);
3107
3108 rt_secret_reschedule(old);
3109
3110 return ret;
3111}
3112
3113static ctl_table ipv4_route_table[] = {
3114 {
3115 .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,
3120 .proc_handler = proc_dointvec,
3121 },
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,
3128 .proc_handler = proc_dointvec,
3129 },
3130 {
3131 /* Deprecated. Use gc_min_interval_ms */
3132
3133 .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,
3138 .proc_handler = proc_dointvec_jiffies,
3139 .strategy = sysctl_jiffies,
3140 },
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,
3147 .proc_handler = proc_dointvec_ms_jiffies,
3148 .strategy = sysctl_ms_jiffies,
3149 },
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,
3156 .proc_handler = proc_dointvec_jiffies,
3157 .strategy = sysctl_jiffies,
3158 },
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,
3165 .proc_handler = proc_dointvec_jiffies,
3166 .strategy = sysctl_jiffies,
3167 },
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,
3174 .proc_handler = proc_dointvec,
3175 },
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,
3182 .proc_handler = proc_dointvec,
3183 },
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,
3190 .proc_handler = proc_dointvec,
3191 },
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,
3198 .proc_handler = proc_dointvec,
3199 },
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,
3206 .proc_handler = proc_dointvec,
3207 },
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,
3214 .proc_handler = proc_dointvec,
3215 },
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,
3222 .proc_handler = proc_dointvec_jiffies,
3223 .strategy = sysctl_jiffies,
3224 },
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,
3231 .proc_handler = proc_dointvec,
3232 },
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,
3239 .proc_handler = proc_dointvec,
3240 },
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,
3247 .proc_handler = ipv4_sysctl_rt_secret_interval,
3248 .strategy = ipv4_sysctl_rt_secret_interval_strategy,
3249 },
3250 { .ctl_name = 0 }
3251};
3252
3253static struct ctl_table empty[1];
3254
3255static struct ctl_table ipv4_skeleton[] =
3256{
3257 { .procname = "route", .ctl_name = NET_IPV4_ROUTE,
3258 .mode = 0555, .child = ipv4_route_table},
3259 { .procname = "neigh", .ctl_name = NET_IPV4_NEIGH,
3260 .mode = 0555, .child = empty},
3261 { }
3262};
3263
3264static __net_initdata struct ctl_path ipv4_path[] = {
3265 { .procname = "net", .ctl_name = CTL_NET, },
3266 { .procname = "ipv4", .ctl_name = NET_IPV4, },
3267 { },
3268};
3269
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,
3276 .proc_handler = ipv4_sysctl_rtcache_flush,
3277 .strategy = ipv4_sysctl_rtcache_flush_strategy,
3278 },
3279 { .ctl_name = 0 },
3280};
3281
3282static __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
3289static __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};
3328#endif
3329
3330
3331static __net_init int rt_secret_timer_init(struct net *net)
3332{
3333 atomic_set(&net->ipv4.rt_genid,
3334 (int) ((num_physpages ^ (num_physpages>>8)) ^
3335 (jiffies ^ (jiffies >> 7))));
3336
3337 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
3341 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 }
3347 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
3361#ifdef CONFIG_NET_CLS_ROUTE
3362struct ip_rt_acct *ip_rt_acct __read_mostly;
3363#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{
3377 int rc = 0;
3378
3379#ifdef CONFIG_NET_CLS_ROUTE
3380 ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
3381 if (!ip_rt_acct)
3382 panic("IP: failed to allocate ip_rt_acct\n");
3383#endif
3384
3385 ipv4_dst_ops.kmem_cachep =
3386 kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
3387 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
3388
3389 ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
3390
3391 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) ?
3396 15 : 17,
3397 0,
3398 &rt_hash_log,
3399 &rt_hash_mask,
3400 rhash_entries ? 0 : 512 * 1024);
3401 memset(rt_hash_table, 0, (rt_hash_mask + 1) * sizeof(struct rt_hash_bucket));
3402 rt_hash_lock_init();
3403
3404 ipv4_dst_ops.gc_thresh = (rt_hash_mask + 1);
3405 ip_rt_max_size = (rt_hash_mask + 1) * 16;
3406
3407 devinet_init();
3408 ip_fib_init();
3409
3410 /* All the timers, started at system startup tend
3411 to synchronize. Perturb it a bit.
3412 */
3413 INIT_DELAYED_WORK_DEFERRABLE(&expires_work, rt_worker_func);
3414 expires_ljiffies = jiffies;
3415 schedule_delayed_work(&expires_work,
3416 net_random() % ip_rt_gc_interval + ip_rt_gc_interval);
3417
3418 if (register_pernet_subsys(&rt_secret_timer_ops))
3419 printk(KERN_ERR "Unable to setup rt_secret_timer\n");
3420
3421 if (ip_rt_proc_init())
3422 printk(KERN_ERR "Unable to create route proc files\n");
3423#ifdef CONFIG_XFRM
3424 xfrm_init();
3425 xfrm4_init();
3426#endif
3427 rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL);
3428
3429#ifdef CONFIG_SYSCTL
3430 register_pernet_subsys(&sysctl_route_ops);
3431#endif
3432 return rc;
3433}
3434
3435#ifdef CONFIG_SYSCTL
3436/*
3437 * We really need to sanitize the damn ipv4 init order, then all
3438 * this nonsense will go away.
3439 */
3440void __init ip_static_sysctl_init(void)
3441{
3442 register_sysctl_paths(ipv4_path, ipv4_skeleton);
3443}
3444#endif
3445
3446EXPORT_SYMBOL(__ip_select_ident);
3447EXPORT_SYMBOL(ip_route_input);
3448EXPORT_SYMBOL(ip_route_output_key);
Clone of davem's net-next-2.6 tree