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