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.
6 * ROUTE - implementation of the IP router.
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>
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
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.
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
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.
65 #define pr_fmt(fmt) "IPv4: " fmt
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>
73 #include <linux/string.h>
74 #include <linux/socket.h>
75 #include <linux/sockios.h>
76 #include <linux/errno.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>
94 #include <net/dst_metadata.h>
95 #include <net/net_namespace.h>
96 #include <net/protocol.h>
98 #include <net/route.h>
99 #include <net/inetpeer.h>
100 #include <net/sock.h>
101 #include <net/ip_fib.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>
110 #include <linux/sysctl.h>
112 #include <net/secure_seq.h>
113 #include <net/ip_tunnels.h>
114 #include <net/l3mdev.h>
116 #include "fib_lookup.h"
118 #define RT_FL_TOS(oldflp4) \
119 ((oldflp4)->flowi4_tos & (IPTOS_RT_MASK | RTO_ONLINK))
121 #define RT_GC_TIMEOUT (300*HZ)
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;
133 static int ip_rt_gc_timeout __read_mostly
= RT_GC_TIMEOUT
;
136 * Interface to generic destination cache.
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
);
150 static u32
*ipv4_cow_metrics(struct dst_entry
*dst
, unsigned long old
)
156 static struct neighbour
*ipv4_neigh_lookup(const struct dst_entry
*dst
,
159 static void ipv4_confirm_neigh(const struct dst_entry
*dst
, const void *daddr
);
161 static struct dst_ops ipv4_dst_ops
= {
163 .check
= ipv4_dst_check
,
164 .default_advmss
= ipv4_default_advmss
,
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
,
177 #define ECN_OR_COST(class) TC_PRIO_##class
179 const __u8 ip_tos2prio
[16] = {
181 ECN_OR_COST(BESTEFFORT
),
183 ECN_OR_COST(BESTEFFORT
),
189 ECN_OR_COST(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
)
197 EXPORT_SYMBOL(ip_tos2prio
);
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)
202 #ifdef CONFIG_PROC_FS
203 static void *rt_cache_seq_start(struct seq_file
*seq
, loff_t
*pos
)
207 return SEQ_START_TOKEN
;
210 static void *rt_cache_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
216 static void rt_cache_seq_stop(struct seq_file
*seq
, void *v
)
220 static int rt_cache_seq_show(struct seq_file
*seq
, void *v
)
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"
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
,
237 static int rt_cache_seq_open(struct inode
*inode
, struct file
*file
)
239 return seq_open(file
, &rt_cache_seq_ops
);
242 static const struct file_operations rt_cache_seq_fops
= {
243 .open
= rt_cache_seq_open
,
246 .release
= seq_release
,
250 static void *rt_cpu_seq_start(struct seq_file
*seq
, loff_t
*pos
)
255 return SEQ_START_TOKEN
;
257 for (cpu
= *pos
-1; cpu
< nr_cpu_ids
; ++cpu
) {
258 if (!cpu_possible(cpu
))
261 return &per_cpu(rt_cache_stat
, cpu
);
266 static void *rt_cpu_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
270 for (cpu
= *pos
; cpu
< nr_cpu_ids
; ++cpu
) {
271 if (!cpu_possible(cpu
))
274 return &per_cpu(rt_cache_stat
, cpu
);
280 static void rt_cpu_seq_stop(struct seq_file
*seq
, void *v
)
285 static int rt_cpu_seq_show(struct seq_file
*seq
, void *v
)
287 struct rt_cache_stat
*st
= v
;
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");
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
),
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 */
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
,
327 static int rt_cpu_seq_open(struct inode
*inode
, struct file
*file
)
329 return seq_open(file
, &rt_cpu_seq_ops
);
332 static const struct file_operations rt_cpu_seq_fops
= {
333 .open
= rt_cpu_seq_open
,
336 .release
= seq_release
,
339 #ifdef CONFIG_IP_ROUTE_CLASSID
340 static int rt_acct_proc_show(struct seq_file
*m
, void *v
)
342 struct ip_rt_acct
*dst
, *src
;
345 dst
= kcalloc(256, sizeof(struct ip_rt_acct
), GFP_KERNEL
);
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
;
359 seq_write(m
, dst
, 256 * sizeof(struct ip_rt_acct
));
365 static int __net_init
ip_rt_do_proc_init(struct net
*net
)
367 struct proc_dir_entry
*pde
;
369 pde
= proc_create("rt_cache", 0444, net
->proc_net
,
374 pde
= proc_create("rt_cache", 0444,
375 net
->proc_net_stat
, &rt_cpu_seq_fops
);
379 #ifdef CONFIG_IP_ROUTE_CLASSID
380 pde
= proc_create_single("rt_acct", 0, net
->proc_net
,
387 #ifdef CONFIG_IP_ROUTE_CLASSID
389 remove_proc_entry("rt_cache", net
->proc_net_stat
);
392 remove_proc_entry("rt_cache", net
->proc_net
);
397 static void __net_exit
ip_rt_do_proc_exit(struct net
*net
)
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
);
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
,
411 static int __init
ip_rt_proc_init(void)
413 return register_pernet_subsys(&ip_rt_proc_ops
);
417 static inline int ip_rt_proc_init(void)
421 #endif /* CONFIG_PROC_FS */
423 static inline bool rt_is_expired(const struct rtable
*rth
)
425 return rth
->rt_genid
!= rt_genid_ipv4(dev_net(rth
->dst
.dev
));
428 void rt_cache_flush(struct net
*net
)
430 rt_genid_bump_ipv4(net
);
433 static struct neighbour
*ipv4_neigh_lookup(const struct dst_entry
*dst
,
437 struct net_device
*dev
= dst
->dev
;
438 const __be32
*pkey
= daddr
;
439 const struct rtable
*rt
;
442 rt
= (const struct rtable
*) dst
;
444 pkey
= (const __be32
*) &rt
->rt_gateway
;
446 pkey
= &ip_hdr(skb
)->daddr
;
448 n
= __ipv4_neigh_lookup(dev
, *(__force u32
*)pkey
);
451 return neigh_create(&arp_tbl
, pkey
, dev
);
454 static void ipv4_confirm_neigh(const struct dst_entry
*dst
, const void *daddr
)
456 struct net_device
*dev
= dst
->dev
;
457 const __be32
*pkey
= daddr
;
458 const struct rtable
*rt
;
460 rt
= (const struct rtable
*)dst
;
462 pkey
= (const __be32
*)&rt
->rt_gateway
;
465 (RTCF_MULTICAST
| RTCF_BROADCAST
| RTCF_LOCAL
)))
468 __ipv4_confirm_neigh(dev
, *(__force u32
*)pkey
);
471 #define IP_IDENTS_SZ 2048u
473 static atomic_t
*ip_idents __read_mostly
;
474 static u32
*ip_tstamps __read_mostly
;
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.
480 u32
ip_idents_reserve(u32 hash
, int segs
)
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
;
488 if (old
!= now
&& cmpxchg(p_tstamp
, old
, now
) == old
)
489 delta
= prandom_u32_max(now
- old
);
491 /* Do not use atomic_add_return() as it makes UBSAN unhappy */
493 old
= (u32
)atomic_read(p_id
);
494 new = old
+ delta
+ segs
;
495 } while (atomic_cmpxchg(p_id
, old
, new) != old
);
499 EXPORT_SYMBOL(ip_idents_reserve
);
501 void __ip_select_ident(struct net
*net
, struct iphdr
*iph
, int segs
)
503 static u32 ip_idents_hashrnd __read_mostly
;
506 net_get_random_once(&ip_idents_hashrnd
, sizeof(ip_idents_hashrnd
));
508 hash
= jhash_3words((__force u32
)iph
->daddr
,
509 (__force u32
)iph
->saddr
,
510 iph
->protocol
^ net_hash_mix(net
),
512 id
= ip_idents_reserve(hash
, segs
);
515 EXPORT_SYMBOL(__ip_select_ident
);
517 static void __build_flow_key(const struct net
*net
, struct flowi4
*fl4
,
518 const struct sock
*sk
,
519 const struct iphdr
*iph
,
521 u8 prot
, u32 mark
, int flow_flags
)
524 const struct inet_sock
*inet
= inet_sk(sk
);
526 oif
= sk
->sk_bound_dev_if
;
528 tos
= RT_CONN_FLAGS(sk
);
529 prot
= inet
->hdrincl
? IPPROTO_RAW
: sk
->sk_protocol
;
531 flowi4_init_output(fl4
, oif
, mark
, tos
,
532 RT_SCOPE_UNIVERSE
, prot
,
534 iph
->daddr
, iph
->saddr
, 0, 0,
535 sock_net_uid(net
, sk
));
538 static void build_skb_flow_key(struct flowi4
*fl4
, const struct sk_buff
*skb
,
539 const struct sock
*sk
)
541 const struct net
*net
= dev_net(skb
->dev
);
542 const struct iphdr
*iph
= ip_hdr(skb
);
543 int oif
= skb
->dev
->ifindex
;
544 u8 tos
= RT_TOS(iph
->tos
);
545 u8 prot
= iph
->protocol
;
546 u32 mark
= skb
->mark
;
548 __build_flow_key(net
, fl4
, sk
, iph
, oif
, tos
, prot
, mark
, 0);
551 static void build_sk_flow_key(struct flowi4
*fl4
, const struct sock
*sk
)
553 const struct inet_sock
*inet
= inet_sk(sk
);
554 const struct ip_options_rcu
*inet_opt
;
555 __be32 daddr
= inet
->inet_daddr
;
558 inet_opt
= rcu_dereference(inet
->inet_opt
);
559 if (inet_opt
&& inet_opt
->opt
.srr
)
560 daddr
= inet_opt
->opt
.faddr
;
561 flowi4_init_output(fl4
, sk
->sk_bound_dev_if
, sk
->sk_mark
,
562 RT_CONN_FLAGS(sk
), RT_SCOPE_UNIVERSE
,
563 inet
->hdrincl
? IPPROTO_RAW
: sk
->sk_protocol
,
564 inet_sk_flowi_flags(sk
),
565 daddr
, inet
->inet_saddr
, 0, 0, sk
->sk_uid
);
569 static void ip_rt_build_flow_key(struct flowi4
*fl4
, const struct sock
*sk
,
570 const struct sk_buff
*skb
)
573 build_skb_flow_key(fl4
, skb
, sk
);
575 build_sk_flow_key(fl4
, sk
);
578 static DEFINE_SPINLOCK(fnhe_lock
);
580 static void fnhe_flush_routes(struct fib_nh_exception
*fnhe
)
584 rt
= rcu_dereference(fnhe
->fnhe_rth_input
);
586 RCU_INIT_POINTER(fnhe
->fnhe_rth_input
, NULL
);
587 dst_dev_put(&rt
->dst
);
588 dst_release(&rt
->dst
);
590 rt
= rcu_dereference(fnhe
->fnhe_rth_output
);
592 RCU_INIT_POINTER(fnhe
->fnhe_rth_output
, NULL
);
593 dst_dev_put(&rt
->dst
);
594 dst_release(&rt
->dst
);
598 static struct fib_nh_exception
*fnhe_oldest(struct fnhe_hash_bucket
*hash
)
600 struct fib_nh_exception
*fnhe
, *oldest
;
602 oldest
= rcu_dereference(hash
->chain
);
603 for (fnhe
= rcu_dereference(oldest
->fnhe_next
); fnhe
;
604 fnhe
= rcu_dereference(fnhe
->fnhe_next
)) {
605 if (time_before(fnhe
->fnhe_stamp
, oldest
->fnhe_stamp
))
608 fnhe_flush_routes(oldest
);
612 static inline u32
fnhe_hashfun(__be32 daddr
)
614 static u32 fnhe_hashrnd __read_mostly
;
617 net_get_random_once(&fnhe_hashrnd
, sizeof(fnhe_hashrnd
));
618 hval
= jhash_1word((__force u32
) daddr
, fnhe_hashrnd
);
619 return hash_32(hval
, FNHE_HASH_SHIFT
);
622 static void fill_route_from_fnhe(struct rtable
*rt
, struct fib_nh_exception
*fnhe
)
624 rt
->rt_pmtu
= fnhe
->fnhe_pmtu
;
625 rt
->rt_mtu_locked
= fnhe
->fnhe_mtu_locked
;
626 rt
->dst
.expires
= fnhe
->fnhe_expires
;
629 rt
->rt_flags
|= RTCF_REDIRECTED
;
630 rt
->rt_gateway
= fnhe
->fnhe_gw
;
631 rt
->rt_uses_gateway
= 1;
635 static void update_or_create_fnhe(struct fib_nh
*nh
, __be32 daddr
, __be32 gw
,
636 u32 pmtu
, bool lock
, unsigned long expires
)
638 struct fnhe_hash_bucket
*hash
;
639 struct fib_nh_exception
*fnhe
;
645 genid
= fnhe_genid(dev_net(nh
->nh_dev
));
646 hval
= fnhe_hashfun(daddr
);
648 spin_lock_bh(&fnhe_lock
);
650 hash
= rcu_dereference(nh
->nh_exceptions
);
652 hash
= kcalloc(FNHE_HASH_SIZE
, sizeof(*hash
), GFP_ATOMIC
);
655 rcu_assign_pointer(nh
->nh_exceptions
, hash
);
661 for (fnhe
= rcu_dereference(hash
->chain
); fnhe
;
662 fnhe
= rcu_dereference(fnhe
->fnhe_next
)) {
663 if (fnhe
->fnhe_daddr
== daddr
)
669 if (fnhe
->fnhe_genid
!= genid
)
670 fnhe
->fnhe_genid
= genid
;
674 fnhe
->fnhe_pmtu
= pmtu
;
675 fnhe
->fnhe_mtu_locked
= lock
;
677 fnhe
->fnhe_expires
= max(1UL, expires
);
678 /* Update all cached dsts too */
679 rt
= rcu_dereference(fnhe
->fnhe_rth_input
);
681 fill_route_from_fnhe(rt
, fnhe
);
682 rt
= rcu_dereference(fnhe
->fnhe_rth_output
);
684 fill_route_from_fnhe(rt
, fnhe
);
686 if (depth
> FNHE_RECLAIM_DEPTH
)
687 fnhe
= fnhe_oldest(hash
);
689 fnhe
= kzalloc(sizeof(*fnhe
), GFP_ATOMIC
);
693 fnhe
->fnhe_next
= hash
->chain
;
694 rcu_assign_pointer(hash
->chain
, fnhe
);
696 fnhe
->fnhe_genid
= genid
;
697 fnhe
->fnhe_daddr
= daddr
;
699 fnhe
->fnhe_pmtu
= pmtu
;
700 fnhe
->fnhe_mtu_locked
= lock
;
701 fnhe
->fnhe_expires
= max(1UL, expires
);
703 /* Exception created; mark the cached routes for the nexthop
704 * stale, so anyone caching it rechecks if this exception
707 rt
= rcu_dereference(nh
->nh_rth_input
);
709 rt
->dst
.obsolete
= DST_OBSOLETE_KILL
;
711 for_each_possible_cpu(i
) {
712 struct rtable __rcu
**prt
;
713 prt
= per_cpu_ptr(nh
->nh_pcpu_rth_output
, i
);
714 rt
= rcu_dereference(*prt
);
716 rt
->dst
.obsolete
= DST_OBSOLETE_KILL
;
720 fnhe
->fnhe_stamp
= jiffies
;
723 spin_unlock_bh(&fnhe_lock
);
726 static void __ip_do_redirect(struct rtable
*rt
, struct sk_buff
*skb
, struct flowi4
*fl4
,
729 __be32 new_gw
= icmp_hdr(skb
)->un
.gateway
;
730 __be32 old_gw
= ip_hdr(skb
)->saddr
;
731 struct net_device
*dev
= skb
->dev
;
732 struct in_device
*in_dev
;
733 struct fib_result res
;
737 switch (icmp_hdr(skb
)->code
& 7) {
739 case ICMP_REDIR_NETTOS
:
740 case ICMP_REDIR_HOST
:
741 case ICMP_REDIR_HOSTTOS
:
748 if (rt
->rt_gateway
!= old_gw
)
751 in_dev
= __in_dev_get_rcu(dev
);
756 if (new_gw
== old_gw
|| !IN_DEV_RX_REDIRECTS(in_dev
) ||
757 ipv4_is_multicast(new_gw
) || ipv4_is_lbcast(new_gw
) ||
758 ipv4_is_zeronet(new_gw
))
759 goto reject_redirect
;
761 if (!IN_DEV_SHARED_MEDIA(in_dev
)) {
762 if (!inet_addr_onlink(in_dev
, new_gw
, old_gw
))
763 goto reject_redirect
;
764 if (IN_DEV_SEC_REDIRECTS(in_dev
) && ip_fib_check_default(new_gw
, dev
))
765 goto reject_redirect
;
767 if (inet_addr_type(net
, new_gw
) != RTN_UNICAST
)
768 goto reject_redirect
;
771 n
= __ipv4_neigh_lookup(rt
->dst
.dev
, new_gw
);
773 n
= neigh_create(&arp_tbl
, &new_gw
, rt
->dst
.dev
);
775 if (!(n
->nud_state
& NUD_VALID
)) {
776 neigh_event_send(n
, NULL
);
778 if (fib_lookup(net
, fl4
, &res
, 0) == 0) {
779 struct fib_nh
*nh
= &FIB_RES_NH(res
);
781 update_or_create_fnhe(nh
, fl4
->daddr
, new_gw
,
783 jiffies
+ ip_rt_gc_timeout
);
786 rt
->dst
.obsolete
= DST_OBSOLETE_KILL
;
787 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE
, n
);
794 #ifdef CONFIG_IP_ROUTE_VERBOSE
795 if (IN_DEV_LOG_MARTIANS(in_dev
)) {
796 const struct iphdr
*iph
= (const struct iphdr
*) skb
->data
;
797 __be32 daddr
= iph
->daddr
;
798 __be32 saddr
= iph
->saddr
;
800 net_info_ratelimited("Redirect from %pI4 on %s about %pI4 ignored\n"
801 " Advised path = %pI4 -> %pI4\n",
802 &old_gw
, dev
->name
, &new_gw
,
809 static void ip_do_redirect(struct dst_entry
*dst
, struct sock
*sk
, struct sk_buff
*skb
)
813 const struct iphdr
*iph
= (const struct iphdr
*) skb
->data
;
814 struct net
*net
= dev_net(skb
->dev
);
815 int oif
= skb
->dev
->ifindex
;
816 u8 tos
= RT_TOS(iph
->tos
);
817 u8 prot
= iph
->protocol
;
818 u32 mark
= skb
->mark
;
820 rt
= (struct rtable
*) dst
;
822 __build_flow_key(net
, &fl4
, sk
, iph
, oif
, tos
, prot
, mark
, 0);
823 __ip_do_redirect(rt
, skb
, &fl4
, true);
826 static struct dst_entry
*ipv4_negative_advice(struct dst_entry
*dst
)
828 struct rtable
*rt
= (struct rtable
*)dst
;
829 struct dst_entry
*ret
= dst
;
832 if (dst
->obsolete
> 0) {
835 } else if ((rt
->rt_flags
& RTCF_REDIRECTED
) ||
846 * 1. The first ip_rt_redirect_number redirects are sent
847 * with exponential backoff, then we stop sending them at all,
848 * assuming that the host ignores our redirects.
849 * 2. If we did not see packets requiring redirects
850 * during ip_rt_redirect_silence, we assume that the host
851 * forgot redirected route and start to send redirects again.
853 * This algorithm is much cheaper and more intelligent than dumb load limiting
856 * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
857 * and "frag. need" (breaks PMTU discovery) in icmp.c.
860 void ip_rt_send_redirect(struct sk_buff
*skb
)
862 struct rtable
*rt
= skb_rtable(skb
);
863 struct in_device
*in_dev
;
864 struct inet_peer
*peer
;
870 in_dev
= __in_dev_get_rcu(rt
->dst
.dev
);
871 if (!in_dev
|| !IN_DEV_TX_REDIRECTS(in_dev
)) {
875 log_martians
= IN_DEV_LOG_MARTIANS(in_dev
);
876 vif
= l3mdev_master_ifindex_rcu(rt
->dst
.dev
);
879 net
= dev_net(rt
->dst
.dev
);
880 peer
= inet_getpeer_v4(net
->ipv4
.peers
, ip_hdr(skb
)->saddr
, vif
, 1);
882 icmp_send(skb
, ICMP_REDIRECT
, ICMP_REDIR_HOST
,
883 rt_nexthop(rt
, ip_hdr(skb
)->daddr
));
887 /* No redirected packets during ip_rt_redirect_silence;
888 * reset the algorithm.
890 if (time_after(jiffies
, peer
->rate_last
+ ip_rt_redirect_silence
))
891 peer
->rate_tokens
= 0;
893 /* Too many ignored redirects; do not send anything
894 * set dst.rate_last to the last seen redirected packet.
896 if (peer
->rate_tokens
>= ip_rt_redirect_number
) {
897 peer
->rate_last
= jiffies
;
901 /* Check for load limit; set rate_last to the latest sent
904 if (peer
->rate_tokens
== 0 ||
907 (ip_rt_redirect_load
<< peer
->rate_tokens
)))) {
908 __be32 gw
= rt_nexthop(rt
, ip_hdr(skb
)->daddr
);
910 icmp_send(skb
, ICMP_REDIRECT
, ICMP_REDIR_HOST
, gw
);
911 peer
->rate_last
= jiffies
;
913 #ifdef CONFIG_IP_ROUTE_VERBOSE
915 peer
->rate_tokens
== ip_rt_redirect_number
)
916 net_warn_ratelimited("host %pI4/if%d ignores redirects for %pI4 to %pI4\n",
917 &ip_hdr(skb
)->saddr
, inet_iif(skb
),
918 &ip_hdr(skb
)->daddr
, &gw
);
925 static int ip_error(struct sk_buff
*skb
)
927 struct rtable
*rt
= skb_rtable(skb
);
928 struct net_device
*dev
= skb
->dev
;
929 struct in_device
*in_dev
;
930 struct inet_peer
*peer
;
936 if (netif_is_l3_master(skb
->dev
)) {
937 dev
= __dev_get_by_index(dev_net(skb
->dev
), IPCB(skb
)->iif
);
942 in_dev
= __in_dev_get_rcu(dev
);
944 /* IP on this device is disabled. */
948 net
= dev_net(rt
->dst
.dev
);
949 if (!IN_DEV_FORWARD(in_dev
)) {
950 switch (rt
->dst
.error
) {
952 __IP_INC_STATS(net
, IPSTATS_MIB_INADDRERRORS
);
956 __IP_INC_STATS(net
, IPSTATS_MIB_INNOROUTES
);
962 switch (rt
->dst
.error
) {
967 code
= ICMP_HOST_UNREACH
;
970 code
= ICMP_NET_UNREACH
;
971 __IP_INC_STATS(net
, IPSTATS_MIB_INNOROUTES
);
974 code
= ICMP_PKT_FILTERED
;
978 peer
= inet_getpeer_v4(net
->ipv4
.peers
, ip_hdr(skb
)->saddr
,
979 l3mdev_master_ifindex(skb
->dev
), 1);
984 peer
->rate_tokens
+= now
- peer
->rate_last
;
985 if (peer
->rate_tokens
> ip_rt_error_burst
)
986 peer
->rate_tokens
= ip_rt_error_burst
;
987 peer
->rate_last
= now
;
988 if (peer
->rate_tokens
>= ip_rt_error_cost
)
989 peer
->rate_tokens
-= ip_rt_error_cost
;
995 icmp_send(skb
, ICMP_DEST_UNREACH
, code
, 0);
1001 static void __ip_rt_update_pmtu(struct rtable
*rt
, struct flowi4
*fl4
, u32 mtu
)
1003 struct dst_entry
*dst
= &rt
->dst
;
1004 u32 old_mtu
= ipv4_mtu(dst
);
1005 struct fib_result res
;
1008 if (ip_mtu_locked(dst
))
1014 if (mtu
< ip_rt_min_pmtu
) {
1016 mtu
= min(old_mtu
, ip_rt_min_pmtu
);
1019 if (rt
->rt_pmtu
== mtu
&& !lock
&&
1020 time_before(jiffies
, dst
->expires
- ip_rt_mtu_expires
/ 2))
1024 if (fib_lookup(dev_net(dst
->dev
), fl4
, &res
, 0) == 0) {
1025 struct fib_nh
*nh
= &FIB_RES_NH(res
);
1027 update_or_create_fnhe(nh
, fl4
->daddr
, 0, mtu
, lock
,
1028 jiffies
+ ip_rt_mtu_expires
);
1033 static void ip_rt_update_pmtu(struct dst_entry
*dst
, struct sock
*sk
,
1034 struct sk_buff
*skb
, u32 mtu
)
1036 struct rtable
*rt
= (struct rtable
*) dst
;
1039 ip_rt_build_flow_key(&fl4
, sk
, skb
);
1040 __ip_rt_update_pmtu(rt
, &fl4
, mtu
);
1043 void ipv4_update_pmtu(struct sk_buff
*skb
, struct net
*net
, u32 mtu
,
1044 int oif
, u8 protocol
)
1046 const struct iphdr
*iph
= (const struct iphdr
*) skb
->data
;
1049 u32 mark
= IP4_REPLY_MARK(net
, skb
->mark
);
1051 __build_flow_key(net
, &fl4
, NULL
, iph
, oif
,
1052 RT_TOS(iph
->tos
), protocol
, mark
, 0);
1053 rt
= __ip_route_output_key(net
, &fl4
);
1055 __ip_rt_update_pmtu(rt
, &fl4
, mtu
);
1059 EXPORT_SYMBOL_GPL(ipv4_update_pmtu
);
1061 static void __ipv4_sk_update_pmtu(struct sk_buff
*skb
, struct sock
*sk
, u32 mtu
)
1063 const struct iphdr
*iph
= (const struct iphdr
*) skb
->data
;
1067 __build_flow_key(sock_net(sk
), &fl4
, sk
, iph
, 0, 0, 0, 0, 0);
1069 if (!fl4
.flowi4_mark
)
1070 fl4
.flowi4_mark
= IP4_REPLY_MARK(sock_net(sk
), skb
->mark
);
1072 rt
= __ip_route_output_key(sock_net(sk
), &fl4
);
1074 __ip_rt_update_pmtu(rt
, &fl4
, mtu
);
1079 void ipv4_sk_update_pmtu(struct sk_buff
*skb
, struct sock
*sk
, u32 mtu
)
1081 const struct iphdr
*iph
= (const struct iphdr
*) skb
->data
;
1084 struct dst_entry
*odst
= NULL
;
1086 struct net
*net
= sock_net(sk
);
1090 if (!ip_sk_accept_pmtu(sk
))
1093 odst
= sk_dst_get(sk
);
1095 if (sock_owned_by_user(sk
) || !odst
) {
1096 __ipv4_sk_update_pmtu(skb
, sk
, mtu
);
1100 __build_flow_key(net
, &fl4
, sk
, iph
, 0, 0, 0, 0, 0);
1102 rt
= (struct rtable
*)odst
;
1103 if (odst
->obsolete
&& !odst
->ops
->check(odst
, 0)) {
1104 rt
= ip_route_output_flow(sock_net(sk
), &fl4
, sk
);
1111 __ip_rt_update_pmtu((struct rtable
*) xfrm_dst_path(&rt
->dst
), &fl4
, mtu
);
1113 if (!dst_check(&rt
->dst
, 0)) {
1115 dst_release(&rt
->dst
);
1117 rt
= ip_route_output_flow(sock_net(sk
), &fl4
, sk
);
1125 sk_dst_set(sk
, &rt
->dst
);
1131 EXPORT_SYMBOL_GPL(ipv4_sk_update_pmtu
);
1133 void ipv4_redirect(struct sk_buff
*skb
, struct net
*net
,
1134 int oif
, u8 protocol
)
1136 const struct iphdr
*iph
= (const struct iphdr
*) skb
->data
;
1140 __build_flow_key(net
, &fl4
, NULL
, iph
, oif
,
1141 RT_TOS(iph
->tos
), protocol
, 0, 0);
1142 rt
= __ip_route_output_key(net
, &fl4
);
1144 __ip_do_redirect(rt
, skb
, &fl4
, false);
1148 EXPORT_SYMBOL_GPL(ipv4_redirect
);
1150 void ipv4_sk_redirect(struct sk_buff
*skb
, struct sock
*sk
)
1152 const struct iphdr
*iph
= (const struct iphdr
*) skb
->data
;
1155 struct net
*net
= sock_net(sk
);
1157 __build_flow_key(net
, &fl4
, sk
, iph
, 0, 0, 0, 0, 0);
1158 rt
= __ip_route_output_key(net
, &fl4
);
1160 __ip_do_redirect(rt
, skb
, &fl4
, false);
1164 EXPORT_SYMBOL_GPL(ipv4_sk_redirect
);
1166 static struct dst_entry
*ipv4_dst_check(struct dst_entry
*dst
, u32 cookie
)
1168 struct rtable
*rt
= (struct rtable
*) dst
;
1170 /* All IPV4 dsts are created with ->obsolete set to the value
1171 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1172 * into this function always.
1174 * When a PMTU/redirect information update invalidates a route,
1175 * this is indicated by setting obsolete to DST_OBSOLETE_KILL or
1176 * DST_OBSOLETE_DEAD by dst_free().
1178 if (dst
->obsolete
!= DST_OBSOLETE_FORCE_CHK
|| rt_is_expired(rt
))
1183 static void ipv4_link_failure(struct sk_buff
*skb
)
1187 icmp_send(skb
, ICMP_DEST_UNREACH
, ICMP_HOST_UNREACH
, 0);
1189 rt
= skb_rtable(skb
);
1191 dst_set_expires(&rt
->dst
, 0);
1194 static int ip_rt_bug(struct net
*net
, struct sock
*sk
, struct sk_buff
*skb
)
1196 pr_debug("%s: %pI4 -> %pI4, %s\n",
1197 __func__
, &ip_hdr(skb
)->saddr
, &ip_hdr(skb
)->daddr
,
1198 skb
->dev
? skb
->dev
->name
: "?");
1205 We do not cache source address of outgoing interface,
1206 because it is used only by IP RR, TS and SRR options,
1207 so that it out of fast path.
1209 BTW remember: "addr" is allowed to be not aligned
1213 void ip_rt_get_source(u8
*addr
, struct sk_buff
*skb
, struct rtable
*rt
)
1217 if (rt_is_output_route(rt
))
1218 src
= ip_hdr(skb
)->saddr
;
1220 struct fib_result res
;
1221 struct iphdr
*iph
= ip_hdr(skb
);
1222 struct flowi4 fl4
= {
1223 .daddr
= iph
->daddr
,
1224 .saddr
= iph
->saddr
,
1225 .flowi4_tos
= RT_TOS(iph
->tos
),
1226 .flowi4_oif
= rt
->dst
.dev
->ifindex
,
1227 .flowi4_iif
= skb
->dev
->ifindex
,
1228 .flowi4_mark
= skb
->mark
,
1232 if (fib_lookup(dev_net(rt
->dst
.dev
), &fl4
, &res
, 0) == 0)
1233 src
= FIB_RES_PREFSRC(dev_net(rt
->dst
.dev
), res
);
1235 src
= inet_select_addr(rt
->dst
.dev
,
1236 rt_nexthop(rt
, iph
->daddr
),
1240 memcpy(addr
, &src
, 4);
1243 #ifdef CONFIG_IP_ROUTE_CLASSID
1244 static void set_class_tag(struct rtable
*rt
, u32 tag
)
1246 if (!(rt
->dst
.tclassid
& 0xFFFF))
1247 rt
->dst
.tclassid
|= tag
& 0xFFFF;
1248 if (!(rt
->dst
.tclassid
& 0xFFFF0000))
1249 rt
->dst
.tclassid
|= tag
& 0xFFFF0000;
1253 static unsigned int ipv4_default_advmss(const struct dst_entry
*dst
)
1255 unsigned int header_size
= sizeof(struct tcphdr
) + sizeof(struct iphdr
);
1256 unsigned int advmss
= max_t(unsigned int, ipv4_mtu(dst
) - header_size
,
1259 return min(advmss
, IPV4_MAX_PMTU
- header_size
);
1262 static unsigned int ipv4_mtu(const struct dst_entry
*dst
)
1264 const struct rtable
*rt
= (const struct rtable
*) dst
;
1265 unsigned int mtu
= rt
->rt_pmtu
;
1267 if (!mtu
|| time_after_eq(jiffies
, rt
->dst
.expires
))
1268 mtu
= dst_metric_raw(dst
, RTAX_MTU
);
1273 mtu
= READ_ONCE(dst
->dev
->mtu
);
1275 if (unlikely(ip_mtu_locked(dst
))) {
1276 if (rt
->rt_uses_gateway
&& mtu
> 576)
1280 mtu
= min_t(unsigned int, mtu
, IP_MAX_MTU
);
1282 return mtu
- lwtunnel_headroom(dst
->lwtstate
, mtu
);
1285 static void ip_del_fnhe(struct fib_nh
*nh
, __be32 daddr
)
1287 struct fnhe_hash_bucket
*hash
;
1288 struct fib_nh_exception
*fnhe
, __rcu
**fnhe_p
;
1289 u32 hval
= fnhe_hashfun(daddr
);
1291 spin_lock_bh(&fnhe_lock
);
1293 hash
= rcu_dereference_protected(nh
->nh_exceptions
,
1294 lockdep_is_held(&fnhe_lock
));
1297 fnhe_p
= &hash
->chain
;
1298 fnhe
= rcu_dereference_protected(*fnhe_p
, lockdep_is_held(&fnhe_lock
));
1300 if (fnhe
->fnhe_daddr
== daddr
) {
1301 rcu_assign_pointer(*fnhe_p
, rcu_dereference_protected(
1302 fnhe
->fnhe_next
, lockdep_is_held(&fnhe_lock
)));
1303 fnhe_flush_routes(fnhe
);
1304 kfree_rcu(fnhe
, rcu
);
1307 fnhe_p
= &fnhe
->fnhe_next
;
1308 fnhe
= rcu_dereference_protected(fnhe
->fnhe_next
,
1309 lockdep_is_held(&fnhe_lock
));
1312 spin_unlock_bh(&fnhe_lock
);
1315 static struct fib_nh_exception
*find_exception(struct fib_nh
*nh
, __be32 daddr
)
1317 struct fnhe_hash_bucket
*hash
= rcu_dereference(nh
->nh_exceptions
);
1318 struct fib_nh_exception
*fnhe
;
1324 hval
= fnhe_hashfun(daddr
);
1326 for (fnhe
= rcu_dereference(hash
[hval
].chain
); fnhe
;
1327 fnhe
= rcu_dereference(fnhe
->fnhe_next
)) {
1328 if (fnhe
->fnhe_daddr
== daddr
) {
1329 if (fnhe
->fnhe_expires
&&
1330 time_after(jiffies
, fnhe
->fnhe_expires
)) {
1331 ip_del_fnhe(nh
, daddr
);
1341 * 1. mtu on route is locked - use it
1342 * 2. mtu from nexthop exception
1343 * 3. mtu from egress device
1346 u32
ip_mtu_from_fib_result(struct fib_result
*res
, __be32 daddr
)
1348 struct fib_info
*fi
= res
->fi
;
1349 struct fib_nh
*nh
= &fi
->fib_nh
[res
->nh_sel
];
1350 struct net_device
*dev
= nh
->nh_dev
;
1353 if (dev_net(dev
)->ipv4
.sysctl_ip_fwd_use_pmtu
||
1354 fi
->fib_metrics
->metrics
[RTAX_LOCK
- 1] & (1 << RTAX_MTU
))
1358 struct fib_nh_exception
*fnhe
;
1360 fnhe
= find_exception(nh
, daddr
);
1361 if (fnhe
&& !time_after_eq(jiffies
, fnhe
->fnhe_expires
))
1362 mtu
= fnhe
->fnhe_pmtu
;
1366 mtu
= min(READ_ONCE(dev
->mtu
), IP_MAX_MTU
);
1368 return mtu
- lwtunnel_headroom(nh
->nh_lwtstate
, mtu
);
1371 static bool rt_bind_exception(struct rtable
*rt
, struct fib_nh_exception
*fnhe
,
1372 __be32 daddr
, const bool do_cache
)
1376 spin_lock_bh(&fnhe_lock
);
1378 if (daddr
== fnhe
->fnhe_daddr
) {
1379 struct rtable __rcu
**porig
;
1380 struct rtable
*orig
;
1381 int genid
= fnhe_genid(dev_net(rt
->dst
.dev
));
1383 if (rt_is_input_route(rt
))
1384 porig
= &fnhe
->fnhe_rth_input
;
1386 porig
= &fnhe
->fnhe_rth_output
;
1387 orig
= rcu_dereference(*porig
);
1389 if (fnhe
->fnhe_genid
!= genid
) {
1390 fnhe
->fnhe_genid
= genid
;
1392 fnhe
->fnhe_pmtu
= 0;
1393 fnhe
->fnhe_expires
= 0;
1394 fnhe
->fnhe_mtu_locked
= false;
1395 fnhe_flush_routes(fnhe
);
1398 fill_route_from_fnhe(rt
, fnhe
);
1399 if (!rt
->rt_gateway
)
1400 rt
->rt_gateway
= daddr
;
1404 rcu_assign_pointer(*porig
, rt
);
1406 dst_dev_put(&orig
->dst
);
1407 dst_release(&orig
->dst
);
1412 fnhe
->fnhe_stamp
= jiffies
;
1414 spin_unlock_bh(&fnhe_lock
);
1419 static bool rt_cache_route(struct fib_nh
*nh
, struct rtable
*rt
)
1421 struct rtable
*orig
, *prev
, **p
;
1424 if (rt_is_input_route(rt
)) {
1425 p
= (struct rtable
**)&nh
->nh_rth_input
;
1427 p
= (struct rtable
**)raw_cpu_ptr(nh
->nh_pcpu_rth_output
);
1431 /* hold dst before doing cmpxchg() to avoid race condition
1435 prev
= cmpxchg(p
, orig
, rt
);
1438 dst_dev_put(&orig
->dst
);
1439 dst_release(&orig
->dst
);
1442 dst_release(&rt
->dst
);
1449 struct uncached_list
{
1451 struct list_head head
;
1454 static DEFINE_PER_CPU_ALIGNED(struct uncached_list
, rt_uncached_list
);
1456 void rt_add_uncached_list(struct rtable
*rt
)
1458 struct uncached_list
*ul
= raw_cpu_ptr(&rt_uncached_list
);
1460 rt
->rt_uncached_list
= ul
;
1462 spin_lock_bh(&ul
->lock
);
1463 list_add_tail(&rt
->rt_uncached
, &ul
->head
);
1464 spin_unlock_bh(&ul
->lock
);
1467 void rt_del_uncached_list(struct rtable
*rt
)
1469 if (!list_empty(&rt
->rt_uncached
)) {
1470 struct uncached_list
*ul
= rt
->rt_uncached_list
;
1472 spin_lock_bh(&ul
->lock
);
1473 list_del(&rt
->rt_uncached
);
1474 spin_unlock_bh(&ul
->lock
);
1478 static void ipv4_dst_destroy(struct dst_entry
*dst
)
1480 struct rtable
*rt
= (struct rtable
*)dst
;
1482 ip_dst_metrics_put(dst
);
1483 rt_del_uncached_list(rt
);
1486 void rt_flush_dev(struct net_device
*dev
)
1488 struct net
*net
= dev_net(dev
);
1492 for_each_possible_cpu(cpu
) {
1493 struct uncached_list
*ul
= &per_cpu(rt_uncached_list
, cpu
);
1495 spin_lock_bh(&ul
->lock
);
1496 list_for_each_entry(rt
, &ul
->head
, rt_uncached
) {
1497 if (rt
->dst
.dev
!= dev
)
1499 rt
->dst
.dev
= net
->loopback_dev
;
1500 dev_hold(rt
->dst
.dev
);
1503 spin_unlock_bh(&ul
->lock
);
1507 static bool rt_cache_valid(const struct rtable
*rt
)
1510 rt
->dst
.obsolete
== DST_OBSOLETE_FORCE_CHK
&&
1514 static void rt_set_nexthop(struct rtable
*rt
, __be32 daddr
,
1515 const struct fib_result
*res
,
1516 struct fib_nh_exception
*fnhe
,
1517 struct fib_info
*fi
, u16 type
, u32 itag
,
1518 const bool do_cache
)
1520 bool cached
= false;
1523 struct fib_nh
*nh
= &FIB_RES_NH(*res
);
1525 if (nh
->nh_gw
&& nh
->nh_scope
== RT_SCOPE_LINK
) {
1526 rt
->rt_gateway
= nh
->nh_gw
;
1527 rt
->rt_uses_gateway
= 1;
1529 ip_dst_init_metrics(&rt
->dst
, fi
->fib_metrics
);
1531 #ifdef CONFIG_IP_ROUTE_CLASSID
1532 rt
->dst
.tclassid
= nh
->nh_tclassid
;
1534 rt
->dst
.lwtstate
= lwtstate_get(nh
->nh_lwtstate
);
1536 cached
= rt_bind_exception(rt
, fnhe
, daddr
, do_cache
);
1538 cached
= rt_cache_route(nh
, rt
);
1539 if (unlikely(!cached
)) {
1540 /* Routes we intend to cache in nexthop exception or
1541 * FIB nexthop have the DST_NOCACHE bit clear.
1542 * However, if we are unsuccessful at storing this
1543 * route into the cache we really need to set it.
1545 if (!rt
->rt_gateway
)
1546 rt
->rt_gateway
= daddr
;
1547 rt_add_uncached_list(rt
);
1550 rt_add_uncached_list(rt
);
1552 #ifdef CONFIG_IP_ROUTE_CLASSID
1553 #ifdef CONFIG_IP_MULTIPLE_TABLES
1554 set_class_tag(rt
, res
->tclassid
);
1556 set_class_tag(rt
, itag
);
1560 struct rtable
*rt_dst_alloc(struct net_device
*dev
,
1561 unsigned int flags
, u16 type
,
1562 bool nopolicy
, bool noxfrm
, bool will_cache
)
1566 rt
= dst_alloc(&ipv4_dst_ops
, dev
, 1, DST_OBSOLETE_FORCE_CHK
,
1567 (will_cache
? 0 : DST_HOST
) |
1568 (nopolicy
? DST_NOPOLICY
: 0) |
1569 (noxfrm
? DST_NOXFRM
: 0));
1572 rt
->rt_genid
= rt_genid_ipv4(dev_net(dev
));
1573 rt
->rt_flags
= flags
;
1575 rt
->rt_is_input
= 0;
1578 rt
->rt_mtu_locked
= 0;
1580 rt
->rt_uses_gateway
= 0;
1581 INIT_LIST_HEAD(&rt
->rt_uncached
);
1583 rt
->dst
.output
= ip_output
;
1584 if (flags
& RTCF_LOCAL
)
1585 rt
->dst
.input
= ip_local_deliver
;
1590 EXPORT_SYMBOL(rt_dst_alloc
);
1592 /* called in rcu_read_lock() section */
1593 int ip_mc_validate_source(struct sk_buff
*skb
, __be32 daddr
, __be32 saddr
,
1594 u8 tos
, struct net_device
*dev
,
1595 struct in_device
*in_dev
, u32
*itag
)
1599 /* Primary sanity checks. */
1603 if (ipv4_is_multicast(saddr
) || ipv4_is_lbcast(saddr
) ||
1604 skb
->protocol
!= htons(ETH_P_IP
))
1607 if (ipv4_is_loopback(saddr
) && !IN_DEV_ROUTE_LOCALNET(in_dev
))
1610 if (ipv4_is_zeronet(saddr
)) {
1611 if (!ipv4_is_local_multicast(daddr
) &&
1612 ip_hdr(skb
)->protocol
!= IPPROTO_IGMP
)
1615 err
= fib_validate_source(skb
, saddr
, 0, tos
, 0, dev
,
1623 /* called in rcu_read_lock() section */
1624 static int ip_route_input_mc(struct sk_buff
*skb
, __be32 daddr
, __be32 saddr
,
1625 u8 tos
, struct net_device
*dev
, int our
)
1627 struct in_device
*in_dev
= __in_dev_get_rcu(dev
);
1628 unsigned int flags
= RTCF_MULTICAST
;
1633 err
= ip_mc_validate_source(skb
, daddr
, saddr
, tos
, dev
, in_dev
, &itag
);
1638 flags
|= RTCF_LOCAL
;
1640 rth
= rt_dst_alloc(dev_net(dev
)->loopback_dev
, flags
, RTN_MULTICAST
,
1641 IN_DEV_CONF_GET(in_dev
, NOPOLICY
), false, false);
1645 #ifdef CONFIG_IP_ROUTE_CLASSID
1646 rth
->dst
.tclassid
= itag
;
1648 rth
->dst
.output
= ip_rt_bug
;
1649 rth
->rt_is_input
= 1;
1651 #ifdef CONFIG_IP_MROUTE
1652 if (!ipv4_is_local_multicast(daddr
) && IN_DEV_MFORWARD(in_dev
))
1653 rth
->dst
.input
= ip_mr_input
;
1655 RT_CACHE_STAT_INC(in_slow_mc
);
1657 skb_dst_set(skb
, &rth
->dst
);
1662 static void ip_handle_martian_source(struct net_device
*dev
,
1663 struct in_device
*in_dev
,
1664 struct sk_buff
*skb
,
1668 RT_CACHE_STAT_INC(in_martian_src
);
1669 #ifdef CONFIG_IP_ROUTE_VERBOSE
1670 if (IN_DEV_LOG_MARTIANS(in_dev
) && net_ratelimit()) {
1672 * RFC1812 recommendation, if source is martian,
1673 * the only hint is MAC header.
1675 pr_warn("martian source %pI4 from %pI4, on dev %s\n",
1676 &daddr
, &saddr
, dev
->name
);
1677 if (dev
->hard_header_len
&& skb_mac_header_was_set(skb
)) {
1678 print_hex_dump(KERN_WARNING
, "ll header: ",
1679 DUMP_PREFIX_OFFSET
, 16, 1,
1680 skb_mac_header(skb
),
1681 dev
->hard_header_len
, false);
1687 /* called in rcu_read_lock() section */
1688 static int __mkroute_input(struct sk_buff
*skb
,
1689 const struct fib_result
*res
,
1690 struct in_device
*in_dev
,
1691 __be32 daddr
, __be32 saddr
, u32 tos
)
1693 struct fib_nh_exception
*fnhe
;
1696 struct in_device
*out_dev
;
1700 /* get a working reference to the output device */
1701 out_dev
= __in_dev_get_rcu(FIB_RES_DEV(*res
));
1703 net_crit_ratelimited("Bug in ip_route_input_slow(). Please report.\n");
1707 err
= fib_validate_source(skb
, saddr
, daddr
, tos
, FIB_RES_OIF(*res
),
1708 in_dev
->dev
, in_dev
, &itag
);
1710 ip_handle_martian_source(in_dev
->dev
, in_dev
, skb
, daddr
,
1716 do_cache
= res
->fi
&& !itag
;
1717 if (out_dev
== in_dev
&& err
&& IN_DEV_TX_REDIRECTS(out_dev
) &&
1718 skb
->protocol
== htons(ETH_P_IP
) &&
1719 (IN_DEV_SHARED_MEDIA(out_dev
) ||
1720 inet_addr_onlink(out_dev
, saddr
, FIB_RES_GW(*res
))))
1721 IPCB(skb
)->flags
|= IPSKB_DOREDIRECT
;
1723 if (skb
->protocol
!= htons(ETH_P_IP
)) {
1724 /* Not IP (i.e. ARP). Do not create route, if it is
1725 * invalid for proxy arp. DNAT routes are always valid.
1727 * Proxy arp feature have been extended to allow, ARP
1728 * replies back to the same interface, to support
1729 * Private VLAN switch technologies. See arp.c.
1731 if (out_dev
== in_dev
&&
1732 IN_DEV_PROXY_ARP_PVLAN(in_dev
) == 0) {
1738 fnhe
= find_exception(&FIB_RES_NH(*res
), daddr
);
1741 rth
= rcu_dereference(fnhe
->fnhe_rth_input
);
1743 rth
= rcu_dereference(FIB_RES_NH(*res
).nh_rth_input
);
1744 if (rt_cache_valid(rth
)) {
1745 skb_dst_set_noref(skb
, &rth
->dst
);
1750 rth
= rt_dst_alloc(out_dev
->dev
, 0, res
->type
,
1751 IN_DEV_CONF_GET(in_dev
, NOPOLICY
),
1752 IN_DEV_CONF_GET(out_dev
, NOXFRM
), do_cache
);
1758 rth
->rt_is_input
= 1;
1759 RT_CACHE_STAT_INC(in_slow_tot
);
1761 rth
->dst
.input
= ip_forward
;
1763 rt_set_nexthop(rth
, daddr
, res
, fnhe
, res
->fi
, res
->type
, itag
,
1765 lwtunnel_set_redirect(&rth
->dst
);
1766 skb_dst_set(skb
, &rth
->dst
);
1773 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1774 /* To make ICMP packets follow the right flow, the multipath hash is
1775 * calculated from the inner IP addresses.
1777 static void ip_multipath_l3_keys(const struct sk_buff
*skb
,
1778 struct flow_keys
*hash_keys
)
1780 const struct iphdr
*outer_iph
= ip_hdr(skb
);
1781 const struct iphdr
*key_iph
= outer_iph
;
1782 const struct iphdr
*inner_iph
;
1783 const struct icmphdr
*icmph
;
1784 struct iphdr _inner_iph
;
1785 struct icmphdr _icmph
;
1787 if (likely(outer_iph
->protocol
!= IPPROTO_ICMP
))
1790 if (unlikely((outer_iph
->frag_off
& htons(IP_OFFSET
)) != 0))
1793 icmph
= skb_header_pointer(skb
, outer_iph
->ihl
* 4, sizeof(_icmph
),
1798 if (icmph
->type
!= ICMP_DEST_UNREACH
&&
1799 icmph
->type
!= ICMP_REDIRECT
&&
1800 icmph
->type
!= ICMP_TIME_EXCEEDED
&&
1801 icmph
->type
!= ICMP_PARAMETERPROB
)
1804 inner_iph
= skb_header_pointer(skb
,
1805 outer_iph
->ihl
* 4 + sizeof(_icmph
),
1806 sizeof(_inner_iph
), &_inner_iph
);
1810 key_iph
= inner_iph
;
1812 hash_keys
->addrs
.v4addrs
.src
= key_iph
->saddr
;
1813 hash_keys
->addrs
.v4addrs
.dst
= key_iph
->daddr
;
1816 /* if skb is set it will be used and fl4 can be NULL */
1817 int fib_multipath_hash(const struct net
*net
, const struct flowi4
*fl4
,
1818 const struct sk_buff
*skb
, struct flow_keys
*flkeys
)
1820 struct flow_keys hash_keys
;
1823 switch (net
->ipv4
.sysctl_fib_multipath_hash_policy
) {
1825 memset(&hash_keys
, 0, sizeof(hash_keys
));
1826 hash_keys
.control
.addr_type
= FLOW_DISSECTOR_KEY_IPV4_ADDRS
;
1828 ip_multipath_l3_keys(skb
, &hash_keys
);
1830 hash_keys
.addrs
.v4addrs
.src
= fl4
->saddr
;
1831 hash_keys
.addrs
.v4addrs
.dst
= fl4
->daddr
;
1835 /* skb is currently provided only when forwarding */
1837 unsigned int flag
= FLOW_DISSECTOR_F_STOP_AT_ENCAP
;
1838 struct flow_keys keys
;
1840 /* short-circuit if we already have L4 hash present */
1842 return skb_get_hash_raw(skb
) >> 1;
1844 memset(&hash_keys
, 0, sizeof(hash_keys
));
1847 skb_flow_dissect_flow_keys(skb
, &keys
, flag
);
1851 hash_keys
.control
.addr_type
= FLOW_DISSECTOR_KEY_IPV4_ADDRS
;
1852 hash_keys
.addrs
.v4addrs
.src
= flkeys
->addrs
.v4addrs
.src
;
1853 hash_keys
.addrs
.v4addrs
.dst
= flkeys
->addrs
.v4addrs
.dst
;
1854 hash_keys
.ports
.src
= flkeys
->ports
.src
;
1855 hash_keys
.ports
.dst
= flkeys
->ports
.dst
;
1856 hash_keys
.basic
.ip_proto
= flkeys
->basic
.ip_proto
;
1858 memset(&hash_keys
, 0, sizeof(hash_keys
));
1859 hash_keys
.control
.addr_type
= FLOW_DISSECTOR_KEY_IPV4_ADDRS
;
1860 hash_keys
.addrs
.v4addrs
.src
= fl4
->saddr
;
1861 hash_keys
.addrs
.v4addrs
.dst
= fl4
->daddr
;
1862 hash_keys
.ports
.src
= fl4
->fl4_sport
;
1863 hash_keys
.ports
.dst
= fl4
->fl4_dport
;
1864 hash_keys
.basic
.ip_proto
= fl4
->flowi4_proto
;
1868 mhash
= flow_hash_from_keys(&hash_keys
);
1872 #endif /* CONFIG_IP_ROUTE_MULTIPATH */
1874 static int ip_mkroute_input(struct sk_buff
*skb
,
1875 struct fib_result
*res
,
1876 struct in_device
*in_dev
,
1877 __be32 daddr
, __be32 saddr
, u32 tos
,
1878 struct flow_keys
*hkeys
)
1880 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1881 if (res
->fi
&& res
->fi
->fib_nhs
> 1) {
1882 int h
= fib_multipath_hash(res
->fi
->fib_net
, NULL
, skb
, hkeys
);
1884 fib_select_multipath(res
, h
);
1888 /* create a routing cache entry */
1889 return __mkroute_input(skb
, res
, in_dev
, daddr
, saddr
, tos
);
1893 * NOTE. We drop all the packets that has local source
1894 * addresses, because every properly looped back packet
1895 * must have correct destination already attached by output routine.
1897 * Such approach solves two big problems:
1898 * 1. Not simplex devices are handled properly.
1899 * 2. IP spoofing attempts are filtered with 100% of guarantee.
1900 * called with rcu_read_lock()
1903 static int ip_route_input_slow(struct sk_buff
*skb
, __be32 daddr
, __be32 saddr
,
1904 u8 tos
, struct net_device
*dev
,
1905 struct fib_result
*res
)
1907 struct in_device
*in_dev
= __in_dev_get_rcu(dev
);
1908 struct flow_keys
*flkeys
= NULL
, _flkeys
;
1909 struct net
*net
= dev_net(dev
);
1910 struct ip_tunnel_info
*tun_info
;
1912 unsigned int flags
= 0;
1918 /* IP on this device is disabled. */
1923 /* Check for the most weird martians, which can be not detected
1927 tun_info
= skb_tunnel_info(skb
);
1928 if (tun_info
&& !(tun_info
->mode
& IP_TUNNEL_INFO_TX
))
1929 fl4
.flowi4_tun_key
.tun_id
= tun_info
->key
.tun_id
;
1931 fl4
.flowi4_tun_key
.tun_id
= 0;
1934 if (ipv4_is_multicast(saddr
) || ipv4_is_lbcast(saddr
))
1935 goto martian_source
;
1939 if (ipv4_is_lbcast(daddr
) || (saddr
== 0 && daddr
== 0))
1942 /* Accept zero addresses only to limited broadcast;
1943 * I even do not know to fix it or not. Waiting for complains :-)
1945 if (ipv4_is_zeronet(saddr
))
1946 goto martian_source
;
1948 if (ipv4_is_zeronet(daddr
))
1949 goto martian_destination
;
1951 /* Following code try to avoid calling IN_DEV_NET_ROUTE_LOCALNET(),
1952 * and call it once if daddr or/and saddr are loopback addresses
1954 if (ipv4_is_loopback(daddr
)) {
1955 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev
, net
))
1956 goto martian_destination
;
1957 } else if (ipv4_is_loopback(saddr
)) {
1958 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev
, net
))
1959 goto martian_source
;
1963 * Now we are ready to route packet.
1966 fl4
.flowi4_iif
= dev
->ifindex
;
1967 fl4
.flowi4_mark
= skb
->mark
;
1968 fl4
.flowi4_tos
= tos
;
1969 fl4
.flowi4_scope
= RT_SCOPE_UNIVERSE
;
1970 fl4
.flowi4_flags
= 0;
1973 fl4
.flowi4_uid
= sock_net_uid(net
, NULL
);
1975 if (fib4_rules_early_flow_dissect(net
, skb
, &fl4
, &_flkeys
)) {
1978 fl4
.flowi4_proto
= 0;
1983 err
= fib_lookup(net
, &fl4
, res
, 0);
1985 if (!IN_DEV_FORWARD(in_dev
))
1986 err
= -EHOSTUNREACH
;
1990 if (res
->type
== RTN_BROADCAST
) {
1991 if (IN_DEV_BFORWARD(in_dev
))
1996 if (res
->type
== RTN_LOCAL
) {
1997 err
= fib_validate_source(skb
, saddr
, daddr
, tos
,
1998 0, dev
, in_dev
, &itag
);
2000 goto martian_source
;
2004 if (!IN_DEV_FORWARD(in_dev
)) {
2005 err
= -EHOSTUNREACH
;
2008 if (res
->type
!= RTN_UNICAST
)
2009 goto martian_destination
;
2012 err
= ip_mkroute_input(skb
, res
, in_dev
, daddr
, saddr
, tos
, flkeys
);
2016 if (skb
->protocol
!= htons(ETH_P_IP
))
2019 if (!ipv4_is_zeronet(saddr
)) {
2020 err
= fib_validate_source(skb
, saddr
, 0, tos
, 0, dev
,
2023 goto martian_source
;
2025 flags
|= RTCF_BROADCAST
;
2026 res
->type
= RTN_BROADCAST
;
2027 RT_CACHE_STAT_INC(in_brd
);
2033 rth
= rcu_dereference(FIB_RES_NH(*res
).nh_rth_input
);
2034 if (rt_cache_valid(rth
)) {
2035 skb_dst_set_noref(skb
, &rth
->dst
);
2043 rth
= rt_dst_alloc(l3mdev_master_dev_rcu(dev
) ? : net
->loopback_dev
,
2044 flags
| RTCF_LOCAL
, res
->type
,
2045 IN_DEV_CONF_GET(in_dev
, NOPOLICY
), false, do_cache
);
2049 rth
->dst
.output
= ip_rt_bug
;
2050 #ifdef CONFIG_IP_ROUTE_CLASSID
2051 rth
->dst
.tclassid
= itag
;
2053 rth
->rt_is_input
= 1;
2055 RT_CACHE_STAT_INC(in_slow_tot
);
2056 if (res
->type
== RTN_UNREACHABLE
) {
2057 rth
->dst
.input
= ip_error
;
2058 rth
->dst
.error
= -err
;
2059 rth
->rt_flags
&= ~RTCF_LOCAL
;
2063 struct fib_nh
*nh
= &FIB_RES_NH(*res
);
2065 rth
->dst
.lwtstate
= lwtstate_get(nh
->nh_lwtstate
);
2066 if (lwtunnel_input_redirect(rth
->dst
.lwtstate
)) {
2067 WARN_ON(rth
->dst
.input
== lwtunnel_input
);
2068 rth
->dst
.lwtstate
->orig_input
= rth
->dst
.input
;
2069 rth
->dst
.input
= lwtunnel_input
;
2072 if (unlikely(!rt_cache_route(nh
, rth
)))
2073 rt_add_uncached_list(rth
);
2075 skb_dst_set(skb
, &rth
->dst
);
2080 RT_CACHE_STAT_INC(in_no_route
);
2081 res
->type
= RTN_UNREACHABLE
;
2087 * Do not cache martian addresses: they should be logged (RFC1812)
2089 martian_destination
:
2090 RT_CACHE_STAT_INC(in_martian_dst
);
2091 #ifdef CONFIG_IP_ROUTE_VERBOSE
2092 if (IN_DEV_LOG_MARTIANS(in_dev
))
2093 net_warn_ratelimited("martian destination %pI4 from %pI4, dev %s\n",
2094 &daddr
, &saddr
, dev
->name
);
2106 ip_handle_martian_source(dev
, in_dev
, skb
, daddr
, saddr
);
2110 int ip_route_input_noref(struct sk_buff
*skb
, __be32 daddr
, __be32 saddr
,
2111 u8 tos
, struct net_device
*dev
)
2113 struct fib_result res
;
2116 tos
&= IPTOS_RT_MASK
;
2118 err
= ip_route_input_rcu(skb
, daddr
, saddr
, tos
, dev
, &res
);
2123 EXPORT_SYMBOL(ip_route_input_noref
);
2125 /* called with rcu_read_lock held */
2126 int ip_route_input_rcu(struct sk_buff
*skb
, __be32 daddr
, __be32 saddr
,
2127 u8 tos
, struct net_device
*dev
, struct fib_result
*res
)
2129 /* Multicast recognition logic is moved from route cache to here.
2130 The problem was that too many Ethernet cards have broken/missing
2131 hardware multicast filters :-( As result the host on multicasting
2132 network acquires a lot of useless route cache entries, sort of
2133 SDR messages from all the world. Now we try to get rid of them.
2134 Really, provided software IP multicast filter is organized
2135 reasonably (at least, hashed), it does not result in a slowdown
2136 comparing with route cache reject entries.
2137 Note, that multicast routers are not affected, because
2138 route cache entry is created eventually.
2140 if (ipv4_is_multicast(daddr
)) {
2141 struct in_device
*in_dev
= __in_dev_get_rcu(dev
);
2146 our
= ip_check_mc_rcu(in_dev
, daddr
, saddr
,
2147 ip_hdr(skb
)->protocol
);
2149 /* check l3 master if no match yet */
2150 if ((!in_dev
|| !our
) && netif_is_l3_slave(dev
)) {
2151 struct in_device
*l3_in_dev
;
2153 l3_in_dev
= __in_dev_get_rcu(skb
->dev
);
2155 our
= ip_check_mc_rcu(l3_in_dev
, daddr
, saddr
,
2156 ip_hdr(skb
)->protocol
);
2160 #ifdef CONFIG_IP_MROUTE
2162 (!ipv4_is_local_multicast(daddr
) &&
2163 IN_DEV_MFORWARD(in_dev
))
2166 err
= ip_route_input_mc(skb
, daddr
, saddr
,
2172 return ip_route_input_slow(skb
, daddr
, saddr
, tos
, dev
, res
);
2175 /* called with rcu_read_lock() */
2176 static struct rtable
*__mkroute_output(const struct fib_result
*res
,
2177 const struct flowi4
*fl4
, int orig_oif
,
2178 struct net_device
*dev_out
,
2181 struct fib_info
*fi
= res
->fi
;
2182 struct fib_nh_exception
*fnhe
;
2183 struct in_device
*in_dev
;
2184 u16 type
= res
->type
;
2188 in_dev
= __in_dev_get_rcu(dev_out
);
2190 return ERR_PTR(-EINVAL
);
2192 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev
)))
2193 if (ipv4_is_loopback(fl4
->saddr
) &&
2194 !(dev_out
->flags
& IFF_LOOPBACK
) &&
2195 !netif_is_l3_master(dev_out
))
2196 return ERR_PTR(-EINVAL
);
2198 if (ipv4_is_lbcast(fl4
->daddr
))
2199 type
= RTN_BROADCAST
;
2200 else if (ipv4_is_multicast(fl4
->daddr
))
2201 type
= RTN_MULTICAST
;
2202 else if (ipv4_is_zeronet(fl4
->daddr
))
2203 return ERR_PTR(-EINVAL
);
2205 if (dev_out
->flags
& IFF_LOOPBACK
)
2206 flags
|= RTCF_LOCAL
;
2209 if (type
== RTN_BROADCAST
) {
2210 flags
|= RTCF_BROADCAST
| RTCF_LOCAL
;
2212 } else if (type
== RTN_MULTICAST
) {
2213 flags
|= RTCF_MULTICAST
| RTCF_LOCAL
;
2214 if (!ip_check_mc_rcu(in_dev
, fl4
->daddr
, fl4
->saddr
,
2216 flags
&= ~RTCF_LOCAL
;
2219 /* If multicast route do not exist use
2220 * default one, but do not gateway in this case.
2223 if (fi
&& res
->prefixlen
< 4)
2225 } else if ((type
== RTN_LOCAL
) && (orig_oif
!= 0) &&
2226 (orig_oif
!= dev_out
->ifindex
)) {
2227 /* For local routes that require a particular output interface
2228 * we do not want to cache the result. Caching the result
2229 * causes incorrect behaviour when there are multiple source
2230 * addresses on the interface, the end result being that if the
2231 * intended recipient is waiting on that interface for the
2232 * packet he won't receive it because it will be delivered on
2233 * the loopback interface and the IP_PKTINFO ipi_ifindex will
2234 * be set to the loopback interface as well.
2240 do_cache
&= fi
!= NULL
;
2242 struct rtable __rcu
**prth
;
2243 struct fib_nh
*nh
= &FIB_RES_NH(*res
);
2245 fnhe
= find_exception(nh
, fl4
->daddr
);
2249 prth
= &fnhe
->fnhe_rth_output
;
2251 if (unlikely(fl4
->flowi4_flags
&
2252 FLOWI_FLAG_KNOWN_NH
&&
2254 nh
->nh_scope
== RT_SCOPE_LINK
))) {
2258 prth
= raw_cpu_ptr(nh
->nh_pcpu_rth_output
);
2260 rth
= rcu_dereference(*prth
);
2261 if (rt_cache_valid(rth
) && dst_hold_safe(&rth
->dst
))
2266 rth
= rt_dst_alloc(dev_out
, flags
, type
,
2267 IN_DEV_CONF_GET(in_dev
, NOPOLICY
),
2268 IN_DEV_CONF_GET(in_dev
, NOXFRM
),
2271 return ERR_PTR(-ENOBUFS
);
2273 rth
->rt_iif
= orig_oif
;
2275 RT_CACHE_STAT_INC(out_slow_tot
);
2277 if (flags
& (RTCF_BROADCAST
| RTCF_MULTICAST
)) {
2278 if (flags
& RTCF_LOCAL
&&
2279 !(dev_out
->flags
& IFF_LOOPBACK
)) {
2280 rth
->dst
.output
= ip_mc_output
;
2281 RT_CACHE_STAT_INC(out_slow_mc
);
2283 #ifdef CONFIG_IP_MROUTE
2284 if (type
== RTN_MULTICAST
) {
2285 if (IN_DEV_MFORWARD(in_dev
) &&
2286 !ipv4_is_local_multicast(fl4
->daddr
)) {
2287 rth
->dst
.input
= ip_mr_input
;
2288 rth
->dst
.output
= ip_mc_output
;
2294 rt_set_nexthop(rth
, fl4
->daddr
, res
, fnhe
, fi
, type
, 0, do_cache
);
2295 lwtunnel_set_redirect(&rth
->dst
);
2301 * Major route resolver routine.
2304 struct rtable
*ip_route_output_key_hash(struct net
*net
, struct flowi4
*fl4
,
2305 const struct sk_buff
*skb
)
2307 __u8 tos
= RT_FL_TOS(fl4
);
2308 struct fib_result res
= {
2316 fl4
->flowi4_iif
= LOOPBACK_IFINDEX
;
2317 fl4
->flowi4_tos
= tos
& IPTOS_RT_MASK
;
2318 fl4
->flowi4_scope
= ((tos
& RTO_ONLINK
) ?
2319 RT_SCOPE_LINK
: RT_SCOPE_UNIVERSE
);
2322 rth
= ip_route_output_key_hash_rcu(net
, fl4
, &res
, skb
);
2327 EXPORT_SYMBOL_GPL(ip_route_output_key_hash
);
2329 struct rtable
*ip_route_output_key_hash_rcu(struct net
*net
, struct flowi4
*fl4
,
2330 struct fib_result
*res
,
2331 const struct sk_buff
*skb
)
2333 struct net_device
*dev_out
= NULL
;
2334 int orig_oif
= fl4
->flowi4_oif
;
2335 unsigned int flags
= 0;
2337 int err
= -ENETUNREACH
;
2340 rth
= ERR_PTR(-EINVAL
);
2341 if (ipv4_is_multicast(fl4
->saddr
) ||
2342 ipv4_is_lbcast(fl4
->saddr
) ||
2343 ipv4_is_zeronet(fl4
->saddr
))
2346 /* I removed check for oif == dev_out->oif here.
2347 It was wrong for two reasons:
2348 1. ip_dev_find(net, saddr) can return wrong iface, if saddr
2349 is assigned to multiple interfaces.
2350 2. Moreover, we are allowed to send packets with saddr
2351 of another iface. --ANK
2354 if (fl4
->flowi4_oif
== 0 &&
2355 (ipv4_is_multicast(fl4
->daddr
) ||
2356 ipv4_is_lbcast(fl4
->daddr
))) {
2357 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2358 dev_out
= __ip_dev_find(net
, fl4
->saddr
, false);
2362 /* Special hack: user can direct multicasts
2363 and limited broadcast via necessary interface
2364 without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
2365 This hack is not just for fun, it allows
2366 vic,vat and friends to work.
2367 They bind socket to loopback, set ttl to zero
2368 and expect that it will work.
2369 From the viewpoint of routing cache they are broken,
2370 because we are not allowed to build multicast path
2371 with loopback source addr (look, routing cache
2372 cannot know, that ttl is zero, so that packet
2373 will not leave this host and route is valid).
2374 Luckily, this hack is good workaround.
2377 fl4
->flowi4_oif
= dev_out
->ifindex
;
2381 if (!(fl4
->flowi4_flags
& FLOWI_FLAG_ANYSRC
)) {
2382 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2383 if (!__ip_dev_find(net
, fl4
->saddr
, false))
2389 if (fl4
->flowi4_oif
) {
2390 dev_out
= dev_get_by_index_rcu(net
, fl4
->flowi4_oif
);
2391 rth
= ERR_PTR(-ENODEV
);
2395 /* RACE: Check return value of inet_select_addr instead. */
2396 if (!(dev_out
->flags
& IFF_UP
) || !__in_dev_get_rcu(dev_out
)) {
2397 rth
= ERR_PTR(-ENETUNREACH
);
2400 if (ipv4_is_local_multicast(fl4
->daddr
) ||
2401 ipv4_is_lbcast(fl4
->daddr
) ||
2402 fl4
->flowi4_proto
== IPPROTO_IGMP
) {
2404 fl4
->saddr
= inet_select_addr(dev_out
, 0,
2409 if (ipv4_is_multicast(fl4
->daddr
))
2410 fl4
->saddr
= inet_select_addr(dev_out
, 0,
2412 else if (!fl4
->daddr
)
2413 fl4
->saddr
= inet_select_addr(dev_out
, 0,
2419 fl4
->daddr
= fl4
->saddr
;
2421 fl4
->daddr
= fl4
->saddr
= htonl(INADDR_LOOPBACK
);
2422 dev_out
= net
->loopback_dev
;
2423 fl4
->flowi4_oif
= LOOPBACK_IFINDEX
;
2424 res
->type
= RTN_LOCAL
;
2425 flags
|= RTCF_LOCAL
;
2429 err
= fib_lookup(net
, fl4
, res
, 0);
2433 if (fl4
->flowi4_oif
&&
2434 (ipv4_is_multicast(fl4
->daddr
) ||
2435 !netif_index_is_l3_master(net
, fl4
->flowi4_oif
))) {
2436 /* Apparently, routing tables are wrong. Assume,
2437 that the destination is on link.
2440 Because we are allowed to send to iface
2441 even if it has NO routes and NO assigned
2442 addresses. When oif is specified, routing
2443 tables are looked up with only one purpose:
2444 to catch if destination is gatewayed, rather than
2445 direct. Moreover, if MSG_DONTROUTE is set,
2446 we send packet, ignoring both routing tables
2447 and ifaddr state. --ANK
2450 We could make it even if oif is unknown,
2451 likely IPv6, but we do not.
2454 if (fl4
->saddr
== 0)
2455 fl4
->saddr
= inet_select_addr(dev_out
, 0,
2457 res
->type
= RTN_UNICAST
;
2464 if (res
->type
== RTN_LOCAL
) {
2466 if (res
->fi
->fib_prefsrc
)
2467 fl4
->saddr
= res
->fi
->fib_prefsrc
;
2469 fl4
->saddr
= fl4
->daddr
;
2472 /* L3 master device is the loopback for that domain */
2473 dev_out
= l3mdev_master_dev_rcu(FIB_RES_DEV(*res
)) ? :
2476 /* make sure orig_oif points to fib result device even
2477 * though packet rx/tx happens over loopback or l3mdev
2479 orig_oif
= FIB_RES_OIF(*res
);
2481 fl4
->flowi4_oif
= dev_out
->ifindex
;
2482 flags
|= RTCF_LOCAL
;
2486 fib_select_path(net
, res
, fl4
, skb
);
2488 dev_out
= FIB_RES_DEV(*res
);
2489 fl4
->flowi4_oif
= dev_out
->ifindex
;
2493 rth
= __mkroute_output(res
, fl4
, orig_oif
, dev_out
, flags
);
2499 static struct dst_entry
*ipv4_blackhole_dst_check(struct dst_entry
*dst
, u32 cookie
)
2504 static unsigned int ipv4_blackhole_mtu(const struct dst_entry
*dst
)
2506 unsigned int mtu
= dst_metric_raw(dst
, RTAX_MTU
);
2508 return mtu
? : dst
->dev
->mtu
;
2511 static void ipv4_rt_blackhole_update_pmtu(struct dst_entry
*dst
, struct sock
*sk
,
2512 struct sk_buff
*skb
, u32 mtu
)
2516 static void ipv4_rt_blackhole_redirect(struct dst_entry
*dst
, struct sock
*sk
,
2517 struct sk_buff
*skb
)
2521 static u32
*ipv4_rt_blackhole_cow_metrics(struct dst_entry
*dst
,
2527 static struct dst_ops ipv4_dst_blackhole_ops
= {
2529 .check
= ipv4_blackhole_dst_check
,
2530 .mtu
= ipv4_blackhole_mtu
,
2531 .default_advmss
= ipv4_default_advmss
,
2532 .update_pmtu
= ipv4_rt_blackhole_update_pmtu
,
2533 .redirect
= ipv4_rt_blackhole_redirect
,
2534 .cow_metrics
= ipv4_rt_blackhole_cow_metrics
,
2535 .neigh_lookup
= ipv4_neigh_lookup
,
2538 struct dst_entry
*ipv4_blackhole_route(struct net
*net
, struct dst_entry
*dst_orig
)
2540 struct rtable
*ort
= (struct rtable
*) dst_orig
;
2543 rt
= dst_alloc(&ipv4_dst_blackhole_ops
, NULL
, 1, DST_OBSOLETE_DEAD
, 0);
2545 struct dst_entry
*new = &rt
->dst
;
2548 new->input
= dst_discard
;
2549 new->output
= dst_discard_out
;
2551 new->dev
= net
->loopback_dev
;
2555 rt
->rt_is_input
= ort
->rt_is_input
;
2556 rt
->rt_iif
= ort
->rt_iif
;
2557 rt
->rt_pmtu
= ort
->rt_pmtu
;
2558 rt
->rt_mtu_locked
= ort
->rt_mtu_locked
;
2560 rt
->rt_genid
= rt_genid_ipv4(net
);
2561 rt
->rt_flags
= ort
->rt_flags
;
2562 rt
->rt_type
= ort
->rt_type
;
2563 rt
->rt_gateway
= ort
->rt_gateway
;
2564 rt
->rt_uses_gateway
= ort
->rt_uses_gateway
;
2566 INIT_LIST_HEAD(&rt
->rt_uncached
);
2569 dst_release(dst_orig
);
2571 return rt
? &rt
->dst
: ERR_PTR(-ENOMEM
);
2574 struct rtable
*ip_route_output_flow(struct net
*net
, struct flowi4
*flp4
,
2575 const struct sock
*sk
)
2577 struct rtable
*rt
= __ip_route_output_key(net
, flp4
);
2582 if (flp4
->flowi4_proto
)
2583 rt
= (struct rtable
*)xfrm_lookup_route(net
, &rt
->dst
,
2584 flowi4_to_flowi(flp4
),
2589 EXPORT_SYMBOL_GPL(ip_route_output_flow
);
2591 /* called with rcu_read_lock held */
2592 static int rt_fill_info(struct net
*net
, __be32 dst
, __be32 src
,
2593 struct rtable
*rt
, u32 table_id
, struct flowi4
*fl4
,
2594 struct sk_buff
*skb
, u32 portid
, u32 seq
)
2597 struct nlmsghdr
*nlh
;
2598 unsigned long expires
= 0;
2600 u32 metrics
[RTAX_MAX
];
2602 nlh
= nlmsg_put(skb
, portid
, seq
, RTM_NEWROUTE
, sizeof(*r
), 0);
2606 r
= nlmsg_data(nlh
);
2607 r
->rtm_family
= AF_INET
;
2608 r
->rtm_dst_len
= 32;
2610 r
->rtm_tos
= fl4
->flowi4_tos
;
2611 r
->rtm_table
= table_id
< 256 ? table_id
: RT_TABLE_COMPAT
;
2612 if (nla_put_u32(skb
, RTA_TABLE
, table_id
))
2613 goto nla_put_failure
;
2614 r
->rtm_type
= rt
->rt_type
;
2615 r
->rtm_scope
= RT_SCOPE_UNIVERSE
;
2616 r
->rtm_protocol
= RTPROT_UNSPEC
;
2617 r
->rtm_flags
= (rt
->rt_flags
& ~0xFFFF) | RTM_F_CLONED
;
2618 if (rt
->rt_flags
& RTCF_NOTIFY
)
2619 r
->rtm_flags
|= RTM_F_NOTIFY
;
2620 if (IPCB(skb
)->flags
& IPSKB_DOREDIRECT
)
2621 r
->rtm_flags
|= RTCF_DOREDIRECT
;
2623 if (nla_put_in_addr(skb
, RTA_DST
, dst
))
2624 goto nla_put_failure
;
2626 r
->rtm_src_len
= 32;
2627 if (nla_put_in_addr(skb
, RTA_SRC
, src
))
2628 goto nla_put_failure
;
2631 nla_put_u32(skb
, RTA_OIF
, rt
->dst
.dev
->ifindex
))
2632 goto nla_put_failure
;
2633 #ifdef CONFIG_IP_ROUTE_CLASSID
2634 if (rt
->dst
.tclassid
&&
2635 nla_put_u32(skb
, RTA_FLOW
, rt
->dst
.tclassid
))
2636 goto nla_put_failure
;
2638 if (!rt_is_input_route(rt
) &&
2639 fl4
->saddr
!= src
) {
2640 if (nla_put_in_addr(skb
, RTA_PREFSRC
, fl4
->saddr
))
2641 goto nla_put_failure
;
2643 if (rt
->rt_uses_gateway
&&
2644 nla_put_in_addr(skb
, RTA_GATEWAY
, rt
->rt_gateway
))
2645 goto nla_put_failure
;
2647 expires
= rt
->dst
.expires
;
2649 unsigned long now
= jiffies
;
2651 if (time_before(now
, expires
))
2657 memcpy(metrics
, dst_metrics_ptr(&rt
->dst
), sizeof(metrics
));
2658 if (rt
->rt_pmtu
&& expires
)
2659 metrics
[RTAX_MTU
- 1] = rt
->rt_pmtu
;
2660 if (rt
->rt_mtu_locked
&& expires
)
2661 metrics
[RTAX_LOCK
- 1] |= BIT(RTAX_MTU
);
2662 if (rtnetlink_put_metrics(skb
, metrics
) < 0)
2663 goto nla_put_failure
;
2665 if (fl4
->flowi4_mark
&&
2666 nla_put_u32(skb
, RTA_MARK
, fl4
->flowi4_mark
))
2667 goto nla_put_failure
;
2669 if (!uid_eq(fl4
->flowi4_uid
, INVALID_UID
) &&
2670 nla_put_u32(skb
, RTA_UID
,
2671 from_kuid_munged(current_user_ns(), fl4
->flowi4_uid
)))
2672 goto nla_put_failure
;
2674 error
= rt
->dst
.error
;
2676 if (rt_is_input_route(rt
)) {
2677 #ifdef CONFIG_IP_MROUTE
2678 if (ipv4_is_multicast(dst
) && !ipv4_is_local_multicast(dst
) &&
2679 IPV4_DEVCONF_ALL(net
, MC_FORWARDING
)) {
2680 int err
= ipmr_get_route(net
, skb
,
2681 fl4
->saddr
, fl4
->daddr
,
2687 goto nla_put_failure
;
2691 if (nla_put_u32(skb
, RTA_IIF
, fl4
->flowi4_iif
))
2692 goto nla_put_failure
;
2695 if (rtnl_put_cacheinfo(skb
, &rt
->dst
, 0, expires
, error
) < 0)
2696 goto nla_put_failure
;
2698 nlmsg_end(skb
, nlh
);
2702 nlmsg_cancel(skb
, nlh
);
2706 static struct sk_buff
*inet_rtm_getroute_build_skb(__be32 src
, __be32 dst
,
2707 u8 ip_proto
, __be16 sport
,
2710 struct sk_buff
*skb
;
2713 skb
= alloc_skb(NLMSG_GOODSIZE
, GFP_KERNEL
);
2717 /* Reserve room for dummy headers, this skb can pass
2718 * through good chunk of routing engine.
2720 skb_reset_mac_header(skb
);
2721 skb_reset_network_header(skb
);
2722 skb
->protocol
= htons(ETH_P_IP
);
2723 iph
= skb_put(skb
, sizeof(struct iphdr
));
2724 iph
->protocol
= ip_proto
;
2730 skb_set_transport_header(skb
, skb
->len
);
2732 switch (iph
->protocol
) {
2734 struct udphdr
*udph
;
2736 udph
= skb_put_zero(skb
, sizeof(struct udphdr
));
2737 udph
->source
= sport
;
2739 udph
->len
= sizeof(struct udphdr
);
2744 struct tcphdr
*tcph
;
2746 tcph
= skb_put_zero(skb
, sizeof(struct tcphdr
));
2747 tcph
->source
= sport
;
2749 tcph
->doff
= sizeof(struct tcphdr
) / 4;
2751 tcph
->check
= ~tcp_v4_check(sizeof(struct tcphdr
),
2755 case IPPROTO_ICMP
: {
2756 struct icmphdr
*icmph
;
2758 icmph
= skb_put_zero(skb
, sizeof(struct icmphdr
));
2759 icmph
->type
= ICMP_ECHO
;
2767 static int inet_rtm_valid_getroute_req(struct sk_buff
*skb
,
2768 const struct nlmsghdr
*nlh
,
2770 struct netlink_ext_ack
*extack
)
2775 if (nlh
->nlmsg_len
< nlmsg_msg_size(sizeof(*rtm
))) {
2776 NL_SET_ERR_MSG(extack
,
2777 "ipv4: Invalid header for route get request");
2781 if (!netlink_strict_get_check(skb
))
2782 return nlmsg_parse(nlh
, sizeof(*rtm
), tb
, RTA_MAX
,
2783 rtm_ipv4_policy
, extack
);
2785 rtm
= nlmsg_data(nlh
);
2786 if ((rtm
->rtm_src_len
&& rtm
->rtm_src_len
!= 32) ||
2787 (rtm
->rtm_dst_len
&& rtm
->rtm_dst_len
!= 32) ||
2788 rtm
->rtm_table
|| rtm
->rtm_protocol
||
2789 rtm
->rtm_scope
|| rtm
->rtm_type
) {
2790 NL_SET_ERR_MSG(extack
, "ipv4: Invalid values in header for route get request");
2794 if (rtm
->rtm_flags
& ~(RTM_F_NOTIFY
|
2795 RTM_F_LOOKUP_TABLE
|
2797 NL_SET_ERR_MSG(extack
, "ipv4: Unsupported rtm_flags for route get request");
2801 err
= nlmsg_parse_strict(nlh
, sizeof(*rtm
), tb
, RTA_MAX
,
2802 rtm_ipv4_policy
, extack
);
2806 if ((tb
[RTA_SRC
] && !rtm
->rtm_src_len
) ||
2807 (tb
[RTA_DST
] && !rtm
->rtm_dst_len
)) {
2808 NL_SET_ERR_MSG(extack
, "ipv4: rtm_src_len and rtm_dst_len must be 32 for IPv4");
2812 for (i
= 0; i
<= RTA_MAX
; i
++) {
2828 NL_SET_ERR_MSG(extack
, "ipv4: Unsupported attribute in route get request");
2836 static int inet_rtm_getroute(struct sk_buff
*in_skb
, struct nlmsghdr
*nlh
,
2837 struct netlink_ext_ack
*extack
)
2839 struct net
*net
= sock_net(in_skb
->sk
);
2840 struct nlattr
*tb
[RTA_MAX
+1];
2841 u32 table_id
= RT_TABLE_MAIN
;
2842 __be16 sport
= 0, dport
= 0;
2843 struct fib_result res
= {};
2844 u8 ip_proto
= IPPROTO_UDP
;
2845 struct rtable
*rt
= NULL
;
2846 struct sk_buff
*skb
;
2848 struct flowi4 fl4
= {};
2856 err
= inet_rtm_valid_getroute_req(in_skb
, nlh
, tb
, extack
);
2860 rtm
= nlmsg_data(nlh
);
2861 src
= tb
[RTA_SRC
] ? nla_get_in_addr(tb
[RTA_SRC
]) : 0;
2862 dst
= tb
[RTA_DST
] ? nla_get_in_addr(tb
[RTA_DST
]) : 0;
2863 iif
= tb
[RTA_IIF
] ? nla_get_u32(tb
[RTA_IIF
]) : 0;
2864 mark
= tb
[RTA_MARK
] ? nla_get_u32(tb
[RTA_MARK
]) : 0;
2866 uid
= make_kuid(current_user_ns(), nla_get_u32(tb
[RTA_UID
]));
2868 uid
= (iif
? INVALID_UID
: current_uid());
2870 if (tb
[RTA_IP_PROTO
]) {
2871 err
= rtm_getroute_parse_ip_proto(tb
[RTA_IP_PROTO
],
2878 sport
= nla_get_be16(tb
[RTA_SPORT
]);
2881 dport
= nla_get_be16(tb
[RTA_DPORT
]);
2883 skb
= inet_rtm_getroute_build_skb(src
, dst
, ip_proto
, sport
, dport
);
2889 fl4
.flowi4_tos
= rtm
->rtm_tos
;
2890 fl4
.flowi4_oif
= tb
[RTA_OIF
] ? nla_get_u32(tb
[RTA_OIF
]) : 0;
2891 fl4
.flowi4_mark
= mark
;
2892 fl4
.flowi4_uid
= uid
;
2894 fl4
.fl4_sport
= sport
;
2896 fl4
.fl4_dport
= dport
;
2897 fl4
.flowi4_proto
= ip_proto
;
2902 struct net_device
*dev
;
2904 dev
= dev_get_by_index_rcu(net
, iif
);
2910 fl4
.flowi4_iif
= iif
; /* for rt_fill_info */
2913 err
= ip_route_input_rcu(skb
, dst
, src
, rtm
->rtm_tos
,
2916 rt
= skb_rtable(skb
);
2917 if (err
== 0 && rt
->dst
.error
)
2918 err
= -rt
->dst
.error
;
2920 fl4
.flowi4_iif
= LOOPBACK_IFINDEX
;
2921 skb
->dev
= net
->loopback_dev
;
2922 rt
= ip_route_output_key_hash_rcu(net
, &fl4
, &res
, skb
);
2927 skb_dst_set(skb
, &rt
->dst
);
2933 if (rtm
->rtm_flags
& RTM_F_NOTIFY
)
2934 rt
->rt_flags
|= RTCF_NOTIFY
;
2936 if (rtm
->rtm_flags
& RTM_F_LOOKUP_TABLE
)
2937 table_id
= res
.table
? res
.table
->tb_id
: 0;
2939 /* reset skb for netlink reply msg */
2941 skb_reset_network_header(skb
);
2942 skb_reset_transport_header(skb
);
2943 skb_reset_mac_header(skb
);
2945 if (rtm
->rtm_flags
& RTM_F_FIB_MATCH
) {
2947 err
= fib_props
[res
.type
].error
;
2949 err
= -EHOSTUNREACH
;
2952 err
= fib_dump_info(skb
, NETLINK_CB(in_skb
).portid
,
2953 nlh
->nlmsg_seq
, RTM_NEWROUTE
, table_id
,
2954 rt
->rt_type
, res
.prefix
, res
.prefixlen
,
2955 fl4
.flowi4_tos
, res
.fi
, 0);
2957 err
= rt_fill_info(net
, dst
, src
, rt
, table_id
, &fl4
, skb
,
2958 NETLINK_CB(in_skb
).portid
, nlh
->nlmsg_seq
);
2965 err
= rtnl_unicast(skb
, net
, NETLINK_CB(in_skb
).portid
);
2975 void ip_rt_multicast_event(struct in_device
*in_dev
)
2977 rt_cache_flush(dev_net(in_dev
->dev
));
2980 #ifdef CONFIG_SYSCTL
2981 static int ip_rt_gc_interval __read_mostly
= 60 * HZ
;
2982 static int ip_rt_gc_min_interval __read_mostly
= HZ
/ 2;
2983 static int ip_rt_gc_elasticity __read_mostly
= 8;
2984 static int ip_min_valid_pmtu __read_mostly
= IPV4_MIN_MTU
;
2986 static int ipv4_sysctl_rtcache_flush(struct ctl_table
*__ctl
, int write
,
2987 void __user
*buffer
,
2988 size_t *lenp
, loff_t
*ppos
)
2990 struct net
*net
= (struct net
*)__ctl
->extra1
;
2993 rt_cache_flush(net
);
2994 fnhe_genid_bump(net
);
3001 static struct ctl_table ipv4_route_table
[] = {
3003 .procname
= "gc_thresh",
3004 .data
= &ipv4_dst_ops
.gc_thresh
,
3005 .maxlen
= sizeof(int),
3007 .proc_handler
= proc_dointvec
,
3010 .procname
= "max_size",
3011 .data
= &ip_rt_max_size
,
3012 .maxlen
= sizeof(int),
3014 .proc_handler
= proc_dointvec
,
3017 /* Deprecated. Use gc_min_interval_ms */
3019 .procname
= "gc_min_interval",
3020 .data
= &ip_rt_gc_min_interval
,
3021 .maxlen
= sizeof(int),
3023 .proc_handler
= proc_dointvec_jiffies
,
3026 .procname
= "gc_min_interval_ms",
3027 .data
= &ip_rt_gc_min_interval
,
3028 .maxlen
= sizeof(int),
3030 .proc_handler
= proc_dointvec_ms_jiffies
,
3033 .procname
= "gc_timeout",
3034 .data
= &ip_rt_gc_timeout
,
3035 .maxlen
= sizeof(int),
3037 .proc_handler
= proc_dointvec_jiffies
,
3040 .procname
= "gc_interval",
3041 .data
= &ip_rt_gc_interval
,
3042 .maxlen
= sizeof(int),
3044 .proc_handler
= proc_dointvec_jiffies
,
3047 .procname
= "redirect_load",
3048 .data
= &ip_rt_redirect_load
,
3049 .maxlen
= sizeof(int),
3051 .proc_handler
= proc_dointvec
,
3054 .procname
= "redirect_number",
3055 .data
= &ip_rt_redirect_number
,
3056 .maxlen
= sizeof(int),
3058 .proc_handler
= proc_dointvec
,
3061 .procname
= "redirect_silence",
3062 .data
= &ip_rt_redirect_silence
,
3063 .maxlen
= sizeof(int),
3065 .proc_handler
= proc_dointvec
,
3068 .procname
= "error_cost",
3069 .data
= &ip_rt_error_cost
,
3070 .maxlen
= sizeof(int),
3072 .proc_handler
= proc_dointvec
,
3075 .procname
= "error_burst",
3076 .data
= &ip_rt_error_burst
,
3077 .maxlen
= sizeof(int),
3079 .proc_handler
= proc_dointvec
,
3082 .procname
= "gc_elasticity",
3083 .data
= &ip_rt_gc_elasticity
,
3084 .maxlen
= sizeof(int),
3086 .proc_handler
= proc_dointvec
,
3089 .procname
= "mtu_expires",
3090 .data
= &ip_rt_mtu_expires
,
3091 .maxlen
= sizeof(int),
3093 .proc_handler
= proc_dointvec_jiffies
,
3096 .procname
= "min_pmtu",
3097 .data
= &ip_rt_min_pmtu
,
3098 .maxlen
= sizeof(int),
3100 .proc_handler
= proc_dointvec_minmax
,
3101 .extra1
= &ip_min_valid_pmtu
,
3104 .procname
= "min_adv_mss",
3105 .data
= &ip_rt_min_advmss
,
3106 .maxlen
= sizeof(int),
3108 .proc_handler
= proc_dointvec
,
3113 static struct ctl_table ipv4_route_flush_table
[] = {
3115 .procname
= "flush",
3116 .maxlen
= sizeof(int),
3118 .proc_handler
= ipv4_sysctl_rtcache_flush
,
3123 static __net_init
int sysctl_route_net_init(struct net
*net
)
3125 struct ctl_table
*tbl
;
3127 tbl
= ipv4_route_flush_table
;
3128 if (!net_eq(net
, &init_net
)) {
3129 tbl
= kmemdup(tbl
, sizeof(ipv4_route_flush_table
), GFP_KERNEL
);
3133 /* Don't export sysctls to unprivileged users */
3134 if (net
->user_ns
!= &init_user_ns
)
3135 tbl
[0].procname
= NULL
;
3137 tbl
[0].extra1
= net
;
3139 net
->ipv4
.route_hdr
= register_net_sysctl(net
, "net/ipv4/route", tbl
);
3140 if (!net
->ipv4
.route_hdr
)
3145 if (tbl
!= ipv4_route_flush_table
)
3151 static __net_exit
void sysctl_route_net_exit(struct net
*net
)
3153 struct ctl_table
*tbl
;
3155 tbl
= net
->ipv4
.route_hdr
->ctl_table_arg
;
3156 unregister_net_sysctl_table(net
->ipv4
.route_hdr
);
3157 BUG_ON(tbl
== ipv4_route_flush_table
);
3161 static __net_initdata
struct pernet_operations sysctl_route_ops
= {
3162 .init
= sysctl_route_net_init
,
3163 .exit
= sysctl_route_net_exit
,
3167 static __net_init
int rt_genid_init(struct net
*net
)
3169 atomic_set(&net
->ipv4
.rt_genid
, 0);
3170 atomic_set(&net
->fnhe_genid
, 0);
3171 atomic_set(&net
->ipv4
.dev_addr_genid
, get_random_int());
3175 static __net_initdata
struct pernet_operations rt_genid_ops
= {
3176 .init
= rt_genid_init
,
3179 static int __net_init
ipv4_inetpeer_init(struct net
*net
)
3181 struct inet_peer_base
*bp
= kmalloc(sizeof(*bp
), GFP_KERNEL
);
3185 inet_peer_base_init(bp
);
3186 net
->ipv4
.peers
= bp
;
3190 static void __net_exit
ipv4_inetpeer_exit(struct net
*net
)
3192 struct inet_peer_base
*bp
= net
->ipv4
.peers
;
3194 net
->ipv4
.peers
= NULL
;
3195 inetpeer_invalidate_tree(bp
);
3199 static __net_initdata
struct pernet_operations ipv4_inetpeer_ops
= {
3200 .init
= ipv4_inetpeer_init
,
3201 .exit
= ipv4_inetpeer_exit
,
3204 #ifdef CONFIG_IP_ROUTE_CLASSID
3205 struct ip_rt_acct __percpu
*ip_rt_acct __read_mostly
;
3206 #endif /* CONFIG_IP_ROUTE_CLASSID */
3208 int __init
ip_rt_init(void)
3212 ip_idents
= kmalloc_array(IP_IDENTS_SZ
, sizeof(*ip_idents
),
3215 panic("IP: failed to allocate ip_idents\n");
3217 prandom_bytes(ip_idents
, IP_IDENTS_SZ
* sizeof(*ip_idents
));
3219 ip_tstamps
= kcalloc(IP_IDENTS_SZ
, sizeof(*ip_tstamps
), GFP_KERNEL
);
3221 panic("IP: failed to allocate ip_tstamps\n");
3223 for_each_possible_cpu(cpu
) {
3224 struct uncached_list
*ul
= &per_cpu(rt_uncached_list
, cpu
);
3226 INIT_LIST_HEAD(&ul
->head
);
3227 spin_lock_init(&ul
->lock
);
3229 #ifdef CONFIG_IP_ROUTE_CLASSID
3230 ip_rt_acct
= __alloc_percpu(256 * sizeof(struct ip_rt_acct
), __alignof__(struct ip_rt_acct
));
3232 panic("IP: failed to allocate ip_rt_acct\n");
3235 ipv4_dst_ops
.kmem_cachep
=
3236 kmem_cache_create("ip_dst_cache", sizeof(struct rtable
), 0,
3237 SLAB_HWCACHE_ALIGN
|SLAB_PANIC
, NULL
);
3239 ipv4_dst_blackhole_ops
.kmem_cachep
= ipv4_dst_ops
.kmem_cachep
;
3241 if (dst_entries_init(&ipv4_dst_ops
) < 0)
3242 panic("IP: failed to allocate ipv4_dst_ops counter\n");
3244 if (dst_entries_init(&ipv4_dst_blackhole_ops
) < 0)
3245 panic("IP: failed to allocate ipv4_dst_blackhole_ops counter\n");
3247 ipv4_dst_ops
.gc_thresh
= ~0;
3248 ip_rt_max_size
= INT_MAX
;
3253 if (ip_rt_proc_init())
3254 pr_err("Unable to create route proc files\n");
3259 rtnl_register(PF_INET
, RTM_GETROUTE
, inet_rtm_getroute
, NULL
,
3260 RTNL_FLAG_DOIT_UNLOCKED
);
3262 #ifdef CONFIG_SYSCTL
3263 register_pernet_subsys(&sysctl_route_ops
);
3265 register_pernet_subsys(&rt_genid_ops
);
3266 register_pernet_subsys(&ipv4_inetpeer_ops
);
3270 #ifdef CONFIG_SYSCTL
3272 * We really need to sanitize the damn ipv4 init order, then all
3273 * this nonsense will go away.
3275 void __init
ip_static_sysctl_init(void)
3277 register_net_sysctl(&init_net
, "net/ipv4/route", ipv4_route_table
);