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 <asm/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/net_namespace.h>
95 #include <net/protocol.h>
97 #include <net/route.h>
98 #include <net/inetpeer.h>
100 #include <net/ip_fib.h>
103 #include <net/icmp.h>
104 #include <net/xfrm.h>
105 #include <net/netevent.h>
106 #include <net/rtnetlink.h>
108 #include <linux/sysctl.h>
109 #include <linux/kmemleak.h>
111 #include <net/secure_seq.h>
113 #define RT_FL_TOS(oldflp4) \
114 ((oldflp4)->flowi4_tos & (IPTOS_RT_MASK | RTO_ONLINK))
116 #define RT_GC_TIMEOUT (300*HZ)
118 static int ip_rt_max_size;
119 static int ip_rt_redirect_number __read_mostly = 9;
120 static int ip_rt_redirect_load __read_mostly = HZ / 50;
121 static int ip_rt_redirect_silence __read_mostly = ((HZ / 50) << (9 + 1));
122 static int ip_rt_error_cost __read_mostly = HZ;
123 static int ip_rt_error_burst __read_mostly = 5 * HZ;
124 static int ip_rt_mtu_expires __read_mostly = 10 * 60 * HZ;
125 static int ip_rt_min_pmtu __read_mostly = 512 + 20 + 20;
126 static int ip_rt_min_advmss __read_mostly = 256;
129 * Interface to generic destination cache.
132 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
133 static unsigned int ipv4_default_advmss(const struct dst_entry *dst);
134 static unsigned int ipv4_mtu(const struct dst_entry *dst);
135 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
136 static void ipv4_link_failure(struct sk_buff *skb);
137 static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
138 struct sk_buff *skb, u32 mtu);
139 static void ip_do_redirect(struct dst_entry *dst, struct sock *sk,
140 struct sk_buff *skb);
141 static void ipv4_dst_destroy(struct dst_entry *dst);
143 static u32 *ipv4_cow_metrics(struct dst_entry *dst, unsigned long old)
149 static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
153 static struct dst_ops ipv4_dst_ops = {
155 .protocol = cpu_to_be16(ETH_P_IP),
156 .check = ipv4_dst_check,
157 .default_advmss = ipv4_default_advmss,
159 .cow_metrics = ipv4_cow_metrics,
160 .destroy = ipv4_dst_destroy,
161 .negative_advice = ipv4_negative_advice,
162 .link_failure = ipv4_link_failure,
163 .update_pmtu = ip_rt_update_pmtu,
164 .redirect = ip_do_redirect,
165 .local_out = __ip_local_out,
166 .neigh_lookup = ipv4_neigh_lookup,
169 #define ECN_OR_COST(class) TC_PRIO_##class
171 const __u8 ip_tos2prio[16] = {
173 ECN_OR_COST(BESTEFFORT),
175 ECN_OR_COST(BESTEFFORT),
181 ECN_OR_COST(INTERACTIVE),
183 ECN_OR_COST(INTERACTIVE),
184 TC_PRIO_INTERACTIVE_BULK,
185 ECN_OR_COST(INTERACTIVE_BULK),
186 TC_PRIO_INTERACTIVE_BULK,
187 ECN_OR_COST(INTERACTIVE_BULK)
189 EXPORT_SYMBOL(ip_tos2prio);
191 static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
192 #define RT_CACHE_STAT_INC(field) raw_cpu_inc(rt_cache_stat.field)
194 #ifdef CONFIG_PROC_FS
195 static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
199 return SEQ_START_TOKEN;
202 static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
208 static void rt_cache_seq_stop(struct seq_file *seq, void *v)
212 static int rt_cache_seq_show(struct seq_file *seq, void *v)
214 if (v == SEQ_START_TOKEN)
215 seq_printf(seq, "%-127s\n",
216 "Iface\tDestination\tGateway \tFlags\t\tRefCnt\tUse\t"
217 "Metric\tSource\t\tMTU\tWindow\tIRTT\tTOS\tHHRef\t"
222 static const struct seq_operations rt_cache_seq_ops = {
223 .start = rt_cache_seq_start,
224 .next = rt_cache_seq_next,
225 .stop = rt_cache_seq_stop,
226 .show = rt_cache_seq_show,
229 static int rt_cache_seq_open(struct inode *inode, struct file *file)
231 return seq_open(file, &rt_cache_seq_ops);
234 static const struct file_operations rt_cache_seq_fops = {
235 .owner = THIS_MODULE,
236 .open = rt_cache_seq_open,
239 .release = seq_release,
243 static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
248 return SEQ_START_TOKEN;
250 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
251 if (!cpu_possible(cpu))
254 return &per_cpu(rt_cache_stat, cpu);
259 static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
263 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
264 if (!cpu_possible(cpu))
267 return &per_cpu(rt_cache_stat, cpu);
273 static void rt_cpu_seq_stop(struct seq_file *seq, void *v)
278 static int rt_cpu_seq_show(struct seq_file *seq, void *v)
280 struct rt_cache_stat *st = v;
282 if (v == SEQ_START_TOKEN) {
283 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");
287 seq_printf(seq,"%08x %08x %08x %08x %08x %08x %08x %08x "
288 " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
289 dst_entries_get_slow(&ipv4_dst_ops),
302 0, /* st->gc_total */
303 0, /* st->gc_ignored */
304 0, /* st->gc_goal_miss */
305 0, /* st->gc_dst_overflow */
306 0, /* st->in_hlist_search */
307 0 /* st->out_hlist_search */
312 static const struct seq_operations rt_cpu_seq_ops = {
313 .start = rt_cpu_seq_start,
314 .next = rt_cpu_seq_next,
315 .stop = rt_cpu_seq_stop,
316 .show = rt_cpu_seq_show,
320 static int rt_cpu_seq_open(struct inode *inode, struct file *file)
322 return seq_open(file, &rt_cpu_seq_ops);
325 static const struct file_operations rt_cpu_seq_fops = {
326 .owner = THIS_MODULE,
327 .open = rt_cpu_seq_open,
330 .release = seq_release,
333 #ifdef CONFIG_IP_ROUTE_CLASSID
334 static int rt_acct_proc_show(struct seq_file *m, void *v)
336 struct ip_rt_acct *dst, *src;
339 dst = kcalloc(256, sizeof(struct ip_rt_acct), GFP_KERNEL);
343 for_each_possible_cpu(i) {
344 src = (struct ip_rt_acct *)per_cpu_ptr(ip_rt_acct, i);
345 for (j = 0; j < 256; j++) {
346 dst[j].o_bytes += src[j].o_bytes;
347 dst[j].o_packets += src[j].o_packets;
348 dst[j].i_bytes += src[j].i_bytes;
349 dst[j].i_packets += src[j].i_packets;
353 seq_write(m, dst, 256 * sizeof(struct ip_rt_acct));
358 static int rt_acct_proc_open(struct inode *inode, struct file *file)
360 return single_open(file, rt_acct_proc_show, NULL);
363 static const struct file_operations rt_acct_proc_fops = {
364 .owner = THIS_MODULE,
365 .open = rt_acct_proc_open,
368 .release = single_release,
372 static int __net_init ip_rt_do_proc_init(struct net *net)
374 struct proc_dir_entry *pde;
376 pde = proc_create("rt_cache", S_IRUGO, net->proc_net,
381 pde = proc_create("rt_cache", S_IRUGO,
382 net->proc_net_stat, &rt_cpu_seq_fops);
386 #ifdef CONFIG_IP_ROUTE_CLASSID
387 pde = proc_create("rt_acct", 0, net->proc_net, &rt_acct_proc_fops);
393 #ifdef CONFIG_IP_ROUTE_CLASSID
395 remove_proc_entry("rt_cache", net->proc_net_stat);
398 remove_proc_entry("rt_cache", net->proc_net);
403 static void __net_exit ip_rt_do_proc_exit(struct net *net)
405 remove_proc_entry("rt_cache", net->proc_net_stat);
406 remove_proc_entry("rt_cache", net->proc_net);
407 #ifdef CONFIG_IP_ROUTE_CLASSID
408 remove_proc_entry("rt_acct", net->proc_net);
412 static struct pernet_operations ip_rt_proc_ops __net_initdata = {
413 .init = ip_rt_do_proc_init,
414 .exit = ip_rt_do_proc_exit,
417 static int __init ip_rt_proc_init(void)
419 return register_pernet_subsys(&ip_rt_proc_ops);
423 static inline int ip_rt_proc_init(void)
427 #endif /* CONFIG_PROC_FS */
429 static inline bool rt_is_expired(const struct rtable *rth)
431 return rth->rt_genid != rt_genid_ipv4(dev_net(rth->dst.dev));
434 void rt_cache_flush(struct net *net)
436 rt_genid_bump_ipv4(net);
439 static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
443 struct net_device *dev = dst->dev;
444 const __be32 *pkey = daddr;
445 const struct rtable *rt;
448 rt = (const struct rtable *) dst;
450 pkey = (const __be32 *) &rt->rt_gateway;
452 pkey = &ip_hdr(skb)->daddr;
454 n = __ipv4_neigh_lookup(dev, *(__force u32 *)pkey);
457 return neigh_create(&arp_tbl, pkey, dev);
460 #define IP_IDENTS_SZ 2048u
461 struct ip_ident_bucket {
466 static struct ip_ident_bucket *ip_idents __read_mostly;
468 /* In order to protect privacy, we add a perturbation to identifiers
469 * if one generator is seldom used. This makes hard for an attacker
470 * to infer how many packets were sent between two points in time.
472 u32 ip_idents_reserve(u32 hash, int segs)
474 struct ip_ident_bucket *bucket = ip_idents + hash % IP_IDENTS_SZ;
475 u32 old = ACCESS_ONCE(bucket->stamp32);
476 u32 now = (u32)jiffies;
479 if (old != now && cmpxchg(&bucket->stamp32, old, now) == old)
480 delta = prandom_u32_max(now - old);
482 return atomic_add_return(segs + delta, &bucket->id) - segs;
484 EXPORT_SYMBOL(ip_idents_reserve);
486 void __ip_select_ident(struct iphdr *iph, int segs)
488 static u32 ip_idents_hashrnd __read_mostly;
491 net_get_random_once(&ip_idents_hashrnd, sizeof(ip_idents_hashrnd));
493 hash = jhash_3words((__force u32)iph->daddr,
494 (__force u32)iph->saddr,
497 id = ip_idents_reserve(hash, segs);
500 EXPORT_SYMBOL(__ip_select_ident);
502 static void __build_flow_key(struct flowi4 *fl4, const struct sock *sk,
503 const struct iphdr *iph,
505 u8 prot, u32 mark, int flow_flags)
508 const struct inet_sock *inet = inet_sk(sk);
510 oif = sk->sk_bound_dev_if;
512 tos = RT_CONN_FLAGS(sk);
513 prot = inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol;
515 flowi4_init_output(fl4, oif, mark, tos,
516 RT_SCOPE_UNIVERSE, prot,
518 iph->daddr, iph->saddr, 0, 0);
521 static void build_skb_flow_key(struct flowi4 *fl4, const struct sk_buff *skb,
522 const struct sock *sk)
524 const struct iphdr *iph = ip_hdr(skb);
525 int oif = skb->dev->ifindex;
526 u8 tos = RT_TOS(iph->tos);
527 u8 prot = iph->protocol;
528 u32 mark = skb->mark;
530 __build_flow_key(fl4, sk, iph, oif, tos, prot, mark, 0);
533 static void build_sk_flow_key(struct flowi4 *fl4, const struct sock *sk)
535 const struct inet_sock *inet = inet_sk(sk);
536 const struct ip_options_rcu *inet_opt;
537 __be32 daddr = inet->inet_daddr;
540 inet_opt = rcu_dereference(inet->inet_opt);
541 if (inet_opt && inet_opt->opt.srr)
542 daddr = inet_opt->opt.faddr;
543 flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
544 RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
545 inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol,
546 inet_sk_flowi_flags(sk),
547 daddr, inet->inet_saddr, 0, 0);
551 static void ip_rt_build_flow_key(struct flowi4 *fl4, const struct sock *sk,
552 const struct sk_buff *skb)
555 build_skb_flow_key(fl4, skb, sk);
557 build_sk_flow_key(fl4, sk);
560 static inline void rt_free(struct rtable *rt)
562 call_rcu(&rt->dst.rcu_head, dst_rcu_free);
565 static DEFINE_SPINLOCK(fnhe_lock);
567 static void fnhe_flush_routes(struct fib_nh_exception *fnhe)
571 rt = rcu_dereference(fnhe->fnhe_rth_input);
573 RCU_INIT_POINTER(fnhe->fnhe_rth_input, NULL);
576 rt = rcu_dereference(fnhe->fnhe_rth_output);
578 RCU_INIT_POINTER(fnhe->fnhe_rth_output, NULL);
583 static struct fib_nh_exception *fnhe_oldest(struct fnhe_hash_bucket *hash)
585 struct fib_nh_exception *fnhe, *oldest;
587 oldest = rcu_dereference(hash->chain);
588 for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe;
589 fnhe = rcu_dereference(fnhe->fnhe_next)) {
590 if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp))
593 fnhe_flush_routes(oldest);
597 static inline u32 fnhe_hashfun(__be32 daddr)
599 static u32 fnhe_hashrnd __read_mostly;
602 net_get_random_once(&fnhe_hashrnd, sizeof(fnhe_hashrnd));
603 hval = jhash_1word((__force u32) daddr, fnhe_hashrnd);
604 return hash_32(hval, FNHE_HASH_SHIFT);
607 static void fill_route_from_fnhe(struct rtable *rt, struct fib_nh_exception *fnhe)
609 rt->rt_pmtu = fnhe->fnhe_pmtu;
610 rt->dst.expires = fnhe->fnhe_expires;
613 rt->rt_flags |= RTCF_REDIRECTED;
614 rt->rt_gateway = fnhe->fnhe_gw;
615 rt->rt_uses_gateway = 1;
619 static void update_or_create_fnhe(struct fib_nh *nh, __be32 daddr, __be32 gw,
620 u32 pmtu, unsigned long expires)
622 struct fnhe_hash_bucket *hash;
623 struct fib_nh_exception *fnhe;
627 u32 hval = fnhe_hashfun(daddr);
629 spin_lock_bh(&fnhe_lock);
631 hash = rcu_dereference(nh->nh_exceptions);
633 hash = kzalloc(FNHE_HASH_SIZE * sizeof(*hash), GFP_ATOMIC);
636 rcu_assign_pointer(nh->nh_exceptions, hash);
642 for (fnhe = rcu_dereference(hash->chain); fnhe;
643 fnhe = rcu_dereference(fnhe->fnhe_next)) {
644 if (fnhe->fnhe_daddr == daddr)
653 fnhe->fnhe_pmtu = pmtu;
654 fnhe->fnhe_expires = max(1UL, expires);
656 /* Update all cached dsts too */
657 rt = rcu_dereference(fnhe->fnhe_rth_input);
659 fill_route_from_fnhe(rt, fnhe);
660 rt = rcu_dereference(fnhe->fnhe_rth_output);
662 fill_route_from_fnhe(rt, fnhe);
664 if (depth > FNHE_RECLAIM_DEPTH)
665 fnhe = fnhe_oldest(hash);
667 fnhe = kzalloc(sizeof(*fnhe), GFP_ATOMIC);
671 fnhe->fnhe_next = hash->chain;
672 rcu_assign_pointer(hash->chain, fnhe);
674 fnhe->fnhe_genid = fnhe_genid(dev_net(nh->nh_dev));
675 fnhe->fnhe_daddr = daddr;
677 fnhe->fnhe_pmtu = pmtu;
678 fnhe->fnhe_expires = expires;
680 /* Exception created; mark the cached routes for the nexthop
681 * stale, so anyone caching it rechecks if this exception
684 rt = rcu_dereference(nh->nh_rth_input);
686 rt->dst.obsolete = DST_OBSOLETE_KILL;
688 for_each_possible_cpu(i) {
689 struct rtable __rcu **prt;
690 prt = per_cpu_ptr(nh->nh_pcpu_rth_output, i);
691 rt = rcu_dereference(*prt);
693 rt->dst.obsolete = DST_OBSOLETE_KILL;
697 fnhe->fnhe_stamp = jiffies;
700 spin_unlock_bh(&fnhe_lock);
703 static void __ip_do_redirect(struct rtable *rt, struct sk_buff *skb, struct flowi4 *fl4,
706 __be32 new_gw = icmp_hdr(skb)->un.gateway;
707 __be32 old_gw = ip_hdr(skb)->saddr;
708 struct net_device *dev = skb->dev;
709 struct in_device *in_dev;
710 struct fib_result res;
714 switch (icmp_hdr(skb)->code & 7) {
716 case ICMP_REDIR_NETTOS:
717 case ICMP_REDIR_HOST:
718 case ICMP_REDIR_HOSTTOS:
725 if (rt->rt_gateway != old_gw)
728 in_dev = __in_dev_get_rcu(dev);
733 if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) ||
734 ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw) ||
735 ipv4_is_zeronet(new_gw))
736 goto reject_redirect;
738 if (!IN_DEV_SHARED_MEDIA(in_dev)) {
739 if (!inet_addr_onlink(in_dev, new_gw, old_gw))
740 goto reject_redirect;
741 if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
742 goto reject_redirect;
744 if (inet_addr_type(net, new_gw) != RTN_UNICAST)
745 goto reject_redirect;
748 n = ipv4_neigh_lookup(&rt->dst, NULL, &new_gw);
750 if (!(n->nud_state & NUD_VALID)) {
751 neigh_event_send(n, NULL);
753 if (fib_lookup(net, fl4, &res) == 0) {
754 struct fib_nh *nh = &FIB_RES_NH(res);
756 update_or_create_fnhe(nh, fl4->daddr, new_gw,
760 rt->dst.obsolete = DST_OBSOLETE_KILL;
761 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, n);
768 #ifdef CONFIG_IP_ROUTE_VERBOSE
769 if (IN_DEV_LOG_MARTIANS(in_dev)) {
770 const struct iphdr *iph = (const struct iphdr *) skb->data;
771 __be32 daddr = iph->daddr;
772 __be32 saddr = iph->saddr;
774 net_info_ratelimited("Redirect from %pI4 on %s about %pI4 ignored\n"
775 " Advised path = %pI4 -> %pI4\n",
776 &old_gw, dev->name, &new_gw,
783 static void ip_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
787 const struct iphdr *iph = (const struct iphdr *) skb->data;
788 int oif = skb->dev->ifindex;
789 u8 tos = RT_TOS(iph->tos);
790 u8 prot = iph->protocol;
791 u32 mark = skb->mark;
793 rt = (struct rtable *) dst;
795 __build_flow_key(&fl4, sk, iph, oif, tos, prot, mark, 0);
796 __ip_do_redirect(rt, skb, &fl4, true);
799 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
801 struct rtable *rt = (struct rtable *)dst;
802 struct dst_entry *ret = dst;
805 if (dst->obsolete > 0) {
808 } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
819 * 1. The first ip_rt_redirect_number redirects are sent
820 * with exponential backoff, then we stop sending them at all,
821 * assuming that the host ignores our redirects.
822 * 2. If we did not see packets requiring redirects
823 * during ip_rt_redirect_silence, we assume that the host
824 * forgot redirected route and start to send redirects again.
826 * This algorithm is much cheaper and more intelligent than dumb load limiting
829 * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
830 * and "frag. need" (breaks PMTU discovery) in icmp.c.
833 void ip_rt_send_redirect(struct sk_buff *skb)
835 struct rtable *rt = skb_rtable(skb);
836 struct in_device *in_dev;
837 struct inet_peer *peer;
842 in_dev = __in_dev_get_rcu(rt->dst.dev);
843 if (!in_dev || !IN_DEV_TX_REDIRECTS(in_dev)) {
847 log_martians = IN_DEV_LOG_MARTIANS(in_dev);
850 net = dev_net(rt->dst.dev);
851 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, 1);
853 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST,
854 rt_nexthop(rt, ip_hdr(skb)->daddr));
858 /* No redirected packets during ip_rt_redirect_silence;
859 * reset the algorithm.
861 if (time_after(jiffies, peer->rate_last + ip_rt_redirect_silence))
862 peer->rate_tokens = 0;
864 /* Too many ignored redirects; do not send anything
865 * set dst.rate_last to the last seen redirected packet.
867 if (peer->rate_tokens >= ip_rt_redirect_number) {
868 peer->rate_last = jiffies;
872 /* Check for load limit; set rate_last to the latest sent
875 if (peer->rate_tokens == 0 ||
878 (ip_rt_redirect_load << peer->rate_tokens)))) {
879 __be32 gw = rt_nexthop(rt, ip_hdr(skb)->daddr);
881 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, gw);
882 peer->rate_last = jiffies;
884 #ifdef CONFIG_IP_ROUTE_VERBOSE
886 peer->rate_tokens == ip_rt_redirect_number)
887 net_warn_ratelimited("host %pI4/if%d ignores redirects for %pI4 to %pI4\n",
888 &ip_hdr(skb)->saddr, inet_iif(skb),
889 &ip_hdr(skb)->daddr, &gw);
896 static int ip_error(struct sk_buff *skb)
898 struct in_device *in_dev = __in_dev_get_rcu(skb->dev);
899 struct rtable *rt = skb_rtable(skb);
900 struct inet_peer *peer;
906 net = dev_net(rt->dst.dev);
907 if (!IN_DEV_FORWARD(in_dev)) {
908 switch (rt->dst.error) {
910 IP_INC_STATS_BH(net, IPSTATS_MIB_INADDRERRORS);
914 IP_INC_STATS_BH(net, IPSTATS_MIB_INNOROUTES);
920 switch (rt->dst.error) {
925 code = ICMP_HOST_UNREACH;
928 code = ICMP_NET_UNREACH;
929 IP_INC_STATS_BH(net, IPSTATS_MIB_INNOROUTES);
932 code = ICMP_PKT_FILTERED;
936 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, 1);
941 peer->rate_tokens += now - peer->rate_last;
942 if (peer->rate_tokens > ip_rt_error_burst)
943 peer->rate_tokens = ip_rt_error_burst;
944 peer->rate_last = now;
945 if (peer->rate_tokens >= ip_rt_error_cost)
946 peer->rate_tokens -= ip_rt_error_cost;
952 icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
958 static void __ip_rt_update_pmtu(struct rtable *rt, struct flowi4 *fl4, u32 mtu)
960 struct dst_entry *dst = &rt->dst;
961 struct fib_result res;
963 if (dst_metric_locked(dst, RTAX_MTU))
966 if (dst->dev->mtu < mtu)
969 if (mtu < ip_rt_min_pmtu)
970 mtu = ip_rt_min_pmtu;
972 if (rt->rt_pmtu == mtu &&
973 time_before(jiffies, dst->expires - ip_rt_mtu_expires / 2))
977 if (fib_lookup(dev_net(dst->dev), fl4, &res) == 0) {
978 struct fib_nh *nh = &FIB_RES_NH(res);
980 update_or_create_fnhe(nh, fl4->daddr, 0, mtu,
981 jiffies + ip_rt_mtu_expires);
986 static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
987 struct sk_buff *skb, u32 mtu)
989 struct rtable *rt = (struct rtable *) dst;
992 ip_rt_build_flow_key(&fl4, sk, skb);
993 __ip_rt_update_pmtu(rt, &fl4, mtu);
996 void ipv4_update_pmtu(struct sk_buff *skb, struct net *net, u32 mtu,
997 int oif, u32 mark, u8 protocol, int flow_flags)
999 const struct iphdr *iph = (const struct iphdr *) skb->data;
1004 mark = IP4_REPLY_MARK(net, skb->mark);
1006 __build_flow_key(&fl4, NULL, iph, oif,
1007 RT_TOS(iph->tos), protocol, mark, flow_flags);
1008 rt = __ip_route_output_key(net, &fl4);
1010 __ip_rt_update_pmtu(rt, &fl4, mtu);
1014 EXPORT_SYMBOL_GPL(ipv4_update_pmtu);
1016 static void __ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
1018 const struct iphdr *iph = (const struct iphdr *) skb->data;
1022 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1024 if (!fl4.flowi4_mark)
1025 fl4.flowi4_mark = IP4_REPLY_MARK(sock_net(sk), skb->mark);
1027 rt = __ip_route_output_key(sock_net(sk), &fl4);
1029 __ip_rt_update_pmtu(rt, &fl4, mtu);
1034 void ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
1036 const struct iphdr *iph = (const struct iphdr *) skb->data;
1039 struct dst_entry *odst = NULL;
1044 if (!ip_sk_accept_pmtu(sk))
1047 odst = sk_dst_get(sk);
1049 if (sock_owned_by_user(sk) || !odst) {
1050 __ipv4_sk_update_pmtu(skb, sk, mtu);
1054 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1056 rt = (struct rtable *)odst;
1057 if (odst->obsolete && odst->ops->check(odst, 0) == NULL) {
1058 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1065 __ip_rt_update_pmtu((struct rtable *) rt->dst.path, &fl4, mtu);
1067 if (!dst_check(&rt->dst, 0)) {
1069 dst_release(&rt->dst);
1071 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1079 sk_dst_set(sk, &rt->dst);
1085 EXPORT_SYMBOL_GPL(ipv4_sk_update_pmtu);
1087 void ipv4_redirect(struct sk_buff *skb, struct net *net,
1088 int oif, u32 mark, u8 protocol, int flow_flags)
1090 const struct iphdr *iph = (const struct iphdr *) skb->data;
1094 __build_flow_key(&fl4, NULL, iph, oif,
1095 RT_TOS(iph->tos), protocol, mark, flow_flags);
1096 rt = __ip_route_output_key(net, &fl4);
1098 __ip_do_redirect(rt, skb, &fl4, false);
1102 EXPORT_SYMBOL_GPL(ipv4_redirect);
1104 void ipv4_sk_redirect(struct sk_buff *skb, struct sock *sk)
1106 const struct iphdr *iph = (const struct iphdr *) skb->data;
1110 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1111 rt = __ip_route_output_key(sock_net(sk), &fl4);
1113 __ip_do_redirect(rt, skb, &fl4, false);
1117 EXPORT_SYMBOL_GPL(ipv4_sk_redirect);
1119 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
1121 struct rtable *rt = (struct rtable *) dst;
1123 /* All IPV4 dsts are created with ->obsolete set to the value
1124 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1125 * into this function always.
1127 * When a PMTU/redirect information update invalidates a route,
1128 * this is indicated by setting obsolete to DST_OBSOLETE_KILL or
1129 * DST_OBSOLETE_DEAD by dst_free().
1131 if (dst->obsolete != DST_OBSOLETE_FORCE_CHK || rt_is_expired(rt))
1136 static void ipv4_link_failure(struct sk_buff *skb)
1140 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
1142 rt = skb_rtable(skb);
1144 dst_set_expires(&rt->dst, 0);
1147 static int ip_rt_bug(struct sock *sk, struct sk_buff *skb)
1149 pr_debug("%s: %pI4 -> %pI4, %s\n",
1150 __func__, &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
1151 skb->dev ? skb->dev->name : "?");
1158 We do not cache source address of outgoing interface,
1159 because it is used only by IP RR, TS and SRR options,
1160 so that it out of fast path.
1162 BTW remember: "addr" is allowed to be not aligned
1166 void ip_rt_get_source(u8 *addr, struct sk_buff *skb, struct rtable *rt)
1170 if (rt_is_output_route(rt))
1171 src = ip_hdr(skb)->saddr;
1173 struct fib_result res;
1179 memset(&fl4, 0, sizeof(fl4));
1180 fl4.daddr = iph->daddr;
1181 fl4.saddr = iph->saddr;
1182 fl4.flowi4_tos = RT_TOS(iph->tos);
1183 fl4.flowi4_oif = rt->dst.dev->ifindex;
1184 fl4.flowi4_iif = skb->dev->ifindex;
1185 fl4.flowi4_mark = skb->mark;
1188 if (fib_lookup(dev_net(rt->dst.dev), &fl4, &res) == 0)
1189 src = FIB_RES_PREFSRC(dev_net(rt->dst.dev), res);
1191 src = inet_select_addr(rt->dst.dev,
1192 rt_nexthop(rt, iph->daddr),
1196 memcpy(addr, &src, 4);
1199 #ifdef CONFIG_IP_ROUTE_CLASSID
1200 static void set_class_tag(struct rtable *rt, u32 tag)
1202 if (!(rt->dst.tclassid & 0xFFFF))
1203 rt->dst.tclassid |= tag & 0xFFFF;
1204 if (!(rt->dst.tclassid & 0xFFFF0000))
1205 rt->dst.tclassid |= tag & 0xFFFF0000;
1209 static unsigned int ipv4_default_advmss(const struct dst_entry *dst)
1211 unsigned int advmss = dst_metric_raw(dst, RTAX_ADVMSS);
1214 advmss = max_t(unsigned int, dst->dev->mtu - 40,
1216 if (advmss > 65535 - 40)
1217 advmss = 65535 - 40;
1222 static unsigned int ipv4_mtu(const struct dst_entry *dst)
1224 const struct rtable *rt = (const struct rtable *) dst;
1225 unsigned int mtu = rt->rt_pmtu;
1227 if (!mtu || time_after_eq(jiffies, rt->dst.expires))
1228 mtu = dst_metric_raw(dst, RTAX_MTU);
1233 mtu = dst->dev->mtu;
1235 if (unlikely(dst_metric_locked(dst, RTAX_MTU))) {
1236 if (rt->rt_uses_gateway && mtu > 576)
1240 return min_t(unsigned int, mtu, IP_MAX_MTU);
1243 static struct fib_nh_exception *find_exception(struct fib_nh *nh, __be32 daddr)
1245 struct fnhe_hash_bucket *hash = rcu_dereference(nh->nh_exceptions);
1246 struct fib_nh_exception *fnhe;
1252 hval = fnhe_hashfun(daddr);
1254 for (fnhe = rcu_dereference(hash[hval].chain); fnhe;
1255 fnhe = rcu_dereference(fnhe->fnhe_next)) {
1256 if (fnhe->fnhe_daddr == daddr)
1262 static bool rt_bind_exception(struct rtable *rt, struct fib_nh_exception *fnhe,
1267 spin_lock_bh(&fnhe_lock);
1269 if (daddr == fnhe->fnhe_daddr) {
1270 struct rtable __rcu **porig;
1271 struct rtable *orig;
1272 int genid = fnhe_genid(dev_net(rt->dst.dev));
1274 if (rt_is_input_route(rt))
1275 porig = &fnhe->fnhe_rth_input;
1277 porig = &fnhe->fnhe_rth_output;
1278 orig = rcu_dereference(*porig);
1280 if (fnhe->fnhe_genid != genid) {
1281 fnhe->fnhe_genid = genid;
1283 fnhe->fnhe_pmtu = 0;
1284 fnhe->fnhe_expires = 0;
1285 fnhe_flush_routes(fnhe);
1288 fill_route_from_fnhe(rt, fnhe);
1289 if (!rt->rt_gateway)
1290 rt->rt_gateway = daddr;
1292 if (!(rt->dst.flags & DST_NOCACHE)) {
1293 rcu_assign_pointer(*porig, rt);
1299 fnhe->fnhe_stamp = jiffies;
1301 spin_unlock_bh(&fnhe_lock);
1306 static bool rt_cache_route(struct fib_nh *nh, struct rtable *rt)
1308 struct rtable *orig, *prev, **p;
1311 if (rt_is_input_route(rt)) {
1312 p = (struct rtable **)&nh->nh_rth_input;
1314 p = (struct rtable **)raw_cpu_ptr(nh->nh_pcpu_rth_output);
1318 prev = cmpxchg(p, orig, rt);
1328 struct uncached_list {
1330 struct list_head head;
1333 static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt_uncached_list);
1335 static void rt_add_uncached_list(struct rtable *rt)
1337 struct uncached_list *ul = raw_cpu_ptr(&rt_uncached_list);
1339 rt->rt_uncached_list = ul;
1341 spin_lock_bh(&ul->lock);
1342 list_add_tail(&rt->rt_uncached, &ul->head);
1343 spin_unlock_bh(&ul->lock);
1346 static void ipv4_dst_destroy(struct dst_entry *dst)
1348 struct rtable *rt = (struct rtable *) dst;
1350 if (!list_empty(&rt->rt_uncached)) {
1351 struct uncached_list *ul = rt->rt_uncached_list;
1353 spin_lock_bh(&ul->lock);
1354 list_del(&rt->rt_uncached);
1355 spin_unlock_bh(&ul->lock);
1359 void rt_flush_dev(struct net_device *dev)
1361 struct net *net = dev_net(dev);
1365 for_each_possible_cpu(cpu) {
1366 struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);
1368 spin_lock_bh(&ul->lock);
1369 list_for_each_entry(rt, &ul->head, rt_uncached) {
1370 if (rt->dst.dev != dev)
1372 rt->dst.dev = net->loopback_dev;
1373 dev_hold(rt->dst.dev);
1376 spin_unlock_bh(&ul->lock);
1380 static bool rt_cache_valid(const struct rtable *rt)
1383 rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
1387 static void rt_set_nexthop(struct rtable *rt, __be32 daddr,
1388 const struct fib_result *res,
1389 struct fib_nh_exception *fnhe,
1390 struct fib_info *fi, u16 type, u32 itag)
1392 bool cached = false;
1395 struct fib_nh *nh = &FIB_RES_NH(*res);
1397 if (nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK) {
1398 rt->rt_gateway = nh->nh_gw;
1399 rt->rt_uses_gateway = 1;
1401 dst_init_metrics(&rt->dst, fi->fib_metrics, true);
1402 #ifdef CONFIG_IP_ROUTE_CLASSID
1403 rt->dst.tclassid = nh->nh_tclassid;
1406 cached = rt_bind_exception(rt, fnhe, daddr);
1407 else if (!(rt->dst.flags & DST_NOCACHE))
1408 cached = rt_cache_route(nh, rt);
1409 if (unlikely(!cached)) {
1410 /* Routes we intend to cache in nexthop exception or
1411 * FIB nexthop have the DST_NOCACHE bit clear.
1412 * However, if we are unsuccessful at storing this
1413 * route into the cache we really need to set it.
1415 rt->dst.flags |= DST_NOCACHE;
1416 if (!rt->rt_gateway)
1417 rt->rt_gateway = daddr;
1418 rt_add_uncached_list(rt);
1421 rt_add_uncached_list(rt);
1423 #ifdef CONFIG_IP_ROUTE_CLASSID
1424 #ifdef CONFIG_IP_MULTIPLE_TABLES
1425 set_class_tag(rt, res->tclassid);
1427 set_class_tag(rt, itag);
1431 static struct rtable *rt_dst_alloc(struct net_device *dev,
1432 bool nopolicy, bool noxfrm, bool will_cache)
1434 return dst_alloc(&ipv4_dst_ops, dev, 1, DST_OBSOLETE_FORCE_CHK,
1435 (will_cache ? 0 : (DST_HOST | DST_NOCACHE)) |
1436 (nopolicy ? DST_NOPOLICY : 0) |
1437 (noxfrm ? DST_NOXFRM : 0));
1440 /* called in rcu_read_lock() section */
1441 static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1442 u8 tos, struct net_device *dev, int our)
1445 struct in_device *in_dev = __in_dev_get_rcu(dev);
1449 /* Primary sanity checks. */
1454 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
1455 skb->protocol != htons(ETH_P_IP))
1458 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
1459 if (ipv4_is_loopback(saddr))
1462 if (ipv4_is_zeronet(saddr)) {
1463 if (!ipv4_is_local_multicast(daddr))
1466 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1471 rth = rt_dst_alloc(dev_net(dev)->loopback_dev,
1472 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, false);
1476 #ifdef CONFIG_IP_ROUTE_CLASSID
1477 rth->dst.tclassid = itag;
1479 rth->dst.output = ip_rt_bug;
1481 rth->rt_genid = rt_genid_ipv4(dev_net(dev));
1482 rth->rt_flags = RTCF_MULTICAST;
1483 rth->rt_type = RTN_MULTICAST;
1484 rth->rt_is_input= 1;
1487 rth->rt_gateway = 0;
1488 rth->rt_uses_gateway = 0;
1489 INIT_LIST_HEAD(&rth->rt_uncached);
1491 rth->dst.input= ip_local_deliver;
1492 rth->rt_flags |= RTCF_LOCAL;
1495 #ifdef CONFIG_IP_MROUTE
1496 if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
1497 rth->dst.input = ip_mr_input;
1499 RT_CACHE_STAT_INC(in_slow_mc);
1501 skb_dst_set(skb, &rth->dst);
1513 static void ip_handle_martian_source(struct net_device *dev,
1514 struct in_device *in_dev,
1515 struct sk_buff *skb,
1519 RT_CACHE_STAT_INC(in_martian_src);
1520 #ifdef CONFIG_IP_ROUTE_VERBOSE
1521 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
1523 * RFC1812 recommendation, if source is martian,
1524 * the only hint is MAC header.
1526 pr_warn("martian source %pI4 from %pI4, on dev %s\n",
1527 &daddr, &saddr, dev->name);
1528 if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
1529 print_hex_dump(KERN_WARNING, "ll header: ",
1530 DUMP_PREFIX_OFFSET, 16, 1,
1531 skb_mac_header(skb),
1532 dev->hard_header_len, true);
1538 /* called in rcu_read_lock() section */
1539 static int __mkroute_input(struct sk_buff *skb,
1540 const struct fib_result *res,
1541 struct in_device *in_dev,
1542 __be32 daddr, __be32 saddr, u32 tos)
1544 struct fib_nh_exception *fnhe;
1547 struct in_device *out_dev;
1548 unsigned int flags = 0;
1552 /* get a working reference to the output device */
1553 out_dev = __in_dev_get_rcu(FIB_RES_DEV(*res));
1554 if (out_dev == NULL) {
1555 net_crit_ratelimited("Bug in ip_route_input_slow(). Please report.\n");
1559 err = fib_validate_source(skb, saddr, daddr, tos, FIB_RES_OIF(*res),
1560 in_dev->dev, in_dev, &itag);
1562 ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
1568 do_cache = res->fi && !itag;
1569 if (out_dev == in_dev && err && IN_DEV_TX_REDIRECTS(out_dev) &&
1570 (IN_DEV_SHARED_MEDIA(out_dev) ||
1571 inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res)))) {
1572 flags |= RTCF_DOREDIRECT;
1576 if (skb->protocol != htons(ETH_P_IP)) {
1577 /* Not IP (i.e. ARP). Do not create route, if it is
1578 * invalid for proxy arp. DNAT routes are always valid.
1580 * Proxy arp feature have been extended to allow, ARP
1581 * replies back to the same interface, to support
1582 * Private VLAN switch technologies. See arp.c.
1584 if (out_dev == in_dev &&
1585 IN_DEV_PROXY_ARP_PVLAN(in_dev) == 0) {
1591 fnhe = find_exception(&FIB_RES_NH(*res), daddr);
1594 rth = rcu_dereference(fnhe->fnhe_rth_input);
1596 rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input);
1598 if (rt_cache_valid(rth)) {
1599 skb_dst_set_noref(skb, &rth->dst);
1604 rth = rt_dst_alloc(out_dev->dev,
1605 IN_DEV_CONF_GET(in_dev, NOPOLICY),
1606 IN_DEV_CONF_GET(out_dev, NOXFRM), do_cache);
1612 rth->rt_genid = rt_genid_ipv4(dev_net(rth->dst.dev));
1613 rth->rt_flags = flags;
1614 rth->rt_type = res->type;
1615 rth->rt_is_input = 1;
1618 rth->rt_gateway = 0;
1619 rth->rt_uses_gateway = 0;
1620 INIT_LIST_HEAD(&rth->rt_uncached);
1621 RT_CACHE_STAT_INC(in_slow_tot);
1623 rth->dst.input = ip_forward;
1624 rth->dst.output = ip_output;
1626 rt_set_nexthop(rth, daddr, res, fnhe, res->fi, res->type, itag);
1627 skb_dst_set(skb, &rth->dst);
1634 static int ip_mkroute_input(struct sk_buff *skb,
1635 struct fib_result *res,
1636 const struct flowi4 *fl4,
1637 struct in_device *in_dev,
1638 __be32 daddr, __be32 saddr, u32 tos)
1640 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1641 if (res->fi && res->fi->fib_nhs > 1)
1642 fib_select_multipath(res);
1645 /* create a routing cache entry */
1646 return __mkroute_input(skb, res, in_dev, daddr, saddr, tos);
1650 * NOTE. We drop all the packets that has local source
1651 * addresses, because every properly looped back packet
1652 * must have correct destination already attached by output routine.
1654 * Such approach solves two big problems:
1655 * 1. Not simplex devices are handled properly.
1656 * 2. IP spoofing attempts are filtered with 100% of guarantee.
1657 * called with rcu_read_lock()
1660 static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1661 u8 tos, struct net_device *dev)
1663 struct fib_result res;
1664 struct in_device *in_dev = __in_dev_get_rcu(dev);
1666 unsigned int flags = 0;
1670 struct net *net = dev_net(dev);
1673 /* IP on this device is disabled. */
1678 /* Check for the most weird martians, which can be not detected
1682 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr))
1683 goto martian_source;
1686 if (ipv4_is_lbcast(daddr) || (saddr == 0 && daddr == 0))
1689 /* Accept zero addresses only to limited broadcast;
1690 * I even do not know to fix it or not. Waiting for complains :-)
1692 if (ipv4_is_zeronet(saddr))
1693 goto martian_source;
1695 if (ipv4_is_zeronet(daddr))
1696 goto martian_destination;
1698 /* Following code try to avoid calling IN_DEV_NET_ROUTE_LOCALNET(),
1699 * and call it once if daddr or/and saddr are loopback addresses
1701 if (ipv4_is_loopback(daddr)) {
1702 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
1703 goto martian_destination;
1704 } else if (ipv4_is_loopback(saddr)) {
1705 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
1706 goto martian_source;
1710 * Now we are ready to route packet.
1713 fl4.flowi4_iif = dev->ifindex;
1714 fl4.flowi4_mark = skb->mark;
1715 fl4.flowi4_tos = tos;
1716 fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
1719 err = fib_lookup(net, &fl4, &res);
1721 if (!IN_DEV_FORWARD(in_dev))
1722 err = -EHOSTUNREACH;
1726 if (res.type == RTN_BROADCAST)
1729 if (res.type == RTN_LOCAL) {
1730 err = fib_validate_source(skb, saddr, daddr, tos,
1731 0, dev, in_dev, &itag);
1733 goto martian_source_keep_err;
1737 if (!IN_DEV_FORWARD(in_dev)) {
1738 err = -EHOSTUNREACH;
1741 if (res.type != RTN_UNICAST)
1742 goto martian_destination;
1744 err = ip_mkroute_input(skb, &res, &fl4, in_dev, daddr, saddr, tos);
1748 if (skb->protocol != htons(ETH_P_IP))
1751 if (!ipv4_is_zeronet(saddr)) {
1752 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1755 goto martian_source_keep_err;
1757 flags |= RTCF_BROADCAST;
1758 res.type = RTN_BROADCAST;
1759 RT_CACHE_STAT_INC(in_brd);
1765 rth = rcu_dereference(FIB_RES_NH(res).nh_rth_input);
1766 if (rt_cache_valid(rth)) {
1767 skb_dst_set_noref(skb, &rth->dst);
1775 rth = rt_dst_alloc(net->loopback_dev,
1776 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, do_cache);
1780 rth->dst.input= ip_local_deliver;
1781 rth->dst.output= ip_rt_bug;
1782 #ifdef CONFIG_IP_ROUTE_CLASSID
1783 rth->dst.tclassid = itag;
1786 rth->rt_genid = rt_genid_ipv4(net);
1787 rth->rt_flags = flags|RTCF_LOCAL;
1788 rth->rt_type = res.type;
1789 rth->rt_is_input = 1;
1792 rth->rt_gateway = 0;
1793 rth->rt_uses_gateway = 0;
1794 INIT_LIST_HEAD(&rth->rt_uncached);
1795 RT_CACHE_STAT_INC(in_slow_tot);
1796 if (res.type == RTN_UNREACHABLE) {
1797 rth->dst.input= ip_error;
1798 rth->dst.error= -err;
1799 rth->rt_flags &= ~RTCF_LOCAL;
1802 if (unlikely(!rt_cache_route(&FIB_RES_NH(res), rth))) {
1803 rth->dst.flags |= DST_NOCACHE;
1804 rt_add_uncached_list(rth);
1807 skb_dst_set(skb, &rth->dst);
1812 RT_CACHE_STAT_INC(in_no_route);
1813 res.type = RTN_UNREACHABLE;
1818 * Do not cache martian addresses: they should be logged (RFC1812)
1820 martian_destination:
1821 RT_CACHE_STAT_INC(in_martian_dst);
1822 #ifdef CONFIG_IP_ROUTE_VERBOSE
1823 if (IN_DEV_LOG_MARTIANS(in_dev))
1824 net_warn_ratelimited("martian destination %pI4 from %pI4, dev %s\n",
1825 &daddr, &saddr, dev->name);
1838 martian_source_keep_err:
1839 ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
1843 int ip_route_input_noref(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1844 u8 tos, struct net_device *dev)
1850 /* Multicast recognition logic is moved from route cache to here.
1851 The problem was that too many Ethernet cards have broken/missing
1852 hardware multicast filters :-( As result the host on multicasting
1853 network acquires a lot of useless route cache entries, sort of
1854 SDR messages from all the world. Now we try to get rid of them.
1855 Really, provided software IP multicast filter is organized
1856 reasonably (at least, hashed), it does not result in a slowdown
1857 comparing with route cache reject entries.
1858 Note, that multicast routers are not affected, because
1859 route cache entry is created eventually.
1861 if (ipv4_is_multicast(daddr)) {
1862 struct in_device *in_dev = __in_dev_get_rcu(dev);
1865 int our = ip_check_mc_rcu(in_dev, daddr, saddr,
1866 ip_hdr(skb)->protocol);
1868 #ifdef CONFIG_IP_MROUTE
1870 (!ipv4_is_local_multicast(daddr) &&
1871 IN_DEV_MFORWARD(in_dev))
1874 int res = ip_route_input_mc(skb, daddr, saddr,
1883 res = ip_route_input_slow(skb, daddr, saddr, tos, dev);
1887 EXPORT_SYMBOL(ip_route_input_noref);
1889 /* called with rcu_read_lock() */
1890 static struct rtable *__mkroute_output(const struct fib_result *res,
1891 const struct flowi4 *fl4, int orig_oif,
1892 struct net_device *dev_out,
1895 struct fib_info *fi = res->fi;
1896 struct fib_nh_exception *fnhe;
1897 struct in_device *in_dev;
1898 u16 type = res->type;
1902 in_dev = __in_dev_get_rcu(dev_out);
1904 return ERR_PTR(-EINVAL);
1906 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
1907 if (ipv4_is_loopback(fl4->saddr) && !(dev_out->flags & IFF_LOOPBACK))
1908 return ERR_PTR(-EINVAL);
1910 if (ipv4_is_lbcast(fl4->daddr))
1911 type = RTN_BROADCAST;
1912 else if (ipv4_is_multicast(fl4->daddr))
1913 type = RTN_MULTICAST;
1914 else if (ipv4_is_zeronet(fl4->daddr))
1915 return ERR_PTR(-EINVAL);
1917 if (dev_out->flags & IFF_LOOPBACK)
1918 flags |= RTCF_LOCAL;
1921 if (type == RTN_BROADCAST) {
1922 flags |= RTCF_BROADCAST | RTCF_LOCAL;
1924 } else if (type == RTN_MULTICAST) {
1925 flags |= RTCF_MULTICAST | RTCF_LOCAL;
1926 if (!ip_check_mc_rcu(in_dev, fl4->daddr, fl4->saddr,
1928 flags &= ~RTCF_LOCAL;
1931 /* If multicast route do not exist use
1932 * default one, but do not gateway in this case.
1935 if (fi && res->prefixlen < 4)
1940 do_cache &= fi != NULL;
1942 struct rtable __rcu **prth;
1943 struct fib_nh *nh = &FIB_RES_NH(*res);
1945 fnhe = find_exception(nh, fl4->daddr);
1947 prth = &fnhe->fnhe_rth_output;
1949 if (unlikely(fl4->flowi4_flags &
1950 FLOWI_FLAG_KNOWN_NH &&
1952 nh->nh_scope == RT_SCOPE_LINK))) {
1956 prth = raw_cpu_ptr(nh->nh_pcpu_rth_output);
1958 rth = rcu_dereference(*prth);
1959 if (rt_cache_valid(rth)) {
1960 dst_hold(&rth->dst);
1966 rth = rt_dst_alloc(dev_out,
1967 IN_DEV_CONF_GET(in_dev, NOPOLICY),
1968 IN_DEV_CONF_GET(in_dev, NOXFRM),
1971 return ERR_PTR(-ENOBUFS);
1973 rth->dst.output = ip_output;
1975 rth->rt_genid = rt_genid_ipv4(dev_net(dev_out));
1976 rth->rt_flags = flags;
1977 rth->rt_type = type;
1978 rth->rt_is_input = 0;
1979 rth->rt_iif = orig_oif ? : 0;
1981 rth->rt_gateway = 0;
1982 rth->rt_uses_gateway = 0;
1983 INIT_LIST_HEAD(&rth->rt_uncached);
1985 RT_CACHE_STAT_INC(out_slow_tot);
1987 if (flags & RTCF_LOCAL)
1988 rth->dst.input = ip_local_deliver;
1989 if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
1990 if (flags & RTCF_LOCAL &&
1991 !(dev_out->flags & IFF_LOOPBACK)) {
1992 rth->dst.output = ip_mc_output;
1993 RT_CACHE_STAT_INC(out_slow_mc);
1995 #ifdef CONFIG_IP_MROUTE
1996 if (type == RTN_MULTICAST) {
1997 if (IN_DEV_MFORWARD(in_dev) &&
1998 !ipv4_is_local_multicast(fl4->daddr)) {
1999 rth->dst.input = ip_mr_input;
2000 rth->dst.output = ip_mc_output;
2006 rt_set_nexthop(rth, fl4->daddr, res, fnhe, fi, type, 0);
2012 * Major route resolver routine.
2015 struct rtable *__ip_route_output_key(struct net *net, struct flowi4 *fl4)
2017 struct net_device *dev_out = NULL;
2018 __u8 tos = RT_FL_TOS(fl4);
2019 unsigned int flags = 0;
2020 struct fib_result res;
2028 orig_oif = fl4->flowi4_oif;
2030 fl4->flowi4_iif = LOOPBACK_IFINDEX;
2031 fl4->flowi4_tos = tos & IPTOS_RT_MASK;
2032 fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
2033 RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);
2037 rth = ERR_PTR(-EINVAL);
2038 if (ipv4_is_multicast(fl4->saddr) ||
2039 ipv4_is_lbcast(fl4->saddr) ||
2040 ipv4_is_zeronet(fl4->saddr))
2043 /* I removed check for oif == dev_out->oif here.
2044 It was wrong for two reasons:
2045 1. ip_dev_find(net, saddr) can return wrong iface, if saddr
2046 is assigned to multiple interfaces.
2047 2. Moreover, we are allowed to send packets with saddr
2048 of another iface. --ANK
2051 if (fl4->flowi4_oif == 0 &&
2052 (ipv4_is_multicast(fl4->daddr) ||
2053 ipv4_is_lbcast(fl4->daddr))) {
2054 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2055 dev_out = __ip_dev_find(net, fl4->saddr, false);
2056 if (dev_out == NULL)
2059 /* Special hack: user can direct multicasts
2060 and limited broadcast via necessary interface
2061 without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
2062 This hack is not just for fun, it allows
2063 vic,vat and friends to work.
2064 They bind socket to loopback, set ttl to zero
2065 and expect that it will work.
2066 From the viewpoint of routing cache they are broken,
2067 because we are not allowed to build multicast path
2068 with loopback source addr (look, routing cache
2069 cannot know, that ttl is zero, so that packet
2070 will not leave this host and route is valid).
2071 Luckily, this hack is good workaround.
2074 fl4->flowi4_oif = dev_out->ifindex;
2078 if (!(fl4->flowi4_flags & FLOWI_FLAG_ANYSRC)) {
2079 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2080 if (!__ip_dev_find(net, fl4->saddr, false))
2086 if (fl4->flowi4_oif) {
2087 dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);
2088 rth = ERR_PTR(-ENODEV);
2089 if (dev_out == NULL)
2092 /* RACE: Check return value of inet_select_addr instead. */
2093 if (!(dev_out->flags & IFF_UP) || !__in_dev_get_rcu(dev_out)) {
2094 rth = ERR_PTR(-ENETUNREACH);
2097 if (ipv4_is_local_multicast(fl4->daddr) ||
2098 ipv4_is_lbcast(fl4->daddr)) {
2100 fl4->saddr = inet_select_addr(dev_out, 0,
2105 if (ipv4_is_multicast(fl4->daddr))
2106 fl4->saddr = inet_select_addr(dev_out, 0,
2108 else if (!fl4->daddr)
2109 fl4->saddr = inet_select_addr(dev_out, 0,
2115 fl4->daddr = fl4->saddr;
2117 fl4->daddr = fl4->saddr = htonl(INADDR_LOOPBACK);
2118 dev_out = net->loopback_dev;
2119 fl4->flowi4_oif = LOOPBACK_IFINDEX;
2120 res.type = RTN_LOCAL;
2121 flags |= RTCF_LOCAL;
2125 if (fib_lookup(net, fl4, &res)) {
2128 if (fl4->flowi4_oif) {
2129 /* Apparently, routing tables are wrong. Assume,
2130 that the destination is on link.
2133 Because we are allowed to send to iface
2134 even if it has NO routes and NO assigned
2135 addresses. When oif is specified, routing
2136 tables are looked up with only one purpose:
2137 to catch if destination is gatewayed, rather than
2138 direct. Moreover, if MSG_DONTROUTE is set,
2139 we send packet, ignoring both routing tables
2140 and ifaddr state. --ANK
2143 We could make it even if oif is unknown,
2144 likely IPv6, but we do not.
2147 if (fl4->saddr == 0)
2148 fl4->saddr = inet_select_addr(dev_out, 0,
2150 res.type = RTN_UNICAST;
2153 rth = ERR_PTR(-ENETUNREACH);
2157 if (res.type == RTN_LOCAL) {
2159 if (res.fi->fib_prefsrc)
2160 fl4->saddr = res.fi->fib_prefsrc;
2162 fl4->saddr = fl4->daddr;
2164 dev_out = net->loopback_dev;
2165 fl4->flowi4_oif = dev_out->ifindex;
2166 flags |= RTCF_LOCAL;
2170 #ifdef CONFIG_IP_ROUTE_MULTIPATH
2171 if (res.fi->fib_nhs > 1 && fl4->flowi4_oif == 0)
2172 fib_select_multipath(&res);
2175 if (!res.prefixlen &&
2176 res.table->tb_num_default > 1 &&
2177 res.type == RTN_UNICAST && !fl4->flowi4_oif)
2178 fib_select_default(&res);
2181 fl4->saddr = FIB_RES_PREFSRC(net, res);
2183 dev_out = FIB_RES_DEV(res);
2184 fl4->flowi4_oif = dev_out->ifindex;
2188 rth = __mkroute_output(&res, fl4, orig_oif, dev_out, flags);
2194 EXPORT_SYMBOL_GPL(__ip_route_output_key);
2196 static struct dst_entry *ipv4_blackhole_dst_check(struct dst_entry *dst, u32 cookie)
2201 static unsigned int ipv4_blackhole_mtu(const struct dst_entry *dst)
2203 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
2205 return mtu ? : dst->dev->mtu;
2208 static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
2209 struct sk_buff *skb, u32 mtu)
2213 static void ipv4_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
2214 struct sk_buff *skb)
2218 static u32 *ipv4_rt_blackhole_cow_metrics(struct dst_entry *dst,
2224 static struct dst_ops ipv4_dst_blackhole_ops = {
2226 .protocol = cpu_to_be16(ETH_P_IP),
2227 .check = ipv4_blackhole_dst_check,
2228 .mtu = ipv4_blackhole_mtu,
2229 .default_advmss = ipv4_default_advmss,
2230 .update_pmtu = ipv4_rt_blackhole_update_pmtu,
2231 .redirect = ipv4_rt_blackhole_redirect,
2232 .cow_metrics = ipv4_rt_blackhole_cow_metrics,
2233 .neigh_lookup = ipv4_neigh_lookup,
2236 struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig)
2238 struct rtable *ort = (struct rtable *) dst_orig;
2241 rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, DST_OBSOLETE_NONE, 0);
2243 struct dst_entry *new = &rt->dst;
2246 new->input = dst_discard;
2247 new->output = dst_discard_sk;
2249 new->dev = ort->dst.dev;
2253 rt->rt_is_input = ort->rt_is_input;
2254 rt->rt_iif = ort->rt_iif;
2255 rt->rt_pmtu = ort->rt_pmtu;
2257 rt->rt_genid = rt_genid_ipv4(net);
2258 rt->rt_flags = ort->rt_flags;
2259 rt->rt_type = ort->rt_type;
2260 rt->rt_gateway = ort->rt_gateway;
2261 rt->rt_uses_gateway = ort->rt_uses_gateway;
2263 INIT_LIST_HEAD(&rt->rt_uncached);
2268 dst_release(dst_orig);
2270 return rt ? &rt->dst : ERR_PTR(-ENOMEM);
2273 struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4,
2276 struct rtable *rt = __ip_route_output_key(net, flp4);
2281 if (flp4->flowi4_proto)
2282 rt = (struct rtable *)xfrm_lookup_route(net, &rt->dst,
2283 flowi4_to_flowi(flp4),
2288 EXPORT_SYMBOL_GPL(ip_route_output_flow);
2290 static int rt_fill_info(struct net *net, __be32 dst, __be32 src,
2291 struct flowi4 *fl4, struct sk_buff *skb, u32 portid,
2292 u32 seq, int event, int nowait, unsigned int flags)
2294 struct rtable *rt = skb_rtable(skb);
2296 struct nlmsghdr *nlh;
2297 unsigned long expires = 0;
2299 u32 metrics[RTAX_MAX];
2301 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*r), flags);
2305 r = nlmsg_data(nlh);
2306 r->rtm_family = AF_INET;
2307 r->rtm_dst_len = 32;
2309 r->rtm_tos = fl4->flowi4_tos;
2310 r->rtm_table = RT_TABLE_MAIN;
2311 if (nla_put_u32(skb, RTA_TABLE, RT_TABLE_MAIN))
2312 goto nla_put_failure;
2313 r->rtm_type = rt->rt_type;
2314 r->rtm_scope = RT_SCOPE_UNIVERSE;
2315 r->rtm_protocol = RTPROT_UNSPEC;
2316 r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
2317 if (rt->rt_flags & RTCF_NOTIFY)
2318 r->rtm_flags |= RTM_F_NOTIFY;
2320 if (nla_put_be32(skb, RTA_DST, dst))
2321 goto nla_put_failure;
2323 r->rtm_src_len = 32;
2324 if (nla_put_be32(skb, RTA_SRC, src))
2325 goto nla_put_failure;
2328 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2329 goto nla_put_failure;
2330 #ifdef CONFIG_IP_ROUTE_CLASSID
2331 if (rt->dst.tclassid &&
2332 nla_put_u32(skb, RTA_FLOW, rt->dst.tclassid))
2333 goto nla_put_failure;
2335 if (!rt_is_input_route(rt) &&
2336 fl4->saddr != src) {
2337 if (nla_put_be32(skb, RTA_PREFSRC, fl4->saddr))
2338 goto nla_put_failure;
2340 if (rt->rt_uses_gateway &&
2341 nla_put_be32(skb, RTA_GATEWAY, rt->rt_gateway))
2342 goto nla_put_failure;
2344 expires = rt->dst.expires;
2346 unsigned long now = jiffies;
2348 if (time_before(now, expires))
2354 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
2355 if (rt->rt_pmtu && expires)
2356 metrics[RTAX_MTU - 1] = rt->rt_pmtu;
2357 if (rtnetlink_put_metrics(skb, metrics) < 0)
2358 goto nla_put_failure;
2360 if (fl4->flowi4_mark &&
2361 nla_put_u32(skb, RTA_MARK, fl4->flowi4_mark))
2362 goto nla_put_failure;
2364 error = rt->dst.error;
2366 if (rt_is_input_route(rt)) {
2367 #ifdef CONFIG_IP_MROUTE
2368 if (ipv4_is_multicast(dst) && !ipv4_is_local_multicast(dst) &&
2369 IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
2370 int err = ipmr_get_route(net, skb,
2371 fl4->saddr, fl4->daddr,
2377 goto nla_put_failure;
2379 if (err == -EMSGSIZE)
2380 goto nla_put_failure;
2386 if (nla_put_u32(skb, RTA_IIF, skb->dev->ifindex))
2387 goto nla_put_failure;
2390 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, error) < 0)
2391 goto nla_put_failure;
2393 return nlmsg_end(skb, nlh);
2396 nlmsg_cancel(skb, nlh);
2400 static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
2402 struct net *net = sock_net(in_skb->sk);
2404 struct nlattr *tb[RTA_MAX+1];
2405 struct rtable *rt = NULL;
2412 struct sk_buff *skb;
2414 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv4_policy);
2418 rtm = nlmsg_data(nlh);
2420 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2426 /* Reserve room for dummy headers, this skb can pass
2427 through good chunk of routing engine.
2429 skb_reset_mac_header(skb);
2430 skb_reset_network_header(skb);
2432 /* Bugfix: need to give ip_route_input enough of an IP header to not gag. */
2433 ip_hdr(skb)->protocol = IPPROTO_ICMP;
2434 skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));
2436 src = tb[RTA_SRC] ? nla_get_be32(tb[RTA_SRC]) : 0;
2437 dst = tb[RTA_DST] ? nla_get_be32(tb[RTA_DST]) : 0;
2438 iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
2439 mark = tb[RTA_MARK] ? nla_get_u32(tb[RTA_MARK]) : 0;
2441 memset(&fl4, 0, sizeof(fl4));
2444 fl4.flowi4_tos = rtm->rtm_tos;
2445 fl4.flowi4_oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0;
2446 fl4.flowi4_mark = mark;
2449 struct net_device *dev;
2451 dev = __dev_get_by_index(net, iif);
2457 skb->protocol = htons(ETH_P_IP);
2461 err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
2464 rt = skb_rtable(skb);
2465 if (err == 0 && rt->dst.error)
2466 err = -rt->dst.error;
2468 rt = ip_route_output_key(net, &fl4);
2478 skb_dst_set(skb, &rt->dst);
2479 if (rtm->rtm_flags & RTM_F_NOTIFY)
2480 rt->rt_flags |= RTCF_NOTIFY;
2482 err = rt_fill_info(net, dst, src, &fl4, skb,
2483 NETLINK_CB(in_skb).portid, nlh->nlmsg_seq,
2484 RTM_NEWROUTE, 0, 0);
2488 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2497 void ip_rt_multicast_event(struct in_device *in_dev)
2499 rt_cache_flush(dev_net(in_dev->dev));
2502 #ifdef CONFIG_SYSCTL
2503 static int ip_rt_gc_timeout __read_mostly = RT_GC_TIMEOUT;
2504 static int ip_rt_gc_interval __read_mostly = 60 * HZ;
2505 static int ip_rt_gc_min_interval __read_mostly = HZ / 2;
2506 static int ip_rt_gc_elasticity __read_mostly = 8;
2508 static int ipv4_sysctl_rtcache_flush(struct ctl_table *__ctl, int write,
2509 void __user *buffer,
2510 size_t *lenp, loff_t *ppos)
2512 struct net *net = (struct net *)__ctl->extra1;
2515 rt_cache_flush(net);
2516 fnhe_genid_bump(net);
2523 static struct ctl_table ipv4_route_table[] = {
2525 .procname = "gc_thresh",
2526 .data = &ipv4_dst_ops.gc_thresh,
2527 .maxlen = sizeof(int),
2529 .proc_handler = proc_dointvec,
2532 .procname = "max_size",
2533 .data = &ip_rt_max_size,
2534 .maxlen = sizeof(int),
2536 .proc_handler = proc_dointvec,
2539 /* Deprecated. Use gc_min_interval_ms */
2541 .procname = "gc_min_interval",
2542 .data = &ip_rt_gc_min_interval,
2543 .maxlen = sizeof(int),
2545 .proc_handler = proc_dointvec_jiffies,
2548 .procname = "gc_min_interval_ms",
2549 .data = &ip_rt_gc_min_interval,
2550 .maxlen = sizeof(int),
2552 .proc_handler = proc_dointvec_ms_jiffies,
2555 .procname = "gc_timeout",
2556 .data = &ip_rt_gc_timeout,
2557 .maxlen = sizeof(int),
2559 .proc_handler = proc_dointvec_jiffies,
2562 .procname = "gc_interval",
2563 .data = &ip_rt_gc_interval,
2564 .maxlen = sizeof(int),
2566 .proc_handler = proc_dointvec_jiffies,
2569 .procname = "redirect_load",
2570 .data = &ip_rt_redirect_load,
2571 .maxlen = sizeof(int),
2573 .proc_handler = proc_dointvec,
2576 .procname = "redirect_number",
2577 .data = &ip_rt_redirect_number,
2578 .maxlen = sizeof(int),
2580 .proc_handler = proc_dointvec,
2583 .procname = "redirect_silence",
2584 .data = &ip_rt_redirect_silence,
2585 .maxlen = sizeof(int),
2587 .proc_handler = proc_dointvec,
2590 .procname = "error_cost",
2591 .data = &ip_rt_error_cost,
2592 .maxlen = sizeof(int),
2594 .proc_handler = proc_dointvec,
2597 .procname = "error_burst",
2598 .data = &ip_rt_error_burst,
2599 .maxlen = sizeof(int),
2601 .proc_handler = proc_dointvec,
2604 .procname = "gc_elasticity",
2605 .data = &ip_rt_gc_elasticity,
2606 .maxlen = sizeof(int),
2608 .proc_handler = proc_dointvec,
2611 .procname = "mtu_expires",
2612 .data = &ip_rt_mtu_expires,
2613 .maxlen = sizeof(int),
2615 .proc_handler = proc_dointvec_jiffies,
2618 .procname = "min_pmtu",
2619 .data = &ip_rt_min_pmtu,
2620 .maxlen = sizeof(int),
2622 .proc_handler = proc_dointvec,
2625 .procname = "min_adv_mss",
2626 .data = &ip_rt_min_advmss,
2627 .maxlen = sizeof(int),
2629 .proc_handler = proc_dointvec,
2634 static struct ctl_table ipv4_route_flush_table[] = {
2636 .procname = "flush",
2637 .maxlen = sizeof(int),
2639 .proc_handler = ipv4_sysctl_rtcache_flush,
2644 static __net_init int sysctl_route_net_init(struct net *net)
2646 struct ctl_table *tbl;
2648 tbl = ipv4_route_flush_table;
2649 if (!net_eq(net, &init_net)) {
2650 tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
2654 /* Don't export sysctls to unprivileged users */
2655 if (net->user_ns != &init_user_ns)
2656 tbl[0].procname = NULL;
2658 tbl[0].extra1 = net;
2660 net->ipv4.route_hdr = register_net_sysctl(net, "net/ipv4/route", tbl);
2661 if (net->ipv4.route_hdr == NULL)
2666 if (tbl != ipv4_route_flush_table)
2672 static __net_exit void sysctl_route_net_exit(struct net *net)
2674 struct ctl_table *tbl;
2676 tbl = net->ipv4.route_hdr->ctl_table_arg;
2677 unregister_net_sysctl_table(net->ipv4.route_hdr);
2678 BUG_ON(tbl == ipv4_route_flush_table);
2682 static __net_initdata struct pernet_operations sysctl_route_ops = {
2683 .init = sysctl_route_net_init,
2684 .exit = sysctl_route_net_exit,
2688 static __net_init int rt_genid_init(struct net *net)
2690 atomic_set(&net->ipv4.rt_genid, 0);
2691 atomic_set(&net->fnhe_genid, 0);
2692 get_random_bytes(&net->ipv4.dev_addr_genid,
2693 sizeof(net->ipv4.dev_addr_genid));
2697 static __net_initdata struct pernet_operations rt_genid_ops = {
2698 .init = rt_genid_init,
2701 static int __net_init ipv4_inetpeer_init(struct net *net)
2703 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
2707 inet_peer_base_init(bp);
2708 net->ipv4.peers = bp;
2712 static void __net_exit ipv4_inetpeer_exit(struct net *net)
2714 struct inet_peer_base *bp = net->ipv4.peers;
2716 net->ipv4.peers = NULL;
2717 inetpeer_invalidate_tree(bp);
2721 static __net_initdata struct pernet_operations ipv4_inetpeer_ops = {
2722 .init = ipv4_inetpeer_init,
2723 .exit = ipv4_inetpeer_exit,
2726 #ifdef CONFIG_IP_ROUTE_CLASSID
2727 struct ip_rt_acct __percpu *ip_rt_acct __read_mostly;
2728 #endif /* CONFIG_IP_ROUTE_CLASSID */
2730 int __init ip_rt_init(void)
2735 ip_idents = kmalloc(IP_IDENTS_SZ * sizeof(*ip_idents), GFP_KERNEL);
2737 panic("IP: failed to allocate ip_idents\n");
2739 prandom_bytes(ip_idents, IP_IDENTS_SZ * sizeof(*ip_idents));
2741 for_each_possible_cpu(cpu) {
2742 struct uncached_list *ul = &per_cpu(rt_uncached_list, cpu);
2744 INIT_LIST_HEAD(&ul->head);
2745 spin_lock_init(&ul->lock);
2747 #ifdef CONFIG_IP_ROUTE_CLASSID
2748 ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
2750 panic("IP: failed to allocate ip_rt_acct\n");
2753 ipv4_dst_ops.kmem_cachep =
2754 kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
2755 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
2757 ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
2759 if (dst_entries_init(&ipv4_dst_ops) < 0)
2760 panic("IP: failed to allocate ipv4_dst_ops counter\n");
2762 if (dst_entries_init(&ipv4_dst_blackhole_ops) < 0)
2763 panic("IP: failed to allocate ipv4_dst_blackhole_ops counter\n");
2765 ipv4_dst_ops.gc_thresh = ~0;
2766 ip_rt_max_size = INT_MAX;
2771 if (ip_rt_proc_init())
2772 pr_err("Unable to create route proc files\n");
2777 rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL, NULL);
2779 #ifdef CONFIG_SYSCTL
2780 register_pernet_subsys(&sysctl_route_ops);
2782 register_pernet_subsys(&rt_genid_ops);
2783 register_pernet_subsys(&ipv4_inetpeer_ops);
2787 #ifdef CONFIG_SYSCTL
2789 * We really need to sanitize the damn ipv4 init order, then all
2790 * this nonsense will go away.
2792 void __init ip_static_sysctl_init(void)
2794 register_net_sysctl(&init_net, "net/ipv4/route", ipv4_route_table);