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