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