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