?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
inet: restore gso for vxlan
[linux-2.6/btrfs-unstable.git] / net / ipv4 / route.c
blobd2d325382b13f4343d70974c327af3527ef1fcae
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 #define pr_fmt(fmt) "IPv4: " fmt
66
67 #include <linux/module.h>
68 #include <asm/uaccess.h>
69 #include <linux/bitops.h>
70 #include <linux/types.h>
71 #include <linux/kernel.h>
72 #include <linux/mm.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/skbuff.h>
83 #include <linux/inetdevice.h>
84 #include <linux/igmp.h>
85 #include <linux/pkt_sched.h>
86 #include <linux/mroute.h>
87 #include <linux/netfilter_ipv4.h>
88 #include <linux/random.h>
89 #include <linux/rcupdate.h>
90 #include <linux/times.h>
91 #include <linux/slab.h>
92 #include <net/dst.h>
93 #include <net/net_namespace.h>
94 #include <net/protocol.h>
95 #include <net/ip.h>
96 #include <net/route.h>
97 #include <net/inetpeer.h>
98 #include <net/sock.h>
99 #include <net/ip_fib.h>
100 #include <net/arp.h>
101 #include <net/tcp.h>
102 #include <net/icmp.h>
103 #include <net/xfrm.h>
104 #include <net/netevent.h>
105 #include <net/rtnetlink.h>
106 #ifdef CONFIG_SYSCTL
107 #include <linux/sysctl.h>
108 #include <linux/kmemleak.h>
109 #endif
110 #include <net/secure_seq.h>
111
112 #define RT_FL_TOS(oldflp4) \
113 ((oldflp4)->flowi4_tos & (IPTOS_RT_MASK | RTO_ONLINK))
114
115 /* IPv4 datagram length is stored into 16bit field (tot_len) */
116 #define IP_MAX_MTU 0xFFFF
117
118 #define RT_GC_TIMEOUT (300*HZ)
119
120 static int ip_rt_max_size;
121 static int ip_rt_redirect_number __read_mostly = 9;
122 static int ip_rt_redirect_load __read_mostly = HZ / 50;
123 static int ip_rt_redirect_silence __read_mostly = ((HZ / 50) << (9 + 1));
124 static int ip_rt_error_cost __read_mostly = HZ;
125 static int ip_rt_error_burst __read_mostly = 5 * HZ;
126 static int ip_rt_mtu_expires __read_mostly = 10 * 60 * HZ;
127 static int ip_rt_min_pmtu __read_mostly = 512 + 20 + 20;
128 static int ip_rt_min_advmss __read_mostly = 256;
129
130 /*
131 * Interface to generic destination cache.
132 */
133
134 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
135 static unsigned int ipv4_default_advmss(const struct dst_entry *dst);
136 static unsigned int ipv4_mtu(const struct dst_entry *dst);
137 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
138 static void ipv4_link_failure(struct sk_buff *skb);
139 static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
140 struct sk_buff *skb, u32 mtu);
141 static void ip_do_redirect(struct dst_entry *dst, struct sock *sk,
142 struct sk_buff *skb);
143 static void ipv4_dst_destroy(struct dst_entry *dst);
144
145 static void ipv4_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
146 int how)
147 {
148 }
149
150 static u32 *ipv4_cow_metrics(struct dst_entry *dst, unsigned long old)
151 {
152 WARN_ON(1);
153 return NULL;
154 }
155
156 static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
157 struct sk_buff *skb,
158 const void *daddr);
159
160 static struct dst_ops ipv4_dst_ops = {
161 .family = AF_INET,
162 .protocol = cpu_to_be16(ETH_P_IP),
163 .check = ipv4_dst_check,
164 .default_advmss = ipv4_default_advmss,
165 .mtu = ipv4_mtu,
166 .cow_metrics = ipv4_cow_metrics,
167 .destroy = ipv4_dst_destroy,
168 .ifdown = ipv4_dst_ifdown,
169 .negative_advice = ipv4_negative_advice,
170 .link_failure = ipv4_link_failure,
171 .update_pmtu = ip_rt_update_pmtu,
172 .redirect = ip_do_redirect,
173 .local_out = __ip_local_out,
174 .neigh_lookup = ipv4_neigh_lookup,
175 };
176
177 #define ECN_OR_COST(class) TC_PRIO_##class
178
179 const __u8 ip_tos2prio[16] = {
180 TC_PRIO_BESTEFFORT,
181 ECN_OR_COST(BESTEFFORT),
182 TC_PRIO_BESTEFFORT,
183 ECN_OR_COST(BESTEFFORT),
184 TC_PRIO_BULK,
185 ECN_OR_COST(BULK),
186 TC_PRIO_BULK,
187 ECN_OR_COST(BULK),
188 TC_PRIO_INTERACTIVE,
189 ECN_OR_COST(INTERACTIVE),
190 TC_PRIO_INTERACTIVE,
191 ECN_OR_COST(INTERACTIVE),
192 TC_PRIO_INTERACTIVE_BULK,
193 ECN_OR_COST(INTERACTIVE_BULK),
194 TC_PRIO_INTERACTIVE_BULK,
195 ECN_OR_COST(INTERACTIVE_BULK)
196 };
197 EXPORT_SYMBOL(ip_tos2prio);
198
199 static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
200 #define RT_CACHE_STAT_INC(field) __this_cpu_inc(rt_cache_stat.field)
201
202 #ifdef CONFIG_PROC_FS
203 static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
204 {
205 if (*pos)
206 return NULL;
207 return SEQ_START_TOKEN;
208 }
209
210 static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
211 {
212 ++*pos;
213 return NULL;
214 }
215
216 static void rt_cache_seq_stop(struct seq_file *seq, void *v)
217 {
218 }
219
220 static int rt_cache_seq_show(struct seq_file *seq, void *v)
221 {
222 if (v == SEQ_START_TOKEN)
223 seq_printf(seq, "%-127s\n",
224 "Iface\tDestination\tGateway \tFlags\t\tRefCnt\tUse\t"
225 "Metric\tSource\t\tMTU\tWindow\tIRTT\tTOS\tHHRef\t"
226 "HHUptod\tSpecDst");
227 return 0;
228 }
229
230 static const struct seq_operations rt_cache_seq_ops = {
231 .start = rt_cache_seq_start,
232 .next = rt_cache_seq_next,
233 .stop = rt_cache_seq_stop,
234 .show = rt_cache_seq_show,
235 };
236
237 static int rt_cache_seq_open(struct inode *inode, struct file *file)
238 {
239 return seq_open(file, &rt_cache_seq_ops);
240 }
241
242 static const struct file_operations rt_cache_seq_fops = {
243 .owner = THIS_MODULE,
244 .open = rt_cache_seq_open,
245 .read = seq_read,
246 .llseek = seq_lseek,
247 .release = seq_release,
248 };
249
250
251 static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
252 {
253 int cpu;
254
255 if (*pos == 0)
256 return SEQ_START_TOKEN;
257
258 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
259 if (!cpu_possible(cpu))
260 continue;
261 *pos = cpu+1;
262 return &per_cpu(rt_cache_stat, cpu);
263 }
264 return NULL;
265 }
266
267 static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
268 {
269 int cpu;
270
271 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
272 if (!cpu_possible(cpu))
273 continue;
274 *pos = cpu+1;
275 return &per_cpu(rt_cache_stat, cpu);
276 }
277 return NULL;
278
279 }
280
281 static void rt_cpu_seq_stop(struct seq_file *seq, void *v)
282 {
283
284 }
285
286 static int rt_cpu_seq_show(struct seq_file *seq, void *v)
287 {
288 struct rt_cache_stat *st = v;
289
290 if (v == SEQ_START_TOKEN) {
291 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");
292 return 0;
293 }
294
295 seq_printf(seq,"%08x %08x %08x %08x %08x %08x %08x %08x "
296 " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
297 dst_entries_get_slow(&ipv4_dst_ops),
298 0, /* st->in_hit */
299 st->in_slow_tot,
300 st->in_slow_mc,
301 st->in_no_route,
302 st->in_brd,
303 st->in_martian_dst,
304 st->in_martian_src,
305
306 0, /* st->out_hit */
307 st->out_slow_tot,
308 st->out_slow_mc,
309
310 0, /* st->gc_total */
311 0, /* st->gc_ignored */
312 0, /* st->gc_goal_miss */
313 0, /* st->gc_dst_overflow */
314 0, /* st->in_hlist_search */
315 0 /* st->out_hlist_search */
316 );
317 return 0;
318 }
319
320 static const struct seq_operations rt_cpu_seq_ops = {
321 .start = rt_cpu_seq_start,
322 .next = rt_cpu_seq_next,
323 .stop = rt_cpu_seq_stop,
324 .show = rt_cpu_seq_show,
325 };
326
327
328 static int rt_cpu_seq_open(struct inode *inode, struct file *file)
329 {
330 return seq_open(file, &rt_cpu_seq_ops);
331 }
332
333 static const struct file_operations rt_cpu_seq_fops = {
334 .owner = THIS_MODULE,
335 .open = rt_cpu_seq_open,
336 .read = seq_read,
337 .llseek = seq_lseek,
338 .release = seq_release,
339 };
340
341 #ifdef CONFIG_IP_ROUTE_CLASSID
342 static int rt_acct_proc_show(struct seq_file *m, void *v)
343 {
344 struct ip_rt_acct *dst, *src;
345 unsigned int i, j;
346
347 dst = kcalloc(256, sizeof(struct ip_rt_acct), GFP_KERNEL);
348 if (!dst)
349 return -ENOMEM;
350
351 for_each_possible_cpu(i) {
352 src = (struct ip_rt_acct *)per_cpu_ptr(ip_rt_acct, i);
353 for (j = 0; j < 256; j++) {
354 dst[j].o_bytes += src[j].o_bytes;
355 dst[j].o_packets += src[j].o_packets;
356 dst[j].i_bytes += src[j].i_bytes;
357 dst[j].i_packets += src[j].i_packets;
358 }
359 }
360
361 seq_write(m, dst, 256 * sizeof(struct ip_rt_acct));
362 kfree(dst);
363 return 0;
364 }
365
366 static int rt_acct_proc_open(struct inode *inode, struct file *file)
367 {
368 return single_open(file, rt_acct_proc_show, NULL);
369 }
370
371 static const struct file_operations rt_acct_proc_fops = {
372 .owner = THIS_MODULE,
373 .open = rt_acct_proc_open,
374 .read = seq_read,
375 .llseek = seq_lseek,
376 .release = single_release,
377 };
378 #endif
379
380 static int __net_init ip_rt_do_proc_init(struct net *net)
381 {
382 struct proc_dir_entry *pde;
383
384 pde = proc_create("rt_cache", S_IRUGO, net->proc_net,
385 &rt_cache_seq_fops);
386 if (!pde)
387 goto err1;
388
389 pde = proc_create("rt_cache", S_IRUGO,
390 net->proc_net_stat, &rt_cpu_seq_fops);
391 if (!pde)
392 goto err2;
393
394 #ifdef CONFIG_IP_ROUTE_CLASSID
395 pde = proc_create("rt_acct", 0, net->proc_net, &rt_acct_proc_fops);
396 if (!pde)
397 goto err3;
398 #endif
399 return 0;
400
401 #ifdef CONFIG_IP_ROUTE_CLASSID
402 err3:
403 remove_proc_entry("rt_cache", net->proc_net_stat);
404 #endif
405 err2:
406 remove_proc_entry("rt_cache", net->proc_net);
407 err1:
408 return -ENOMEM;
409 }
410
411 static void __net_exit ip_rt_do_proc_exit(struct net *net)
412 {
413 remove_proc_entry("rt_cache", net->proc_net_stat);
414 remove_proc_entry("rt_cache", net->proc_net);
415 #ifdef CONFIG_IP_ROUTE_CLASSID
416 remove_proc_entry("rt_acct", net->proc_net);
417 #endif
418 }
419
420 static struct pernet_operations ip_rt_proc_ops __net_initdata = {
421 .init = ip_rt_do_proc_init,
422 .exit = ip_rt_do_proc_exit,
423 };
424
425 static int __init ip_rt_proc_init(void)
426 {
427 return register_pernet_subsys(&ip_rt_proc_ops);
428 }
429
430 #else
431 static inline int ip_rt_proc_init(void)
432 {
433 return 0;
434 }
435 #endif /* CONFIG_PROC_FS */
436
437 static inline bool rt_is_expired(const struct rtable *rth)
438 {
439 return rth->rt_genid != rt_genid_ipv4(dev_net(rth->dst.dev));
440 }
441
442 void rt_cache_flush(struct net *net)
443 {
444 rt_genid_bump_ipv4(net);
445 }
446
447 static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
448 struct sk_buff *skb,
449 const void *daddr)
450 {
451 struct net_device *dev = dst->dev;
452 const __be32 *pkey = daddr;
453 const struct rtable *rt;
454 struct neighbour *n;
455
456 rt = (const struct rtable *) dst;
457 if (rt->rt_gateway)
458 pkey = (const __be32 *) &rt->rt_gateway;
459 else if (skb)
460 pkey = &ip_hdr(skb)->daddr;
461
462 n = __ipv4_neigh_lookup(dev, *(__force u32 *)pkey);
463 if (n)
464 return n;
465 return neigh_create(&arp_tbl, pkey, dev);
466 }
467
468 /*
469 * Peer allocation may fail only in serious out-of-memory conditions. However
470 * we still can generate some output.
471 * Random ID selection looks a bit dangerous because we have no chances to
472 * select ID being unique in a reasonable period of time.
473 * But broken packet identifier may be better than no packet at all.
474 */
475 static void ip_select_fb_ident(struct iphdr *iph)
476 {
477 static DEFINE_SPINLOCK(ip_fb_id_lock);
478 static u32 ip_fallback_id;
479 u32 salt;
480
481 spin_lock_bh(&ip_fb_id_lock);
482 salt = secure_ip_id((__force __be32)ip_fallback_id ^ iph->daddr);
483 iph->id = htons(salt & 0xFFFF);
484 ip_fallback_id = salt;
485 spin_unlock_bh(&ip_fb_id_lock);
486 }
487
488 void __ip_select_ident(struct iphdr *iph, struct dst_entry *dst, int more)
489 {
490 struct net *net = dev_net(dst->dev);
491 struct inet_peer *peer;
492
493 peer = inet_getpeer_v4(net->ipv4.peers, iph->daddr, 1);
494 if (peer) {
495 iph->id = htons(inet_getid(peer, more));
496 inet_putpeer(peer);
497 return;
498 }
499
500 ip_select_fb_ident(iph);
501 }
502 EXPORT_SYMBOL(__ip_select_ident);
503
504 static void __build_flow_key(struct flowi4 *fl4, const struct sock *sk,
505 const struct iphdr *iph,
506 int oif, u8 tos,
507 u8 prot, u32 mark, int flow_flags)
508 {
509 if (sk) {
510 const struct inet_sock *inet = inet_sk(sk);
511
512 oif = sk->sk_bound_dev_if;
513 mark = sk->sk_mark;
514 tos = RT_CONN_FLAGS(sk);
515 prot = inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol;
516 }
517 flowi4_init_output(fl4, oif, mark, tos,
518 RT_SCOPE_UNIVERSE, prot,
519 flow_flags,
520 iph->daddr, iph->saddr, 0, 0);
521 }
522
523 static void build_skb_flow_key(struct flowi4 *fl4, const struct sk_buff *skb,
524 const struct sock *sk)
525 {
526 const struct iphdr *iph = ip_hdr(skb);
527 int oif = skb->dev->ifindex;
528 u8 tos = RT_TOS(iph->tos);
529 u8 prot = iph->protocol;
530 u32 mark = skb->mark;
531
532 __build_flow_key(fl4, sk, iph, oif, tos, prot, mark, 0);
533 }
534
535 static void build_sk_flow_key(struct flowi4 *fl4, const struct sock *sk)
536 {
537 const struct inet_sock *inet = inet_sk(sk);
538 const struct ip_options_rcu *inet_opt;
539 __be32 daddr = inet->inet_daddr;
540
541 rcu_read_lock();
542 inet_opt = rcu_dereference(inet->inet_opt);
543 if (inet_opt && inet_opt->opt.srr)
544 daddr = inet_opt->opt.faddr;
545 flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
546 RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
547 inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol,
548 inet_sk_flowi_flags(sk),
549 daddr, inet->inet_saddr, 0, 0);
550 rcu_read_unlock();
551 }
552
553 static void ip_rt_build_flow_key(struct flowi4 *fl4, const struct sock *sk,
554 const struct sk_buff *skb)
555 {
556 if (skb)
557 build_skb_flow_key(fl4, skb, sk);
558 else
559 build_sk_flow_key(fl4, sk);
560 }
561
562 static inline void rt_free(struct rtable *rt)
563 {
564 call_rcu(&rt->dst.rcu_head, dst_rcu_free);
565 }
566
567 static DEFINE_SPINLOCK(fnhe_lock);
568
569 static void fnhe_flush_routes(struct fib_nh_exception *fnhe)
570 {
571 struct rtable *rt;
572
573 rt = rcu_dereference(fnhe->fnhe_rth_input);
574 if (rt) {
575 RCU_INIT_POINTER(fnhe->fnhe_rth_input, NULL);
576 rt_free(rt);
577 }
578 rt = rcu_dereference(fnhe->fnhe_rth_output);
579 if (rt) {
580 RCU_INIT_POINTER(fnhe->fnhe_rth_output, NULL);
581 rt_free(rt);
582 }
583 }
584
585 static struct fib_nh_exception *fnhe_oldest(struct fnhe_hash_bucket *hash)
586 {
587 struct fib_nh_exception *fnhe, *oldest;
588
589 oldest = rcu_dereference(hash->chain);
590 for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe;
591 fnhe = rcu_dereference(fnhe->fnhe_next)) {
592 if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp))
593 oldest = fnhe;
594 }
595 fnhe_flush_routes(oldest);
596 return oldest;
597 }
598
599 static inline u32 fnhe_hashfun(__be32 daddr)
600 {
601 u32 hval;
602
603 hval = (__force u32) daddr;
604 hval ^= (hval >> 11) ^ (hval >> 22);
605
606 return hval & (FNHE_HASH_SIZE - 1);
607 }
608
609 static void fill_route_from_fnhe(struct rtable *rt, struct fib_nh_exception *fnhe)
610 {
611 rt->rt_pmtu = fnhe->fnhe_pmtu;
612 rt->dst.expires = fnhe->fnhe_expires;
613
614 if (fnhe->fnhe_gw) {
615 rt->rt_flags |= RTCF_REDIRECTED;
616 rt->rt_gateway = fnhe->fnhe_gw;
617 rt->rt_uses_gateway = 1;
618 }
619 }
620
621 static void update_or_create_fnhe(struct fib_nh *nh, __be32 daddr, __be32 gw,
622 u32 pmtu, unsigned long expires)
623 {
624 struct fnhe_hash_bucket *hash;
625 struct fib_nh_exception *fnhe;
626 struct rtable *rt;
627 unsigned int i;
628 int depth;
629 u32 hval = fnhe_hashfun(daddr);
630
631 spin_lock_bh(&fnhe_lock);
632
633 hash = nh->nh_exceptions;
634 if (!hash) {
635 hash = kzalloc(FNHE_HASH_SIZE * sizeof(*hash), GFP_ATOMIC);
636 if (!hash)
637 goto out_unlock;
638 nh->nh_exceptions = hash;
639 }
640
641 hash += hval;
642
643 depth = 0;
644 for (fnhe = rcu_dereference(hash->chain); fnhe;
645 fnhe = rcu_dereference(fnhe->fnhe_next)) {
646 if (fnhe->fnhe_daddr == daddr)
647 break;
648 depth++;
649 }
650
651 if (fnhe) {
652 if (gw)
653 fnhe->fnhe_gw = gw;
654 if (pmtu) {
655 fnhe->fnhe_pmtu = pmtu;
656 fnhe->fnhe_expires = max(1UL, expires);
657 }
658 /* Update all cached dsts too */
659 rt = rcu_dereference(fnhe->fnhe_rth_input);
660 if (rt)
661 fill_route_from_fnhe(rt, fnhe);
662 rt = rcu_dereference(fnhe->fnhe_rth_output);
663 if (rt)
664 fill_route_from_fnhe(rt, fnhe);
665 } else {
666 if (depth > FNHE_RECLAIM_DEPTH)
667 fnhe = fnhe_oldest(hash);
668 else {
669 fnhe = kzalloc(sizeof(*fnhe), GFP_ATOMIC);
670 if (!fnhe)
671 goto out_unlock;
672
673 fnhe->fnhe_next = hash->chain;
674 rcu_assign_pointer(hash->chain, fnhe);
675 }
676 fnhe->fnhe_genid = fnhe_genid(dev_net(nh->nh_dev));
677 fnhe->fnhe_daddr = daddr;
678 fnhe->fnhe_gw = gw;
679 fnhe->fnhe_pmtu = pmtu;
680 fnhe->fnhe_expires = expires;
681
682 /* Exception created; mark the cached routes for the nexthop
683 * stale, so anyone caching it rechecks if this exception
684 * applies to them.
685 */
686 rt = rcu_dereference(nh->nh_rth_input);
687 if (rt)
688 rt->dst.obsolete = DST_OBSOLETE_KILL;
689
690 for_each_possible_cpu(i) {
691 struct rtable __rcu **prt;
692 prt = per_cpu_ptr(nh->nh_pcpu_rth_output, i);
693 rt = rcu_dereference(*prt);
694 if (rt)
695 rt->dst.obsolete = DST_OBSOLETE_KILL;
696 }
697 }
698
699 fnhe->fnhe_stamp = jiffies;
700
701 out_unlock:
702 spin_unlock_bh(&fnhe_lock);
703 return;
704 }
705
706 static void __ip_do_redirect(struct rtable *rt, struct sk_buff *skb, struct flowi4 *fl4,
707 bool kill_route)
708 {
709 __be32 new_gw = icmp_hdr(skb)->un.gateway;
710 __be32 old_gw = ip_hdr(skb)->saddr;
711 struct net_device *dev = skb->dev;
712 struct in_device *in_dev;
713 struct fib_result res;
714 struct neighbour *n;
715 struct net *net;
716
717 switch (icmp_hdr(skb)->code & 7) {
718 case ICMP_REDIR_NET:
719 case ICMP_REDIR_NETTOS:
720 case ICMP_REDIR_HOST:
721 case ICMP_REDIR_HOSTTOS:
722 break;
723
724 default:
725 return;
726 }
727
728 if (rt->rt_gateway != old_gw)
729 return;
730
731 in_dev = __in_dev_get_rcu(dev);
732 if (!in_dev)
733 return;
734
735 net = dev_net(dev);
736 if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) ||
737 ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw) ||
738 ipv4_is_zeronet(new_gw))
739 goto reject_redirect;
740
741 if (!IN_DEV_SHARED_MEDIA(in_dev)) {
742 if (!inet_addr_onlink(in_dev, new_gw, old_gw))
743 goto reject_redirect;
744 if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
745 goto reject_redirect;
746 } else {
747 if (inet_addr_type(net, new_gw) != RTN_UNICAST)
748 goto reject_redirect;
749 }
750
751 n = ipv4_neigh_lookup(&rt->dst, NULL, &new_gw);
752 if (n) {
753 if (!(n->nud_state & NUD_VALID)) {
754 neigh_event_send(n, NULL);
755 } else {
756 if (fib_lookup(net, fl4, &res) == 0) {
757 struct fib_nh *nh = &FIB_RES_NH(res);
758
759 update_or_create_fnhe(nh, fl4->daddr, new_gw,
760 0, 0);
761 }
762 if (kill_route)
763 rt->dst.obsolete = DST_OBSOLETE_KILL;
764 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, n);
765 }
766 neigh_release(n);
767 }
768 return;
769
770 reject_redirect:
771 #ifdef CONFIG_IP_ROUTE_VERBOSE
772 if (IN_DEV_LOG_MARTIANS(in_dev)) {
773 const struct iphdr *iph = (const struct iphdr *) skb->data;
774 __be32 daddr = iph->daddr;
775 __be32 saddr = iph->saddr;
776
777 net_info_ratelimited("Redirect from %pI4 on %s about %pI4 ignored\n"
778 " Advised path = %pI4 -> %pI4\n",
779 &old_gw, dev->name, &new_gw,
780 &saddr, &daddr);
781 }
782 #endif
783 ;
784 }
785
786 static void ip_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
787 {
788 struct rtable *rt;
789 struct flowi4 fl4;
790 const struct iphdr *iph = (const struct iphdr *) skb->data;
791 int oif = skb->dev->ifindex;
792 u8 tos = RT_TOS(iph->tos);
793 u8 prot = iph->protocol;
794 u32 mark = skb->mark;
795
796 rt = (struct rtable *) dst;
797
798 __build_flow_key(&fl4, sk, iph, oif, tos, prot, mark, 0);
799 __ip_do_redirect(rt, skb, &fl4, true);
800 }
801
802 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
803 {
804 struct rtable *rt = (struct rtable *)dst;
805 struct dst_entry *ret = dst;
806
807 if (rt) {
808 if (dst->obsolete > 0) {
809 ip_rt_put(rt);
810 ret = NULL;
811 } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
812 rt->dst.expires) {
813 ip_rt_put(rt);
814 ret = NULL;
815 }
816 }
817 return ret;
818 }
819
820 /*
821 * Algorithm:
822 * 1. The first ip_rt_redirect_number redirects are sent
823 * with exponential backoff, then we stop sending them at all,
824 * assuming that the host ignores our redirects.
825 * 2. If we did not see packets requiring redirects
826 * during ip_rt_redirect_silence, we assume that the host
827 * forgot redirected route and start to send redirects again.
828 *
829 * This algorithm is much cheaper and more intelligent than dumb load limiting
830 * in icmp.c.
831 *
832 * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
833 * and "frag. need" (breaks PMTU discovery) in icmp.c.
834 */
835
836 void ip_rt_send_redirect(struct sk_buff *skb)
837 {
838 struct rtable *rt = skb_rtable(skb);
839 struct in_device *in_dev;
840 struct inet_peer *peer;
841 struct net *net;
842 int log_martians;
843
844 rcu_read_lock();
845 in_dev = __in_dev_get_rcu(rt->dst.dev);
846 if (!in_dev || !IN_DEV_TX_REDIRECTS(in_dev)) {
847 rcu_read_unlock();
848 return;
849 }
850 log_martians = IN_DEV_LOG_MARTIANS(in_dev);
851 rcu_read_unlock();
852
853 net = dev_net(rt->dst.dev);
854 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, 1);
855 if (!peer) {
856 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST,
857 rt_nexthop(rt, ip_hdr(skb)->daddr));
858 return;
859 }
860
861 /* No redirected packets during ip_rt_redirect_silence;
862 * reset the algorithm.
863 */
864 if (time_after(jiffies, peer->rate_last + ip_rt_redirect_silence))
865 peer->rate_tokens = 0;
866
867 /* Too many ignored redirects; do not send anything
868 * set dst.rate_last to the last seen redirected packet.
869 */
870 if (peer->rate_tokens >= ip_rt_redirect_number) {
871 peer->rate_last = jiffies;
872 goto out_put_peer;
873 }
874
875 /* Check for load limit; set rate_last to the latest sent
876 * redirect.
877 */
878 if (peer->rate_tokens == 0 ||
879 time_after(jiffies,
880 (peer->rate_last +
881 (ip_rt_redirect_load << peer->rate_tokens)))) {
882 __be32 gw = rt_nexthop(rt, ip_hdr(skb)->daddr);
883
884 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, gw);
885 peer->rate_last = jiffies;
886 ++peer->rate_tokens;
887 #ifdef CONFIG_IP_ROUTE_VERBOSE
888 if (log_martians &&
889 peer->rate_tokens == ip_rt_redirect_number)
890 net_warn_ratelimited("host %pI4/if%d ignores redirects for %pI4 to %pI4\n",
891 &ip_hdr(skb)->saddr, inet_iif(skb),
892 &ip_hdr(skb)->daddr, &gw);
893 #endif
894 }
895 out_put_peer:
896 inet_putpeer(peer);
897 }
898
899 static int ip_error(struct sk_buff *skb)
900 {
901 struct in_device *in_dev = __in_dev_get_rcu(skb->dev);
902 struct rtable *rt = skb_rtable(skb);
903 struct inet_peer *peer;
904 unsigned long now;
905 struct net *net;
906 bool send;
907 int code;
908
909 net = dev_net(rt->dst.dev);
910 if (!IN_DEV_FORWARD(in_dev)) {
911 switch (rt->dst.error) {
912 case EHOSTUNREACH:
913 IP_INC_STATS_BH(net, IPSTATS_MIB_INADDRERRORS);
914 break;
915
916 case ENETUNREACH:
917 IP_INC_STATS_BH(net, IPSTATS_MIB_INNOROUTES);
918 break;
919 }
920 goto out;
921 }
922
923 switch (rt->dst.error) {
924 case EINVAL:
925 default:
926 goto out;
927 case EHOSTUNREACH:
928 code = ICMP_HOST_UNREACH;
929 break;
930 case ENETUNREACH:
931 code = ICMP_NET_UNREACH;
932 IP_INC_STATS_BH(net, IPSTATS_MIB_INNOROUTES);
933 break;
934 case EACCES:
935 code = ICMP_PKT_FILTERED;
936 break;
937 }
938
939 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, 1);
940
941 send = true;
942 if (peer) {
943 now = jiffies;
944 peer->rate_tokens += now - peer->rate_last;
945 if (peer->rate_tokens > ip_rt_error_burst)
946 peer->rate_tokens = ip_rt_error_burst;
947 peer->rate_last = now;
948 if (peer->rate_tokens >= ip_rt_error_cost)
949 peer->rate_tokens -= ip_rt_error_cost;
950 else
951 send = false;
952 inet_putpeer(peer);
953 }
954 if (send)
955 icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
956
957 out: kfree_skb(skb);
958 return 0;
959 }
960
961 static void __ip_rt_update_pmtu(struct rtable *rt, struct flowi4 *fl4, u32 mtu)
962 {
963 struct dst_entry *dst = &rt->dst;
964 struct fib_result res;
965
966 if (dst_metric_locked(dst, RTAX_MTU))
967 return;
968
969 if (dst->dev->mtu < mtu)
970 return;
971
972 if (mtu < ip_rt_min_pmtu)
973 mtu = ip_rt_min_pmtu;
974
975 if (rt->rt_pmtu == mtu &&
976 time_before(jiffies, dst->expires - ip_rt_mtu_expires / 2))
977 return;
978
979 rcu_read_lock();
980 if (fib_lookup(dev_net(dst->dev), fl4, &res) == 0) {
981 struct fib_nh *nh = &FIB_RES_NH(res);
982
983 update_or_create_fnhe(nh, fl4->daddr, 0, mtu,
984 jiffies + ip_rt_mtu_expires);
985 }
986 rcu_read_unlock();
987 }
988
989 static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
990 struct sk_buff *skb, u32 mtu)
991 {
992 struct rtable *rt = (struct rtable *) dst;
993 struct flowi4 fl4;
994
995 ip_rt_build_flow_key(&fl4, sk, skb);
996 __ip_rt_update_pmtu(rt, &fl4, mtu);
997 }
998
999 void ipv4_update_pmtu(struct sk_buff *skb, struct net *net, u32 mtu,
1000 int oif, u32 mark, u8 protocol, int flow_flags)
1001 {
1002 const struct iphdr *iph = (const struct iphdr *) skb->data;
1003 struct flowi4 fl4;
1004 struct rtable *rt;
1005
1006 __build_flow_key(&fl4, NULL, iph, oif,
1007 RT_TOS(iph->tos), protocol, mark, flow_flags);
1008 rt = __ip_route_output_key(net, &fl4);
1009 if (!IS_ERR(rt)) {
1010 __ip_rt_update_pmtu(rt, &fl4, mtu);
1011 ip_rt_put(rt);
1012 }
1013 }
1014 EXPORT_SYMBOL_GPL(ipv4_update_pmtu);
1015
1016 static void __ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
1017 {
1018 const struct iphdr *iph = (const struct iphdr *) skb->data;
1019 struct flowi4 fl4;
1020 struct rtable *rt;
1021
1022 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1023 rt = __ip_route_output_key(sock_net(sk), &fl4);
1024 if (!IS_ERR(rt)) {
1025 __ip_rt_update_pmtu(rt, &fl4, mtu);
1026 ip_rt_put(rt);
1027 }
1028 }
1029
1030 void ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
1031 {
1032 const struct iphdr *iph = (const struct iphdr *) skb->data;
1033 struct flowi4 fl4;
1034 struct rtable *rt;
1035 struct dst_entry *dst;
1036 bool new = false;
1037
1038 bh_lock_sock(sk);
1039 rt = (struct rtable *) __sk_dst_get(sk);
1040
1041 if (sock_owned_by_user(sk) || !rt) {
1042 __ipv4_sk_update_pmtu(skb, sk, mtu);
1043 goto out;
1044 }
1045
1046 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1047
1048 if (!__sk_dst_check(sk, 0)) {
1049 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1050 if (IS_ERR(rt))
1051 goto out;
1052
1053 new = true;
1054 }
1055
1056 __ip_rt_update_pmtu((struct rtable *) rt->dst.path, &fl4, mtu);
1057
1058 dst = dst_check(&rt->dst, 0);
1059 if (!dst) {
1060 if (new)
1061 dst_release(&rt->dst);
1062
1063 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1064 if (IS_ERR(rt))
1065 goto out;
1066
1067 new = true;
1068 }
1069
1070 if (new)
1071 __sk_dst_set(sk, &rt->dst);
1072
1073 out:
1074 bh_unlock_sock(sk);
1075 }
1076 EXPORT_SYMBOL_GPL(ipv4_sk_update_pmtu);
1077
1078 void ipv4_redirect(struct sk_buff *skb, struct net *net,
1079 int oif, u32 mark, u8 protocol, int flow_flags)
1080 {
1081 const struct iphdr *iph = (const struct iphdr *) skb->data;
1082 struct flowi4 fl4;
1083 struct rtable *rt;
1084
1085 __build_flow_key(&fl4, NULL, iph, oif,
1086 RT_TOS(iph->tos), protocol, mark, flow_flags);
1087 rt = __ip_route_output_key(net, &fl4);
1088 if (!IS_ERR(rt)) {
1089 __ip_do_redirect(rt, skb, &fl4, false);
1090 ip_rt_put(rt);
1091 }
1092 }
1093 EXPORT_SYMBOL_GPL(ipv4_redirect);
1094
1095 void ipv4_sk_redirect(struct sk_buff *skb, struct sock *sk)
1096 {
1097 const struct iphdr *iph = (const struct iphdr *) skb->data;
1098 struct flowi4 fl4;
1099 struct rtable *rt;
1100
1101 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1102 rt = __ip_route_output_key(sock_net(sk), &fl4);
1103 if (!IS_ERR(rt)) {
1104 __ip_do_redirect(rt, skb, &fl4, false);
1105 ip_rt_put(rt);
1106 }
1107 }
1108 EXPORT_SYMBOL_GPL(ipv4_sk_redirect);
1109
1110 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
1111 {
1112 struct rtable *rt = (struct rtable *) dst;
1113
1114 /* All IPV4 dsts are created with ->obsolete set to the value
1115 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1116 * into this function always.
1117 *
1118 * When a PMTU/redirect information update invalidates a route,
1119 * this is indicated by setting obsolete to DST_OBSOLETE_KILL or
1120 * DST_OBSOLETE_DEAD by dst_free().
1121 */
1122 if (dst->obsolete != DST_OBSOLETE_FORCE_CHK || rt_is_expired(rt))
1123 return NULL;
1124 return dst;
1125 }
1126
1127 static void ipv4_link_failure(struct sk_buff *skb)
1128 {
1129 struct rtable *rt;
1130
1131 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
1132
1133 rt = skb_rtable(skb);
1134 if (rt)
1135 dst_set_expires(&rt->dst, 0);
1136 }
1137
1138 static int ip_rt_bug(struct sk_buff *skb)
1139 {
1140 pr_debug("%s: %pI4 -> %pI4, %s\n",
1141 __func__, &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
1142 skb->dev ? skb->dev->name : "?");
1143 kfree_skb(skb);
1144 WARN_ON(1);
1145 return 0;
1146 }
1147
1148 /*
1149 We do not cache source address of outgoing interface,
1150 because it is used only by IP RR, TS and SRR options,
1151 so that it out of fast path.
1152
1153 BTW remember: "addr" is allowed to be not aligned
1154 in IP options!
1155 */
1156
1157 void ip_rt_get_source(u8 *addr, struct sk_buff *skb, struct rtable *rt)
1158 {
1159 __be32 src;
1160
1161 if (rt_is_output_route(rt))
1162 src = ip_hdr(skb)->saddr;
1163 else {
1164 struct fib_result res;
1165 struct flowi4 fl4;
1166 struct iphdr *iph;
1167
1168 iph = ip_hdr(skb);
1169
1170 memset(&fl4, 0, sizeof(fl4));
1171 fl4.daddr = iph->daddr;
1172 fl4.saddr = iph->saddr;
1173 fl4.flowi4_tos = RT_TOS(iph->tos);
1174 fl4.flowi4_oif = rt->dst.dev->ifindex;
1175 fl4.flowi4_iif = skb->dev->ifindex;
1176 fl4.flowi4_mark = skb->mark;
1177
1178 rcu_read_lock();
1179 if (fib_lookup(dev_net(rt->dst.dev), &fl4, &res) == 0)
1180 src = FIB_RES_PREFSRC(dev_net(rt->dst.dev), res);
1181 else
1182 src = inet_select_addr(rt->dst.dev,
1183 rt_nexthop(rt, iph->daddr),
1184 RT_SCOPE_UNIVERSE);
1185 rcu_read_unlock();
1186 }
1187 memcpy(addr, &src, 4);
1188 }
1189
1190 #ifdef CONFIG_IP_ROUTE_CLASSID
1191 static void set_class_tag(struct rtable *rt, u32 tag)
1192 {
1193 if (!(rt->dst.tclassid & 0xFFFF))
1194 rt->dst.tclassid |= tag & 0xFFFF;
1195 if (!(rt->dst.tclassid & 0xFFFF0000))
1196 rt->dst.tclassid |= tag & 0xFFFF0000;
1197 }
1198 #endif
1199
1200 static unsigned int ipv4_default_advmss(const struct dst_entry *dst)
1201 {
1202 unsigned int advmss = dst_metric_raw(dst, RTAX_ADVMSS);
1203
1204 if (advmss == 0) {
1205 advmss = max_t(unsigned int, dst->dev->mtu - 40,
1206 ip_rt_min_advmss);
1207 if (advmss > 65535 - 40)
1208 advmss = 65535 - 40;
1209 }
1210 return advmss;
1211 }
1212
1213 static unsigned int ipv4_mtu(const struct dst_entry *dst)
1214 {
1215 const struct rtable *rt = (const struct rtable *) dst;
1216 unsigned int mtu = rt->rt_pmtu;
1217
1218 if (!mtu || time_after_eq(jiffies, rt->dst.expires))
1219 mtu = dst_metric_raw(dst, RTAX_MTU);
1220
1221 if (mtu)
1222 return mtu;
1223
1224 mtu = dst->dev->mtu;
1225
1226 if (unlikely(dst_metric_locked(dst, RTAX_MTU))) {
1227 if (rt->rt_uses_gateway && mtu > 576)
1228 mtu = 576;
1229 }
1230
1231 return min_t(unsigned int, mtu, IP_MAX_MTU);
1232 }
1233
1234 static struct fib_nh_exception *find_exception(struct fib_nh *nh, __be32 daddr)
1235 {
1236 struct fnhe_hash_bucket *hash = nh->nh_exceptions;
1237 struct fib_nh_exception *fnhe;
1238 u32 hval;
1239
1240 if (!hash)
1241 return NULL;
1242
1243 hval = fnhe_hashfun(daddr);
1244
1245 for (fnhe = rcu_dereference(hash[hval].chain); fnhe;
1246 fnhe = rcu_dereference(fnhe->fnhe_next)) {
1247 if (fnhe->fnhe_daddr == daddr)
1248 return fnhe;
1249 }
1250 return NULL;
1251 }
1252
1253 static bool rt_bind_exception(struct rtable *rt, struct fib_nh_exception *fnhe,
1254 __be32 daddr)
1255 {
1256 bool ret = false;
1257
1258 spin_lock_bh(&fnhe_lock);
1259
1260 if (daddr == fnhe->fnhe_daddr) {
1261 struct rtable __rcu **porig;
1262 struct rtable *orig;
1263 int genid = fnhe_genid(dev_net(rt->dst.dev));
1264
1265 if (rt_is_input_route(rt))
1266 porig = &fnhe->fnhe_rth_input;
1267 else
1268 porig = &fnhe->fnhe_rth_output;
1269 orig = rcu_dereference(*porig);
1270
1271 if (fnhe->fnhe_genid != genid) {
1272 fnhe->fnhe_genid = genid;
1273 fnhe->fnhe_gw = 0;
1274 fnhe->fnhe_pmtu = 0;
1275 fnhe->fnhe_expires = 0;
1276 fnhe_flush_routes(fnhe);
1277 orig = NULL;
1278 }
1279 fill_route_from_fnhe(rt, fnhe);
1280 if (!rt->rt_gateway)
1281 rt->rt_gateway = daddr;
1282
1283 if (!(rt->dst.flags & DST_NOCACHE)) {
1284 rcu_assign_pointer(*porig, rt);
1285 if (orig)
1286 rt_free(orig);
1287 ret = true;
1288 }
1289
1290 fnhe->fnhe_stamp = jiffies;
1291 }
1292 spin_unlock_bh(&fnhe_lock);
1293
1294 return ret;
1295 }
1296
1297 static bool rt_cache_route(struct fib_nh *nh, struct rtable *rt)
1298 {
1299 struct rtable *orig, *prev, **p;
1300 bool ret = true;
1301
1302 if (rt_is_input_route(rt)) {
1303 p = (struct rtable **)&nh->nh_rth_input;
1304 } else {
1305 p = (struct rtable **)__this_cpu_ptr(nh->nh_pcpu_rth_output);
1306 }
1307 orig = *p;
1308
1309 prev = cmpxchg(p, orig, rt);
1310 if (prev == orig) {
1311 if (orig)
1312 rt_free(orig);
1313 } else
1314 ret = false;
1315
1316 return ret;
1317 }
1318
1319 static DEFINE_SPINLOCK(rt_uncached_lock);
1320 static LIST_HEAD(rt_uncached_list);
1321
1322 static void rt_add_uncached_list(struct rtable *rt)
1323 {
1324 spin_lock_bh(&rt_uncached_lock);
1325 list_add_tail(&rt->rt_uncached, &rt_uncached_list);
1326 spin_unlock_bh(&rt_uncached_lock);
1327 }
1328
1329 static void ipv4_dst_destroy(struct dst_entry *dst)
1330 {
1331 struct rtable *rt = (struct rtable *) dst;
1332
1333 if (!list_empty(&rt->rt_uncached)) {
1334 spin_lock_bh(&rt_uncached_lock);
1335 list_del(&rt->rt_uncached);
1336 spin_unlock_bh(&rt_uncached_lock);
1337 }
1338 }
1339
1340 void rt_flush_dev(struct net_device *dev)
1341 {
1342 if (!list_empty(&rt_uncached_list)) {
1343 struct net *net = dev_net(dev);
1344 struct rtable *rt;
1345
1346 spin_lock_bh(&rt_uncached_lock);
1347 list_for_each_entry(rt, &rt_uncached_list, rt_uncached) {
1348 if (rt->dst.dev != dev)
1349 continue;
1350 rt->dst.dev = net->loopback_dev;
1351 dev_hold(rt->dst.dev);
1352 dev_put(dev);
1353 }
1354 spin_unlock_bh(&rt_uncached_lock);
1355 }
1356 }
1357
1358 static bool rt_cache_valid(const struct rtable *rt)
1359 {
1360 return rt &&
1361 rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
1362 !rt_is_expired(rt);
1363 }
1364
1365 static void rt_set_nexthop(struct rtable *rt, __be32 daddr,
1366 const struct fib_result *res,
1367 struct fib_nh_exception *fnhe,
1368 struct fib_info *fi, u16 type, u32 itag)
1369 {
1370 bool cached = false;
1371
1372 if (fi) {
1373 struct fib_nh *nh = &FIB_RES_NH(*res);
1374
1375 if (nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK) {
1376 rt->rt_gateway = nh->nh_gw;
1377 rt->rt_uses_gateway = 1;
1378 }
1379 dst_init_metrics(&rt->dst, fi->fib_metrics, true);
1380 #ifdef CONFIG_IP_ROUTE_CLASSID
1381 rt->dst.tclassid = nh->nh_tclassid;
1382 #endif
1383 if (unlikely(fnhe))
1384 cached = rt_bind_exception(rt, fnhe, daddr);
1385 else if (!(rt->dst.flags & DST_NOCACHE))
1386 cached = rt_cache_route(nh, rt);
1387 if (unlikely(!cached)) {
1388 /* Routes we intend to cache in nexthop exception or
1389 * FIB nexthop have the DST_NOCACHE bit clear.
1390 * However, if we are unsuccessful at storing this
1391 * route into the cache we really need to set it.
1392 */
1393 rt->dst.flags |= DST_NOCACHE;
1394 if (!rt->rt_gateway)
1395 rt->rt_gateway = daddr;
1396 rt_add_uncached_list(rt);
1397 }
1398 } else
1399 rt_add_uncached_list(rt);
1400
1401 #ifdef CONFIG_IP_ROUTE_CLASSID
1402 #ifdef CONFIG_IP_MULTIPLE_TABLES
1403 set_class_tag(rt, res->tclassid);
1404 #endif
1405 set_class_tag(rt, itag);
1406 #endif
1407 }
1408
1409 static struct rtable *rt_dst_alloc(struct net_device *dev,
1410 bool nopolicy, bool noxfrm, bool will_cache)
1411 {
1412 return dst_alloc(&ipv4_dst_ops, dev, 1, DST_OBSOLETE_FORCE_CHK,
1413 (will_cache ? 0 : (DST_HOST | DST_NOCACHE)) |
1414 (nopolicy ? DST_NOPOLICY : 0) |
1415 (noxfrm ? DST_NOXFRM : 0));
1416 }
1417
1418 /* called in rcu_read_lock() section */
1419 static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1420 u8 tos, struct net_device *dev, int our)
1421 {
1422 struct rtable *rth;
1423 struct in_device *in_dev = __in_dev_get_rcu(dev);
1424 u32 itag = 0;
1425 int err;
1426
1427 /* Primary sanity checks. */
1428
1429 if (in_dev == NULL)
1430 return -EINVAL;
1431
1432 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
1433 skb->protocol != htons(ETH_P_IP))
1434 goto e_inval;
1435
1436 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
1437 if (ipv4_is_loopback(saddr))
1438 goto e_inval;
1439
1440 if (ipv4_is_zeronet(saddr)) {
1441 if (!ipv4_is_local_multicast(daddr))
1442 goto e_inval;
1443 } else {
1444 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1445 in_dev, &itag);
1446 if (err < 0)
1447 goto e_err;
1448 }
1449 rth = rt_dst_alloc(dev_net(dev)->loopback_dev,
1450 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, false);
1451 if (!rth)
1452 goto e_nobufs;
1453
1454 #ifdef CONFIG_IP_ROUTE_CLASSID
1455 rth->dst.tclassid = itag;
1456 #endif
1457 rth->dst.output = ip_rt_bug;
1458
1459 rth->rt_genid = rt_genid_ipv4(dev_net(dev));
1460 rth->rt_flags = RTCF_MULTICAST;
1461 rth->rt_type = RTN_MULTICAST;
1462 rth->rt_is_input= 1;
1463 rth->rt_iif = 0;
1464 rth->rt_pmtu = 0;
1465 rth->rt_gateway = 0;
1466 rth->rt_uses_gateway = 0;
1467 INIT_LIST_HEAD(&rth->rt_uncached);
1468 if (our) {
1469 rth->dst.input= ip_local_deliver;
1470 rth->rt_flags |= RTCF_LOCAL;
1471 }
1472
1473 #ifdef CONFIG_IP_MROUTE
1474 if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
1475 rth->dst.input = ip_mr_input;
1476 #endif
1477 RT_CACHE_STAT_INC(in_slow_mc);
1478
1479 skb_dst_set(skb, &rth->dst);
1480 return 0;
1481
1482 e_nobufs:
1483 return -ENOBUFS;
1484 e_inval:
1485 return -EINVAL;
1486 e_err:
1487 return err;
1488 }
1489
1490
1491 static void ip_handle_martian_source(struct net_device *dev,
1492 struct in_device *in_dev,
1493 struct sk_buff *skb,
1494 __be32 daddr,
1495 __be32 saddr)
1496 {
1497 RT_CACHE_STAT_INC(in_martian_src);
1498 #ifdef CONFIG_IP_ROUTE_VERBOSE
1499 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
1500 /*
1501 * RFC1812 recommendation, if source is martian,
1502 * the only hint is MAC header.
1503 */
1504 pr_warn("martian source %pI4 from %pI4, on dev %s\n",
1505 &daddr, &saddr, dev->name);
1506 if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
1507 print_hex_dump(KERN_WARNING, "ll header: ",
1508 DUMP_PREFIX_OFFSET, 16, 1,
1509 skb_mac_header(skb),
1510 dev->hard_header_len, true);
1511 }
1512 }
1513 #endif
1514 }
1515
1516 /* called in rcu_read_lock() section */
1517 static int __mkroute_input(struct sk_buff *skb,
1518 const struct fib_result *res,
1519 struct in_device *in_dev,
1520 __be32 daddr, __be32 saddr, u32 tos)
1521 {
1522 struct fib_nh_exception *fnhe;
1523 struct rtable *rth;
1524 int err;
1525 struct in_device *out_dev;
1526 unsigned int flags = 0;
1527 bool do_cache;
1528 u32 itag;
1529
1530 /* get a working reference to the output device */
1531 out_dev = __in_dev_get_rcu(FIB_RES_DEV(*res));
1532 if (out_dev == NULL) {
1533 net_crit_ratelimited("Bug in ip_route_input_slow(). Please report.\n");
1534 return -EINVAL;
1535 }
1536
1537 err = fib_validate_source(skb, saddr, daddr, tos, FIB_RES_OIF(*res),
1538 in_dev->dev, in_dev, &itag);
1539 if (err < 0) {
1540 ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
1541 saddr);
1542
1543 goto cleanup;
1544 }
1545
1546 do_cache = res->fi && !itag;
1547 if (out_dev == in_dev && err && IN_DEV_TX_REDIRECTS(out_dev) &&
1548 (IN_DEV_SHARED_MEDIA(out_dev) ||
1549 inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res)))) {
1550 flags |= RTCF_DOREDIRECT;
1551 do_cache = false;
1552 }
1553
1554 if (skb->protocol != htons(ETH_P_IP)) {
1555 /* Not IP (i.e. ARP). Do not create route, if it is
1556 * invalid for proxy arp. DNAT routes are always valid.
1557 *
1558 * Proxy arp feature have been extended to allow, ARP
1559 * replies back to the same interface, to support
1560 * Private VLAN switch technologies. See arp.c.
1561 */
1562 if (out_dev == in_dev &&
1563 IN_DEV_PROXY_ARP_PVLAN(in_dev) == 0) {
1564 err = -EINVAL;
1565 goto cleanup;
1566 }
1567 }
1568
1569 fnhe = find_exception(&FIB_RES_NH(*res), daddr);
1570 if (do_cache) {
1571 if (fnhe != NULL)
1572 rth = rcu_dereference(fnhe->fnhe_rth_input);
1573 else
1574 rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input);
1575
1576 if (rt_cache_valid(rth)) {
1577 skb_dst_set_noref(skb, &rth->dst);
1578 goto out;
1579 }
1580 }
1581
1582 rth = rt_dst_alloc(out_dev->dev,
1583 IN_DEV_CONF_GET(in_dev, NOPOLICY),
1584 IN_DEV_CONF_GET(out_dev, NOXFRM), do_cache);
1585 if (!rth) {
1586 err = -ENOBUFS;
1587 goto cleanup;
1588 }
1589
1590 rth->rt_genid = rt_genid_ipv4(dev_net(rth->dst.dev));
1591 rth->rt_flags = flags;
1592 rth->rt_type = res->type;
1593 rth->rt_is_input = 1;
1594 rth->rt_iif = 0;
1595 rth->rt_pmtu = 0;
1596 rth->rt_gateway = 0;
1597 rth->rt_uses_gateway = 0;
1598 INIT_LIST_HEAD(&rth->rt_uncached);
1599
1600 rth->dst.input = ip_forward;
1601 rth->dst.output = ip_output;
1602
1603 rt_set_nexthop(rth, daddr, res, fnhe, res->fi, res->type, itag);
1604 skb_dst_set(skb, &rth->dst);
1605 out:
1606 err = 0;
1607 cleanup:
1608 return err;
1609 }
1610
1611 static int ip_mkroute_input(struct sk_buff *skb,
1612 struct fib_result *res,
1613 const struct flowi4 *fl4,
1614 struct in_device *in_dev,
1615 __be32 daddr, __be32 saddr, u32 tos)
1616 {
1617 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1618 if (res->fi && res->fi->fib_nhs > 1)
1619 fib_select_multipath(res);
1620 #endif
1621
1622 /* create a routing cache entry */
1623 return __mkroute_input(skb, res, in_dev, daddr, saddr, tos);
1624 }
1625
1626 /*
1627 * NOTE. We drop all the packets that has local source
1628 * addresses, because every properly looped back packet
1629 * must have correct destination already attached by output routine.
1630 *
1631 * Such approach solves two big problems:
1632 * 1. Not simplex devices are handled properly.
1633 * 2. IP spoofing attempts are filtered with 100% of guarantee.
1634 * called with rcu_read_lock()
1635 */
1636
1637 static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1638 u8 tos, struct net_device *dev)
1639 {
1640 struct fib_result res;
1641 struct in_device *in_dev = __in_dev_get_rcu(dev);
1642 struct flowi4 fl4;
1643 unsigned int flags = 0;
1644 u32 itag = 0;
1645 struct rtable *rth;
1646 int err = -EINVAL;
1647 struct net *net = dev_net(dev);
1648 bool do_cache;
1649
1650 /* IP on this device is disabled. */
1651
1652 if (!in_dev)
1653 goto out;
1654
1655 /* Check for the most weird martians, which can be not detected
1656 by fib_lookup.
1657 */
1658
1659 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr))
1660 goto martian_source;
1661
1662 res.fi = NULL;
1663 if (ipv4_is_lbcast(daddr) || (saddr == 0 && daddr == 0))
1664 goto brd_input;
1665
1666 /* Accept zero addresses only to limited broadcast;
1667 * I even do not know to fix it or not. Waiting for complains :-)
1668 */
1669 if (ipv4_is_zeronet(saddr))
1670 goto martian_source;
1671
1672 if (ipv4_is_zeronet(daddr))
1673 goto martian_destination;
1674
1675 /* Following code try to avoid calling IN_DEV_NET_ROUTE_LOCALNET(),
1676 * and call it once if daddr or/and saddr are loopback addresses
1677 */
1678 if (ipv4_is_loopback(daddr)) {
1679 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
1680 goto martian_destination;
1681 } else if (ipv4_is_loopback(saddr)) {
1682 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
1683 goto martian_source;
1684 }
1685
1686 /*
1687 * Now we are ready to route packet.
1688 */
1689 fl4.flowi4_oif = 0;
1690 fl4.flowi4_iif = dev->ifindex;
1691 fl4.flowi4_mark = skb->mark;
1692 fl4.flowi4_tos = tos;
1693 fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
1694 fl4.daddr = daddr;
1695 fl4.saddr = saddr;
1696 err = fib_lookup(net, &fl4, &res);
1697 if (err != 0)
1698 goto no_route;
1699
1700 RT_CACHE_STAT_INC(in_slow_tot);
1701
1702 if (res.type == RTN_BROADCAST)
1703 goto brd_input;
1704
1705 if (res.type == RTN_LOCAL) {
1706 err = fib_validate_source(skb, saddr, daddr, tos,
1707 LOOPBACK_IFINDEX,
1708 dev, in_dev, &itag);
1709 if (err < 0)
1710 goto martian_source_keep_err;
1711 goto local_input;
1712 }
1713
1714 if (!IN_DEV_FORWARD(in_dev))
1715 goto no_route;
1716 if (res.type != RTN_UNICAST)
1717 goto martian_destination;
1718
1719 err = ip_mkroute_input(skb, &res, &fl4, in_dev, daddr, saddr, tos);
1720 out: return err;
1721
1722 brd_input:
1723 if (skb->protocol != htons(ETH_P_IP))
1724 goto e_inval;
1725
1726 if (!ipv4_is_zeronet(saddr)) {
1727 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1728 in_dev, &itag);
1729 if (err < 0)
1730 goto martian_source_keep_err;
1731 }
1732 flags |= RTCF_BROADCAST;
1733 res.type = RTN_BROADCAST;
1734 RT_CACHE_STAT_INC(in_brd);
1735
1736 local_input:
1737 do_cache = false;
1738 if (res.fi) {
1739 if (!itag) {
1740 rth = rcu_dereference(FIB_RES_NH(res).nh_rth_input);
1741 if (rt_cache_valid(rth)) {
1742 skb_dst_set_noref(skb, &rth->dst);
1743 err = 0;
1744 goto out;
1745 }
1746 do_cache = true;
1747 }
1748 }
1749
1750 rth = rt_dst_alloc(net->loopback_dev,
1751 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, do_cache);
1752 if (!rth)
1753 goto e_nobufs;
1754
1755 rth->dst.input= ip_local_deliver;
1756 rth->dst.output= ip_rt_bug;
1757 #ifdef CONFIG_IP_ROUTE_CLASSID
1758 rth->dst.tclassid = itag;
1759 #endif
1760
1761 rth->rt_genid = rt_genid_ipv4(net);
1762 rth->rt_flags = flags|RTCF_LOCAL;
1763 rth->rt_type = res.type;
1764 rth->rt_is_input = 1;
1765 rth->rt_iif = 0;
1766 rth->rt_pmtu = 0;
1767 rth->rt_gateway = 0;
1768 rth->rt_uses_gateway = 0;
1769 INIT_LIST_HEAD(&rth->rt_uncached);
1770 if (res.type == RTN_UNREACHABLE) {
1771 rth->dst.input= ip_error;
1772 rth->dst.error= -err;
1773 rth->rt_flags &= ~RTCF_LOCAL;
1774 }
1775 if (do_cache)
1776 rt_cache_route(&FIB_RES_NH(res), rth);
1777 skb_dst_set(skb, &rth->dst);
1778 err = 0;
1779 goto out;
1780
1781 no_route:
1782 RT_CACHE_STAT_INC(in_no_route);
1783 res.type = RTN_UNREACHABLE;
1784 if (err == -ESRCH)
1785 err = -ENETUNREACH;
1786 goto local_input;
1787
1788 /*
1789 * Do not cache martian addresses: they should be logged (RFC1812)
1790 */
1791 martian_destination:
1792 RT_CACHE_STAT_INC(in_martian_dst);
1793 #ifdef CONFIG_IP_ROUTE_VERBOSE
1794 if (IN_DEV_LOG_MARTIANS(in_dev))
1795 net_warn_ratelimited("martian destination %pI4 from %pI4, dev %s\n",
1796 &daddr, &saddr, dev->name);
1797 #endif
1798
1799 e_inval:
1800 err = -EINVAL;
1801 goto out;
1802
1803 e_nobufs:
1804 err = -ENOBUFS;
1805 goto out;
1806
1807 martian_source:
1808 err = -EINVAL;
1809 martian_source_keep_err:
1810 ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
1811 goto out;
1812 }
1813
1814 int ip_route_input_noref(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1815 u8 tos, struct net_device *dev)
1816 {
1817 int res;
1818
1819 rcu_read_lock();
1820
1821 /* Multicast recognition logic is moved from route cache to here.
1822 The problem was that too many Ethernet cards have broken/missing
1823 hardware multicast filters :-( As result the host on multicasting
1824 network acquires a lot of useless route cache entries, sort of
1825 SDR messages from all the world. Now we try to get rid of them.
1826 Really, provided software IP multicast filter is organized
1827 reasonably (at least, hashed), it does not result in a slowdown
1828 comparing with route cache reject entries.
1829 Note, that multicast routers are not affected, because
1830 route cache entry is created eventually.
1831 */
1832 if (ipv4_is_multicast(daddr)) {
1833 struct in_device *in_dev = __in_dev_get_rcu(dev);
1834
1835 if (in_dev) {
1836 int our = ip_check_mc_rcu(in_dev, daddr, saddr,
1837 ip_hdr(skb)->protocol);
1838 if (our
1839 #ifdef CONFIG_IP_MROUTE
1840 ||
1841 (!ipv4_is_local_multicast(daddr) &&
1842 IN_DEV_MFORWARD(in_dev))
1843 #endif
1844 ) {
1845 int res = ip_route_input_mc(skb, daddr, saddr,
1846 tos, dev, our);
1847 rcu_read_unlock();
1848 return res;
1849 }
1850 }
1851 rcu_read_unlock();
1852 return -EINVAL;
1853 }
1854 res = ip_route_input_slow(skb, daddr, saddr, tos, dev);
1855 rcu_read_unlock();
1856 return res;
1857 }
1858 EXPORT_SYMBOL(ip_route_input_noref);
1859
1860 /* called with rcu_read_lock() */
1861 static struct rtable *__mkroute_output(const struct fib_result *res,
1862 const struct flowi4 *fl4, int orig_oif,
1863 struct net_device *dev_out,
1864 unsigned int flags)
1865 {
1866 struct fib_info *fi = res->fi;
1867 struct fib_nh_exception *fnhe;
1868 struct in_device *in_dev;
1869 u16 type = res->type;
1870 struct rtable *rth;
1871 bool do_cache;
1872
1873 in_dev = __in_dev_get_rcu(dev_out);
1874 if (!in_dev)
1875 return ERR_PTR(-EINVAL);
1876
1877 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
1878 if (ipv4_is_loopback(fl4->saddr) && !(dev_out->flags & IFF_LOOPBACK))
1879 return ERR_PTR(-EINVAL);
1880
1881 if (ipv4_is_lbcast(fl4->daddr))
1882 type = RTN_BROADCAST;
1883 else if (ipv4_is_multicast(fl4->daddr))
1884 type = RTN_MULTICAST;
1885 else if (ipv4_is_zeronet(fl4->daddr))
1886 return ERR_PTR(-EINVAL);
1887
1888 if (dev_out->flags & IFF_LOOPBACK)
1889 flags |= RTCF_LOCAL;
1890
1891 do_cache = true;
1892 if (type == RTN_BROADCAST) {
1893 flags |= RTCF_BROADCAST | RTCF_LOCAL;
1894 fi = NULL;
1895 } else if (type == RTN_MULTICAST) {
1896 flags |= RTCF_MULTICAST | RTCF_LOCAL;
1897 if (!ip_check_mc_rcu(in_dev, fl4->daddr, fl4->saddr,
1898 fl4->flowi4_proto))
1899 flags &= ~RTCF_LOCAL;
1900 else
1901 do_cache = false;
1902 /* If multicast route do not exist use
1903 * default one, but do not gateway in this case.
1904 * Yes, it is hack.
1905 */
1906 if (fi && res->prefixlen < 4)
1907 fi = NULL;
1908 }
1909
1910 fnhe = NULL;
1911 do_cache &= fi != NULL;
1912 if (do_cache) {
1913 struct rtable __rcu **prth;
1914 struct fib_nh *nh = &FIB_RES_NH(*res);
1915
1916 fnhe = find_exception(nh, fl4->daddr);
1917 if (fnhe)
1918 prth = &fnhe->fnhe_rth_output;
1919 else {
1920 if (unlikely(fl4->flowi4_flags &
1921 FLOWI_FLAG_KNOWN_NH &&
1922 !(nh->nh_gw &&
1923 nh->nh_scope == RT_SCOPE_LINK))) {
1924 do_cache = false;
1925 goto add;
1926 }
1927 prth = __this_cpu_ptr(nh->nh_pcpu_rth_output);
1928 }
1929 rth = rcu_dereference(*prth);
1930 if (rt_cache_valid(rth)) {
1931 dst_hold(&rth->dst);
1932 return rth;
1933 }
1934 }
1935
1936 add:
1937 rth = rt_dst_alloc(dev_out,
1938 IN_DEV_CONF_GET(in_dev, NOPOLICY),
1939 IN_DEV_CONF_GET(in_dev, NOXFRM),
1940 do_cache);
1941 if (!rth)
1942 return ERR_PTR(-ENOBUFS);
1943
1944 rth->dst.output = ip_output;
1945
1946 rth->rt_genid = rt_genid_ipv4(dev_net(dev_out));
1947 rth->rt_flags = flags;
1948 rth->rt_type = type;
1949 rth->rt_is_input = 0;
1950 rth->rt_iif = orig_oif ? : 0;
1951 rth->rt_pmtu = 0;
1952 rth->rt_gateway = 0;
1953 rth->rt_uses_gateway = 0;
1954 INIT_LIST_HEAD(&rth->rt_uncached);
1955
1956 RT_CACHE_STAT_INC(out_slow_tot);
1957
1958 if (flags & RTCF_LOCAL)
1959 rth->dst.input = ip_local_deliver;
1960 if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
1961 if (flags & RTCF_LOCAL &&
1962 !(dev_out->flags & IFF_LOOPBACK)) {
1963 rth->dst.output = ip_mc_output;
1964 RT_CACHE_STAT_INC(out_slow_mc);
1965 }
1966 #ifdef CONFIG_IP_MROUTE
1967 if (type == RTN_MULTICAST) {
1968 if (IN_DEV_MFORWARD(in_dev) &&
1969 !ipv4_is_local_multicast(fl4->daddr)) {
1970 rth->dst.input = ip_mr_input;
1971 rth->dst.output = ip_mc_output;
1972 }
1973 }
1974 #endif
1975 }
1976
1977 rt_set_nexthop(rth, fl4->daddr, res, fnhe, fi, type, 0);
1978
1979 return rth;
1980 }
1981
1982 /*
1983 * Major route resolver routine.
1984 */
1985
1986 struct rtable *__ip_route_output_key(struct net *net, struct flowi4 *fl4)
1987 {
1988 struct net_device *dev_out = NULL;
1989 __u8 tos = RT_FL_TOS(fl4);
1990 unsigned int flags = 0;
1991 struct fib_result res;
1992 struct rtable *rth;
1993 int orig_oif;
1994
1995 res.tclassid = 0;
1996 res.fi = NULL;
1997 res.table = NULL;
1998
1999 orig_oif = fl4->flowi4_oif;
2000
2001 fl4->flowi4_iif = LOOPBACK_IFINDEX;
2002 fl4->flowi4_tos = tos & IPTOS_RT_MASK;
2003 fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
2004 RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);
2005
2006 rcu_read_lock();
2007 if (fl4->saddr) {
2008 rth = ERR_PTR(-EINVAL);
2009 if (ipv4_is_multicast(fl4->saddr) ||
2010 ipv4_is_lbcast(fl4->saddr) ||
2011 ipv4_is_zeronet(fl4->saddr))
2012 goto out;
2013
2014 /* I removed check for oif == dev_out->oif here.
2015 It was wrong for two reasons:
2016 1. ip_dev_find(net, saddr) can return wrong iface, if saddr
2017 is assigned to multiple interfaces.
2018 2. Moreover, we are allowed to send packets with saddr
2019 of another iface. --ANK
2020 */
2021
2022 if (fl4->flowi4_oif == 0 &&
2023 (ipv4_is_multicast(fl4->daddr) ||
2024 ipv4_is_lbcast(fl4->daddr))) {
2025 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2026 dev_out = __ip_dev_find(net, fl4->saddr, false);
2027 if (dev_out == NULL)
2028 goto out;
2029
2030 /* Special hack: user can direct multicasts
2031 and limited broadcast via necessary interface
2032 without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
2033 This hack is not just for fun, it allows
2034 vic,vat and friends to work.
2035 They bind socket to loopback, set ttl to zero
2036 and expect that it will work.
2037 From the viewpoint of routing cache they are broken,
2038 because we are not allowed to build multicast path
2039 with loopback source addr (look, routing cache
2040 cannot know, that ttl is zero, so that packet
2041 will not leave this host and route is valid).
2042 Luckily, this hack is good workaround.
2043 */
2044
2045 fl4->flowi4_oif = dev_out->ifindex;
2046 goto make_route;
2047 }
2048
2049 if (!(fl4->flowi4_flags & FLOWI_FLAG_ANYSRC)) {
2050 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2051 if (!__ip_dev_find(net, fl4->saddr, false))
2052 goto out;
2053 }
2054 }
2055
2056
2057 if (fl4->flowi4_oif) {
2058 dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);
2059 rth = ERR_PTR(-ENODEV);
2060 if (dev_out == NULL)
2061 goto out;
2062
2063 /* RACE: Check return value of inet_select_addr instead. */
2064 if (!(dev_out->flags & IFF_UP) || !__in_dev_get_rcu(dev_out)) {
2065 rth = ERR_PTR(-ENETUNREACH);
2066 goto out;
2067 }
2068 if (ipv4_is_local_multicast(fl4->daddr) ||
2069 ipv4_is_lbcast(fl4->daddr)) {
2070 if (!fl4->saddr)
2071 fl4->saddr = inet_select_addr(dev_out, 0,
2072 RT_SCOPE_LINK);
2073 goto make_route;
2074 }
2075 if (!fl4->saddr) {
2076 if (ipv4_is_multicast(fl4->daddr))
2077 fl4->saddr = inet_select_addr(dev_out, 0,
2078 fl4->flowi4_scope);
2079 else if (!fl4->daddr)
2080 fl4->saddr = inet_select_addr(dev_out, 0,
2081 RT_SCOPE_HOST);
2082 }
2083 }
2084
2085 if (!fl4->daddr) {
2086 fl4->daddr = fl4->saddr;
2087 if (!fl4->daddr)
2088 fl4->daddr = fl4->saddr = htonl(INADDR_LOOPBACK);
2089 dev_out = net->loopback_dev;
2090 fl4->flowi4_oif = LOOPBACK_IFINDEX;
2091 res.type = RTN_LOCAL;
2092 flags |= RTCF_LOCAL;
2093 goto make_route;
2094 }
2095
2096 if (fib_lookup(net, fl4, &res)) {
2097 res.fi = NULL;
2098 res.table = NULL;
2099 if (fl4->flowi4_oif) {
2100 /* Apparently, routing tables are wrong. Assume,
2101 that the destination is on link.
2102
2103 WHY? DW.
2104 Because we are allowed to send to iface
2105 even if it has NO routes and NO assigned
2106 addresses. When oif is specified, routing
2107 tables are looked up with only one purpose:
2108 to catch if destination is gatewayed, rather than
2109 direct. Moreover, if MSG_DONTROUTE is set,
2110 we send packet, ignoring both routing tables
2111 and ifaddr state. --ANK
2112
2113
2114 We could make it even if oif is unknown,
2115 likely IPv6, but we do not.
2116 */
2117
2118 if (fl4->saddr == 0)
2119 fl4->saddr = inet_select_addr(dev_out, 0,
2120 RT_SCOPE_LINK);
2121 res.type = RTN_UNICAST;
2122 goto make_route;
2123 }
2124 rth = ERR_PTR(-ENETUNREACH);
2125 goto out;
2126 }
2127
2128 if (res.type == RTN_LOCAL) {
2129 if (!fl4->saddr) {
2130 if (res.fi->fib_prefsrc)
2131 fl4->saddr = res.fi->fib_prefsrc;
2132 else
2133 fl4->saddr = fl4->daddr;
2134 }
2135 dev_out = net->loopback_dev;
2136 fl4->flowi4_oif = dev_out->ifindex;
2137 flags |= RTCF_LOCAL;
2138 goto make_route;
2139 }
2140
2141 #ifdef CONFIG_IP_ROUTE_MULTIPATH
2142 if (res.fi->fib_nhs > 1 && fl4->flowi4_oif == 0)
2143 fib_select_multipath(&res);
2144 else
2145 #endif
2146 if (!res.prefixlen &&
2147 res.table->tb_num_default > 1 &&
2148 res.type == RTN_UNICAST && !fl4->flowi4_oif)
2149 fib_select_default(&res);
2150
2151 if (!fl4->saddr)
2152 fl4->saddr = FIB_RES_PREFSRC(net, res);
2153
2154 dev_out = FIB_RES_DEV(res);
2155 fl4->flowi4_oif = dev_out->ifindex;
2156
2157
2158 make_route:
2159 rth = __mkroute_output(&res, fl4, orig_oif, dev_out, flags);
2160
2161 out:
2162 rcu_read_unlock();
2163 return rth;
2164 }
2165 EXPORT_SYMBOL_GPL(__ip_route_output_key);
2166
2167 static struct dst_entry *ipv4_blackhole_dst_check(struct dst_entry *dst, u32 cookie)
2168 {
2169 return NULL;
2170 }
2171
2172 static unsigned int ipv4_blackhole_mtu(const struct dst_entry *dst)
2173 {
2174 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
2175
2176 return mtu ? : dst->dev->mtu;
2177 }
2178
2179 static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
2180 struct sk_buff *skb, u32 mtu)
2181 {
2182 }
2183
2184 static void ipv4_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
2185 struct sk_buff *skb)
2186 {
2187 }
2188
2189 static u32 *ipv4_rt_blackhole_cow_metrics(struct dst_entry *dst,
2190 unsigned long old)
2191 {
2192 return NULL;
2193 }
2194
2195 static struct dst_ops ipv4_dst_blackhole_ops = {
2196 .family = AF_INET,
2197 .protocol = cpu_to_be16(ETH_P_IP),
2198 .check = ipv4_blackhole_dst_check,
2199 .mtu = ipv4_blackhole_mtu,
2200 .default_advmss = ipv4_default_advmss,
2201 .update_pmtu = ipv4_rt_blackhole_update_pmtu,
2202 .redirect = ipv4_rt_blackhole_redirect,
2203 .cow_metrics = ipv4_rt_blackhole_cow_metrics,
2204 .neigh_lookup = ipv4_neigh_lookup,
2205 };
2206
2207 struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig)
2208 {
2209 struct rtable *ort = (struct rtable *) dst_orig;
2210 struct rtable *rt;
2211
2212 rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, DST_OBSOLETE_NONE, 0);
2213 if (rt) {
2214 struct dst_entry *new = &rt->dst;
2215
2216 new->__use = 1;
2217 new->input = dst_discard;
2218 new->output = dst_discard;
2219
2220 new->dev = ort->dst.dev;
2221 if (new->dev)
2222 dev_hold(new->dev);
2223
2224 rt->rt_is_input = ort->rt_is_input;
2225 rt->rt_iif = ort->rt_iif;
2226 rt->rt_pmtu = ort->rt_pmtu;
2227
2228 rt->rt_genid = rt_genid_ipv4(net);
2229 rt->rt_flags = ort->rt_flags;
2230 rt->rt_type = ort->rt_type;
2231 rt->rt_gateway = ort->rt_gateway;
2232 rt->rt_uses_gateway = ort->rt_uses_gateway;
2233
2234 INIT_LIST_HEAD(&rt->rt_uncached);
2235
2236 dst_free(new);
2237 }
2238
2239 dst_release(dst_orig);
2240
2241 return rt ? &rt->dst : ERR_PTR(-ENOMEM);
2242 }
2243
2244 struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4,
2245 struct sock *sk)
2246 {
2247 struct rtable *rt = __ip_route_output_key(net, flp4);
2248
2249 if (IS_ERR(rt))
2250 return rt;
2251
2252 if (flp4->flowi4_proto)
2253 rt = (struct rtable *) xfrm_lookup(net, &rt->dst,
2254 flowi4_to_flowi(flp4),
2255 sk, 0);
2256
2257 return rt;
2258 }
2259 EXPORT_SYMBOL_GPL(ip_route_output_flow);
2260
2261 static int rt_fill_info(struct net *net, __be32 dst, __be32 src,
2262 struct flowi4 *fl4, struct sk_buff *skb, u32 portid,
2263 u32 seq, int event, int nowait, unsigned int flags)
2264 {
2265 struct rtable *rt = skb_rtable(skb);
2266 struct rtmsg *r;
2267 struct nlmsghdr *nlh;
2268 unsigned long expires = 0;
2269 u32 error;
2270 u32 metrics[RTAX_MAX];
2271
2272 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*r), flags);
2273 if (nlh == NULL)
2274 return -EMSGSIZE;
2275
2276 r = nlmsg_data(nlh);
2277 r->rtm_family = AF_INET;
2278 r->rtm_dst_len = 32;
2279 r->rtm_src_len = 0;
2280 r->rtm_tos = fl4->flowi4_tos;
2281 r->rtm_table = RT_TABLE_MAIN;
2282 if (nla_put_u32(skb, RTA_TABLE, RT_TABLE_MAIN))
2283 goto nla_put_failure;
2284 r->rtm_type = rt->rt_type;
2285 r->rtm_scope = RT_SCOPE_UNIVERSE;
2286 r->rtm_protocol = RTPROT_UNSPEC;
2287 r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
2288 if (rt->rt_flags & RTCF_NOTIFY)
2289 r->rtm_flags |= RTM_F_NOTIFY;
2290
2291 if (nla_put_be32(skb, RTA_DST, dst))
2292 goto nla_put_failure;
2293 if (src) {
2294 r->rtm_src_len = 32;
2295 if (nla_put_be32(skb, RTA_SRC, src))
2296 goto nla_put_failure;
2297 }
2298 if (rt->dst.dev &&
2299 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2300 goto nla_put_failure;
2301 #ifdef CONFIG_IP_ROUTE_CLASSID
2302 if (rt->dst.tclassid &&
2303 nla_put_u32(skb, RTA_FLOW, rt->dst.tclassid))
2304 goto nla_put_failure;
2305 #endif
2306 if (!rt_is_input_route(rt) &&
2307 fl4->saddr != src) {
2308 if (nla_put_be32(skb, RTA_PREFSRC, fl4->saddr))
2309 goto nla_put_failure;
2310 }
2311 if (rt->rt_uses_gateway &&
2312 nla_put_be32(skb, RTA_GATEWAY, rt->rt_gateway))
2313 goto nla_put_failure;
2314
2315 expires = rt->dst.expires;
2316 if (expires) {
2317 unsigned long now = jiffies;
2318
2319 if (time_before(now, expires))
2320 expires -= now;
2321 else
2322 expires = 0;
2323 }
2324
2325 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
2326 if (rt->rt_pmtu && expires)
2327 metrics[RTAX_MTU - 1] = rt->rt_pmtu;
2328 if (rtnetlink_put_metrics(skb, metrics) < 0)
2329 goto nla_put_failure;
2330
2331 if (fl4->flowi4_mark &&
2332 nla_put_u32(skb, RTA_MARK, fl4->flowi4_mark))
2333 goto nla_put_failure;
2334
2335 error = rt->dst.error;
2336
2337 if (rt_is_input_route(rt)) {
2338 #ifdef CONFIG_IP_MROUTE
2339 if (ipv4_is_multicast(dst) && !ipv4_is_local_multicast(dst) &&
2340 IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
2341 int err = ipmr_get_route(net, skb,
2342 fl4->saddr, fl4->daddr,
2343 r, nowait);
2344 if (err <= 0) {
2345 if (!nowait) {
2346 if (err == 0)
2347 return 0;
2348 goto nla_put_failure;
2349 } else {
2350 if (err == -EMSGSIZE)
2351 goto nla_put_failure;
2352 error = err;
2353 }
2354 }
2355 } else
2356 #endif
2357 if (nla_put_u32(skb, RTA_IIF, rt->rt_iif))
2358 goto nla_put_failure;
2359 }
2360
2361 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, error) < 0)
2362 goto nla_put_failure;
2363
2364 return nlmsg_end(skb, nlh);
2365
2366 nla_put_failure:
2367 nlmsg_cancel(skb, nlh);
2368 return -EMSGSIZE;
2369 }
2370
2371 static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
2372 {
2373 struct net *net = sock_net(in_skb->sk);
2374 struct rtmsg *rtm;
2375 struct nlattr *tb[RTA_MAX+1];
2376 struct rtable *rt = NULL;
2377 struct flowi4 fl4;
2378 __be32 dst = 0;
2379 __be32 src = 0;
2380 u32 iif;
2381 int err;
2382 int mark;
2383 struct sk_buff *skb;
2384
2385 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv4_policy);
2386 if (err < 0)
2387 goto errout;
2388
2389 rtm = nlmsg_data(nlh);
2390
2391 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2392 if (skb == NULL) {
2393 err = -ENOBUFS;
2394 goto errout;
2395 }
2396
2397 /* Reserve room for dummy headers, this skb can pass
2398 through good chunk of routing engine.
2399 */
2400 skb_reset_mac_header(skb);
2401 skb_reset_network_header(skb);
2402
2403 /* Bugfix: need to give ip_route_input enough of an IP header to not gag. */
2404 ip_hdr(skb)->protocol = IPPROTO_ICMP;
2405 skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));
2406
2407 src = tb[RTA_SRC] ? nla_get_be32(tb[RTA_SRC]) : 0;
2408 dst = tb[RTA_DST] ? nla_get_be32(tb[RTA_DST]) : 0;
2409 iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
2410 mark = tb[RTA_MARK] ? nla_get_u32(tb[RTA_MARK]) : 0;
2411
2412 memset(&fl4, 0, sizeof(fl4));
2413 fl4.daddr = dst;
2414 fl4.saddr = src;
2415 fl4.flowi4_tos = rtm->rtm_tos;
2416 fl4.flowi4_oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0;
2417 fl4.flowi4_mark = mark;
2418
2419 if (iif) {
2420 struct net_device *dev;
2421
2422 dev = __dev_get_by_index(net, iif);
2423 if (dev == NULL) {
2424 err = -ENODEV;
2425 goto errout_free;
2426 }
2427
2428 skb->protocol = htons(ETH_P_IP);
2429 skb->dev = dev;
2430 skb->mark = mark;
2431 local_bh_disable();
2432 err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
2433 local_bh_enable();
2434
2435 rt = skb_rtable(skb);
2436 if (err == 0 && rt->dst.error)
2437 err = -rt->dst.error;
2438 } else {
2439 rt = ip_route_output_key(net, &fl4);
2440
2441 err = 0;
2442 if (IS_ERR(rt))
2443 err = PTR_ERR(rt);
2444 }
2445
2446 if (err)
2447 goto errout_free;
2448
2449 skb_dst_set(skb, &rt->dst);
2450 if (rtm->rtm_flags & RTM_F_NOTIFY)
2451 rt->rt_flags |= RTCF_NOTIFY;
2452
2453 err = rt_fill_info(net, dst, src, &fl4, skb,
2454 NETLINK_CB(in_skb).portid, nlh->nlmsg_seq,
2455 RTM_NEWROUTE, 0, 0);
2456 if (err <= 0)
2457 goto errout_free;
2458
2459 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2460 errout:
2461 return err;
2462
2463 errout_free:
2464 kfree_skb(skb);
2465 goto errout;
2466 }
2467
2468 int ip_rt_dump(struct sk_buff *skb, struct netlink_callback *cb)
2469 {
2470 return skb->len;
2471 }
2472
2473 void ip_rt_multicast_event(struct in_device *in_dev)
2474 {
2475 rt_cache_flush(dev_net(in_dev->dev));
2476 }
2477
2478 #ifdef CONFIG_SYSCTL
2479 static int ip_rt_gc_timeout __read_mostly = RT_GC_TIMEOUT;
2480 static int ip_rt_gc_interval __read_mostly = 60 * HZ;
2481 static int ip_rt_gc_min_interval __read_mostly = HZ / 2;
2482 static int ip_rt_gc_elasticity __read_mostly = 8;
2483
2484 static int ipv4_sysctl_rtcache_flush(struct ctl_table *__ctl, int write,
2485 void __user *buffer,
2486 size_t *lenp, loff_t *ppos)
2487 {
2488 struct net *net = (struct net *)__ctl->extra1;
2489
2490 if (write) {
2491 rt_cache_flush(net);
2492 fnhe_genid_bump(net);
2493 return 0;
2494 }
2495
2496 return -EINVAL;
2497 }
2498
2499 static struct ctl_table ipv4_route_table[] = {
2500 {
2501 .procname = "gc_thresh",
2502 .data = &ipv4_dst_ops.gc_thresh,
2503 .maxlen = sizeof(int),
2504 .mode = 0644,
2505 .proc_handler = proc_dointvec,
2506 },
2507 {
2508 .procname = "max_size",
2509 .data = &ip_rt_max_size,
2510 .maxlen = sizeof(int),
2511 .mode = 0644,
2512 .proc_handler = proc_dointvec,
2513 },
2514 {
2515 /* Deprecated. Use gc_min_interval_ms */
2516
2517 .procname = "gc_min_interval",
2518 .data = &ip_rt_gc_min_interval,
2519 .maxlen = sizeof(int),
2520 .mode = 0644,
2521 .proc_handler = proc_dointvec_jiffies,
2522 },
2523 {
2524 .procname = "gc_min_interval_ms",
2525 .data = &ip_rt_gc_min_interval,
2526 .maxlen = sizeof(int),
2527 .mode = 0644,
2528 .proc_handler = proc_dointvec_ms_jiffies,
2529 },
2530 {
2531 .procname = "gc_timeout",
2532 .data = &ip_rt_gc_timeout,
2533 .maxlen = sizeof(int),
2534 .mode = 0644,
2535 .proc_handler = proc_dointvec_jiffies,
2536 },
2537 {
2538 .procname = "gc_interval",
2539 .data = &ip_rt_gc_interval,
2540 .maxlen = sizeof(int),
2541 .mode = 0644,
2542 .proc_handler = proc_dointvec_jiffies,
2543 },
2544 {
2545 .procname = "redirect_load",
2546 .data = &ip_rt_redirect_load,
2547 .maxlen = sizeof(int),
2548 .mode = 0644,
2549 .proc_handler = proc_dointvec,
2550 },
2551 {
2552 .procname = "redirect_number",
2553 .data = &ip_rt_redirect_number,
2554 .maxlen = sizeof(int),
2555 .mode = 0644,
2556 .proc_handler = proc_dointvec,
2557 },
2558 {
2559 .procname = "redirect_silence",
2560 .data = &ip_rt_redirect_silence,
2561 .maxlen = sizeof(int),
2562 .mode = 0644,
2563 .proc_handler = proc_dointvec,
2564 },
2565 {
2566 .procname = "error_cost",
2567 .data = &ip_rt_error_cost,
2568 .maxlen = sizeof(int),
2569 .mode = 0644,
2570 .proc_handler = proc_dointvec,
2571 },
2572 {
2573 .procname = "error_burst",
2574 .data = &ip_rt_error_burst,
2575 .maxlen = sizeof(int),
2576 .mode = 0644,
2577 .proc_handler = proc_dointvec,
2578 },
2579 {
2580 .procname = "gc_elasticity",
2581 .data = &ip_rt_gc_elasticity,
2582 .maxlen = sizeof(int),
2583 .mode = 0644,
2584 .proc_handler = proc_dointvec,
2585 },
2586 {
2587 .procname = "mtu_expires",
2588 .data = &ip_rt_mtu_expires,
2589 .maxlen = sizeof(int),
2590 .mode = 0644,
2591 .proc_handler = proc_dointvec_jiffies,
2592 },
2593 {
2594 .procname = "min_pmtu",
2595 .data = &ip_rt_min_pmtu,
2596 .maxlen = sizeof(int),
2597 .mode = 0644,
2598 .proc_handler = proc_dointvec,
2599 },
2600 {
2601 .procname = "min_adv_mss",
2602 .data = &ip_rt_min_advmss,
2603 .maxlen = sizeof(int),
2604 .mode = 0644,
2605 .proc_handler = proc_dointvec,
2606 },
2607 { }
2608 };
2609
2610 static struct ctl_table ipv4_route_flush_table[] = {
2611 {
2612 .procname = "flush",
2613 .maxlen = sizeof(int),
2614 .mode = 0200,
2615 .proc_handler = ipv4_sysctl_rtcache_flush,
2616 },
2617 { },
2618 };
2619
2620 static __net_init int sysctl_route_net_init(struct net *net)
2621 {
2622 struct ctl_table *tbl;
2623
2624 tbl = ipv4_route_flush_table;
2625 if (!net_eq(net, &init_net)) {
2626 tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
2627 if (tbl == NULL)
2628 goto err_dup;
2629
2630 /* Don't export sysctls to unprivileged users */
2631 if (net->user_ns != &init_user_ns)
2632 tbl[0].procname = NULL;
2633 }
2634 tbl[0].extra1 = net;
2635
2636 net->ipv4.route_hdr = register_net_sysctl(net, "net/ipv4/route", tbl);
2637 if (net->ipv4.route_hdr == NULL)
2638 goto err_reg;
2639 return 0;
2640
2641 err_reg:
2642 if (tbl != ipv4_route_flush_table)
2643 kfree(tbl);
2644 err_dup:
2645 return -ENOMEM;
2646 }
2647
2648 static __net_exit void sysctl_route_net_exit(struct net *net)
2649 {
2650 struct ctl_table *tbl;
2651
2652 tbl = net->ipv4.route_hdr->ctl_table_arg;
2653 unregister_net_sysctl_table(net->ipv4.route_hdr);
2654 BUG_ON(tbl == ipv4_route_flush_table);
2655 kfree(tbl);
2656 }
2657
2658 static __net_initdata struct pernet_operations sysctl_route_ops = {
2659 .init = sysctl_route_net_init,
2660 .exit = sysctl_route_net_exit,
2661 };
2662 #endif
2663
2664 static __net_init int rt_genid_init(struct net *net)
2665 {
2666 atomic_set(&net->ipv4.rt_genid, 0);
2667 atomic_set(&net->fnhe_genid, 0);
2668 get_random_bytes(&net->ipv4.dev_addr_genid,
2669 sizeof(net->ipv4.dev_addr_genid));
2670 return 0;
2671 }
2672
2673 static __net_initdata struct pernet_operations rt_genid_ops = {
2674 .init = rt_genid_init,
2675 };
2676
2677 static int __net_init ipv4_inetpeer_init(struct net *net)
2678 {
2679 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
2680
2681 if (!bp)
2682 return -ENOMEM;
2683 inet_peer_base_init(bp);
2684 net->ipv4.peers = bp;
2685 return 0;
2686 }
2687
2688 static void __net_exit ipv4_inetpeer_exit(struct net *net)
2689 {
2690 struct inet_peer_base *bp = net->ipv4.peers;
2691
2692 net->ipv4.peers = NULL;
2693 inetpeer_invalidate_tree(bp);
2694 kfree(bp);
2695 }
2696
2697 static __net_initdata struct pernet_operations ipv4_inetpeer_ops = {
2698 .init = ipv4_inetpeer_init,
2699 .exit = ipv4_inetpeer_exit,
2700 };
2701
2702 #ifdef CONFIG_IP_ROUTE_CLASSID
2703 struct ip_rt_acct __percpu *ip_rt_acct __read_mostly;
2704 #endif /* CONFIG_IP_ROUTE_CLASSID */
2705
2706 int __init ip_rt_init(void)
2707 {
2708 int rc = 0;
2709
2710 #ifdef CONFIG_IP_ROUTE_CLASSID
2711 ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
2712 if (!ip_rt_acct)
2713 panic("IP: failed to allocate ip_rt_acct\n");
2714 #endif
2715
2716 ipv4_dst_ops.kmem_cachep =
2717 kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
2718 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
2719
2720 ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
2721
2722 if (dst_entries_init(&ipv4_dst_ops) < 0)
2723 panic("IP: failed to allocate ipv4_dst_ops counter\n");
2724
2725 if (dst_entries_init(&ipv4_dst_blackhole_ops) < 0)
2726 panic("IP: failed to allocate ipv4_dst_blackhole_ops counter\n");
2727
2728 ipv4_dst_ops.gc_thresh = ~0;
2729 ip_rt_max_size = INT_MAX;
2730
2731 devinet_init();
2732 ip_fib_init();
2733
2734 if (ip_rt_proc_init())
2735 pr_err("Unable to create route proc files\n");
2736 #ifdef CONFIG_XFRM
2737 xfrm_init();
2738 xfrm4_init();
2739 #endif
2740 rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL, NULL);
2741
2742 #ifdef CONFIG_SYSCTL
2743 register_pernet_subsys(&sysctl_route_ops);
2744 #endif
2745 register_pernet_subsys(&rt_genid_ops);
2746 register_pernet_subsys(&ipv4_inetpeer_ops);
2747 return rc;
2748 }
2749
2750 #ifdef CONFIG_SYSCTL
2751 /*
2752 * We really need to sanitize the damn ipv4 init order, then all
2753 * this nonsense will go away.
2754 */
2755 void __init ip_static_sysctl_init(void)
2756 {
2757 register_net_sysctl(&init_net, "net/ipv4/route", ipv4_route_table);
2758 }
2759 #endif
(deprecated) Btrfs devel tree