?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[IPV4]: Use the fancy alloc_large_system_hash() function for route hash table
[linux-2.6/sactl.git] / net / ipv4 / route.c
blob9fcbb1b0a8d6f57f40b50699a3d17b3468fbfda1
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 * Version: $Id: route.c,v 1.103 2002/01/12 07:44:09 davem Exp $
9 *
10 * Authors: Ross Biro
11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Alan Cox, <gw4pts@gw4pts.ampr.org>
13 * Linus Torvalds, <Linus.Torvalds@helsinki.fi>
14 * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
15 *
16 * Fixes:
17 * Alan Cox : Verify area fixes.
18 * Alan Cox : cli() protects routing changes
19 * Rui Oliveira : ICMP routing table updates
20 * (rco@di.uminho.pt) Routing table insertion and update
21 * Linus Torvalds : Rewrote bits to be sensible
22 * Alan Cox : Added BSD route gw semantics
23 * Alan Cox : Super /proc >4K
24 * Alan Cox : MTU in route table
25 * Alan Cox : MSS actually. Also added the window
26 * clamper.
27 * Sam Lantinga : Fixed route matching in rt_del()
28 * Alan Cox : Routing cache support.
29 * Alan Cox : Removed compatibility cruft.
30 * Alan Cox : RTF_REJECT support.
31 * Alan Cox : TCP irtt support.
32 * Jonathan Naylor : Added Metric support.
33 * Miquel van Smoorenburg : BSD API fixes.
34 * Miquel van Smoorenburg : Metrics.
35 * Alan Cox : Use __u32 properly
36 * Alan Cox : Aligned routing errors more closely with BSD
37 * our system is still very different.
38 * Alan Cox : Faster /proc handling
39 * Alexey Kuznetsov : Massive rework to support tree based routing,
40 * routing caches and better behaviour.
41 *
42 * Olaf Erb : irtt wasn't being copied right.
43 * Bjorn Ekwall : Kerneld route support.
44 * Alan Cox : Multicast fixed (I hope)
45 * Pavel Krauz : Limited broadcast fixed
46 * Mike McLagan : Routing by source
47 * Alexey Kuznetsov : End of old history. Split to fib.c and
48 * route.c and rewritten from scratch.
49 * Andi Kleen : Load-limit warning messages.
50 * Vitaly E. Lavrov : Transparent proxy revived after year coma.
51 * Vitaly E. Lavrov : Race condition in ip_route_input_slow.
52 * Tobias Ringstrom : Uninitialized res.type in ip_route_output_slow.
53 * Vladimir V. Ivanov : IP rule info (flowid) is really useful.
54 * Marc Boucher : routing by fwmark
55 * Robert Olsson : Added rt_cache statistics
56 * Arnaldo C. Melo : Convert proc stuff to seq_file
57 * Eric Dumazet : hashed spinlocks
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/config.h>
66 #include <linux/module.h>
67 #include <asm/uaccess.h>
68 #include <asm/system.h>
69 #include <linux/bitops.h>
70 #include <linux/types.h>
71 #include <linux/kernel.h>
72 #include <linux/sched.h>
73 #include <linux/mm.h>
74 #include <linux/bootmem.h>
75 #include <linux/string.h>
76 #include <linux/socket.h>
77 #include <linux/sockios.h>
78 #include <linux/errno.h>
79 #include <linux/in.h>
80 #include <linux/inet.h>
81 #include <linux/netdevice.h>
82 #include <linux/proc_fs.h>
83 #include <linux/init.h>
84 #include <linux/skbuff.h>
85 #include <linux/rtnetlink.h>
86 #include <linux/inetdevice.h>
87 #include <linux/igmp.h>
88 #include <linux/pkt_sched.h>
89 #include <linux/mroute.h>
90 #include <linux/netfilter_ipv4.h>
91 #include <linux/random.h>
92 #include <linux/jhash.h>
93 #include <linux/rcupdate.h>
94 #include <linux/times.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/ip_mp_alg.h>
106 #ifdef CONFIG_SYSCTL
107 #include <linux/sysctl.h>
108 #endif
109
110 #define RT_FL_TOS(oldflp) \
111 ((u32)(oldflp->fl4_tos & (IPTOS_RT_MASK | RTO_ONLINK)))
112
113 #define IP_MAX_MTU 0xFFF0
114
115 #define RT_GC_TIMEOUT (300*HZ)
116
117 static int ip_rt_min_delay = 2 * HZ;
118 static int ip_rt_max_delay = 10 * HZ;
119 static int ip_rt_max_size;
120 static int ip_rt_gc_timeout = RT_GC_TIMEOUT;
121 static int ip_rt_gc_interval = 60 * HZ;
122 static int ip_rt_gc_min_interval = HZ / 2;
123 static int ip_rt_redirect_number = 9;
124 static int ip_rt_redirect_load = HZ / 50;
125 static int ip_rt_redirect_silence = ((HZ / 50) << (9 + 1));
126 static int ip_rt_error_cost = HZ;
127 static int ip_rt_error_burst = 5 * HZ;
128 static int ip_rt_gc_elasticity = 8;
129 static int ip_rt_mtu_expires = 10 * 60 * HZ;
130 static int ip_rt_min_pmtu = 512 + 20 + 20;
131 static int ip_rt_min_advmss = 256;
132 static int ip_rt_secret_interval = 10 * 60 * HZ;
133 static unsigned long rt_deadline;
134
135 #define RTprint(a...) printk(KERN_DEBUG a)
136
137 static struct timer_list rt_flush_timer;
138 static struct timer_list rt_periodic_timer;
139 static struct timer_list rt_secret_timer;
140
141 /*
142 * Interface to generic destination cache.
143 */
144
145 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
146 static void ipv4_dst_destroy(struct dst_entry *dst);
147 static void ipv4_dst_ifdown(struct dst_entry *dst,
148 struct net_device *dev, int how);
149 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
150 static void ipv4_link_failure(struct sk_buff *skb);
151 static void ip_rt_update_pmtu(struct dst_entry *dst, u32 mtu);
152 static int rt_garbage_collect(void);
153
154
155 static struct dst_ops ipv4_dst_ops = {
156 .family = AF_INET,
157 .protocol = __constant_htons(ETH_P_IP),
158 .gc = rt_garbage_collect,
159 .check = ipv4_dst_check,
160 .destroy = ipv4_dst_destroy,
161 .ifdown = ipv4_dst_ifdown,
162 .negative_advice = ipv4_negative_advice,
163 .link_failure = ipv4_link_failure,
164 .update_pmtu = ip_rt_update_pmtu,
165 .entry_size = sizeof(struct rtable),
166 };
167
168 #define ECN_OR_COST(class) TC_PRIO_##class
169
170 __u8 ip_tos2prio[16] = {
171 TC_PRIO_BESTEFFORT,
172 ECN_OR_COST(FILLER),
173 TC_PRIO_BESTEFFORT,
174 ECN_OR_COST(BESTEFFORT),
175 TC_PRIO_BULK,
176 ECN_OR_COST(BULK),
177 TC_PRIO_BULK,
178 ECN_OR_COST(BULK),
179 TC_PRIO_INTERACTIVE,
180 ECN_OR_COST(INTERACTIVE),
181 TC_PRIO_INTERACTIVE,
182 ECN_OR_COST(INTERACTIVE),
183 TC_PRIO_INTERACTIVE_BULK,
184 ECN_OR_COST(INTERACTIVE_BULK),
185 TC_PRIO_INTERACTIVE_BULK,
186 ECN_OR_COST(INTERACTIVE_BULK)
187 };
188
189
190 /*
191 * Route cache.
192 */
193
194 /* The locking scheme is rather straight forward:
195 *
196 * 1) Read-Copy Update protects the buckets of the central route hash.
197 * 2) Only writers remove entries, and they hold the lock
198 * as they look at rtable reference counts.
199 * 3) Only readers acquire references to rtable entries,
200 * they do so with atomic increments and with the
201 * lock held.
202 */
203
204 struct rt_hash_bucket {
205 struct rtable *chain;
206 };
207 #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
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 */
212 #if NR_CPUS >= 32
213 #define RT_HASH_LOCK_SZ 4096
214 #elif NR_CPUS >= 16
215 #define RT_HASH_LOCK_SZ 2048
216 #elif NR_CPUS >= 8
217 #define RT_HASH_LOCK_SZ 1024
218 #elif NR_CPUS >= 4
219 #define RT_HASH_LOCK_SZ 512
220 #else
221 #define RT_HASH_LOCK_SZ 256
222 #endif
223
224 static spinlock_t *rt_hash_locks;
225 # define rt_hash_lock_addr(slot) &rt_hash_locks[(slot) & (RT_HASH_LOCK_SZ - 1)]
226 # define rt_hash_lock_init() { \
227 int i; \
228 rt_hash_locks = kmalloc(sizeof(spinlock_t) * RT_HASH_LOCK_SZ, GFP_KERNEL); \
229 if (!rt_hash_locks) panic("IP: failed to allocate rt_hash_locks\n"); \
230 for (i = 0; i < RT_HASH_LOCK_SZ; i++) \
231 spin_lock_init(&rt_hash_locks[i]); \
232 }
233 #else
234 # define rt_hash_lock_addr(slot) NULL
235 # define rt_hash_lock_init()
236 #endif
237
238 static struct rt_hash_bucket *rt_hash_table;
239 static unsigned rt_hash_mask;
240 static int rt_hash_log;
241 static unsigned int rt_hash_rnd;
242
243 struct rt_cache_stat *rt_cache_stat;
244
245 static int rt_intern_hash(unsigned hash, struct rtable *rth,
246 struct rtable **res);
247
248 static unsigned int rt_hash_code(u32 daddr, u32 saddr, u8 tos)
249 {
250 return (jhash_3words(daddr, saddr, (u32) tos, rt_hash_rnd)
251 & rt_hash_mask);
252 }
253
254 #ifdef CONFIG_PROC_FS
255 struct rt_cache_iter_state {
256 int bucket;
257 };
258
259 static struct rtable *rt_cache_get_first(struct seq_file *seq)
260 {
261 struct rtable *r = NULL;
262 struct rt_cache_iter_state *st = seq->private;
263
264 for (st->bucket = rt_hash_mask; st->bucket >= 0; --st->bucket) {
265 rcu_read_lock_bh();
266 r = rt_hash_table[st->bucket].chain;
267 if (r)
268 break;
269 rcu_read_unlock_bh();
270 }
271 return r;
272 }
273
274 static struct rtable *rt_cache_get_next(struct seq_file *seq, struct rtable *r)
275 {
276 struct rt_cache_iter_state *st = rcu_dereference(seq->private);
277
278 r = r->u.rt_next;
279 while (!r) {
280 rcu_read_unlock_bh();
281 if (--st->bucket < 0)
282 break;
283 rcu_read_lock_bh();
284 r = rt_hash_table[st->bucket].chain;
285 }
286 return r;
287 }
288
289 static struct rtable *rt_cache_get_idx(struct seq_file *seq, loff_t pos)
290 {
291 struct rtable *r = rt_cache_get_first(seq);
292
293 if (r)
294 while (pos && (r = rt_cache_get_next(seq, r)))
295 --pos;
296 return pos ? NULL : r;
297 }
298
299 static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
300 {
301 return *pos ? rt_cache_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
302 }
303
304 static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
305 {
306 struct rtable *r = NULL;
307
308 if (v == SEQ_START_TOKEN)
309 r = rt_cache_get_first(seq);
310 else
311 r = rt_cache_get_next(seq, v);
312 ++*pos;
313 return r;
314 }
315
316 static void rt_cache_seq_stop(struct seq_file *seq, void *v)
317 {
318 if (v && v != SEQ_START_TOKEN)
319 rcu_read_unlock_bh();
320 }
321
322 static int rt_cache_seq_show(struct seq_file *seq, void *v)
323 {
324 if (v == SEQ_START_TOKEN)
325 seq_printf(seq, "%-127s\n",
326 "Iface\tDestination\tGateway \tFlags\t\tRefCnt\tUse\t"
327 "Metric\tSource\t\tMTU\tWindow\tIRTT\tTOS\tHHRef\t"
328 "HHUptod\tSpecDst");
329 else {
330 struct rtable *r = v;
331 char temp[256];
332
333 sprintf(temp, "%s\t%08lX\t%08lX\t%8X\t%d\t%u\t%d\t"
334 "%08lX\t%d\t%u\t%u\t%02X\t%d\t%1d\t%08X",
335 r->u.dst.dev ? r->u.dst.dev->name : "*",
336 (unsigned long)r->rt_dst, (unsigned long)r->rt_gateway,
337 r->rt_flags, atomic_read(&r->u.dst.__refcnt),
338 r->u.dst.__use, 0, (unsigned long)r->rt_src,
339 (dst_metric(&r->u.dst, RTAX_ADVMSS) ?
340 (int)dst_metric(&r->u.dst, RTAX_ADVMSS) + 40 : 0),
341 dst_metric(&r->u.dst, RTAX_WINDOW),
342 (int)((dst_metric(&r->u.dst, RTAX_RTT) >> 3) +
343 dst_metric(&r->u.dst, RTAX_RTTVAR)),
344 r->fl.fl4_tos,
345 r->u.dst.hh ? atomic_read(&r->u.dst.hh->hh_refcnt) : -1,
346 r->u.dst.hh ? (r->u.dst.hh->hh_output ==
347 dev_queue_xmit) : 0,
348 r->rt_spec_dst);
349 seq_printf(seq, "%-127s\n", temp);
350 }
351 return 0;
352 }
353
354 static struct seq_operations rt_cache_seq_ops = {
355 .start = rt_cache_seq_start,
356 .next = rt_cache_seq_next,
357 .stop = rt_cache_seq_stop,
358 .show = rt_cache_seq_show,
359 };
360
361 static int rt_cache_seq_open(struct inode *inode, struct file *file)
362 {
363 struct seq_file *seq;
364 int rc = -ENOMEM;
365 struct rt_cache_iter_state *s = kmalloc(sizeof(*s), GFP_KERNEL);
366
367 if (!s)
368 goto out;
369 rc = seq_open(file, &rt_cache_seq_ops);
370 if (rc)
371 goto out_kfree;
372 seq = file->private_data;
373 seq->private = s;
374 memset(s, 0, sizeof(*s));
375 out:
376 return rc;
377 out_kfree:
378 kfree(s);
379 goto out;
380 }
381
382 static struct file_operations rt_cache_seq_fops = {
383 .owner = THIS_MODULE,
384 .open = rt_cache_seq_open,
385 .read = seq_read,
386 .llseek = seq_lseek,
387 .release = seq_release_private,
388 };
389
390
391 static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
392 {
393 int cpu;
394
395 if (*pos == 0)
396 return SEQ_START_TOKEN;
397
398 for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) {
399 if (!cpu_possible(cpu))
400 continue;
401 *pos = cpu+1;
402 return per_cpu_ptr(rt_cache_stat, cpu);
403 }
404 return NULL;
405 }
406
407 static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
408 {
409 int cpu;
410
411 for (cpu = *pos; cpu < NR_CPUS; ++cpu) {
412 if (!cpu_possible(cpu))
413 continue;
414 *pos = cpu+1;
415 return per_cpu_ptr(rt_cache_stat, cpu);
416 }
417 return NULL;
418
419 }
420
421 static void rt_cpu_seq_stop(struct seq_file *seq, void *v)
422 {
423
424 }
425
426 static int rt_cpu_seq_show(struct seq_file *seq, void *v)
427 {
428 struct rt_cache_stat *st = v;
429
430 if (v == SEQ_START_TOKEN) {
431 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");
432 return 0;
433 }
434
435 seq_printf(seq,"%08x %08x %08x %08x %08x %08x %08x %08x "
436 " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
437 atomic_read(&ipv4_dst_ops.entries),
438 st->in_hit,
439 st->in_slow_tot,
440 st->in_slow_mc,
441 st->in_no_route,
442 st->in_brd,
443 st->in_martian_dst,
444 st->in_martian_src,
445
446 st->out_hit,
447 st->out_slow_tot,
448 st->out_slow_mc,
449
450 st->gc_total,
451 st->gc_ignored,
452 st->gc_goal_miss,
453 st->gc_dst_overflow,
454 st->in_hlist_search,
455 st->out_hlist_search
456 );
457 return 0;
458 }
459
460 static struct seq_operations rt_cpu_seq_ops = {
461 .start = rt_cpu_seq_start,
462 .next = rt_cpu_seq_next,
463 .stop = rt_cpu_seq_stop,
464 .show = rt_cpu_seq_show,
465 };
466
467
468 static int rt_cpu_seq_open(struct inode *inode, struct file *file)
469 {
470 return seq_open(file, &rt_cpu_seq_ops);
471 }
472
473 static struct file_operations rt_cpu_seq_fops = {
474 .owner = THIS_MODULE,
475 .open = rt_cpu_seq_open,
476 .read = seq_read,
477 .llseek = seq_lseek,
478 .release = seq_release,
479 };
480
481 #endif /* CONFIG_PROC_FS */
482
483 static __inline__ void rt_free(struct rtable *rt)
484 {
485 multipath_remove(rt);
486 call_rcu_bh(&rt->u.dst.rcu_head, dst_rcu_free);
487 }
488
489 static __inline__ void rt_drop(struct rtable *rt)
490 {
491 multipath_remove(rt);
492 ip_rt_put(rt);
493 call_rcu_bh(&rt->u.dst.rcu_head, dst_rcu_free);
494 }
495
496 static __inline__ int rt_fast_clean(struct rtable *rth)
497 {
498 /* Kill broadcast/multicast entries very aggresively, if they
499 collide in hash table with more useful entries */
500 return (rth->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST)) &&
501 rth->fl.iif && rth->u.rt_next;
502 }
503
504 static __inline__ int rt_valuable(struct rtable *rth)
505 {
506 return (rth->rt_flags & (RTCF_REDIRECTED | RTCF_NOTIFY)) ||
507 rth->u.dst.expires;
508 }
509
510 static int rt_may_expire(struct rtable *rth, unsigned long tmo1, unsigned long tmo2)
511 {
512 unsigned long age;
513 int ret = 0;
514
515 if (atomic_read(&rth->u.dst.__refcnt))
516 goto out;
517
518 ret = 1;
519 if (rth->u.dst.expires &&
520 time_after_eq(jiffies, rth->u.dst.expires))
521 goto out;
522
523 age = jiffies - rth->u.dst.lastuse;
524 ret = 0;
525 if ((age <= tmo1 && !rt_fast_clean(rth)) ||
526 (age <= tmo2 && rt_valuable(rth)))
527 goto out;
528 ret = 1;
529 out: return ret;
530 }
531
532 /* Bits of score are:
533 * 31: very valuable
534 * 30: not quite useless
535 * 29..0: usage counter
536 */
537 static inline u32 rt_score(struct rtable *rt)
538 {
539 u32 score = jiffies - rt->u.dst.lastuse;
540
541 score = ~score & ~(3<<30);
542
543 if (rt_valuable(rt))
544 score |= (1<<31);
545
546 if (!rt->fl.iif ||
547 !(rt->rt_flags & (RTCF_BROADCAST|RTCF_MULTICAST|RTCF_LOCAL)))
548 score |= (1<<30);
549
550 return score;
551 }
552
553 static inline int compare_keys(struct flowi *fl1, struct flowi *fl2)
554 {
555 return memcmp(&fl1->nl_u.ip4_u, &fl2->nl_u.ip4_u, sizeof(fl1->nl_u.ip4_u)) == 0 &&
556 fl1->oif == fl2->oif &&
557 fl1->iif == fl2->iif;
558 }
559
560 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
561 static struct rtable **rt_remove_balanced_route(struct rtable **chain_head,
562 struct rtable *expentry,
563 int *removed_count)
564 {
565 int passedexpired = 0;
566 struct rtable **nextstep = NULL;
567 struct rtable **rthp = chain_head;
568 struct rtable *rth;
569
570 if (removed_count)
571 *removed_count = 0;
572
573 while ((rth = *rthp) != NULL) {
574 if (rth == expentry)
575 passedexpired = 1;
576
577 if (((*rthp)->u.dst.flags & DST_BALANCED) != 0 &&
578 compare_keys(&(*rthp)->fl, &expentry->fl)) {
579 if (*rthp == expentry) {
580 *rthp = rth->u.rt_next;
581 continue;
582 } else {
583 *rthp = rth->u.rt_next;
584 rt_free(rth);
585 if (removed_count)
586 ++(*removed_count);
587 }
588 } else {
589 if (!((*rthp)->u.dst.flags & DST_BALANCED) &&
590 passedexpired && !nextstep)
591 nextstep = &rth->u.rt_next;
592
593 rthp = &rth->u.rt_next;
594 }
595 }
596
597 rt_free(expentry);
598 if (removed_count)
599 ++(*removed_count);
600
601 return nextstep;
602 }
603 #endif /* CONFIG_IP_ROUTE_MULTIPATH_CACHED */
604
605
606 /* This runs via a timer and thus is always in BH context. */
607 static void rt_check_expire(unsigned long dummy)
608 {
609 static int rover;
610 int i = rover, t;
611 struct rtable *rth, **rthp;
612 unsigned long now = jiffies;
613
614 for (t = ip_rt_gc_interval << rt_hash_log; t >= 0;
615 t -= ip_rt_gc_timeout) {
616 unsigned long tmo = ip_rt_gc_timeout;
617
618 i = (i + 1) & rt_hash_mask;
619 rthp = &rt_hash_table[i].chain;
620
621 spin_lock(rt_hash_lock_addr(i));
622 while ((rth = *rthp) != NULL) {
623 if (rth->u.dst.expires) {
624 /* Entry is expired even if it is in use */
625 if (time_before_eq(now, rth->u.dst.expires)) {
626 tmo >>= 1;
627 rthp = &rth->u.rt_next;
628 continue;
629 }
630 } else if (!rt_may_expire(rth, tmo, ip_rt_gc_timeout)) {
631 tmo >>= 1;
632 rthp = &rth->u.rt_next;
633 continue;
634 }
635
636 /* Cleanup aged off entries. */
637 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
638 /* remove all related balanced entries if necessary */
639 if (rth->u.dst.flags & DST_BALANCED) {
640 rthp = rt_remove_balanced_route(
641 &rt_hash_table[i].chain,
642 rth, NULL);
643 if (!rthp)
644 break;
645 } else {
646 *rthp = rth->u.rt_next;
647 rt_free(rth);
648 }
649 #else /* CONFIG_IP_ROUTE_MULTIPATH_CACHED */
650 *rthp = rth->u.rt_next;
651 rt_free(rth);
652 #endif /* CONFIG_IP_ROUTE_MULTIPATH_CACHED */
653 }
654 spin_unlock(rt_hash_lock_addr(i));
655
656 /* Fallback loop breaker. */
657 if (time_after(jiffies, now))
658 break;
659 }
660 rover = i;
661 mod_timer(&rt_periodic_timer, now + ip_rt_gc_interval);
662 }
663
664 /* This can run from both BH and non-BH contexts, the latter
665 * in the case of a forced flush event.
666 */
667 static void rt_run_flush(unsigned long dummy)
668 {
669 int i;
670 struct rtable *rth, *next;
671
672 rt_deadline = 0;
673
674 get_random_bytes(&rt_hash_rnd, 4);
675
676 for (i = rt_hash_mask; i >= 0; i--) {
677 spin_lock_bh(rt_hash_lock_addr(i));
678 rth = rt_hash_table[i].chain;
679 if (rth)
680 rt_hash_table[i].chain = NULL;
681 spin_unlock_bh(rt_hash_lock_addr(i));
682
683 for (; rth; rth = next) {
684 next = rth->u.rt_next;
685 rt_free(rth);
686 }
687 }
688 }
689
690 static DEFINE_SPINLOCK(rt_flush_lock);
691
692 void rt_cache_flush(int delay)
693 {
694 unsigned long now = jiffies;
695 int user_mode = !in_softirq();
696
697 if (delay < 0)
698 delay = ip_rt_min_delay;
699
700 /* flush existing multipath state*/
701 multipath_flush();
702
703 spin_lock_bh(&rt_flush_lock);
704
705 if (del_timer(&rt_flush_timer) && delay > 0 && rt_deadline) {
706 long tmo = (long)(rt_deadline - now);
707
708 /* If flush timer is already running
709 and flush request is not immediate (delay > 0):
710
711 if deadline is not achieved, prolongate timer to "delay",
712 otherwise fire it at deadline time.
713 */
714
715 if (user_mode && tmo < ip_rt_max_delay-ip_rt_min_delay)
716 tmo = 0;
717
718 if (delay > tmo)
719 delay = tmo;
720 }
721
722 if (delay <= 0) {
723 spin_unlock_bh(&rt_flush_lock);
724 rt_run_flush(0);
725 return;
726 }
727
728 if (rt_deadline == 0)
729 rt_deadline = now + ip_rt_max_delay;
730
731 mod_timer(&rt_flush_timer, now+delay);
732 spin_unlock_bh(&rt_flush_lock);
733 }
734
735 static void rt_secret_rebuild(unsigned long dummy)
736 {
737 unsigned long now = jiffies;
738
739 rt_cache_flush(0);
740 mod_timer(&rt_secret_timer, now + ip_rt_secret_interval);
741 }
742
743 /*
744 Short description of GC goals.
745
746 We want to build algorithm, which will keep routing cache
747 at some equilibrium point, when number of aged off entries
748 is kept approximately equal to newly generated ones.
749
750 Current expiration strength is variable "expire".
751 We try to adjust it dynamically, so that if networking
752 is idle expires is large enough to keep enough of warm entries,
753 and when load increases it reduces to limit cache size.
754 */
755
756 static int rt_garbage_collect(void)
757 {
758 static unsigned long expire = RT_GC_TIMEOUT;
759 static unsigned long last_gc;
760 static int rover;
761 static int equilibrium;
762 struct rtable *rth, **rthp;
763 unsigned long now = jiffies;
764 int goal;
765
766 /*
767 * Garbage collection is pretty expensive,
768 * do not make it too frequently.
769 */
770
771 RT_CACHE_STAT_INC(gc_total);
772
773 if (now - last_gc < ip_rt_gc_min_interval &&
774 atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size) {
775 RT_CACHE_STAT_INC(gc_ignored);
776 goto out;
777 }
778
779 /* Calculate number of entries, which we want to expire now. */
780 goal = atomic_read(&ipv4_dst_ops.entries) -
781 (ip_rt_gc_elasticity << rt_hash_log);
782 if (goal <= 0) {
783 if (equilibrium < ipv4_dst_ops.gc_thresh)
784 equilibrium = ipv4_dst_ops.gc_thresh;
785 goal = atomic_read(&ipv4_dst_ops.entries) - equilibrium;
786 if (goal > 0) {
787 equilibrium += min_t(unsigned int, goal / 2, rt_hash_mask + 1);
788 goal = atomic_read(&ipv4_dst_ops.entries) - equilibrium;
789 }
790 } else {
791 /* We are in dangerous area. Try to reduce cache really
792 * aggressively.
793 */
794 goal = max_t(unsigned int, goal / 2, rt_hash_mask + 1);
795 equilibrium = atomic_read(&ipv4_dst_ops.entries) - goal;
796 }
797
798 if (now - last_gc >= ip_rt_gc_min_interval)
799 last_gc = now;
800
801 if (goal <= 0) {
802 equilibrium += goal;
803 goto work_done;
804 }
805
806 do {
807 int i, k;
808
809 for (i = rt_hash_mask, k = rover; i >= 0; i--) {
810 unsigned long tmo = expire;
811
812 k = (k + 1) & rt_hash_mask;
813 rthp = &rt_hash_table[k].chain;
814 spin_lock_bh(rt_hash_lock_addr(k));
815 while ((rth = *rthp) != NULL) {
816 if (!rt_may_expire(rth, tmo, expire)) {
817 tmo >>= 1;
818 rthp = &rth->u.rt_next;
819 continue;
820 }
821 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
822 /* remove all related balanced entries
823 * if necessary
824 */
825 if (rth->u.dst.flags & DST_BALANCED) {
826 int r;
827
828 rthp = rt_remove_balanced_route(
829 &rt_hash_table[i].chain,
830 rth,
831 &r);
832 goal -= r;
833 if (!rthp)
834 break;
835 } else {
836 *rthp = rth->u.rt_next;
837 rt_free(rth);
838 goal--;
839 }
840 #else /* CONFIG_IP_ROUTE_MULTIPATH_CACHED */
841 *rthp = rth->u.rt_next;
842 rt_free(rth);
843 goal--;
844 #endif /* CONFIG_IP_ROUTE_MULTIPATH_CACHED */
845 }
846 spin_unlock_bh(rt_hash_lock_addr(k));
847 if (goal <= 0)
848 break;
849 }
850 rover = k;
851
852 if (goal <= 0)
853 goto work_done;
854
855 /* Goal is not achieved. We stop process if:
856
857 - if expire reduced to zero. Otherwise, expire is halfed.
858 - if table is not full.
859 - if we are called from interrupt.
860 - jiffies check is just fallback/debug loop breaker.
861 We will not spin here for long time in any case.
862 */
863
864 RT_CACHE_STAT_INC(gc_goal_miss);
865
866 if (expire == 0)
867 break;
868
869 expire >>= 1;
870 #if RT_CACHE_DEBUG >= 2
871 printk(KERN_DEBUG "expire>> %u %d %d %d\n", expire,
872 atomic_read(&ipv4_dst_ops.entries), goal, i);
873 #endif
874
875 if (atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size)
876 goto out;
877 } while (!in_softirq() && time_before_eq(jiffies, now));
878
879 if (atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size)
880 goto out;
881 if (net_ratelimit())
882 printk(KERN_WARNING "dst cache overflow\n");
883 RT_CACHE_STAT_INC(gc_dst_overflow);
884 return 1;
885
886 work_done:
887 expire += ip_rt_gc_min_interval;
888 if (expire > ip_rt_gc_timeout ||
889 atomic_read(&ipv4_dst_ops.entries) < ipv4_dst_ops.gc_thresh)
890 expire = ip_rt_gc_timeout;
891 #if RT_CACHE_DEBUG >= 2
892 printk(KERN_DEBUG "expire++ %u %d %d %d\n", expire,
893 atomic_read(&ipv4_dst_ops.entries), goal, rover);
894 #endif
895 out: return 0;
896 }
897
898 static int rt_intern_hash(unsigned hash, struct rtable *rt, struct rtable **rp)
899 {
900 struct rtable *rth, **rthp;
901 unsigned long now;
902 struct rtable *cand, **candp;
903 u32 min_score;
904 int chain_length;
905 int attempts = !in_softirq();
906
907 restart:
908 chain_length = 0;
909 min_score = ~(u32)0;
910 cand = NULL;
911 candp = NULL;
912 now = jiffies;
913
914 rthp = &rt_hash_table[hash].chain;
915
916 spin_lock_bh(rt_hash_lock_addr(hash));
917 while ((rth = *rthp) != NULL) {
918 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
919 if (!(rth->u.dst.flags & DST_BALANCED) &&
920 compare_keys(&rth->fl, &rt->fl)) {
921 #else
922 if (compare_keys(&rth->fl, &rt->fl)) {
923 #endif
924 /* Put it first */
925 *rthp = rth->u.rt_next;
926 /*
927 * Since lookup is lockfree, the deletion
928 * must be visible to another weakly ordered CPU before
929 * the insertion at the start of the hash chain.
930 */
931 rcu_assign_pointer(rth->u.rt_next,
932 rt_hash_table[hash].chain);
933 /*
934 * Since lookup is lockfree, the update writes
935 * must be ordered for consistency on SMP.
936 */
937 rcu_assign_pointer(rt_hash_table[hash].chain, rth);
938
939 rth->u.dst.__use++;
940 dst_hold(&rth->u.dst);
941 rth->u.dst.lastuse = now;
942 spin_unlock_bh(rt_hash_lock_addr(hash));
943
944 rt_drop(rt);
945 *rp = rth;
946 return 0;
947 }
948
949 if (!atomic_read(&rth->u.dst.__refcnt)) {
950 u32 score = rt_score(rth);
951
952 if (score <= min_score) {
953 cand = rth;
954 candp = rthp;
955 min_score = score;
956 }
957 }
958
959 chain_length++;
960
961 rthp = &rth->u.rt_next;
962 }
963
964 if (cand) {
965 /* ip_rt_gc_elasticity used to be average length of chain
966 * length, when exceeded gc becomes really aggressive.
967 *
968 * The second limit is less certain. At the moment it allows
969 * only 2 entries per bucket. We will see.
970 */
971 if (chain_length > ip_rt_gc_elasticity) {
972 *candp = cand->u.rt_next;
973 rt_free(cand);
974 }
975 }
976
977 /* Try to bind route to arp only if it is output
978 route or unicast forwarding path.
979 */
980 if (rt->rt_type == RTN_UNICAST || rt->fl.iif == 0) {
981 int err = arp_bind_neighbour(&rt->u.dst);
982 if (err) {
983 spin_unlock_bh(rt_hash_lock_addr(hash));
984
985 if (err != -ENOBUFS) {
986 rt_drop(rt);
987 return err;
988 }
989
990 /* Neighbour tables are full and nothing
991 can be released. Try to shrink route cache,
992 it is most likely it holds some neighbour records.
993 */
994 if (attempts-- > 0) {
995 int saved_elasticity = ip_rt_gc_elasticity;
996 int saved_int = ip_rt_gc_min_interval;
997 ip_rt_gc_elasticity = 1;
998 ip_rt_gc_min_interval = 0;
999 rt_garbage_collect();
1000 ip_rt_gc_min_interval = saved_int;
1001 ip_rt_gc_elasticity = saved_elasticity;
1002 goto restart;
1003 }
1004
1005 if (net_ratelimit())
1006 printk(KERN_WARNING "Neighbour table overflow.\n");
1007 rt_drop(rt);
1008 return -ENOBUFS;
1009 }
1010 }
1011
1012 rt->u.rt_next = rt_hash_table[hash].chain;
1013 #if RT_CACHE_DEBUG >= 2
1014 if (rt->u.rt_next) {
1015 struct rtable *trt;
1016 printk(KERN_DEBUG "rt_cache @%02x: %u.%u.%u.%u", hash,
1017 NIPQUAD(rt->rt_dst));
1018 for (trt = rt->u.rt_next; trt; trt = trt->u.rt_next)
1019 printk(" . %u.%u.%u.%u", NIPQUAD(trt->rt_dst));
1020 printk("\n");
1021 }
1022 #endif
1023 rt_hash_table[hash].chain = rt;
1024 spin_unlock_bh(rt_hash_lock_addr(hash));
1025 *rp = rt;
1026 return 0;
1027 }
1028
1029 void rt_bind_peer(struct rtable *rt, int create)
1030 {
1031 static DEFINE_SPINLOCK(rt_peer_lock);
1032 struct inet_peer *peer;
1033
1034 peer = inet_getpeer(rt->rt_dst, create);
1035
1036 spin_lock_bh(&rt_peer_lock);
1037 if (rt->peer == NULL) {
1038 rt->peer = peer;
1039 peer = NULL;
1040 }
1041 spin_unlock_bh(&rt_peer_lock);
1042 if (peer)
1043 inet_putpeer(peer);
1044 }
1045
1046 /*
1047 * Peer allocation may fail only in serious out-of-memory conditions. However
1048 * we still can generate some output.
1049 * Random ID selection looks a bit dangerous because we have no chances to
1050 * select ID being unique in a reasonable period of time.
1051 * But broken packet identifier may be better than no packet at all.
1052 */
1053 static void ip_select_fb_ident(struct iphdr *iph)
1054 {
1055 static DEFINE_SPINLOCK(ip_fb_id_lock);
1056 static u32 ip_fallback_id;
1057 u32 salt;
1058
1059 spin_lock_bh(&ip_fb_id_lock);
1060 salt = secure_ip_id(ip_fallback_id ^ iph->daddr);
1061 iph->id = htons(salt & 0xFFFF);
1062 ip_fallback_id = salt;
1063 spin_unlock_bh(&ip_fb_id_lock);
1064 }
1065
1066 void __ip_select_ident(struct iphdr *iph, struct dst_entry *dst, int more)
1067 {
1068 struct rtable *rt = (struct rtable *) dst;
1069
1070 if (rt) {
1071 if (rt->peer == NULL)
1072 rt_bind_peer(rt, 1);
1073
1074 /* If peer is attached to destination, it is never detached,
1075 so that we need not to grab a lock to dereference it.
1076 */
1077 if (rt->peer) {
1078 iph->id = htons(inet_getid(rt->peer, more));
1079 return;
1080 }
1081 } else
1082 printk(KERN_DEBUG "rt_bind_peer(0) @%p\n",
1083 __builtin_return_address(0));
1084
1085 ip_select_fb_ident(iph);
1086 }
1087
1088 static void rt_del(unsigned hash, struct rtable *rt)
1089 {
1090 struct rtable **rthp;
1091
1092 spin_lock_bh(rt_hash_lock_addr(hash));
1093 ip_rt_put(rt);
1094 for (rthp = &rt_hash_table[hash].chain; *rthp;
1095 rthp = &(*rthp)->u.rt_next)
1096 if (*rthp == rt) {
1097 *rthp = rt->u.rt_next;
1098 rt_free(rt);
1099 break;
1100 }
1101 spin_unlock_bh(rt_hash_lock_addr(hash));
1102 }
1103
1104 void ip_rt_redirect(u32 old_gw, u32 daddr, u32 new_gw,
1105 u32 saddr, u8 tos, struct net_device *dev)
1106 {
1107 int i, k;
1108 struct in_device *in_dev = in_dev_get(dev);
1109 struct rtable *rth, **rthp;
1110 u32 skeys[2] = { saddr, 0 };
1111 int ikeys[2] = { dev->ifindex, 0 };
1112
1113 tos &= IPTOS_RT_MASK;
1114
1115 if (!in_dev)
1116 return;
1117
1118 if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev)
1119 || MULTICAST(new_gw) || BADCLASS(new_gw) || ZERONET(new_gw))
1120 goto reject_redirect;
1121
1122 if (!IN_DEV_SHARED_MEDIA(in_dev)) {
1123 if (!inet_addr_onlink(in_dev, new_gw, old_gw))
1124 goto reject_redirect;
1125 if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
1126 goto reject_redirect;
1127 } else {
1128 if (inet_addr_type(new_gw) != RTN_UNICAST)
1129 goto reject_redirect;
1130 }
1131
1132 for (i = 0; i < 2; i++) {
1133 for (k = 0; k < 2; k++) {
1134 unsigned hash = rt_hash_code(daddr,
1135 skeys[i] ^ (ikeys[k] << 5),
1136 tos);
1137
1138 rthp=&rt_hash_table[hash].chain;
1139
1140 rcu_read_lock();
1141 while ((rth = rcu_dereference(*rthp)) != NULL) {
1142 struct rtable *rt;
1143
1144 if (rth->fl.fl4_dst != daddr ||
1145 rth->fl.fl4_src != skeys[i] ||
1146 rth->fl.fl4_tos != tos ||
1147 rth->fl.oif != ikeys[k] ||
1148 rth->fl.iif != 0) {
1149 rthp = &rth->u.rt_next;
1150 continue;
1151 }
1152
1153 if (rth->rt_dst != daddr ||
1154 rth->rt_src != saddr ||
1155 rth->u.dst.error ||
1156 rth->rt_gateway != old_gw ||
1157 rth->u.dst.dev != dev)
1158 break;
1159
1160 dst_hold(&rth->u.dst);
1161 rcu_read_unlock();
1162
1163 rt = dst_alloc(&ipv4_dst_ops);
1164 if (rt == NULL) {
1165 ip_rt_put(rth);
1166 in_dev_put(in_dev);
1167 return;
1168 }
1169
1170 /* Copy all the information. */
1171 *rt = *rth;
1172 INIT_RCU_HEAD(&rt->u.dst.rcu_head);
1173 rt->u.dst.__use = 1;
1174 atomic_set(&rt->u.dst.__refcnt, 1);
1175 rt->u.dst.child = NULL;
1176 if (rt->u.dst.dev)
1177 dev_hold(rt->u.dst.dev);
1178 if (rt->idev)
1179 in_dev_hold(rt->idev);
1180 rt->u.dst.obsolete = 0;
1181 rt->u.dst.lastuse = jiffies;
1182 rt->u.dst.path = &rt->u.dst;
1183 rt->u.dst.neighbour = NULL;
1184 rt->u.dst.hh = NULL;
1185 rt->u.dst.xfrm = NULL;
1186
1187 rt->rt_flags |= RTCF_REDIRECTED;
1188
1189 /* Gateway is different ... */
1190 rt->rt_gateway = new_gw;
1191
1192 /* Redirect received -> path was valid */
1193 dst_confirm(&rth->u.dst);
1194
1195 if (rt->peer)
1196 atomic_inc(&rt->peer->refcnt);
1197
1198 if (arp_bind_neighbour(&rt->u.dst) ||
1199 !(rt->u.dst.neighbour->nud_state &
1200 NUD_VALID)) {
1201 if (rt->u.dst.neighbour)
1202 neigh_event_send(rt->u.dst.neighbour, NULL);
1203 ip_rt_put(rth);
1204 rt_drop(rt);
1205 goto do_next;
1206 }
1207
1208 rt_del(hash, rth);
1209 if (!rt_intern_hash(hash, rt, &rt))
1210 ip_rt_put(rt);
1211 goto do_next;
1212 }
1213 rcu_read_unlock();
1214 do_next:
1215 ;
1216 }
1217 }
1218 in_dev_put(in_dev);
1219 return;
1220
1221 reject_redirect:
1222 #ifdef CONFIG_IP_ROUTE_VERBOSE
1223 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit())
1224 printk(KERN_INFO "Redirect from %u.%u.%u.%u on %s about "
1225 "%u.%u.%u.%u ignored.\n"
1226 " Advised path = %u.%u.%u.%u -> %u.%u.%u.%u, "
1227 "tos %02x\n",
1228 NIPQUAD(old_gw), dev->name, NIPQUAD(new_gw),
1229 NIPQUAD(saddr), NIPQUAD(daddr), tos);
1230 #endif
1231 in_dev_put(in_dev);
1232 }
1233
1234 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
1235 {
1236 struct rtable *rt = (struct rtable*)dst;
1237 struct dst_entry *ret = dst;
1238
1239 if (rt) {
1240 if (dst->obsolete) {
1241 ip_rt_put(rt);
1242 ret = NULL;
1243 } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
1244 rt->u.dst.expires) {
1245 unsigned hash = rt_hash_code(rt->fl.fl4_dst,
1246 rt->fl.fl4_src ^
1247 (rt->fl.oif << 5),
1248 rt->fl.fl4_tos);
1249 #if RT_CACHE_DEBUG >= 1
1250 printk(KERN_DEBUG "ip_rt_advice: redirect to "
1251 "%u.%u.%u.%u/%02x dropped\n",
1252 NIPQUAD(rt->rt_dst), rt->fl.fl4_tos);
1253 #endif
1254 rt_del(hash, rt);
1255 ret = NULL;
1256 }
1257 }
1258 return ret;
1259 }
1260
1261 /*
1262 * Algorithm:
1263 * 1. The first ip_rt_redirect_number redirects are sent
1264 * with exponential backoff, then we stop sending them at all,
1265 * assuming that the host ignores our redirects.
1266 * 2. If we did not see packets requiring redirects
1267 * during ip_rt_redirect_silence, we assume that the host
1268 * forgot redirected route and start to send redirects again.
1269 *
1270 * This algorithm is much cheaper and more intelligent than dumb load limiting
1271 * in icmp.c.
1272 *
1273 * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
1274 * and "frag. need" (breaks PMTU discovery) in icmp.c.
1275 */
1276
1277 void ip_rt_send_redirect(struct sk_buff *skb)
1278 {
1279 struct rtable *rt = (struct rtable*)skb->dst;
1280 struct in_device *in_dev = in_dev_get(rt->u.dst.dev);
1281
1282 if (!in_dev)
1283 return;
1284
1285 if (!IN_DEV_TX_REDIRECTS(in_dev))
1286 goto out;
1287
1288 /* No redirected packets during ip_rt_redirect_silence;
1289 * reset the algorithm.
1290 */
1291 if (time_after(jiffies, rt->u.dst.rate_last + ip_rt_redirect_silence))
1292 rt->u.dst.rate_tokens = 0;
1293
1294 /* Too many ignored redirects; do not send anything
1295 * set u.dst.rate_last to the last seen redirected packet.
1296 */
1297 if (rt->u.dst.rate_tokens >= ip_rt_redirect_number) {
1298 rt->u.dst.rate_last = jiffies;
1299 goto out;
1300 }
1301
1302 /* Check for load limit; set rate_last to the latest sent
1303 * redirect.
1304 */
1305 if (time_after(jiffies,
1306 (rt->u.dst.rate_last +
1307 (ip_rt_redirect_load << rt->u.dst.rate_tokens)))) {
1308 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, rt->rt_gateway);
1309 rt->u.dst.rate_last = jiffies;
1310 ++rt->u.dst.rate_tokens;
1311 #ifdef CONFIG_IP_ROUTE_VERBOSE
1312 if (IN_DEV_LOG_MARTIANS(in_dev) &&
1313 rt->u.dst.rate_tokens == ip_rt_redirect_number &&
1314 net_ratelimit())
1315 printk(KERN_WARNING "host %u.%u.%u.%u/if%d ignores "
1316 "redirects for %u.%u.%u.%u to %u.%u.%u.%u.\n",
1317 NIPQUAD(rt->rt_src), rt->rt_iif,
1318 NIPQUAD(rt->rt_dst), NIPQUAD(rt->rt_gateway));
1319 #endif
1320 }
1321 out:
1322 in_dev_put(in_dev);
1323 }
1324
1325 static int ip_error(struct sk_buff *skb)
1326 {
1327 struct rtable *rt = (struct rtable*)skb->dst;
1328 unsigned long now;
1329 int code;
1330
1331 switch (rt->u.dst.error) {
1332 case EINVAL:
1333 default:
1334 goto out;
1335 case EHOSTUNREACH:
1336 code = ICMP_HOST_UNREACH;
1337 break;
1338 case ENETUNREACH:
1339 code = ICMP_NET_UNREACH;
1340 break;
1341 case EACCES:
1342 code = ICMP_PKT_FILTERED;
1343 break;
1344 }
1345
1346 now = jiffies;
1347 rt->u.dst.rate_tokens += now - rt->u.dst.rate_last;
1348 if (rt->u.dst.rate_tokens > ip_rt_error_burst)
1349 rt->u.dst.rate_tokens = ip_rt_error_burst;
1350 rt->u.dst.rate_last = now;
1351 if (rt->u.dst.rate_tokens >= ip_rt_error_cost) {
1352 rt->u.dst.rate_tokens -= ip_rt_error_cost;
1353 icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
1354 }
1355
1356 out: kfree_skb(skb);
1357 return 0;
1358 }
1359
1360 /*
1361 * The last two values are not from the RFC but
1362 * are needed for AMPRnet AX.25 paths.
1363 */
1364
1365 static unsigned short mtu_plateau[] =
1366 {32000, 17914, 8166, 4352, 2002, 1492, 576, 296, 216, 128 };
1367
1368 static __inline__ unsigned short guess_mtu(unsigned short old_mtu)
1369 {
1370 int i;
1371
1372 for (i = 0; i < ARRAY_SIZE(mtu_plateau); i++)
1373 if (old_mtu > mtu_plateau[i])
1374 return mtu_plateau[i];
1375 return 68;
1376 }
1377
1378 unsigned short ip_rt_frag_needed(struct iphdr *iph, unsigned short new_mtu)
1379 {
1380 int i;
1381 unsigned short old_mtu = ntohs(iph->tot_len);
1382 struct rtable *rth;
1383 u32 skeys[2] = { iph->saddr, 0, };
1384 u32 daddr = iph->daddr;
1385 u8 tos = iph->tos & IPTOS_RT_MASK;
1386 unsigned short est_mtu = 0;
1387
1388 if (ipv4_config.no_pmtu_disc)
1389 return 0;
1390
1391 for (i = 0; i < 2; i++) {
1392 unsigned hash = rt_hash_code(daddr, skeys[i], tos);
1393
1394 rcu_read_lock();
1395 for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
1396 rth = rcu_dereference(rth->u.rt_next)) {
1397 if (rth->fl.fl4_dst == daddr &&
1398 rth->fl.fl4_src == skeys[i] &&
1399 rth->rt_dst == daddr &&
1400 rth->rt_src == iph->saddr &&
1401 rth->fl.fl4_tos == tos &&
1402 rth->fl.iif == 0 &&
1403 !(dst_metric_locked(&rth->u.dst, RTAX_MTU))) {
1404 unsigned short mtu = new_mtu;
1405
1406 if (new_mtu < 68 || new_mtu >= old_mtu) {
1407
1408 /* BSD 4.2 compatibility hack :-( */
1409 if (mtu == 0 &&
1410 old_mtu >= rth->u.dst.metrics[RTAX_MTU-1] &&
1411 old_mtu >= 68 + (iph->ihl << 2))
1412 old_mtu -= iph->ihl << 2;
1413
1414 mtu = guess_mtu(old_mtu);
1415 }
1416 if (mtu <= rth->u.dst.metrics[RTAX_MTU-1]) {
1417 if (mtu < rth->u.dst.metrics[RTAX_MTU-1]) {
1418 dst_confirm(&rth->u.dst);
1419 if (mtu < ip_rt_min_pmtu) {
1420 mtu = ip_rt_min_pmtu;
1421 rth->u.dst.metrics[RTAX_LOCK-1] |=
1422 (1 << RTAX_MTU);
1423 }
1424 rth->u.dst.metrics[RTAX_MTU-1] = mtu;
1425 dst_set_expires(&rth->u.dst,
1426 ip_rt_mtu_expires);
1427 }
1428 est_mtu = mtu;
1429 }
1430 }
1431 }
1432 rcu_read_unlock();
1433 }
1434 return est_mtu ? : new_mtu;
1435 }
1436
1437 static void ip_rt_update_pmtu(struct dst_entry *dst, u32 mtu)
1438 {
1439 if (dst->metrics[RTAX_MTU-1] > mtu && mtu >= 68 &&
1440 !(dst_metric_locked(dst, RTAX_MTU))) {
1441 if (mtu < ip_rt_min_pmtu) {
1442 mtu = ip_rt_min_pmtu;
1443 dst->metrics[RTAX_LOCK-1] |= (1 << RTAX_MTU);
1444 }
1445 dst->metrics[RTAX_MTU-1] = mtu;
1446 dst_set_expires(dst, ip_rt_mtu_expires);
1447 }
1448 }
1449
1450 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
1451 {
1452 return NULL;
1453 }
1454
1455 static void ipv4_dst_destroy(struct dst_entry *dst)
1456 {
1457 struct rtable *rt = (struct rtable *) dst;
1458 struct inet_peer *peer = rt->peer;
1459 struct in_device *idev = rt->idev;
1460
1461 if (peer) {
1462 rt->peer = NULL;
1463 inet_putpeer(peer);
1464 }
1465
1466 if (idev) {
1467 rt->idev = NULL;
1468 in_dev_put(idev);
1469 }
1470 }
1471
1472 static void ipv4_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
1473 int how)
1474 {
1475 struct rtable *rt = (struct rtable *) dst;
1476 struct in_device *idev = rt->idev;
1477 if (dev != &loopback_dev && idev && idev->dev == dev) {
1478 struct in_device *loopback_idev = in_dev_get(&loopback_dev);
1479 if (loopback_idev) {
1480 rt->idev = loopback_idev;
1481 in_dev_put(idev);
1482 }
1483 }
1484 }
1485
1486 static void ipv4_link_failure(struct sk_buff *skb)
1487 {
1488 struct rtable *rt;
1489
1490 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
1491
1492 rt = (struct rtable *) skb->dst;
1493 if (rt)
1494 dst_set_expires(&rt->u.dst, 0);
1495 }
1496
1497 static int ip_rt_bug(struct sk_buff *skb)
1498 {
1499 printk(KERN_DEBUG "ip_rt_bug: %u.%u.%u.%u -> %u.%u.%u.%u, %s\n",
1500 NIPQUAD(skb->nh.iph->saddr), NIPQUAD(skb->nh.iph->daddr),
1501 skb->dev ? skb->dev->name : "?");
1502 kfree_skb(skb);
1503 return 0;
1504 }
1505
1506 /*
1507 We do not cache source address of outgoing interface,
1508 because it is used only by IP RR, TS and SRR options,
1509 so that it out of fast path.
1510
1511 BTW remember: "addr" is allowed to be not aligned
1512 in IP options!
1513 */
1514
1515 void ip_rt_get_source(u8 *addr, struct rtable *rt)
1516 {
1517 u32 src;
1518 struct fib_result res;
1519
1520 if (rt->fl.iif == 0)
1521 src = rt->rt_src;
1522 else if (fib_lookup(&rt->fl, &res) == 0) {
1523 src = FIB_RES_PREFSRC(res);
1524 fib_res_put(&res);
1525 } else
1526 src = inet_select_addr(rt->u.dst.dev, rt->rt_gateway,
1527 RT_SCOPE_UNIVERSE);
1528 memcpy(addr, &src, 4);
1529 }
1530
1531 #ifdef CONFIG_NET_CLS_ROUTE
1532 static void set_class_tag(struct rtable *rt, u32 tag)
1533 {
1534 if (!(rt->u.dst.tclassid & 0xFFFF))
1535 rt->u.dst.tclassid |= tag & 0xFFFF;
1536 if (!(rt->u.dst.tclassid & 0xFFFF0000))
1537 rt->u.dst.tclassid |= tag & 0xFFFF0000;
1538 }
1539 #endif
1540
1541 static void rt_set_nexthop(struct rtable *rt, struct fib_result *res, u32 itag)
1542 {
1543 struct fib_info *fi = res->fi;
1544
1545 if (fi) {
1546 if (FIB_RES_GW(*res) &&
1547 FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK)
1548 rt->rt_gateway = FIB_RES_GW(*res);
1549 memcpy(rt->u.dst.metrics, fi->fib_metrics,
1550 sizeof(rt->u.dst.metrics));
1551 if (fi->fib_mtu == 0) {
1552 rt->u.dst.metrics[RTAX_MTU-1] = rt->u.dst.dev->mtu;
1553 if (rt->u.dst.metrics[RTAX_LOCK-1] & (1 << RTAX_MTU) &&
1554 rt->rt_gateway != rt->rt_dst &&
1555 rt->u.dst.dev->mtu > 576)
1556 rt->u.dst.metrics[RTAX_MTU-1] = 576;
1557 }
1558 #ifdef CONFIG_NET_CLS_ROUTE
1559 rt->u.dst.tclassid = FIB_RES_NH(*res).nh_tclassid;
1560 #endif
1561 } else
1562 rt->u.dst.metrics[RTAX_MTU-1]= rt->u.dst.dev->mtu;
1563
1564 if (rt->u.dst.metrics[RTAX_HOPLIMIT-1] == 0)
1565 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = sysctl_ip_default_ttl;
1566 if (rt->u.dst.metrics[RTAX_MTU-1] > IP_MAX_MTU)
1567 rt->u.dst.metrics[RTAX_MTU-1] = IP_MAX_MTU;
1568 if (rt->u.dst.metrics[RTAX_ADVMSS-1] == 0)
1569 rt->u.dst.metrics[RTAX_ADVMSS-1] = max_t(unsigned int, rt->u.dst.dev->mtu - 40,
1570 ip_rt_min_advmss);
1571 if (rt->u.dst.metrics[RTAX_ADVMSS-1] > 65535 - 40)
1572 rt->u.dst.metrics[RTAX_ADVMSS-1] = 65535 - 40;
1573
1574 #ifdef CONFIG_NET_CLS_ROUTE
1575 #ifdef CONFIG_IP_MULTIPLE_TABLES
1576 set_class_tag(rt, fib_rules_tclass(res));
1577 #endif
1578 set_class_tag(rt, itag);
1579 #endif
1580 rt->rt_type = res->type;
1581 }
1582
1583 static int ip_route_input_mc(struct sk_buff *skb, u32 daddr, u32 saddr,
1584 u8 tos, struct net_device *dev, int our)
1585 {
1586 unsigned hash;
1587 struct rtable *rth;
1588 u32 spec_dst;
1589 struct in_device *in_dev = in_dev_get(dev);
1590 u32 itag = 0;
1591
1592 /* Primary sanity checks. */
1593
1594 if (in_dev == NULL)
1595 return -EINVAL;
1596
1597 if (MULTICAST(saddr) || BADCLASS(saddr) || LOOPBACK(saddr) ||
1598 skb->protocol != htons(ETH_P_IP))
1599 goto e_inval;
1600
1601 if (ZERONET(saddr)) {
1602 if (!LOCAL_MCAST(daddr))
1603 goto e_inval;
1604 spec_dst = inet_select_addr(dev, 0, RT_SCOPE_LINK);
1605 } else if (fib_validate_source(saddr, 0, tos, 0,
1606 dev, &spec_dst, &itag) < 0)
1607 goto e_inval;
1608
1609 rth = dst_alloc(&ipv4_dst_ops);
1610 if (!rth)
1611 goto e_nobufs;
1612
1613 rth->u.dst.output= ip_rt_bug;
1614
1615 atomic_set(&rth->u.dst.__refcnt, 1);
1616 rth->u.dst.flags= DST_HOST;
1617 if (in_dev->cnf.no_policy)
1618 rth->u.dst.flags |= DST_NOPOLICY;
1619 rth->fl.fl4_dst = daddr;
1620 rth->rt_dst = daddr;
1621 rth->fl.fl4_tos = tos;
1622 #ifdef CONFIG_IP_ROUTE_FWMARK
1623 rth->fl.fl4_fwmark= skb->nfmark;
1624 #endif
1625 rth->fl.fl4_src = saddr;
1626 rth->rt_src = saddr;
1627 #ifdef CONFIG_NET_CLS_ROUTE
1628 rth->u.dst.tclassid = itag;
1629 #endif
1630 rth->rt_iif =
1631 rth->fl.iif = dev->ifindex;
1632 rth->u.dst.dev = &loopback_dev;
1633 dev_hold(rth->u.dst.dev);
1634 rth->idev = in_dev_get(rth->u.dst.dev);
1635 rth->fl.oif = 0;
1636 rth->rt_gateway = daddr;
1637 rth->rt_spec_dst= spec_dst;
1638 rth->rt_type = RTN_MULTICAST;
1639 rth->rt_flags = RTCF_MULTICAST;
1640 if (our) {
1641 rth->u.dst.input= ip_local_deliver;
1642 rth->rt_flags |= RTCF_LOCAL;
1643 }
1644
1645 #ifdef CONFIG_IP_MROUTE
1646 if (!LOCAL_MCAST(daddr) && IN_DEV_MFORWARD(in_dev))
1647 rth->u.dst.input = ip_mr_input;
1648 #endif
1649 RT_CACHE_STAT_INC(in_slow_mc);
1650
1651 in_dev_put(in_dev);
1652 hash = rt_hash_code(daddr, saddr ^ (dev->ifindex << 5), tos);
1653 return rt_intern_hash(hash, rth, (struct rtable**) &skb->dst);
1654
1655 e_nobufs:
1656 in_dev_put(in_dev);
1657 return -ENOBUFS;
1658
1659 e_inval:
1660 in_dev_put(in_dev);
1661 return -EINVAL;
1662 }
1663
1664
1665 static void ip_handle_martian_source(struct net_device *dev,
1666 struct in_device *in_dev,
1667 struct sk_buff *skb,
1668 u32 daddr,
1669 u32 saddr)
1670 {
1671 RT_CACHE_STAT_INC(in_martian_src);
1672 #ifdef CONFIG_IP_ROUTE_VERBOSE
1673 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
1674 /*
1675 * RFC1812 recommendation, if source is martian,
1676 * the only hint is MAC header.
1677 */
1678 printk(KERN_WARNING "martian source %u.%u.%u.%u from "
1679 "%u.%u.%u.%u, on dev %s\n",
1680 NIPQUAD(daddr), NIPQUAD(saddr), dev->name);
1681 if (dev->hard_header_len) {
1682 int i;
1683 unsigned char *p = skb->mac.raw;
1684 printk(KERN_WARNING "ll header: ");
1685 for (i = 0; i < dev->hard_header_len; i++, p++) {
1686 printk("%02x", *p);
1687 if (i < (dev->hard_header_len - 1))
1688 printk(":");
1689 }
1690 printk("\n");
1691 }
1692 }
1693 #endif
1694 }
1695
1696 static inline int __mkroute_input(struct sk_buff *skb,
1697 struct fib_result* res,
1698 struct in_device *in_dev,
1699 u32 daddr, u32 saddr, u32 tos,
1700 struct rtable **result)
1701 {
1702
1703 struct rtable *rth;
1704 int err;
1705 struct in_device *out_dev;
1706 unsigned flags = 0;
1707 u32 spec_dst, itag;
1708
1709 /* get a working reference to the output device */
1710 out_dev = in_dev_get(FIB_RES_DEV(*res));
1711 if (out_dev == NULL) {
1712 if (net_ratelimit())
1713 printk(KERN_CRIT "Bug in ip_route_input" \
1714 "_slow(). Please, report\n");
1715 return -EINVAL;
1716 }
1717
1718
1719 err = fib_validate_source(saddr, daddr, tos, FIB_RES_OIF(*res),
1720 in_dev->dev, &spec_dst, &itag);
1721 if (err < 0) {
1722 ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
1723 saddr);
1724
1725 err = -EINVAL;
1726 goto cleanup;
1727 }
1728
1729 if (err)
1730 flags |= RTCF_DIRECTSRC;
1731
1732 if (out_dev == in_dev && err && !(flags & (RTCF_NAT | RTCF_MASQ)) &&
1733 (IN_DEV_SHARED_MEDIA(out_dev) ||
1734 inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
1735 flags |= RTCF_DOREDIRECT;
1736
1737 if (skb->protocol != htons(ETH_P_IP)) {
1738 /* Not IP (i.e. ARP). Do not create route, if it is
1739 * invalid for proxy arp. DNAT routes are always valid.
1740 */
1741 if (out_dev == in_dev && !(flags & RTCF_DNAT)) {
1742 err = -EINVAL;
1743 goto cleanup;
1744 }
1745 }
1746
1747
1748 rth = dst_alloc(&ipv4_dst_ops);
1749 if (!rth) {
1750 err = -ENOBUFS;
1751 goto cleanup;
1752 }
1753
1754 rth->u.dst.flags= DST_HOST;
1755 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
1756 if (res->fi->fib_nhs > 1)
1757 rth->u.dst.flags |= DST_BALANCED;
1758 #endif
1759 if (in_dev->cnf.no_policy)
1760 rth->u.dst.flags |= DST_NOPOLICY;
1761 if (in_dev->cnf.no_xfrm)
1762 rth->u.dst.flags |= DST_NOXFRM;
1763 rth->fl.fl4_dst = daddr;
1764 rth->rt_dst = daddr;
1765 rth->fl.fl4_tos = tos;
1766 #ifdef CONFIG_IP_ROUTE_FWMARK
1767 rth->fl.fl4_fwmark= skb->nfmark;
1768 #endif
1769 rth->fl.fl4_src = saddr;
1770 rth->rt_src = saddr;
1771 rth->rt_gateway = daddr;
1772 rth->rt_iif =
1773 rth->fl.iif = in_dev->dev->ifindex;
1774 rth->u.dst.dev = (out_dev)->dev;
1775 dev_hold(rth->u.dst.dev);
1776 rth->idev = in_dev_get(rth->u.dst.dev);
1777 rth->fl.oif = 0;
1778 rth->rt_spec_dst= spec_dst;
1779
1780 rth->u.dst.input = ip_forward;
1781 rth->u.dst.output = ip_output;
1782
1783 rt_set_nexthop(rth, res, itag);
1784
1785 rth->rt_flags = flags;
1786
1787 *result = rth;
1788 err = 0;
1789 cleanup:
1790 /* release the working reference to the output device */
1791 in_dev_put(out_dev);
1792 return err;
1793 }
1794
1795 static inline int ip_mkroute_input_def(struct sk_buff *skb,
1796 struct fib_result* res,
1797 const struct flowi *fl,
1798 struct in_device *in_dev,
1799 u32 daddr, u32 saddr, u32 tos)
1800 {
1801 struct rtable* rth = NULL;
1802 int err;
1803 unsigned hash;
1804
1805 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1806 if (res->fi && res->fi->fib_nhs > 1 && fl->oif == 0)
1807 fib_select_multipath(fl, res);
1808 #endif
1809
1810 /* create a routing cache entry */
1811 err = __mkroute_input(skb, res, in_dev, daddr, saddr, tos, &rth);
1812 if (err)
1813 return err;
1814 atomic_set(&rth->u.dst.__refcnt, 1);
1815
1816 /* put it into the cache */
1817 hash = rt_hash_code(daddr, saddr ^ (fl->iif << 5), tos);
1818 return rt_intern_hash(hash, rth, (struct rtable**)&skb->dst);
1819 }
1820
1821 static inline int ip_mkroute_input(struct sk_buff *skb,
1822 struct fib_result* res,
1823 const struct flowi *fl,
1824 struct in_device *in_dev,
1825 u32 daddr, u32 saddr, u32 tos)
1826 {
1827 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
1828 struct rtable* rth = NULL;
1829 unsigned char hop, hopcount, lasthop;
1830 int err = -EINVAL;
1831 unsigned int hash;
1832
1833 if (res->fi)
1834 hopcount = res->fi->fib_nhs;
1835 else
1836 hopcount = 1;
1837
1838 lasthop = hopcount - 1;
1839
1840 /* distinguish between multipath and singlepath */
1841 if (hopcount < 2)
1842 return ip_mkroute_input_def(skb, res, fl, in_dev, daddr,
1843 saddr, tos);
1844
1845 /* add all alternatives to the routing cache */
1846 for (hop = 0; hop < hopcount; hop++) {
1847 res->nh_sel = hop;
1848
1849 /* create a routing cache entry */
1850 err = __mkroute_input(skb, res, in_dev, daddr, saddr, tos,
1851 &rth);
1852 if (err)
1853 return err;
1854
1855 /* put it into the cache */
1856 hash = rt_hash_code(daddr, saddr ^ (fl->iif << 5), tos);
1857 err = rt_intern_hash(hash, rth, (struct rtable**)&skb->dst);
1858 if (err)
1859 return err;
1860
1861 /* forward hop information to multipath impl. */
1862 multipath_set_nhinfo(rth,
1863 FIB_RES_NETWORK(*res),
1864 FIB_RES_NETMASK(*res),
1865 res->prefixlen,
1866 &FIB_RES_NH(*res));
1867
1868 /* only for the last hop the reference count is handled
1869 * outside
1870 */
1871 if (hop == lasthop)
1872 atomic_set(&(skb->dst->__refcnt), 1);
1873 }
1874 return err;
1875 #else /* CONFIG_IP_ROUTE_MULTIPATH_CACHED */
1876 return ip_mkroute_input_def(skb, res, fl, in_dev, daddr, saddr, tos);
1877 #endif /* CONFIG_IP_ROUTE_MULTIPATH_CACHED */
1878 }
1879
1880
1881 /*
1882 * NOTE. We drop all the packets that has local source
1883 * addresses, because every properly looped back packet
1884 * must have correct destination already attached by output routine.
1885 *
1886 * Such approach solves two big problems:
1887 * 1. Not simplex devices are handled properly.
1888 * 2. IP spoofing attempts are filtered with 100% of guarantee.
1889 */
1890
1891 static int ip_route_input_slow(struct sk_buff *skb, u32 daddr, u32 saddr,
1892 u8 tos, struct net_device *dev)
1893 {
1894 struct fib_result res;
1895 struct in_device *in_dev = in_dev_get(dev);
1896 struct flowi fl = { .nl_u = { .ip4_u =
1897 { .daddr = daddr,
1898 .saddr = saddr,
1899 .tos = tos,
1900 .scope = RT_SCOPE_UNIVERSE,
1901 #ifdef CONFIG_IP_ROUTE_FWMARK
1902 .fwmark = skb->nfmark
1903 #endif
1904 } },
1905 .iif = dev->ifindex };
1906 unsigned flags = 0;
1907 u32 itag = 0;
1908 struct rtable * rth;
1909 unsigned hash;
1910 u32 spec_dst;
1911 int err = -EINVAL;
1912 int free_res = 0;
1913
1914 /* IP on this device is disabled. */
1915
1916 if (!in_dev)
1917 goto out;
1918
1919 /* Check for the most weird martians, which can be not detected
1920 by fib_lookup.
1921 */
1922
1923 if (MULTICAST(saddr) || BADCLASS(saddr) || LOOPBACK(saddr))
1924 goto martian_source;
1925
1926 if (daddr == 0xFFFFFFFF || (saddr == 0 && daddr == 0))
1927 goto brd_input;
1928
1929 /* Accept zero addresses only to limited broadcast;
1930 * I even do not know to fix it or not. Waiting for complains :-)
1931 */
1932 if (ZERONET(saddr))
1933 goto martian_source;
1934
1935 if (BADCLASS(daddr) || ZERONET(daddr) || LOOPBACK(daddr))
1936 goto martian_destination;
1937
1938 /*
1939 * Now we are ready to route packet.
1940 */
1941 if ((err = fib_lookup(&fl, &res)) != 0) {
1942 if (!IN_DEV_FORWARD(in_dev))
1943 goto e_hostunreach;
1944 goto no_route;
1945 }
1946 free_res = 1;
1947
1948 RT_CACHE_STAT_INC(in_slow_tot);
1949
1950 if (res.type == RTN_BROADCAST)
1951 goto brd_input;
1952
1953 if (res.type == RTN_LOCAL) {
1954 int result;
1955 result = fib_validate_source(saddr, daddr, tos,
1956 loopback_dev.ifindex,
1957 dev, &spec_dst, &itag);
1958 if (result < 0)
1959 goto martian_source;
1960 if (result)
1961 flags |= RTCF_DIRECTSRC;
1962 spec_dst = daddr;
1963 goto local_input;
1964 }
1965
1966 if (!IN_DEV_FORWARD(in_dev))
1967 goto e_hostunreach;
1968 if (res.type != RTN_UNICAST)
1969 goto martian_destination;
1970
1971 err = ip_mkroute_input(skb, &res, &fl, in_dev, daddr, saddr, tos);
1972 if (err == -ENOBUFS)
1973 goto e_nobufs;
1974 if (err == -EINVAL)
1975 goto e_inval;
1976
1977 done:
1978 in_dev_put(in_dev);
1979 if (free_res)
1980 fib_res_put(&res);
1981 out: return err;
1982
1983 brd_input:
1984 if (skb->protocol != htons(ETH_P_IP))
1985 goto e_inval;
1986
1987 if (ZERONET(saddr))
1988 spec_dst = inet_select_addr(dev, 0, RT_SCOPE_LINK);
1989 else {
1990 err = fib_validate_source(saddr, 0, tos, 0, dev, &spec_dst,
1991 &itag);
1992 if (err < 0)
1993 goto martian_source;
1994 if (err)
1995 flags |= RTCF_DIRECTSRC;
1996 }
1997 flags |= RTCF_BROADCAST;
1998 res.type = RTN_BROADCAST;
1999 RT_CACHE_STAT_INC(in_brd);
2000
2001 local_input:
2002 rth = dst_alloc(&ipv4_dst_ops);
2003 if (!rth)
2004 goto e_nobufs;
2005
2006 rth->u.dst.output= ip_rt_bug;
2007
2008 atomic_set(&rth->u.dst.__refcnt, 1);
2009 rth->u.dst.flags= DST_HOST;
2010 if (in_dev->cnf.no_policy)
2011 rth->u.dst.flags |= DST_NOPOLICY;
2012 rth->fl.fl4_dst = daddr;
2013 rth->rt_dst = daddr;
2014 rth->fl.fl4_tos = tos;
2015 #ifdef CONFIG_IP_ROUTE_FWMARK
2016 rth->fl.fl4_fwmark= skb->nfmark;
2017 #endif
2018 rth->fl.fl4_src = saddr;
2019 rth->rt_src = saddr;
2020 #ifdef CONFIG_NET_CLS_ROUTE
2021 rth->u.dst.tclassid = itag;
2022 #endif
2023 rth->rt_iif =
2024 rth->fl.iif = dev->ifindex;
2025 rth->u.dst.dev = &loopback_dev;
2026 dev_hold(rth->u.dst.dev);
2027 rth->idev = in_dev_get(rth->u.dst.dev);
2028 rth->rt_gateway = daddr;
2029 rth->rt_spec_dst= spec_dst;
2030 rth->u.dst.input= ip_local_deliver;
2031 rth->rt_flags = flags|RTCF_LOCAL;
2032 if (res.type == RTN_UNREACHABLE) {
2033 rth->u.dst.input= ip_error;
2034 rth->u.dst.error= -err;
2035 rth->rt_flags &= ~RTCF_LOCAL;
2036 }
2037 rth->rt_type = res.type;
2038 hash = rt_hash_code(daddr, saddr ^ (fl.iif << 5), tos);
2039 err = rt_intern_hash(hash, rth, (struct rtable**)&skb->dst);
2040 goto done;
2041
2042 no_route:
2043 RT_CACHE_STAT_INC(in_no_route);
2044 spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
2045 res.type = RTN_UNREACHABLE;
2046 goto local_input;
2047
2048 /*
2049 * Do not cache martian addresses: they should be logged (RFC1812)
2050 */
2051 martian_destination:
2052 RT_CACHE_STAT_INC(in_martian_dst);
2053 #ifdef CONFIG_IP_ROUTE_VERBOSE
2054 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit())
2055 printk(KERN_WARNING "martian destination %u.%u.%u.%u from "
2056 "%u.%u.%u.%u, dev %s\n",
2057 NIPQUAD(daddr), NIPQUAD(saddr), dev->name);
2058 #endif
2059
2060 e_hostunreach:
2061 err = -EHOSTUNREACH;
2062 goto done;
2063
2064 e_inval:
2065 err = -EINVAL;
2066 goto done;
2067
2068 e_nobufs:
2069 err = -ENOBUFS;
2070 goto done;
2071
2072 martian_source:
2073 ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
2074 goto e_inval;
2075 }
2076
2077 int ip_route_input(struct sk_buff *skb, u32 daddr, u32 saddr,
2078 u8 tos, struct net_device *dev)
2079 {
2080 struct rtable * rth;
2081 unsigned hash;
2082 int iif = dev->ifindex;
2083
2084 tos &= IPTOS_RT_MASK;
2085 hash = rt_hash_code(daddr, saddr ^ (iif << 5), tos);
2086
2087 rcu_read_lock();
2088 for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
2089 rth = rcu_dereference(rth->u.rt_next)) {
2090 if (rth->fl.fl4_dst == daddr &&
2091 rth->fl.fl4_src == saddr &&
2092 rth->fl.iif == iif &&
2093 rth->fl.oif == 0 &&
2094 #ifdef CONFIG_IP_ROUTE_FWMARK
2095 rth->fl.fl4_fwmark == skb->nfmark &&
2096 #endif
2097 rth->fl.fl4_tos == tos) {
2098 rth->u.dst.lastuse = jiffies;
2099 dst_hold(&rth->u.dst);
2100 rth->u.dst.__use++;
2101 RT_CACHE_STAT_INC(in_hit);
2102 rcu_read_unlock();
2103 skb->dst = (struct dst_entry*)rth;
2104 return 0;
2105 }
2106 RT_CACHE_STAT_INC(in_hlist_search);
2107 }
2108 rcu_read_unlock();
2109
2110 /* Multicast recognition logic is moved from route cache to here.
2111 The problem was that too many Ethernet cards have broken/missing
2112 hardware multicast filters :-( As result the host on multicasting
2113 network acquires a lot of useless route cache entries, sort of
2114 SDR messages from all the world. Now we try to get rid of them.
2115 Really, provided software IP multicast filter is organized
2116 reasonably (at least, hashed), it does not result in a slowdown
2117 comparing with route cache reject entries.
2118 Note, that multicast routers are not affected, because
2119 route cache entry is created eventually.
2120 */
2121 if (MULTICAST(daddr)) {
2122 struct in_device *in_dev;
2123
2124 rcu_read_lock();
2125 if ((in_dev = __in_dev_get(dev)) != NULL) {
2126 int our = ip_check_mc(in_dev, daddr, saddr,
2127 skb->nh.iph->protocol);
2128 if (our
2129 #ifdef CONFIG_IP_MROUTE
2130 || (!LOCAL_MCAST(daddr) && IN_DEV_MFORWARD(in_dev))
2131 #endif
2132 ) {
2133 rcu_read_unlock();
2134 return ip_route_input_mc(skb, daddr, saddr,
2135 tos, dev, our);
2136 }
2137 }
2138 rcu_read_unlock();
2139 return -EINVAL;
2140 }
2141 return ip_route_input_slow(skb, daddr, saddr, tos, dev);
2142 }
2143
2144 static inline int __mkroute_output(struct rtable **result,
2145 struct fib_result* res,
2146 const struct flowi *fl,
2147 const struct flowi *oldflp,
2148 struct net_device *dev_out,
2149 unsigned flags)
2150 {
2151 struct rtable *rth;
2152 struct in_device *in_dev;
2153 u32 tos = RT_FL_TOS(oldflp);
2154 int err = 0;
2155
2156 if (LOOPBACK(fl->fl4_src) && !(dev_out->flags&IFF_LOOPBACK))
2157 return -EINVAL;
2158
2159 if (fl->fl4_dst == 0xFFFFFFFF)
2160 res->type = RTN_BROADCAST;
2161 else if (MULTICAST(fl->fl4_dst))
2162 res->type = RTN_MULTICAST;
2163 else if (BADCLASS(fl->fl4_dst) || ZERONET(fl->fl4_dst))
2164 return -EINVAL;
2165
2166 if (dev_out->flags & IFF_LOOPBACK)
2167 flags |= RTCF_LOCAL;
2168
2169 /* get work reference to inet device */
2170 in_dev = in_dev_get(dev_out);
2171 if (!in_dev)
2172 return -EINVAL;
2173
2174 if (res->type == RTN_BROADCAST) {
2175 flags |= RTCF_BROADCAST | RTCF_LOCAL;
2176 if (res->fi) {
2177 fib_info_put(res->fi);
2178 res->fi = NULL;
2179 }
2180 } else if (res->type == RTN_MULTICAST) {
2181 flags |= RTCF_MULTICAST|RTCF_LOCAL;
2182 if (!ip_check_mc(in_dev, oldflp->fl4_dst, oldflp->fl4_src,
2183 oldflp->proto))
2184 flags &= ~RTCF_LOCAL;
2185 /* If multicast route do not exist use
2186 default one, but do not gateway in this case.
2187 Yes, it is hack.
2188 */
2189 if (res->fi && res->prefixlen < 4) {
2190 fib_info_put(res->fi);
2191 res->fi = NULL;
2192 }
2193 }
2194
2195
2196 rth = dst_alloc(&ipv4_dst_ops);
2197 if (!rth) {
2198 err = -ENOBUFS;
2199 goto cleanup;
2200 }
2201
2202 rth->u.dst.flags= DST_HOST;
2203 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
2204 if (res->fi) {
2205 rth->rt_multipath_alg = res->fi->fib_mp_alg;
2206 if (res->fi->fib_nhs > 1)
2207 rth->u.dst.flags |= DST_BALANCED;
2208 }
2209 #endif
2210 if (in_dev->cnf.no_xfrm)
2211 rth->u.dst.flags |= DST_NOXFRM;
2212 if (in_dev->cnf.no_policy)
2213 rth->u.dst.flags |= DST_NOPOLICY;
2214
2215 rth->fl.fl4_dst = oldflp->fl4_dst;
2216 rth->fl.fl4_tos = tos;
2217 rth->fl.fl4_src = oldflp->fl4_src;
2218 rth->fl.oif = oldflp->oif;
2219 #ifdef CONFIG_IP_ROUTE_FWMARK
2220 rth->fl.fl4_fwmark= oldflp->fl4_fwmark;
2221 #endif
2222 rth->rt_dst = fl->fl4_dst;
2223 rth->rt_src = fl->fl4_src;
2224 rth->rt_iif = oldflp->oif ? : dev_out->ifindex;
2225 /* get references to the devices that are to be hold by the routing
2226 cache entry */
2227 rth->u.dst.dev = dev_out;
2228 dev_hold(dev_out);
2229 rth->idev = in_dev_get(dev_out);
2230 rth->rt_gateway = fl->fl4_dst;
2231 rth->rt_spec_dst= fl->fl4_src;
2232
2233 rth->u.dst.output=ip_output;
2234
2235 RT_CACHE_STAT_INC(out_slow_tot);
2236
2237 if (flags & RTCF_LOCAL) {
2238 rth->u.dst.input = ip_local_deliver;
2239 rth->rt_spec_dst = fl->fl4_dst;
2240 }
2241 if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
2242 rth->rt_spec_dst = fl->fl4_src;
2243 if (flags & RTCF_LOCAL &&
2244 !(dev_out->flags & IFF_LOOPBACK)) {
2245 rth->u.dst.output = ip_mc_output;
2246 RT_CACHE_STAT_INC(out_slow_mc);
2247 }
2248 #ifdef CONFIG_IP_MROUTE
2249 if (res->type == RTN_MULTICAST) {
2250 if (IN_DEV_MFORWARD(in_dev) &&
2251 !LOCAL_MCAST(oldflp->fl4_dst)) {
2252 rth->u.dst.input = ip_mr_input;
2253 rth->u.dst.output = ip_mc_output;
2254 }
2255 }
2256 #endif
2257 }
2258
2259 rt_set_nexthop(rth, res, 0);
2260
2261 rth->rt_flags = flags;
2262
2263 *result = rth;
2264 cleanup:
2265 /* release work reference to inet device */
2266 in_dev_put(in_dev);
2267
2268 return err;
2269 }
2270
2271 static inline int ip_mkroute_output_def(struct rtable **rp,
2272 struct fib_result* res,
2273 const struct flowi *fl,
2274 const struct flowi *oldflp,
2275 struct net_device *dev_out,
2276 unsigned flags)
2277 {
2278 struct rtable *rth = NULL;
2279 int err = __mkroute_output(&rth, res, fl, oldflp, dev_out, flags);
2280 unsigned hash;
2281 if (err == 0) {
2282 u32 tos = RT_FL_TOS(oldflp);
2283
2284 atomic_set(&rth->u.dst.__refcnt, 1);
2285
2286 hash = rt_hash_code(oldflp->fl4_dst,
2287 oldflp->fl4_src ^ (oldflp->oif << 5), tos);
2288 err = rt_intern_hash(hash, rth, rp);
2289 }
2290
2291 return err;
2292 }
2293
2294 static inline int ip_mkroute_output(struct rtable** rp,
2295 struct fib_result* res,
2296 const struct flowi *fl,
2297 const struct flowi *oldflp,
2298 struct net_device *dev_out,
2299 unsigned flags)
2300 {
2301 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
2302 u32 tos = RT_FL_TOS(oldflp);
2303 unsigned char hop;
2304 unsigned hash;
2305 int err = -EINVAL;
2306 struct rtable *rth = NULL;
2307
2308 if (res->fi && res->fi->fib_nhs > 1) {
2309 unsigned char hopcount = res->fi->fib_nhs;
2310
2311 for (hop = 0; hop < hopcount; hop++) {
2312 struct net_device *dev2nexthop;
2313
2314 res->nh_sel = hop;
2315
2316 /* hold a work reference to the output device */
2317 dev2nexthop = FIB_RES_DEV(*res);
2318 dev_hold(dev2nexthop);
2319
2320 err = __mkroute_output(&rth, res, fl, oldflp,
2321 dev2nexthop, flags);
2322
2323 if (err != 0)
2324 goto cleanup;
2325
2326 hash = rt_hash_code(oldflp->fl4_dst,
2327 oldflp->fl4_src ^
2328 (oldflp->oif << 5), tos);
2329 err = rt_intern_hash(hash, rth, rp);
2330
2331 /* forward hop information to multipath impl. */
2332 multipath_set_nhinfo(rth,
2333 FIB_RES_NETWORK(*res),
2334 FIB_RES_NETMASK(*res),
2335 res->prefixlen,
2336 &FIB_RES_NH(*res));
2337 cleanup:
2338 /* release work reference to output device */
2339 dev_put(dev2nexthop);
2340
2341 if (err != 0)
2342 return err;
2343 }
2344 atomic_set(&(*rp)->u.dst.__refcnt, 1);
2345 return err;
2346 } else {
2347 return ip_mkroute_output_def(rp, res, fl, oldflp, dev_out,
2348 flags);
2349 }
2350 #else /* CONFIG_IP_ROUTE_MULTIPATH_CACHED */
2351 return ip_mkroute_output_def(rp, res, fl, oldflp, dev_out, flags);
2352 #endif
2353 }
2354
2355 /*
2356 * Major route resolver routine.
2357 */
2358
2359 static int ip_route_output_slow(struct rtable **rp, const struct flowi *oldflp)
2360 {
2361 u32 tos = RT_FL_TOS(oldflp);
2362 struct flowi fl = { .nl_u = { .ip4_u =
2363 { .daddr = oldflp->fl4_dst,
2364 .saddr = oldflp->fl4_src,
2365 .tos = tos & IPTOS_RT_MASK,
2366 .scope = ((tos & RTO_ONLINK) ?
2367 RT_SCOPE_LINK :
2368 RT_SCOPE_UNIVERSE),
2369 #ifdef CONFIG_IP_ROUTE_FWMARK
2370 .fwmark = oldflp->fl4_fwmark
2371 #endif
2372 } },
2373 .iif = loopback_dev.ifindex,
2374 .oif = oldflp->oif };
2375 struct fib_result res;
2376 unsigned flags = 0;
2377 struct net_device *dev_out = NULL;
2378 int free_res = 0;
2379 int err;
2380
2381
2382 res.fi = NULL;
2383 #ifdef CONFIG_IP_MULTIPLE_TABLES
2384 res.r = NULL;
2385 #endif
2386
2387 if (oldflp->fl4_src) {
2388 err = -EINVAL;
2389 if (MULTICAST(oldflp->fl4_src) ||
2390 BADCLASS(oldflp->fl4_src) ||
2391 ZERONET(oldflp->fl4_src))
2392 goto out;
2393
2394 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2395 dev_out = ip_dev_find(oldflp->fl4_src);
2396 if (dev_out == NULL)
2397 goto out;
2398
2399 /* I removed check for oif == dev_out->oif here.
2400 It was wrong for two reasons:
2401 1. ip_dev_find(saddr) can return wrong iface, if saddr is
2402 assigned to multiple interfaces.
2403 2. Moreover, we are allowed to send packets with saddr
2404 of another iface. --ANK
2405 */
2406
2407 if (oldflp->oif == 0
2408 && (MULTICAST(oldflp->fl4_dst) || oldflp->fl4_dst == 0xFFFFFFFF)) {
2409 /* Special hack: user can direct multicasts
2410 and limited broadcast via necessary interface
2411 without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
2412 This hack is not just for fun, it allows
2413 vic,vat and friends to work.
2414 They bind socket to loopback, set ttl to zero
2415 and expect that it will work.
2416 From the viewpoint of routing cache they are broken,
2417 because we are not allowed to build multicast path
2418 with loopback source addr (look, routing cache
2419 cannot know, that ttl is zero, so that packet
2420 will not leave this host and route is valid).
2421 Luckily, this hack is good workaround.
2422 */
2423
2424 fl.oif = dev_out->ifindex;
2425 goto make_route;
2426 }
2427 if (dev_out)
2428 dev_put(dev_out);
2429 dev_out = NULL;
2430 }
2431
2432
2433 if (oldflp->oif) {
2434 dev_out = dev_get_by_index(oldflp->oif);
2435 err = -ENODEV;
2436 if (dev_out == NULL)
2437 goto out;
2438 if (__in_dev_get(dev_out) == NULL) {
2439 dev_put(dev_out);
2440 goto out; /* Wrong error code */
2441 }
2442
2443 if (LOCAL_MCAST(oldflp->fl4_dst) || oldflp->fl4_dst == 0xFFFFFFFF) {
2444 if (!fl.fl4_src)
2445 fl.fl4_src = inet_select_addr(dev_out, 0,
2446 RT_SCOPE_LINK);
2447 goto make_route;
2448 }
2449 if (!fl.fl4_src) {
2450 if (MULTICAST(oldflp->fl4_dst))
2451 fl.fl4_src = inet_select_addr(dev_out, 0,
2452 fl.fl4_scope);
2453 else if (!oldflp->fl4_dst)
2454 fl.fl4_src = inet_select_addr(dev_out, 0,
2455 RT_SCOPE_HOST);
2456 }
2457 }
2458
2459 if (!fl.fl4_dst) {
2460 fl.fl4_dst = fl.fl4_src;
2461 if (!fl.fl4_dst)
2462 fl.fl4_dst = fl.fl4_src = htonl(INADDR_LOOPBACK);
2463 if (dev_out)
2464 dev_put(dev_out);
2465 dev_out = &loopback_dev;
2466 dev_hold(dev_out);
2467 fl.oif = loopback_dev.ifindex;
2468 res.type = RTN_LOCAL;
2469 flags |= RTCF_LOCAL;
2470 goto make_route;
2471 }
2472
2473 if (fib_lookup(&fl, &res)) {
2474 res.fi = NULL;
2475 if (oldflp->oif) {
2476 /* Apparently, routing tables are wrong. Assume,
2477 that the destination is on link.
2478
2479 WHY? DW.
2480 Because we are allowed to send to iface
2481 even if it has NO routes and NO assigned
2482 addresses. When oif is specified, routing
2483 tables are looked up with only one purpose:
2484 to catch if destination is gatewayed, rather than
2485 direct. Moreover, if MSG_DONTROUTE is set,
2486 we send packet, ignoring both routing tables
2487 and ifaddr state. --ANK
2488
2489
2490 We could make it even if oif is unknown,
2491 likely IPv6, but we do not.
2492 */
2493
2494 if (fl.fl4_src == 0)
2495 fl.fl4_src = inet_select_addr(dev_out, 0,
2496 RT_SCOPE_LINK);
2497 res.type = RTN_UNICAST;
2498 goto make_route;
2499 }
2500 if (dev_out)
2501 dev_put(dev_out);
2502 err = -ENETUNREACH;
2503 goto out;
2504 }
2505 free_res = 1;
2506
2507 if (res.type == RTN_LOCAL) {
2508 if (!fl.fl4_src)
2509 fl.fl4_src = fl.fl4_dst;
2510 if (dev_out)
2511 dev_put(dev_out);
2512 dev_out = &loopback_dev;
2513 dev_hold(dev_out);
2514 fl.oif = dev_out->ifindex;
2515 if (res.fi)
2516 fib_info_put(res.fi);
2517 res.fi = NULL;
2518 flags |= RTCF_LOCAL;
2519 goto make_route;
2520 }
2521
2522 #ifdef CONFIG_IP_ROUTE_MULTIPATH
2523 if (res.fi->fib_nhs > 1 && fl.oif == 0)
2524 fib_select_multipath(&fl, &res);
2525 else
2526 #endif
2527 if (!res.prefixlen && res.type == RTN_UNICAST && !fl.oif)
2528 fib_select_default(&fl, &res);
2529
2530 if (!fl.fl4_src)
2531 fl.fl4_src = FIB_RES_PREFSRC(res);
2532
2533 if (dev_out)
2534 dev_put(dev_out);
2535 dev_out = FIB_RES_DEV(res);
2536 dev_hold(dev_out);
2537 fl.oif = dev_out->ifindex;
2538
2539
2540 make_route:
2541 err = ip_mkroute_output(rp, &res, &fl, oldflp, dev_out, flags);
2542
2543
2544 if (free_res)
2545 fib_res_put(&res);
2546 if (dev_out)
2547 dev_put(dev_out);
2548 out: return err;
2549 }
2550
2551 int __ip_route_output_key(struct rtable **rp, const struct flowi *flp)
2552 {
2553 unsigned hash;
2554 struct rtable *rth;
2555
2556 hash = rt_hash_code(flp->fl4_dst, flp->fl4_src ^ (flp->oif << 5), flp->fl4_tos);
2557
2558 rcu_read_lock_bh();
2559 for (rth = rcu_dereference(rt_hash_table[hash].chain); rth;
2560 rth = rcu_dereference(rth->u.rt_next)) {
2561 if (rth->fl.fl4_dst == flp->fl4_dst &&
2562 rth->fl.fl4_src == flp->fl4_src &&
2563 rth->fl.iif == 0 &&
2564 rth->fl.oif == flp->oif &&
2565 #ifdef CONFIG_IP_ROUTE_FWMARK
2566 rth->fl.fl4_fwmark == flp->fl4_fwmark &&
2567 #endif
2568 !((rth->fl.fl4_tos ^ flp->fl4_tos) &
2569 (IPTOS_RT_MASK | RTO_ONLINK))) {
2570
2571 /* check for multipath routes and choose one if
2572 * necessary
2573 */
2574 if (multipath_select_route(flp, rth, rp)) {
2575 dst_hold(&(*rp)->u.dst);
2576 RT_CACHE_STAT_INC(out_hit);
2577 rcu_read_unlock_bh();
2578 return 0;
2579 }
2580
2581 rth->u.dst.lastuse = jiffies;
2582 dst_hold(&rth->u.dst);
2583 rth->u.dst.__use++;
2584 RT_CACHE_STAT_INC(out_hit);
2585 rcu_read_unlock_bh();
2586 *rp = rth;
2587 return 0;
2588 }
2589 RT_CACHE_STAT_INC(out_hlist_search);
2590 }
2591 rcu_read_unlock_bh();
2592
2593 return ip_route_output_slow(rp, flp);
2594 }
2595
2596 int ip_route_output_flow(struct rtable **rp, struct flowi *flp, struct sock *sk, int flags)
2597 {
2598 int err;
2599
2600 if ((err = __ip_route_output_key(rp, flp)) != 0)
2601 return err;
2602
2603 if (flp->proto) {
2604 if (!flp->fl4_src)
2605 flp->fl4_src = (*rp)->rt_src;
2606 if (!flp->fl4_dst)
2607 flp->fl4_dst = (*rp)->rt_dst;
2608 return xfrm_lookup((struct dst_entry **)rp, flp, sk, flags);
2609 }
2610
2611 return 0;
2612 }
2613
2614 int ip_route_output_key(struct rtable **rp, struct flowi *flp)
2615 {
2616 return ip_route_output_flow(rp, flp, NULL, 0);
2617 }
2618
2619 static int rt_fill_info(struct sk_buff *skb, u32 pid, u32 seq, int event,
2620 int nowait, unsigned int flags)
2621 {
2622 struct rtable *rt = (struct rtable*)skb->dst;
2623 struct rtmsg *r;
2624 struct nlmsghdr *nlh;
2625 unsigned char *b = skb->tail;
2626 struct rta_cacheinfo ci;
2627 #ifdef CONFIG_IP_MROUTE
2628 struct rtattr *eptr;
2629 #endif
2630 nlh = NLMSG_NEW(skb, pid, seq, event, sizeof(*r), flags);
2631 r = NLMSG_DATA(nlh);
2632 r->rtm_family = AF_INET;
2633 r->rtm_dst_len = 32;
2634 r->rtm_src_len = 0;
2635 r->rtm_tos = rt->fl.fl4_tos;
2636 r->rtm_table = RT_TABLE_MAIN;
2637 r->rtm_type = rt->rt_type;
2638 r->rtm_scope = RT_SCOPE_UNIVERSE;
2639 r->rtm_protocol = RTPROT_UNSPEC;
2640 r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
2641 if (rt->rt_flags & RTCF_NOTIFY)
2642 r->rtm_flags |= RTM_F_NOTIFY;
2643 RTA_PUT(skb, RTA_DST, 4, &rt->rt_dst);
2644 if (rt->fl.fl4_src) {
2645 r->rtm_src_len = 32;
2646 RTA_PUT(skb, RTA_SRC, 4, &rt->fl.fl4_src);
2647 }
2648 if (rt->u.dst.dev)
2649 RTA_PUT(skb, RTA_OIF, sizeof(int), &rt->u.dst.dev->ifindex);
2650 #ifdef CONFIG_NET_CLS_ROUTE
2651 if (rt->u.dst.tclassid)
2652 RTA_PUT(skb, RTA_FLOW, 4, &rt->u.dst.tclassid);
2653 #endif
2654 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
2655 if (rt->rt_multipath_alg != IP_MP_ALG_NONE) {
2656 __u32 alg = rt->rt_multipath_alg;
2657
2658 RTA_PUT(skb, RTA_MP_ALGO, 4, &alg);
2659 }
2660 #endif
2661 if (rt->fl.iif)
2662 RTA_PUT(skb, RTA_PREFSRC, 4, &rt->rt_spec_dst);
2663 else if (rt->rt_src != rt->fl.fl4_src)
2664 RTA_PUT(skb, RTA_PREFSRC, 4, &rt->rt_src);
2665 if (rt->rt_dst != rt->rt_gateway)
2666 RTA_PUT(skb, RTA_GATEWAY, 4, &rt->rt_gateway);
2667 if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0)
2668 goto rtattr_failure;
2669 ci.rta_lastuse = jiffies_to_clock_t(jiffies - rt->u.dst.lastuse);
2670 ci.rta_used = rt->u.dst.__use;
2671 ci.rta_clntref = atomic_read(&rt->u.dst.__refcnt);
2672 if (rt->u.dst.expires)
2673 ci.rta_expires = jiffies_to_clock_t(rt->u.dst.expires - jiffies);
2674 else
2675 ci.rta_expires = 0;
2676 ci.rta_error = rt->u.dst.error;
2677 ci.rta_id = ci.rta_ts = ci.rta_tsage = 0;
2678 if (rt->peer) {
2679 ci.rta_id = rt->peer->ip_id_count;
2680 if (rt->peer->tcp_ts_stamp) {
2681 ci.rta_ts = rt->peer->tcp_ts;
2682 ci.rta_tsage = xtime.tv_sec - rt->peer->tcp_ts_stamp;
2683 }
2684 }
2685 #ifdef CONFIG_IP_MROUTE
2686 eptr = (struct rtattr*)skb->tail;
2687 #endif
2688 RTA_PUT(skb, RTA_CACHEINFO, sizeof(ci), &ci);
2689 if (rt->fl.iif) {
2690 #ifdef CONFIG_IP_MROUTE
2691 u32 dst = rt->rt_dst;
2692
2693 if (MULTICAST(dst) && !LOCAL_MCAST(dst) &&
2694 ipv4_devconf.mc_forwarding) {
2695 int err = ipmr_get_route(skb, r, nowait);
2696 if (err <= 0) {
2697 if (!nowait) {
2698 if (err == 0)
2699 return 0;
2700 goto nlmsg_failure;
2701 } else {
2702 if (err == -EMSGSIZE)
2703 goto nlmsg_failure;
2704 ((struct rta_cacheinfo*)RTA_DATA(eptr))->rta_error = err;
2705 }
2706 }
2707 } else
2708 #endif
2709 RTA_PUT(skb, RTA_IIF, sizeof(int), &rt->fl.iif);
2710 }
2711
2712 nlh->nlmsg_len = skb->tail - b;
2713 return skb->len;
2714
2715 nlmsg_failure:
2716 rtattr_failure:
2717 skb_trim(skb, b - skb->data);
2718 return -1;
2719 }
2720
2721 int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg)
2722 {
2723 struct rtattr **rta = arg;
2724 struct rtmsg *rtm = NLMSG_DATA(nlh);
2725 struct rtable *rt = NULL;
2726 u32 dst = 0;
2727 u32 src = 0;
2728 int iif = 0;
2729 int err = -ENOBUFS;
2730 struct sk_buff *skb;
2731
2732 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2733 if (!skb)
2734 goto out;
2735
2736 /* Reserve room for dummy headers, this skb can pass
2737 through good chunk of routing engine.
2738 */
2739 skb->mac.raw = skb->data;
2740 skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));
2741
2742 if (rta[RTA_SRC - 1])
2743 memcpy(&src, RTA_DATA(rta[RTA_SRC - 1]), 4);
2744 if (rta[RTA_DST - 1])
2745 memcpy(&dst, RTA_DATA(rta[RTA_DST - 1]), 4);
2746 if (rta[RTA_IIF - 1])
2747 memcpy(&iif, RTA_DATA(rta[RTA_IIF - 1]), sizeof(int));
2748
2749 if (iif) {
2750 struct net_device *dev = __dev_get_by_index(iif);
2751 err = -ENODEV;
2752 if (!dev)
2753 goto out_free;
2754 skb->protocol = htons(ETH_P_IP);
2755 skb->dev = dev;
2756 local_bh_disable();
2757 err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
2758 local_bh_enable();
2759 rt = (struct rtable*)skb->dst;
2760 if (!err && rt->u.dst.error)
2761 err = -rt->u.dst.error;
2762 } else {
2763 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = dst,
2764 .saddr = src,
2765 .tos = rtm->rtm_tos } } };
2766 int oif = 0;
2767 if (rta[RTA_OIF - 1])
2768 memcpy(&oif, RTA_DATA(rta[RTA_OIF - 1]), sizeof(int));
2769 fl.oif = oif;
2770 err = ip_route_output_key(&rt, &fl);
2771 }
2772 if (err)
2773 goto out_free;
2774
2775 skb->dst = &rt->u.dst;
2776 if (rtm->rtm_flags & RTM_F_NOTIFY)
2777 rt->rt_flags |= RTCF_NOTIFY;
2778
2779 NETLINK_CB(skb).dst_pid = NETLINK_CB(in_skb).pid;
2780
2781 err = rt_fill_info(skb, NETLINK_CB(in_skb).pid, nlh->nlmsg_seq,
2782 RTM_NEWROUTE, 0, 0);
2783 if (!err)
2784 goto out_free;
2785 if (err < 0) {
2786 err = -EMSGSIZE;
2787 goto out_free;
2788 }
2789
2790 err = netlink_unicast(rtnl, skb, NETLINK_CB(in_skb).pid, MSG_DONTWAIT);
2791 if (err > 0)
2792 err = 0;
2793 out: return err;
2794
2795 out_free:
2796 kfree_skb(skb);
2797 goto out;
2798 }
2799
2800 int ip_rt_dump(struct sk_buff *skb, struct netlink_callback *cb)
2801 {
2802 struct rtable *rt;
2803 int h, s_h;
2804 int idx, s_idx;
2805
2806 s_h = cb->args[0];
2807 s_idx = idx = cb->args[1];
2808 for (h = 0; h <= rt_hash_mask; h++) {
2809 if (h < s_h) continue;
2810 if (h > s_h)
2811 s_idx = 0;
2812 rcu_read_lock_bh();
2813 for (rt = rcu_dereference(rt_hash_table[h].chain), idx = 0; rt;
2814 rt = rcu_dereference(rt->u.rt_next), idx++) {
2815 if (idx < s_idx)
2816 continue;
2817 skb->dst = dst_clone(&rt->u.dst);
2818 if (rt_fill_info(skb, NETLINK_CB(cb->skb).pid,
2819 cb->nlh->nlmsg_seq, RTM_NEWROUTE,
2820 1, NLM_F_MULTI) <= 0) {
2821 dst_release(xchg(&skb->dst, NULL));
2822 rcu_read_unlock_bh();
2823 goto done;
2824 }
2825 dst_release(xchg(&skb->dst, NULL));
2826 }
2827 rcu_read_unlock_bh();
2828 }
2829
2830 done:
2831 cb->args[0] = h;
2832 cb->args[1] = idx;
2833 return skb->len;
2834 }
2835
2836 void ip_rt_multicast_event(struct in_device *in_dev)
2837 {
2838 rt_cache_flush(0);
2839 }
2840
2841 #ifdef CONFIG_SYSCTL
2842 static int flush_delay;
2843
2844 static int ipv4_sysctl_rtcache_flush(ctl_table *ctl, int write,
2845 struct file *filp, void __user *buffer,
2846 size_t *lenp, loff_t *ppos)
2847 {
2848 if (write) {
2849 proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
2850 rt_cache_flush(flush_delay);
2851 return 0;
2852 }
2853
2854 return -EINVAL;
2855 }
2856
2857 static int ipv4_sysctl_rtcache_flush_strategy(ctl_table *table,
2858 int __user *name,
2859 int nlen,
2860 void __user *oldval,
2861 size_t __user *oldlenp,
2862 void __user *newval,
2863 size_t newlen,
2864 void **context)
2865 {
2866 int delay;
2867 if (newlen != sizeof(int))
2868 return -EINVAL;
2869 if (get_user(delay, (int __user *)newval))
2870 return -EFAULT;
2871 rt_cache_flush(delay);
2872 return 0;
2873 }
2874
2875 ctl_table ipv4_route_table[] = {
2876 {
2877 .ctl_name = NET_IPV4_ROUTE_FLUSH,
2878 .procname = "flush",
2879 .data = &flush_delay,
2880 .maxlen = sizeof(int),
2881 .mode = 0200,
2882 .proc_handler = &ipv4_sysctl_rtcache_flush,
2883 .strategy = &ipv4_sysctl_rtcache_flush_strategy,
2884 },
2885 {
2886 .ctl_name = NET_IPV4_ROUTE_MIN_DELAY,
2887 .procname = "min_delay",
2888 .data = &ip_rt_min_delay,
2889 .maxlen = sizeof(int),
2890 .mode = 0644,
2891 .proc_handler = &proc_dointvec_jiffies,
2892 .strategy = &sysctl_jiffies,
2893 },
2894 {
2895 .ctl_name = NET_IPV4_ROUTE_MAX_DELAY,
2896 .procname = "max_delay",
2897 .data = &ip_rt_max_delay,
2898 .maxlen = sizeof(int),
2899 .mode = 0644,
2900 .proc_handler = &proc_dointvec_jiffies,
2901 .strategy = &sysctl_jiffies,
2902 },
2903 {
2904 .ctl_name = NET_IPV4_ROUTE_GC_THRESH,
2905 .procname = "gc_thresh",
2906 .data = &ipv4_dst_ops.gc_thresh,
2907 .maxlen = sizeof(int),
2908 .mode = 0644,
2909 .proc_handler = &proc_dointvec,
2910 },
2911 {
2912 .ctl_name = NET_IPV4_ROUTE_MAX_SIZE,
2913 .procname = "max_size",
2914 .data = &ip_rt_max_size,
2915 .maxlen = sizeof(int),
2916 .mode = 0644,
2917 .proc_handler = &proc_dointvec,
2918 },
2919 {
2920 /* Deprecated. Use gc_min_interval_ms */
2921
2922 .ctl_name = NET_IPV4_ROUTE_GC_MIN_INTERVAL,
2923 .procname = "gc_min_interval",
2924 .data = &ip_rt_gc_min_interval,
2925 .maxlen = sizeof(int),
2926 .mode = 0644,
2927 .proc_handler = &proc_dointvec_jiffies,
2928 .strategy = &sysctl_jiffies,
2929 },
2930 {
2931 .ctl_name = NET_IPV4_ROUTE_GC_MIN_INTERVAL_MS,
2932 .procname = "gc_min_interval_ms",
2933 .data = &ip_rt_gc_min_interval,
2934 .maxlen = sizeof(int),
2935 .mode = 0644,
2936 .proc_handler = &proc_dointvec_ms_jiffies,
2937 .strategy = &sysctl_ms_jiffies,
2938 },
2939 {
2940 .ctl_name = NET_IPV4_ROUTE_GC_TIMEOUT,
2941 .procname = "gc_timeout",
2942 .data = &ip_rt_gc_timeout,
2943 .maxlen = sizeof(int),
2944 .mode = 0644,
2945 .proc_handler = &proc_dointvec_jiffies,
2946 .strategy = &sysctl_jiffies,
2947 },
2948 {
2949 .ctl_name = NET_IPV4_ROUTE_GC_INTERVAL,
2950 .procname = "gc_interval",
2951 .data = &ip_rt_gc_interval,
2952 .maxlen = sizeof(int),
2953 .mode = 0644,
2954 .proc_handler = &proc_dointvec_jiffies,
2955 .strategy = &sysctl_jiffies,
2956 },
2957 {
2958 .ctl_name = NET_IPV4_ROUTE_REDIRECT_LOAD,
2959 .procname = "redirect_load",
2960 .data = &ip_rt_redirect_load,
2961 .maxlen = sizeof(int),
2962 .mode = 0644,
2963 .proc_handler = &proc_dointvec,
2964 },
2965 {
2966 .ctl_name = NET_IPV4_ROUTE_REDIRECT_NUMBER,
2967 .procname = "redirect_number",
2968 .data = &ip_rt_redirect_number,
2969 .maxlen = sizeof(int),
2970 .mode = 0644,
2971 .proc_handler = &proc_dointvec,
2972 },
2973 {
2974 .ctl_name = NET_IPV4_ROUTE_REDIRECT_SILENCE,
2975 .procname = "redirect_silence",
2976 .data = &ip_rt_redirect_silence,
2977 .maxlen = sizeof(int),
2978 .mode = 0644,
2979 .proc_handler = &proc_dointvec,
2980 },
2981 {
2982 .ctl_name = NET_IPV4_ROUTE_ERROR_COST,
2983 .procname = "error_cost",
2984 .data = &ip_rt_error_cost,
2985 .maxlen = sizeof(int),
2986 .mode = 0644,
2987 .proc_handler = &proc_dointvec,
2988 },
2989 {
2990 .ctl_name = NET_IPV4_ROUTE_ERROR_BURST,
2991 .procname = "error_burst",
2992 .data = &ip_rt_error_burst,
2993 .maxlen = sizeof(int),
2994 .mode = 0644,
2995 .proc_handler = &proc_dointvec,
2996 },
2997 {
2998 .ctl_name = NET_IPV4_ROUTE_GC_ELASTICITY,
2999 .procname = "gc_elasticity",
3000 .data = &ip_rt_gc_elasticity,
3001 .maxlen = sizeof(int),
3002 .mode = 0644,
3003 .proc_handler = &proc_dointvec,
3004 },
3005 {
3006 .ctl_name = NET_IPV4_ROUTE_MTU_EXPIRES,
3007 .procname = "mtu_expires",
3008 .data = &ip_rt_mtu_expires,
3009 .maxlen = sizeof(int),
3010 .mode = 0644,
3011 .proc_handler = &proc_dointvec_jiffies,
3012 .strategy = &sysctl_jiffies,
3013 },
3014 {
3015 .ctl_name = NET_IPV4_ROUTE_MIN_PMTU,
3016 .procname = "min_pmtu",
3017 .data = &ip_rt_min_pmtu,
3018 .maxlen = sizeof(int),
3019 .mode = 0644,
3020 .proc_handler = &proc_dointvec,
3021 },
3022 {
3023 .ctl_name = NET_IPV4_ROUTE_MIN_ADVMSS,
3024 .procname = "min_adv_mss",
3025 .data = &ip_rt_min_advmss,
3026 .maxlen = sizeof(int),
3027 .mode = 0644,
3028 .proc_handler = &proc_dointvec,
3029 },
3030 {
3031 .ctl_name = NET_IPV4_ROUTE_SECRET_INTERVAL,
3032 .procname = "secret_interval",
3033 .data = &ip_rt_secret_interval,
3034 .maxlen = sizeof(int),
3035 .mode = 0644,
3036 .proc_handler = &proc_dointvec_jiffies,
3037 .strategy = &sysctl_jiffies,
3038 },
3039 { .ctl_name = 0 }
3040 };
3041 #endif
3042
3043 #ifdef CONFIG_NET_CLS_ROUTE
3044 struct ip_rt_acct *ip_rt_acct;
3045
3046 /* This code sucks. But you should have seen it before! --RR */
3047
3048 /* IP route accounting ptr for this logical cpu number. */
3049 #define IP_RT_ACCT_CPU(i) (ip_rt_acct + i * 256)
3050
3051 #ifdef CONFIG_PROC_FS
3052 static int ip_rt_acct_read(char *buffer, char **start, off_t offset,
3053 int length, int *eof, void *data)
3054 {
3055 unsigned int i;
3056
3057 if ((offset & 3) || (length & 3))
3058 return -EIO;
3059
3060 if (offset >= sizeof(struct ip_rt_acct) * 256) {
3061 *eof = 1;
3062 return 0;
3063 }
3064
3065 if (offset + length >= sizeof(struct ip_rt_acct) * 256) {
3066 length = sizeof(struct ip_rt_acct) * 256 - offset;
3067 *eof = 1;
3068 }
3069
3070 offset /= sizeof(u32);
3071
3072 if (length > 0) {
3073 u32 *src = ((u32 *) IP_RT_ACCT_CPU(0)) + offset;
3074 u32 *dst = (u32 *) buffer;
3075
3076 /* Copy first cpu. */
3077 *start = buffer;
3078 memcpy(dst, src, length);
3079
3080 /* Add the other cpus in, one int at a time */
3081 for_each_cpu(i) {
3082 unsigned int j;
3083
3084 src = ((u32 *) IP_RT_ACCT_CPU(i)) + offset;
3085
3086 for (j = 0; j < length/4; j++)
3087 dst[j] += src[j];
3088 }
3089 }
3090 return length;
3091 }
3092 #endif /* CONFIG_PROC_FS */
3093 #endif /* CONFIG_NET_CLS_ROUTE */
3094
3095 static __initdata unsigned long rhash_entries;
3096 static int __init set_rhash_entries(char *str)
3097 {
3098 if (!str)
3099 return 0;
3100 rhash_entries = simple_strtoul(str, &str, 0);
3101 return 1;
3102 }
3103 __setup("rhash_entries=", set_rhash_entries);
3104
3105 int __init ip_rt_init(void)
3106 {
3107 int rc = 0;
3108
3109 rt_hash_rnd = (int) ((num_physpages ^ (num_physpages>>8)) ^
3110 (jiffies ^ (jiffies >> 7)));
3111
3112 #ifdef CONFIG_NET_CLS_ROUTE
3113 {
3114 int order;
3115 for (order = 0;
3116 (PAGE_SIZE << order) < 256 * sizeof(struct ip_rt_acct) * NR_CPUS; order++)
3117 /* NOTHING */;
3118 ip_rt_acct = (struct ip_rt_acct *)__get_free_pages(GFP_KERNEL, order);
3119 if (!ip_rt_acct)
3120 panic("IP: failed to allocate ip_rt_acct\n");
3121 memset(ip_rt_acct, 0, PAGE_SIZE << order);
3122 }
3123 #endif
3124
3125 ipv4_dst_ops.kmem_cachep = kmem_cache_create("ip_dst_cache",
3126 sizeof(struct rtable),
3127 0, SLAB_HWCACHE_ALIGN,
3128 NULL, NULL);
3129
3130 if (!ipv4_dst_ops.kmem_cachep)
3131 panic("IP: failed to allocate ip_dst_cache\n");
3132
3133 rt_hash_table = (struct rt_hash_bucket *)
3134 alloc_large_system_hash("IP route cache",
3135 sizeof(struct rt_hash_bucket),
3136 rhash_entries,
3137 (num_physpages >= 128 * 1024) ?
3138 (27 - PAGE_SHIFT) :
3139 (29 - PAGE_SHIFT),
3140 HASH_HIGHMEM,
3141 &rt_hash_log,
3142 &rt_hash_mask,
3143 0);
3144 memset(rt_hash_table, 0, (rt_hash_mask + 1) * sizeof(struct rt_hash_bucket));
3145 rt_hash_lock_init();
3146
3147 ipv4_dst_ops.gc_thresh = (rt_hash_mask + 1);
3148 ip_rt_max_size = (rt_hash_mask + 1) * 16;
3149
3150 rt_cache_stat = alloc_percpu(struct rt_cache_stat);
3151 if (!rt_cache_stat)
3152 return -ENOMEM;
3153
3154 devinet_init();
3155 ip_fib_init();
3156
3157 init_timer(&rt_flush_timer);
3158 rt_flush_timer.function = rt_run_flush;
3159 init_timer(&rt_periodic_timer);
3160 rt_periodic_timer.function = rt_check_expire;
3161 init_timer(&rt_secret_timer);
3162 rt_secret_timer.function = rt_secret_rebuild;
3163
3164 /* All the timers, started at system startup tend
3165 to synchronize. Perturb it a bit.
3166 */
3167 rt_periodic_timer.expires = jiffies + net_random() % ip_rt_gc_interval +
3168 ip_rt_gc_interval;
3169 add_timer(&rt_periodic_timer);
3170
3171 rt_secret_timer.expires = jiffies + net_random() % ip_rt_secret_interval +
3172 ip_rt_secret_interval;
3173 add_timer(&rt_secret_timer);
3174
3175 #ifdef CONFIG_PROC_FS
3176 {
3177 struct proc_dir_entry *rtstat_pde = NULL; /* keep gcc happy */
3178 if (!proc_net_fops_create("rt_cache", S_IRUGO, &rt_cache_seq_fops) ||
3179 !(rtstat_pde = create_proc_entry("rt_cache", S_IRUGO,
3180 proc_net_stat))) {
3181 free_percpu(rt_cache_stat);
3182 return -ENOMEM;
3183 }
3184 rtstat_pde->proc_fops = &rt_cpu_seq_fops;
3185 }
3186 #ifdef CONFIG_NET_CLS_ROUTE
3187 create_proc_read_entry("rt_acct", 0, proc_net, ip_rt_acct_read, NULL);
3188 #endif
3189 #endif
3190 #ifdef CONFIG_XFRM
3191 xfrm_init();
3192 xfrm4_init();
3193 #endif
3194 return rc;
3195 }
3196
3197 EXPORT_SYMBOL(__ip_select_ident);
3198 EXPORT_SYMBOL(ip_route_input);
3199 EXPORT_SYMBOL(ip_route_output_key);
SocketAccessConTroL development