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