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 IP_MAX_MTU 0xFFF0
118 #define RT_GC_TIMEOUT (300*HZ)
120 static int ip_rt_max_size;
121 static int ip_rt_redirect_number __read_mostly = 9;
122 static int ip_rt_redirect_load __read_mostly = HZ / 50;
123 static int ip_rt_redirect_silence __read_mostly = ((HZ / 50) << (9 + 1));
124 static int ip_rt_error_cost __read_mostly = HZ;
125 static int ip_rt_error_burst __read_mostly = 5 * HZ;
126 static int ip_rt_mtu_expires __read_mostly = 10 * 60 * HZ;
127 static int ip_rt_min_pmtu __read_mostly = 512 + 20 + 20;
128 static int ip_rt_min_advmss __read_mostly = 256;
131 * Interface to generic destination cache.
134 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
135 static unsigned int ipv4_default_advmss(const struct dst_entry *dst);
136 static unsigned int ipv4_mtu(const struct dst_entry *dst);
137 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
138 static void ipv4_link_failure(struct sk_buff *skb);
139 static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
140 struct sk_buff *skb, u32 mtu);
141 static void ip_do_redirect(struct dst_entry *dst, struct sock *sk,
142 struct sk_buff *skb);
143 static void ipv4_dst_destroy(struct dst_entry *dst);
145 static void ipv4_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
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,
160 static struct dst_ops ipv4_dst_ops = {
162 .protocol = cpu_to_be16(ETH_P_IP),
163 .check = ipv4_dst_check,
164 .default_advmss = ipv4_default_advmss,
166 .cow_metrics = ipv4_cow_metrics,
167 .destroy = ipv4_dst_destroy,
168 .ifdown = ipv4_dst_ifdown,
169 .negative_advice = ipv4_negative_advice,
170 .link_failure = ipv4_link_failure,
171 .update_pmtu = ip_rt_update_pmtu,
172 .redirect = ip_do_redirect,
173 .local_out = __ip_local_out,
174 .neigh_lookup = ipv4_neigh_lookup,
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) __this_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 .owner = THIS_MODULE,
244 .open = rt_cache_seq_open,
247 .release = seq_release,
251 static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
256 return SEQ_START_TOKEN;
258 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
259 if (!cpu_possible(cpu))
262 return &per_cpu(rt_cache_stat, cpu);
267 static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
271 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
272 if (!cpu_possible(cpu))
275 return &per_cpu(rt_cache_stat, cpu);
281 static void rt_cpu_seq_stop(struct seq_file *seq, void *v)
286 static int rt_cpu_seq_show(struct seq_file *seq, void *v)
288 struct rt_cache_stat *st = v;
290 if (v == SEQ_START_TOKEN) {
291 seq_printf(seq, "entries in_hit in_slow_tot in_slow_mc in_no_route in_brd in_martian_dst in_martian_src out_hit out_slow_tot out_slow_mc gc_total gc_ignored gc_goal_miss gc_dst_overflow in_hlist_search out_hlist_search\n");
295 seq_printf(seq,"%08x %08x %08x %08x %08x %08x %08x %08x "
296 " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
297 dst_entries_get_slow(&ipv4_dst_ops),
320 static const struct seq_operations rt_cpu_seq_ops = {
321 .start = rt_cpu_seq_start,
322 .next = rt_cpu_seq_next,
323 .stop = rt_cpu_seq_stop,
324 .show = rt_cpu_seq_show,
328 static int rt_cpu_seq_open(struct inode *inode, struct file *file)
330 return seq_open(file, &rt_cpu_seq_ops);
333 static const struct file_operations rt_cpu_seq_fops = {
334 .owner = THIS_MODULE,
335 .open = rt_cpu_seq_open,
338 .release = seq_release,
341 #ifdef CONFIG_IP_ROUTE_CLASSID
342 static int rt_acct_proc_show(struct seq_file *m, void *v)
344 struct ip_rt_acct *dst, *src;
347 dst = kcalloc(256, sizeof(struct ip_rt_acct), GFP_KERNEL);
351 for_each_possible_cpu(i) {
352 src = (struct ip_rt_acct *)per_cpu_ptr(ip_rt_acct, i);
353 for (j = 0; j < 256; j++) {
354 dst[j].o_bytes += src[j].o_bytes;
355 dst[j].o_packets += src[j].o_packets;
356 dst[j].i_bytes += src[j].i_bytes;
357 dst[j].i_packets += src[j].i_packets;
361 seq_write(m, dst, 256 * sizeof(struct ip_rt_acct));
366 static int rt_acct_proc_open(struct inode *inode, struct file *file)
368 return single_open(file, rt_acct_proc_show, NULL);
371 static const struct file_operations rt_acct_proc_fops = {
372 .owner = THIS_MODULE,
373 .open = rt_acct_proc_open,
376 .release = single_release,
380 static int __net_init ip_rt_do_proc_init(struct net *net)
382 struct proc_dir_entry *pde;
384 pde = proc_create("rt_cache", S_IRUGO, net->proc_net,
389 pde = proc_create("rt_cache", S_IRUGO,
390 net->proc_net_stat, &rt_cpu_seq_fops);
394 #ifdef CONFIG_IP_ROUTE_CLASSID
395 pde = proc_create("rt_acct", 0, net->proc_net, &rt_acct_proc_fops);
401 #ifdef CONFIG_IP_ROUTE_CLASSID
403 remove_proc_entry("rt_cache", net->proc_net_stat);
406 remove_proc_entry("rt_cache", net->proc_net);
411 static void __net_exit ip_rt_do_proc_exit(struct net *net)
413 remove_proc_entry("rt_cache", net->proc_net_stat);
414 remove_proc_entry("rt_cache", net->proc_net);
415 #ifdef CONFIG_IP_ROUTE_CLASSID
416 remove_proc_entry("rt_acct", net->proc_net);
420 static struct pernet_operations ip_rt_proc_ops __net_initdata = {
421 .init = ip_rt_do_proc_init,
422 .exit = ip_rt_do_proc_exit,
425 static int __init ip_rt_proc_init(void)
427 return register_pernet_subsys(&ip_rt_proc_ops);
431 static inline int ip_rt_proc_init(void)
435 #endif /* CONFIG_PROC_FS */
437 static inline bool rt_is_expired(const struct rtable *rth)
439 return rth->rt_genid != rt_genid(dev_net(rth->dst.dev));
442 void rt_cache_flush(struct net *net)
447 static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
451 struct net_device *dev = dst->dev;
452 const __be32 *pkey = daddr;
453 const struct rtable *rt;
456 rt = (const struct rtable *) dst;
458 pkey = (const __be32 *) &rt->rt_gateway;
460 pkey = &ip_hdr(skb)->daddr;
462 n = __ipv4_neigh_lookup(dev, *(__force u32 *)pkey);
465 return neigh_create(&arp_tbl, pkey, dev);
468 #define IP_IDENTS_SZ 2048u
469 struct ip_ident_bucket {
474 static struct ip_ident_bucket *ip_idents __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 struct ip_ident_bucket *bucket = ip_idents + hash % IP_IDENTS_SZ;
483 u32 old = ACCESS_ONCE(bucket->stamp32);
484 u32 now = (u32)jiffies;
487 if (old != now && cmpxchg(&bucket->stamp32, old, now) == old) {
488 u64 x = prandom_u32();
491 delta = (u32)(x >> 32);
494 return atomic_add_return(segs + delta, &bucket->id) - segs;
496 EXPORT_SYMBOL(ip_idents_reserve);
498 void __ip_select_ident(struct iphdr *iph, int segs)
500 static u32 ip_idents_hashrnd __read_mostly;
501 static bool hashrnd_initialized = false;
504 if (unlikely(!hashrnd_initialized)) {
505 hashrnd_initialized = true;
506 get_random_bytes(&ip_idents_hashrnd, sizeof(ip_idents_hashrnd));
509 hash = jhash_3words((__force u32)iph->daddr,
510 (__force u32)iph->saddr,
513 id = ip_idents_reserve(hash, segs);
516 EXPORT_SYMBOL(__ip_select_ident);
518 static void __build_flow_key(struct flowi4 *fl4, 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 sk ? sock_i_uid(sk) : 0);
538 static void build_skb_flow_key(struct flowi4 *fl4, const struct sk_buff *skb,
541 const struct iphdr *iph = ip_hdr(skb);
542 int oif = skb->dev->ifindex;
543 u8 tos = RT_TOS(iph->tos);
544 u8 prot = iph->protocol;
545 u32 mark = skb->mark;
547 __build_flow_key(fl4, sk, iph, oif, tos, prot, mark, 0);
550 static void build_sk_flow_key(struct flowi4 *fl4, struct sock *sk)
552 const struct inet_sock *inet = inet_sk(sk);
553 const struct ip_options_rcu *inet_opt;
554 __be32 daddr = inet->inet_daddr;
557 inet_opt = rcu_dereference(inet->inet_opt);
558 if (inet_opt && inet_opt->opt.srr)
559 daddr = inet_opt->opt.faddr;
560 flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
561 RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
562 inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol,
563 inet_sk_flowi_flags(sk),
564 daddr, inet->inet_saddr, 0, 0,
569 static void ip_rt_build_flow_key(struct flowi4 *fl4, 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 inline void rt_free(struct rtable *rt)
580 call_rcu(&rt->dst.rcu_head, dst_rcu_free);
583 static DEFINE_SPINLOCK(fnhe_lock);
585 static struct fib_nh_exception *fnhe_oldest(struct fnhe_hash_bucket *hash)
587 struct fib_nh_exception *fnhe, *oldest;
590 oldest = rcu_dereference(hash->chain);
591 for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe;
592 fnhe = rcu_dereference(fnhe->fnhe_next)) {
593 if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp))
596 orig = rcu_dereference(oldest->fnhe_rth);
598 RCU_INIT_POINTER(oldest->fnhe_rth, NULL);
604 static inline u32 fnhe_hashfun(__be32 daddr)
608 hval = (__force u32) daddr;
609 hval ^= (hval >> 11) ^ (hval >> 22);
611 return hval & (FNHE_HASH_SIZE - 1);
614 static void update_or_create_fnhe(struct fib_nh *nh, __be32 daddr, __be32 gw,
615 u32 pmtu, unsigned long expires)
617 struct fnhe_hash_bucket *hash;
618 struct fib_nh_exception *fnhe;
620 u32 hval = fnhe_hashfun(daddr);
622 spin_lock_bh(&fnhe_lock);
624 hash = nh->nh_exceptions;
626 hash = kzalloc(FNHE_HASH_SIZE * sizeof(*hash), GFP_ATOMIC);
629 nh->nh_exceptions = hash;
635 for (fnhe = rcu_dereference(hash->chain); fnhe;
636 fnhe = rcu_dereference(fnhe->fnhe_next)) {
637 if (fnhe->fnhe_daddr == daddr)
646 fnhe->fnhe_pmtu = pmtu;
647 fnhe->fnhe_expires = expires;
650 if (depth > FNHE_RECLAIM_DEPTH)
651 fnhe = fnhe_oldest(hash);
653 fnhe = kzalloc(sizeof(*fnhe), GFP_ATOMIC);
657 fnhe->fnhe_next = hash->chain;
658 rcu_assign_pointer(hash->chain, fnhe);
660 fnhe->fnhe_daddr = daddr;
662 fnhe->fnhe_pmtu = pmtu;
663 fnhe->fnhe_expires = expires;
666 fnhe->fnhe_stamp = jiffies;
669 spin_unlock_bh(&fnhe_lock);
673 static void __ip_do_redirect(struct rtable *rt, struct sk_buff *skb, struct flowi4 *fl4,
676 __be32 new_gw = icmp_hdr(skb)->un.gateway;
677 __be32 old_gw = ip_hdr(skb)->saddr;
678 struct net_device *dev = skb->dev;
679 struct in_device *in_dev;
680 struct fib_result res;
684 switch (icmp_hdr(skb)->code & 7) {
686 case ICMP_REDIR_NETTOS:
687 case ICMP_REDIR_HOST:
688 case ICMP_REDIR_HOSTTOS:
695 if (rt->rt_gateway != old_gw)
698 in_dev = __in_dev_get_rcu(dev);
703 if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) ||
704 ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw) ||
705 ipv4_is_zeronet(new_gw))
706 goto reject_redirect;
708 if (!IN_DEV_SHARED_MEDIA(in_dev)) {
709 if (!inet_addr_onlink(in_dev, new_gw, old_gw))
710 goto reject_redirect;
711 if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
712 goto reject_redirect;
714 if (inet_addr_type(net, new_gw) != RTN_UNICAST)
715 goto reject_redirect;
718 n = ipv4_neigh_lookup(&rt->dst, NULL, &new_gw);
720 if (!(n->nud_state & NUD_VALID)) {
721 neigh_event_send(n, NULL);
723 if (fib_lookup(net, fl4, &res) == 0) {
724 struct fib_nh *nh = &FIB_RES_NH(res);
726 update_or_create_fnhe(nh, fl4->daddr, new_gw,
730 rt->dst.obsolete = DST_OBSOLETE_KILL;
731 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, n);
738 #ifdef CONFIG_IP_ROUTE_VERBOSE
739 if (IN_DEV_LOG_MARTIANS(in_dev)) {
740 const struct iphdr *iph = (const struct iphdr *) skb->data;
741 __be32 daddr = iph->daddr;
742 __be32 saddr = iph->saddr;
744 net_info_ratelimited("Redirect from %pI4 on %s about %pI4 ignored\n"
745 " Advised path = %pI4 -> %pI4\n",
746 &old_gw, dev->name, &new_gw,
753 static void ip_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
757 const struct iphdr *iph = (const struct iphdr *) skb->data;
758 int oif = skb->dev->ifindex;
759 u8 tos = RT_TOS(iph->tos);
760 u8 prot = iph->protocol;
761 u32 mark = skb->mark;
763 rt = (struct rtable *) dst;
765 __build_flow_key(&fl4, sk, iph, oif, tos, prot, mark, 0);
766 __ip_do_redirect(rt, skb, &fl4, true);
769 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
771 struct rtable *rt = (struct rtable *)dst;
772 struct dst_entry *ret = dst;
775 if (dst->obsolete > 0) {
778 } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
789 * 1. The first ip_rt_redirect_number redirects are sent
790 * with exponential backoff, then we stop sending them at all,
791 * assuming that the host ignores our redirects.
792 * 2. If we did not see packets requiring redirects
793 * during ip_rt_redirect_silence, we assume that the host
794 * forgot redirected route and start to send redirects again.
796 * This algorithm is much cheaper and more intelligent than dumb load limiting
799 * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
800 * and "frag. need" (breaks PMTU discovery) in icmp.c.
803 void ip_rt_send_redirect(struct sk_buff *skb)
805 struct rtable *rt = skb_rtable(skb);
806 struct in_device *in_dev;
807 struct inet_peer *peer;
812 in_dev = __in_dev_get_rcu(rt->dst.dev);
813 if (!in_dev || !IN_DEV_TX_REDIRECTS(in_dev)) {
817 log_martians = IN_DEV_LOG_MARTIANS(in_dev);
820 net = dev_net(rt->dst.dev);
821 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, 1);
823 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST,
824 rt_nexthop(rt, ip_hdr(skb)->daddr));
828 /* No redirected packets during ip_rt_redirect_silence;
829 * reset the algorithm.
831 if (time_after(jiffies, peer->rate_last + ip_rt_redirect_silence))
832 peer->rate_tokens = 0;
834 /* Too many ignored redirects; do not send anything
835 * set dst.rate_last to the last seen redirected packet.
837 if (peer->rate_tokens >= ip_rt_redirect_number) {
838 peer->rate_last = jiffies;
842 /* Check for load limit; set rate_last to the latest sent
845 if (peer->rate_tokens == 0 ||
848 (ip_rt_redirect_load << peer->rate_tokens)))) {
849 __be32 gw = rt_nexthop(rt, ip_hdr(skb)->daddr);
851 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, gw);
852 peer->rate_last = jiffies;
854 #ifdef CONFIG_IP_ROUTE_VERBOSE
856 peer->rate_tokens == ip_rt_redirect_number)
857 net_warn_ratelimited("host %pI4/if%d ignores redirects for %pI4 to %pI4\n",
858 &ip_hdr(skb)->saddr, inet_iif(skb),
859 &ip_hdr(skb)->daddr, &gw);
866 static int ip_error(struct sk_buff *skb)
868 struct in_device *in_dev = __in_dev_get_rcu(skb->dev);
869 struct rtable *rt = skb_rtable(skb);
870 struct inet_peer *peer;
876 net = dev_net(rt->dst.dev);
877 if (!IN_DEV_FORWARD(in_dev)) {
878 switch (rt->dst.error) {
880 IP_INC_STATS_BH(net, IPSTATS_MIB_INADDRERRORS);
884 IP_INC_STATS_BH(net, IPSTATS_MIB_INNOROUTES);
890 switch (rt->dst.error) {
895 code = ICMP_HOST_UNREACH;
898 code = ICMP_NET_UNREACH;
899 IP_INC_STATS_BH(net, IPSTATS_MIB_INNOROUTES);
902 code = ICMP_PKT_FILTERED;
906 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, 1);
911 peer->rate_tokens += now - peer->rate_last;
912 if (peer->rate_tokens > ip_rt_error_burst)
913 peer->rate_tokens = ip_rt_error_burst;
914 peer->rate_last = now;
915 if (peer->rate_tokens >= ip_rt_error_cost)
916 peer->rate_tokens -= ip_rt_error_cost;
922 icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
928 static void __ip_rt_update_pmtu(struct rtable *rt, struct flowi4 *fl4, u32 mtu)
930 struct dst_entry *dst = &rt->dst;
931 struct fib_result res;
933 if (dst_metric_locked(dst, RTAX_MTU))
936 if (dst->dev->mtu < mtu)
939 if (mtu < ip_rt_min_pmtu)
940 mtu = ip_rt_min_pmtu;
943 dst->obsolete = DST_OBSOLETE_KILL;
946 dst->expires = max(1UL, jiffies + ip_rt_mtu_expires);
950 if (fib_lookup(dev_net(dst->dev), fl4, &res) == 0) {
951 struct fib_nh *nh = &FIB_RES_NH(res);
953 update_or_create_fnhe(nh, fl4->daddr, 0, mtu,
954 jiffies + ip_rt_mtu_expires);
959 static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
960 struct sk_buff *skb, u32 mtu)
962 struct rtable *rt = (struct rtable *) dst;
965 ip_rt_build_flow_key(&fl4, sk, skb);
966 __ip_rt_update_pmtu(rt, &fl4, mtu);
969 void ipv4_update_pmtu(struct sk_buff *skb, struct net *net, u32 mtu,
970 int oif, u32 mark, u8 protocol, int flow_flags)
972 const struct iphdr *iph = (const struct iphdr *) skb->data;
977 mark = IP4_REPLY_MARK(net, skb->mark);
979 __build_flow_key(&fl4, NULL, iph, oif,
980 RT_TOS(iph->tos), protocol, mark, flow_flags);
981 rt = __ip_route_output_key(net, &fl4);
983 __ip_rt_update_pmtu(rt, &fl4, mtu);
987 EXPORT_SYMBOL_GPL(ipv4_update_pmtu);
989 static void __ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
991 const struct iphdr *iph = (const struct iphdr *) skb->data;
995 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
997 if (!fl4.flowi4_mark)
998 fl4.flowi4_mark = IP4_REPLY_MARK(sock_net(sk), skb->mark);
1000 rt = __ip_route_output_key(sock_net(sk), &fl4);
1002 __ip_rt_update_pmtu(rt, &fl4, mtu);
1007 void ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
1009 const struct iphdr *iph = (const struct iphdr *) skb->data;
1012 struct dst_entry *odst = NULL;
1016 odst = sk_dst_get(sk);
1018 if (sock_owned_by_user(sk) || !odst) {
1019 __ipv4_sk_update_pmtu(skb, sk, mtu);
1023 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1025 rt = (struct rtable *)odst;
1026 if (odst->obsolete && odst->ops->check(odst, 0) == NULL) {
1027 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1034 __ip_rt_update_pmtu((struct rtable *) rt->dst.path, &fl4, mtu);
1036 if (!dst_check(&rt->dst, 0)) {
1038 dst_release(&rt->dst);
1040 rt = ip_route_output_flow(sock_net(sk), &fl4, sk);
1048 sk_dst_set(sk, &rt->dst);
1054 EXPORT_SYMBOL_GPL(ipv4_sk_update_pmtu);
1056 void ipv4_redirect(struct sk_buff *skb, struct net *net,
1057 int oif, u32 mark, u8 protocol, int flow_flags)
1059 const struct iphdr *iph = (const struct iphdr *) skb->data;
1063 __build_flow_key(&fl4, NULL, iph, oif,
1064 RT_TOS(iph->tos), protocol, mark, flow_flags);
1065 rt = __ip_route_output_key(net, &fl4);
1067 __ip_do_redirect(rt, skb, &fl4, false);
1071 EXPORT_SYMBOL_GPL(ipv4_redirect);
1073 void ipv4_sk_redirect(struct sk_buff *skb, struct sock *sk)
1075 const struct iphdr *iph = (const struct iphdr *) skb->data;
1079 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1080 rt = __ip_route_output_key(sock_net(sk), &fl4);
1082 __ip_do_redirect(rt, skb, &fl4, false);
1086 EXPORT_SYMBOL_GPL(ipv4_sk_redirect);
1088 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
1090 struct rtable *rt = (struct rtable *) dst;
1092 /* All IPV4 dsts are created with ->obsolete set to the value
1093 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1094 * into this function always.
1096 * When a PMTU/redirect information update invalidates a
1097 * route, this is indicated by setting obsolete to
1098 * DST_OBSOLETE_KILL.
1100 if (dst->obsolete == DST_OBSOLETE_KILL || rt_is_expired(rt))
1105 static void ipv4_link_failure(struct sk_buff *skb)
1109 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
1111 rt = skb_rtable(skb);
1113 dst_set_expires(&rt->dst, 0);
1116 static int ip_rt_bug(struct sk_buff *skb)
1118 pr_debug("%s: %pI4 -> %pI4, %s\n",
1119 __func__, &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
1120 skb->dev ? skb->dev->name : "?");
1127 We do not cache source address of outgoing interface,
1128 because it is used only by IP RR, TS and SRR options,
1129 so that it out of fast path.
1131 BTW remember: "addr" is allowed to be not aligned
1135 void ip_rt_get_source(u8 *addr, struct sk_buff *skb, struct rtable *rt)
1139 if (rt_is_output_route(rt))
1140 src = ip_hdr(skb)->saddr;
1142 struct fib_result res;
1148 memset(&fl4, 0, sizeof(fl4));
1149 fl4.daddr = iph->daddr;
1150 fl4.saddr = iph->saddr;
1151 fl4.flowi4_tos = RT_TOS(iph->tos);
1152 fl4.flowi4_oif = rt->dst.dev->ifindex;
1153 fl4.flowi4_iif = skb->dev->ifindex;
1154 fl4.flowi4_mark = skb->mark;
1157 if (fib_lookup(dev_net(rt->dst.dev), &fl4, &res) == 0)
1158 src = FIB_RES_PREFSRC(dev_net(rt->dst.dev), res);
1160 src = inet_select_addr(rt->dst.dev,
1161 rt_nexthop(rt, iph->daddr),
1165 memcpy(addr, &src, 4);
1168 #ifdef CONFIG_IP_ROUTE_CLASSID
1169 static void set_class_tag(struct rtable *rt, u32 tag)
1171 if (!(rt->dst.tclassid & 0xFFFF))
1172 rt->dst.tclassid |= tag & 0xFFFF;
1173 if (!(rt->dst.tclassid & 0xFFFF0000))
1174 rt->dst.tclassid |= tag & 0xFFFF0000;
1178 static unsigned int ipv4_default_advmss(const struct dst_entry *dst)
1180 unsigned int advmss = dst_metric_raw(dst, RTAX_ADVMSS);
1183 advmss = max_t(unsigned int, dst->dev->mtu - 40,
1185 if (advmss > 65535 - 40)
1186 advmss = 65535 - 40;
1191 static unsigned int ipv4_mtu(const struct dst_entry *dst)
1193 const struct rtable *rt = (const struct rtable *) dst;
1194 unsigned int mtu = rt->rt_pmtu;
1196 if (!mtu || time_after_eq(jiffies, rt->dst.expires))
1197 mtu = dst_metric_raw(dst, RTAX_MTU);
1202 mtu = dst->dev->mtu;
1204 if (unlikely(dst_metric_locked(dst, RTAX_MTU))) {
1205 if (rt->rt_uses_gateway && mtu > 576)
1209 if (mtu > IP_MAX_MTU)
1215 static struct fib_nh_exception *find_exception(struct fib_nh *nh, __be32 daddr)
1217 struct fnhe_hash_bucket *hash = nh->nh_exceptions;
1218 struct fib_nh_exception *fnhe;
1224 hval = fnhe_hashfun(daddr);
1226 for (fnhe = rcu_dereference(hash[hval].chain); fnhe;
1227 fnhe = rcu_dereference(fnhe->fnhe_next)) {
1228 if (fnhe->fnhe_daddr == daddr)
1234 static bool rt_bind_exception(struct rtable *rt, struct fib_nh_exception *fnhe,
1239 spin_lock_bh(&fnhe_lock);
1241 if (daddr == fnhe->fnhe_daddr) {
1242 struct rtable *orig = rcu_dereference(fnhe->fnhe_rth);
1243 if (orig && rt_is_expired(orig)) {
1245 fnhe->fnhe_pmtu = 0;
1246 fnhe->fnhe_expires = 0;
1248 if (fnhe->fnhe_pmtu) {
1249 unsigned long expires = fnhe->fnhe_expires;
1250 unsigned long diff = expires - jiffies;
1252 if (time_before(jiffies, expires)) {
1253 rt->rt_pmtu = fnhe->fnhe_pmtu;
1254 dst_set_expires(&rt->dst, diff);
1257 if (fnhe->fnhe_gw) {
1258 rt->rt_flags |= RTCF_REDIRECTED;
1259 rt->rt_gateway = fnhe->fnhe_gw;
1260 rt->rt_uses_gateway = 1;
1261 } else if (!rt->rt_gateway)
1262 rt->rt_gateway = daddr;
1264 rcu_assign_pointer(fnhe->fnhe_rth, rt);
1268 fnhe->fnhe_stamp = jiffies;
1271 spin_unlock_bh(&fnhe_lock);
1276 static bool rt_cache_route(struct fib_nh *nh, struct rtable *rt)
1278 struct rtable *orig, *prev, **p;
1281 if (rt_is_input_route(rt)) {
1282 p = (struct rtable **)&nh->nh_rth_input;
1284 p = (struct rtable **)__this_cpu_ptr(nh->nh_pcpu_rth_output);
1288 prev = cmpxchg(p, orig, rt);
1298 static DEFINE_SPINLOCK(rt_uncached_lock);
1299 static LIST_HEAD(rt_uncached_list);
1301 static void rt_add_uncached_list(struct rtable *rt)
1303 spin_lock_bh(&rt_uncached_lock);
1304 list_add_tail(&rt->rt_uncached, &rt_uncached_list);
1305 spin_unlock_bh(&rt_uncached_lock);
1308 static void ipv4_dst_destroy(struct dst_entry *dst)
1310 struct rtable *rt = (struct rtable *) dst;
1312 if (!list_empty(&rt->rt_uncached)) {
1313 spin_lock_bh(&rt_uncached_lock);
1314 list_del(&rt->rt_uncached);
1315 spin_unlock_bh(&rt_uncached_lock);
1319 void rt_flush_dev(struct net_device *dev)
1321 if (!list_empty(&rt_uncached_list)) {
1322 struct net *net = dev_net(dev);
1325 spin_lock_bh(&rt_uncached_lock);
1326 list_for_each_entry(rt, &rt_uncached_list, rt_uncached) {
1327 if (rt->dst.dev != dev)
1329 rt->dst.dev = net->loopback_dev;
1330 dev_hold(rt->dst.dev);
1333 spin_unlock_bh(&rt_uncached_lock);
1337 static bool rt_cache_valid(const struct rtable *rt)
1340 rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
1344 static void rt_set_nexthop(struct rtable *rt, __be32 daddr,
1345 const struct fib_result *res,
1346 struct fib_nh_exception *fnhe,
1347 struct fib_info *fi, u16 type, u32 itag)
1349 bool cached = false;
1352 struct fib_nh *nh = &FIB_RES_NH(*res);
1354 if (nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK) {
1355 rt->rt_gateway = nh->nh_gw;
1356 rt->rt_uses_gateway = 1;
1358 dst_init_metrics(&rt->dst, fi->fib_metrics, true);
1359 #ifdef CONFIG_IP_ROUTE_CLASSID
1360 rt->dst.tclassid = nh->nh_tclassid;
1363 cached = rt_bind_exception(rt, fnhe, daddr);
1364 else if (!(rt->dst.flags & DST_NOCACHE))
1365 cached = rt_cache_route(nh, rt);
1366 if (unlikely(!cached)) {
1367 /* Routes we intend to cache in nexthop exception or
1368 * FIB nexthop have the DST_NOCACHE bit clear.
1369 * However, if we are unsuccessful at storing this
1370 * route into the cache we really need to set it.
1372 rt->dst.flags |= DST_NOCACHE;
1373 if (!rt->rt_gateway)
1374 rt->rt_gateway = daddr;
1375 rt_add_uncached_list(rt);
1378 rt_add_uncached_list(rt);
1380 #ifdef CONFIG_IP_ROUTE_CLASSID
1381 #ifdef CONFIG_IP_MULTIPLE_TABLES
1382 set_class_tag(rt, res->tclassid);
1384 set_class_tag(rt, itag);
1388 static struct rtable *rt_dst_alloc(struct net_device *dev,
1389 bool nopolicy, bool noxfrm, bool will_cache)
1391 return dst_alloc(&ipv4_dst_ops, dev, 1, DST_OBSOLETE_FORCE_CHK,
1392 (will_cache ? 0 : (DST_HOST | DST_NOCACHE)) |
1393 (nopolicy ? DST_NOPOLICY : 0) |
1394 (noxfrm ? DST_NOXFRM : 0));
1397 /* called in rcu_read_lock() section */
1398 static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1399 u8 tos, struct net_device *dev, int our)
1402 struct in_device *in_dev = __in_dev_get_rcu(dev);
1406 /* Primary sanity checks. */
1411 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
1412 skb->protocol != htons(ETH_P_IP))
1415 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
1416 if (ipv4_is_loopback(saddr))
1419 if (ipv4_is_zeronet(saddr)) {
1420 if (!ipv4_is_local_multicast(daddr))
1423 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1428 rth = rt_dst_alloc(dev_net(dev)->loopback_dev,
1429 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, false);
1433 #ifdef CONFIG_IP_ROUTE_CLASSID
1434 rth->dst.tclassid = itag;
1436 rth->dst.output = ip_rt_bug;
1438 rth->rt_genid = rt_genid(dev_net(dev));
1439 rth->rt_flags = RTCF_MULTICAST;
1440 rth->rt_type = RTN_MULTICAST;
1441 rth->rt_is_input= 1;
1444 rth->rt_gateway = 0;
1445 rth->rt_uses_gateway = 0;
1446 INIT_LIST_HEAD(&rth->rt_uncached);
1448 rth->dst.input= ip_local_deliver;
1449 rth->rt_flags |= RTCF_LOCAL;
1452 #ifdef CONFIG_IP_MROUTE
1453 if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
1454 rth->dst.input = ip_mr_input;
1456 RT_CACHE_STAT_INC(in_slow_mc);
1458 skb_dst_set(skb, &rth->dst);
1470 static void ip_handle_martian_source(struct net_device *dev,
1471 struct in_device *in_dev,
1472 struct sk_buff *skb,
1476 RT_CACHE_STAT_INC(in_martian_src);
1477 #ifdef CONFIG_IP_ROUTE_VERBOSE
1478 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
1480 * RFC1812 recommendation, if source is martian,
1481 * the only hint is MAC header.
1483 pr_warn("martian source %pI4 from %pI4, on dev %s\n",
1484 &daddr, &saddr, dev->name);
1485 if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
1486 print_hex_dump(KERN_WARNING, "ll header: ",
1487 DUMP_PREFIX_OFFSET, 16, 1,
1488 skb_mac_header(skb),
1489 dev->hard_header_len, true);
1495 /* called in rcu_read_lock() section */
1496 static int __mkroute_input(struct sk_buff *skb,
1497 const struct fib_result *res,
1498 struct in_device *in_dev,
1499 __be32 daddr, __be32 saddr, u32 tos)
1503 struct in_device *out_dev;
1504 unsigned int flags = 0;
1508 /* get a working reference to the output device */
1509 out_dev = __in_dev_get_rcu(FIB_RES_DEV(*res));
1510 if (out_dev == NULL) {
1511 net_crit_ratelimited("Bug in ip_route_input_slow(). Please report.\n");
1515 err = fib_validate_source(skb, saddr, daddr, tos, FIB_RES_OIF(*res),
1516 in_dev->dev, in_dev, &itag);
1518 ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
1524 do_cache = res->fi && !itag;
1525 if (out_dev == in_dev && err && IN_DEV_TX_REDIRECTS(out_dev) &&
1526 skb->protocol == htons(ETH_P_IP) &&
1527 (IN_DEV_SHARED_MEDIA(out_dev) ||
1528 inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
1529 IPCB(skb)->flags |= IPSKB_DOREDIRECT;
1531 if (skb->protocol != htons(ETH_P_IP)) {
1532 /* Not IP (i.e. ARP). Do not create route, if it is
1533 * invalid for proxy arp. DNAT routes are always valid.
1535 * Proxy arp feature have been extended to allow, ARP
1536 * replies back to the same interface, to support
1537 * Private VLAN switch technologies. See arp.c.
1539 if (out_dev == in_dev &&
1540 IN_DEV_PROXY_ARP_PVLAN(in_dev) == 0) {
1547 rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input);
1548 if (rt_cache_valid(rth)) {
1549 skb_dst_set_noref(skb, &rth->dst);
1554 rth = rt_dst_alloc(out_dev->dev,
1555 IN_DEV_CONF_GET(in_dev, NOPOLICY),
1556 IN_DEV_CONF_GET(out_dev, NOXFRM), do_cache);
1562 rth->rt_genid = rt_genid(dev_net(rth->dst.dev));
1563 rth->rt_flags = flags;
1564 rth->rt_type = res->type;
1565 rth->rt_is_input = 1;
1568 rth->rt_gateway = 0;
1569 rth->rt_uses_gateway = 0;
1570 INIT_LIST_HEAD(&rth->rt_uncached);
1571 RT_CACHE_STAT_INC(in_slow_tot);
1573 rth->dst.input = ip_forward;
1574 rth->dst.output = ip_output;
1576 rt_set_nexthop(rth, daddr, res, NULL, res->fi, res->type, itag);
1577 skb_dst_set(skb, &rth->dst);
1584 static int ip_mkroute_input(struct sk_buff *skb,
1585 struct fib_result *res,
1586 const struct flowi4 *fl4,
1587 struct in_device *in_dev,
1588 __be32 daddr, __be32 saddr, u32 tos)
1590 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1591 if (res->fi && res->fi->fib_nhs > 1)
1592 fib_select_multipath(res);
1595 /* create a routing cache entry */
1596 return __mkroute_input(skb, res, in_dev, daddr, saddr, tos);
1600 * NOTE. We drop all the packets that has local source
1601 * addresses, because every properly looped back packet
1602 * must have correct destination already attached by output routine.
1604 * Such approach solves two big problems:
1605 * 1. Not simplex devices are handled properly.
1606 * 2. IP spoofing attempts are filtered with 100% of guarantee.
1607 * called with rcu_read_lock()
1610 static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1611 u8 tos, struct net_device *dev)
1613 struct fib_result res;
1614 struct in_device *in_dev = __in_dev_get_rcu(dev);
1616 unsigned int flags = 0;
1620 struct net *net = dev_net(dev);
1623 /* IP on this device is disabled. */
1628 /* Check for the most weird martians, which can be not detected
1632 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr))
1633 goto martian_source;
1636 if (ipv4_is_lbcast(daddr) || (saddr == 0 && daddr == 0))
1639 /* Accept zero addresses only to limited broadcast;
1640 * I even do not know to fix it or not. Waiting for complains :-)
1642 if (ipv4_is_zeronet(saddr))
1643 goto martian_source;
1645 if (ipv4_is_zeronet(daddr))
1646 goto martian_destination;
1648 /* Following code try to avoid calling IN_DEV_NET_ROUTE_LOCALNET(),
1649 * and call it once if daddr or/and saddr are loopback addresses
1651 if (ipv4_is_loopback(daddr)) {
1652 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
1653 goto martian_destination;
1654 } else if (ipv4_is_loopback(saddr)) {
1655 if (!IN_DEV_NET_ROUTE_LOCALNET(in_dev, net))
1656 goto martian_source;
1660 * Now we are ready to route packet.
1663 fl4.flowi4_iif = dev->ifindex;
1664 fl4.flowi4_mark = skb->mark;
1665 fl4.flowi4_tos = tos;
1666 fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
1669 err = fib_lookup(net, &fl4, &res);
1673 if (res.type == RTN_BROADCAST)
1676 if (res.type == RTN_LOCAL) {
1677 err = fib_validate_source(skb, saddr, daddr, tos,
1679 dev, in_dev, &itag);
1681 goto martian_source_keep_err;
1685 if (!IN_DEV_FORWARD(in_dev))
1687 if (res.type != RTN_UNICAST)
1688 goto martian_destination;
1690 err = ip_mkroute_input(skb, &res, &fl4, in_dev, daddr, saddr, tos);
1694 if (skb->protocol != htons(ETH_P_IP))
1697 if (!ipv4_is_zeronet(saddr)) {
1698 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1701 goto martian_source_keep_err;
1703 flags |= RTCF_BROADCAST;
1704 res.type = RTN_BROADCAST;
1705 RT_CACHE_STAT_INC(in_brd);
1711 rth = rcu_dereference(FIB_RES_NH(res).nh_rth_input);
1712 if (rt_cache_valid(rth)) {
1713 skb_dst_set_noref(skb, &rth->dst);
1721 rth = rt_dst_alloc(net->loopback_dev,
1722 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, do_cache);
1726 rth->dst.input= ip_local_deliver;
1727 rth->dst.output= ip_rt_bug;
1728 #ifdef CONFIG_IP_ROUTE_CLASSID
1729 rth->dst.tclassid = itag;
1732 rth->rt_genid = rt_genid(net);
1733 rth->rt_flags = flags|RTCF_LOCAL;
1734 rth->rt_type = res.type;
1735 rth->rt_is_input = 1;
1738 rth->rt_gateway = 0;
1739 rth->rt_uses_gateway = 0;
1740 INIT_LIST_HEAD(&rth->rt_uncached);
1741 RT_CACHE_STAT_INC(in_slow_tot);
1742 if (res.type == RTN_UNREACHABLE) {
1743 rth->dst.input= ip_error;
1744 rth->dst.error= -err;
1745 rth->rt_flags &= ~RTCF_LOCAL;
1748 if (unlikely(!rt_cache_route(&FIB_RES_NH(res), rth))) {
1749 rth->dst.flags |= DST_NOCACHE;
1750 rt_add_uncached_list(rth);
1753 skb_dst_set(skb, &rth->dst);
1758 RT_CACHE_STAT_INC(in_no_route);
1759 res.type = RTN_UNREACHABLE;
1765 * Do not cache martian addresses: they should be logged (RFC1812)
1767 martian_destination:
1768 RT_CACHE_STAT_INC(in_martian_dst);
1769 #ifdef CONFIG_IP_ROUTE_VERBOSE
1770 if (IN_DEV_LOG_MARTIANS(in_dev))
1771 net_warn_ratelimited("martian destination %pI4 from %pI4, dev %s\n",
1772 &daddr, &saddr, dev->name);
1785 martian_source_keep_err:
1786 ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
1790 int ip_route_input_noref(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1791 u8 tos, struct net_device *dev)
1797 /* Multicast recognition logic is moved from route cache to here.
1798 The problem was that too many Ethernet cards have broken/missing
1799 hardware multicast filters :-( As result the host on multicasting
1800 network acquires a lot of useless route cache entries, sort of
1801 SDR messages from all the world. Now we try to get rid of them.
1802 Really, provided software IP multicast filter is organized
1803 reasonably (at least, hashed), it does not result in a slowdown
1804 comparing with route cache reject entries.
1805 Note, that multicast routers are not affected, because
1806 route cache entry is created eventually.
1808 if (ipv4_is_multicast(daddr)) {
1809 struct in_device *in_dev = __in_dev_get_rcu(dev);
1812 int our = ip_check_mc_rcu(in_dev, daddr, saddr,
1813 ip_hdr(skb)->protocol);
1815 #ifdef CONFIG_IP_MROUTE
1817 (!ipv4_is_local_multicast(daddr) &&
1818 IN_DEV_MFORWARD(in_dev))
1821 int res = ip_route_input_mc(skb, daddr, saddr,
1830 res = ip_route_input_slow(skb, daddr, saddr, tos, dev);
1834 EXPORT_SYMBOL(ip_route_input_noref);
1836 /* called with rcu_read_lock() */
1837 static struct rtable *__mkroute_output(const struct fib_result *res,
1838 const struct flowi4 *fl4, int orig_oif,
1839 struct net_device *dev_out,
1842 struct fib_info *fi = res->fi;
1843 struct fib_nh_exception *fnhe;
1844 struct in_device *in_dev;
1845 u16 type = res->type;
1849 in_dev = __in_dev_get_rcu(dev_out);
1851 return ERR_PTR(-EINVAL);
1853 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
1854 if (ipv4_is_loopback(fl4->saddr) && !(dev_out->flags & IFF_LOOPBACK))
1855 return ERR_PTR(-EINVAL);
1857 if (ipv4_is_lbcast(fl4->daddr))
1858 type = RTN_BROADCAST;
1859 else if (ipv4_is_multicast(fl4->daddr))
1860 type = RTN_MULTICAST;
1861 else if (ipv4_is_zeronet(fl4->daddr))
1862 return ERR_PTR(-EINVAL);
1864 if (dev_out->flags & IFF_LOOPBACK)
1865 flags |= RTCF_LOCAL;
1868 if (type == RTN_BROADCAST) {
1869 flags |= RTCF_BROADCAST | RTCF_LOCAL;
1871 } else if (type == RTN_MULTICAST) {
1872 flags |= RTCF_MULTICAST | RTCF_LOCAL;
1873 if (!ip_check_mc_rcu(in_dev, fl4->daddr, fl4->saddr,
1875 flags &= ~RTCF_LOCAL;
1878 /* If multicast route do not exist use
1879 * default one, but do not gateway in this case.
1882 if (fi && res->prefixlen < 4)
1887 do_cache &= fi != NULL;
1889 struct rtable __rcu **prth;
1890 struct fib_nh *nh = &FIB_RES_NH(*res);
1892 fnhe = find_exception(nh, fl4->daddr);
1894 prth = &fnhe->fnhe_rth;
1896 if (unlikely(fl4->flowi4_flags &
1897 FLOWI_FLAG_KNOWN_NH &&
1899 nh->nh_scope == RT_SCOPE_LINK))) {
1903 prth = __this_cpu_ptr(nh->nh_pcpu_rth_output);
1905 rth = rcu_dereference(*prth);
1906 if (rt_cache_valid(rth)) {
1907 dst_hold(&rth->dst);
1913 rth = rt_dst_alloc(dev_out,
1914 IN_DEV_CONF_GET(in_dev, NOPOLICY),
1915 IN_DEV_CONF_GET(in_dev, NOXFRM),
1918 return ERR_PTR(-ENOBUFS);
1920 rth->dst.output = ip_output;
1922 rth->rt_genid = rt_genid(dev_net(dev_out));
1923 rth->rt_flags = flags;
1924 rth->rt_type = type;
1925 rth->rt_is_input = 0;
1926 rth->rt_iif = orig_oif ? : 0;
1928 rth->rt_gateway = 0;
1929 rth->rt_uses_gateway = 0;
1930 INIT_LIST_HEAD(&rth->rt_uncached);
1932 RT_CACHE_STAT_INC(out_slow_tot);
1934 if (flags & RTCF_LOCAL)
1935 rth->dst.input = ip_local_deliver;
1936 if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
1937 if (flags & RTCF_LOCAL &&
1938 !(dev_out->flags & IFF_LOOPBACK)) {
1939 rth->dst.output = ip_mc_output;
1940 RT_CACHE_STAT_INC(out_slow_mc);
1942 #ifdef CONFIG_IP_MROUTE
1943 if (type == RTN_MULTICAST) {
1944 if (IN_DEV_MFORWARD(in_dev) &&
1945 !ipv4_is_local_multicast(fl4->daddr)) {
1946 rth->dst.input = ip_mr_input;
1947 rth->dst.output = ip_mc_output;
1953 rt_set_nexthop(rth, fl4->daddr, res, fnhe, fi, type, 0);
1959 * Major route resolver routine.
1962 struct rtable *__ip_route_output_key(struct net *net, struct flowi4 *fl4)
1964 struct net_device *dev_out = NULL;
1965 __u8 tos = RT_FL_TOS(fl4);
1966 unsigned int flags = 0;
1967 struct fib_result res;
1975 orig_oif = fl4->flowi4_oif;
1977 fl4->flowi4_iif = LOOPBACK_IFINDEX;
1978 fl4->flowi4_tos = tos & IPTOS_RT_MASK;
1979 fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
1980 RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);
1984 rth = ERR_PTR(-EINVAL);
1985 if (ipv4_is_multicast(fl4->saddr) ||
1986 ipv4_is_lbcast(fl4->saddr) ||
1987 ipv4_is_zeronet(fl4->saddr))
1990 /* I removed check for oif == dev_out->oif here.
1991 It was wrong for two reasons:
1992 1. ip_dev_find(net, saddr) can return wrong iface, if saddr
1993 is assigned to multiple interfaces.
1994 2. Moreover, we are allowed to send packets with saddr
1995 of another iface. --ANK
1998 if (fl4->flowi4_oif == 0 &&
1999 (ipv4_is_multicast(fl4->daddr) ||
2000 ipv4_is_lbcast(fl4->daddr))) {
2001 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2002 dev_out = __ip_dev_find(net, fl4->saddr, false);
2003 if (dev_out == NULL)
2006 /* Special hack: user can direct multicasts
2007 and limited broadcast via necessary interface
2008 without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
2009 This hack is not just for fun, it allows
2010 vic,vat and friends to work.
2011 They bind socket to loopback, set ttl to zero
2012 and expect that it will work.
2013 From the viewpoint of routing cache they are broken,
2014 because we are not allowed to build multicast path
2015 with loopback source addr (look, routing cache
2016 cannot know, that ttl is zero, so that packet
2017 will not leave this host and route is valid).
2018 Luckily, this hack is good workaround.
2021 fl4->flowi4_oif = dev_out->ifindex;
2025 if (!(fl4->flowi4_flags & FLOWI_FLAG_ANYSRC)) {
2026 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
2027 if (!__ip_dev_find(net, fl4->saddr, false))
2033 if (fl4->flowi4_oif) {
2034 dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);
2035 rth = ERR_PTR(-ENODEV);
2036 if (dev_out == NULL)
2039 /* RACE: Check return value of inet_select_addr instead. */
2040 if (!(dev_out->flags & IFF_UP) || !__in_dev_get_rcu(dev_out)) {
2041 rth = ERR_PTR(-ENETUNREACH);
2044 if (ipv4_is_local_multicast(fl4->daddr) ||
2045 ipv4_is_lbcast(fl4->daddr)) {
2047 fl4->saddr = inet_select_addr(dev_out, 0,
2052 if (ipv4_is_multicast(fl4->daddr))
2053 fl4->saddr = inet_select_addr(dev_out, 0,
2055 else if (!fl4->daddr)
2056 fl4->saddr = inet_select_addr(dev_out, 0,
2062 fl4->daddr = fl4->saddr;
2064 fl4->daddr = fl4->saddr = htonl(INADDR_LOOPBACK);
2065 dev_out = net->loopback_dev;
2066 fl4->flowi4_oif = LOOPBACK_IFINDEX;
2067 res.type = RTN_LOCAL;
2068 flags |= RTCF_LOCAL;
2072 if (fib_lookup(net, fl4, &res)) {
2075 if (fl4->flowi4_oif) {
2076 /* Apparently, routing tables are wrong. Assume,
2077 that the destination is on link.
2080 Because we are allowed to send to iface
2081 even if it has NO routes and NO assigned
2082 addresses. When oif is specified, routing
2083 tables are looked up with only one purpose:
2084 to catch if destination is gatewayed, rather than
2085 direct. Moreover, if MSG_DONTROUTE is set,
2086 we send packet, ignoring both routing tables
2087 and ifaddr state. --ANK
2090 We could make it even if oif is unknown,
2091 likely IPv6, but we do not.
2094 if (fl4->saddr == 0)
2095 fl4->saddr = inet_select_addr(dev_out, 0,
2097 res.type = RTN_UNICAST;
2100 rth = ERR_PTR(-ENETUNREACH);
2104 if (res.type == RTN_LOCAL) {
2106 if (res.fi->fib_prefsrc)
2107 fl4->saddr = res.fi->fib_prefsrc;
2109 fl4->saddr = fl4->daddr;
2111 dev_out = net->loopback_dev;
2112 fl4->flowi4_oif = dev_out->ifindex;
2113 flags |= RTCF_LOCAL;
2117 #ifdef CONFIG_IP_ROUTE_MULTIPATH
2118 if (res.fi->fib_nhs > 1 && fl4->flowi4_oif == 0)
2119 fib_select_multipath(&res);
2122 if (!res.prefixlen &&
2123 res.table->tb_num_default > 1 &&
2124 res.type == RTN_UNICAST && !fl4->flowi4_oif)
2125 fib_select_default(&res);
2128 fl4->saddr = FIB_RES_PREFSRC(net, res);
2130 dev_out = FIB_RES_DEV(res);
2131 fl4->flowi4_oif = dev_out->ifindex;
2135 rth = __mkroute_output(&res, fl4, orig_oif, dev_out, flags);
2141 EXPORT_SYMBOL_GPL(__ip_route_output_key);
2143 static struct dst_entry *ipv4_blackhole_dst_check(struct dst_entry *dst, u32 cookie)
2148 static unsigned int ipv4_blackhole_mtu(const struct dst_entry *dst)
2150 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
2152 return mtu ? : dst->dev->mtu;
2155 static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
2156 struct sk_buff *skb, u32 mtu)
2160 static void ipv4_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
2161 struct sk_buff *skb)
2165 static u32 *ipv4_rt_blackhole_cow_metrics(struct dst_entry *dst,
2171 static struct dst_ops ipv4_dst_blackhole_ops = {
2173 .protocol = cpu_to_be16(ETH_P_IP),
2174 .check = ipv4_blackhole_dst_check,
2175 .mtu = ipv4_blackhole_mtu,
2176 .default_advmss = ipv4_default_advmss,
2177 .update_pmtu = ipv4_rt_blackhole_update_pmtu,
2178 .redirect = ipv4_rt_blackhole_redirect,
2179 .cow_metrics = ipv4_rt_blackhole_cow_metrics,
2180 .neigh_lookup = ipv4_neigh_lookup,
2183 struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig)
2185 struct rtable *ort = (struct rtable *) dst_orig;
2188 rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, DST_OBSOLETE_NONE, 0);
2190 struct dst_entry *new = &rt->dst;
2193 new->input = dst_discard;
2194 new->output = dst_discard;
2196 new->dev = ort->dst.dev;
2200 rt->rt_is_input = ort->rt_is_input;
2201 rt->rt_iif = ort->rt_iif;
2202 rt->rt_pmtu = ort->rt_pmtu;
2204 rt->rt_genid = rt_genid(net);
2205 rt->rt_flags = ort->rt_flags;
2206 rt->rt_type = ort->rt_type;
2207 rt->rt_gateway = ort->rt_gateway;
2208 rt->rt_uses_gateway = ort->rt_uses_gateway;
2210 INIT_LIST_HEAD(&rt->rt_uncached);
2215 dst_release(dst_orig);
2217 return rt ? &rt->dst : ERR_PTR(-ENOMEM);
2220 struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4,
2223 struct rtable *rt = __ip_route_output_key(net, flp4);
2228 if (flp4->flowi4_proto)
2229 rt = (struct rtable *) xfrm_lookup(net, &rt->dst,
2230 flowi4_to_flowi(flp4),
2235 EXPORT_SYMBOL_GPL(ip_route_output_flow);
2237 static int rt_fill_info(struct net *net, __be32 dst, __be32 src,
2238 struct flowi4 *fl4, struct sk_buff *skb, u32 portid,
2239 u32 seq, int event, int nowait, unsigned int flags)
2241 struct rtable *rt = skb_rtable(skb);
2243 struct nlmsghdr *nlh;
2244 unsigned long expires = 0;
2246 u32 metrics[RTAX_MAX];
2248 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*r), flags);
2252 r = nlmsg_data(nlh);
2253 r->rtm_family = AF_INET;
2254 r->rtm_dst_len = 32;
2256 r->rtm_tos = fl4->flowi4_tos;
2257 r->rtm_table = RT_TABLE_MAIN;
2258 if (nla_put_u32(skb, RTA_TABLE, RT_TABLE_MAIN))
2259 goto nla_put_failure;
2260 r->rtm_type = rt->rt_type;
2261 r->rtm_scope = RT_SCOPE_UNIVERSE;
2262 r->rtm_protocol = RTPROT_UNSPEC;
2263 r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
2264 if (rt->rt_flags & RTCF_NOTIFY)
2265 r->rtm_flags |= RTM_F_NOTIFY;
2266 if (IPCB(skb)->flags & IPSKB_DOREDIRECT)
2267 r->rtm_flags |= RTCF_DOREDIRECT;
2269 if (nla_put_be32(skb, RTA_DST, dst))
2270 goto nla_put_failure;
2272 r->rtm_src_len = 32;
2273 if (nla_put_be32(skb, RTA_SRC, src))
2274 goto nla_put_failure;
2277 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2278 goto nla_put_failure;
2279 #ifdef CONFIG_IP_ROUTE_CLASSID
2280 if (rt->dst.tclassid &&
2281 nla_put_u32(skb, RTA_FLOW, rt->dst.tclassid))
2282 goto nla_put_failure;
2284 if (!rt_is_input_route(rt) &&
2285 fl4->saddr != src) {
2286 if (nla_put_be32(skb, RTA_PREFSRC, fl4->saddr))
2287 goto nla_put_failure;
2289 if (rt->rt_uses_gateway &&
2290 nla_put_be32(skb, RTA_GATEWAY, rt->rt_gateway))
2291 goto nla_put_failure;
2293 expires = rt->dst.expires;
2295 unsigned long now = jiffies;
2297 if (time_before(now, expires))
2303 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
2304 if (rt->rt_pmtu && expires)
2305 metrics[RTAX_MTU - 1] = rt->rt_pmtu;
2306 if (rtnetlink_put_metrics(skb, metrics) < 0)
2307 goto nla_put_failure;
2309 if (fl4->flowi4_mark &&
2310 nla_put_u32(skb, RTA_MARK, fl4->flowi4_mark))
2311 goto nla_put_failure;
2313 if (!uid_eq(fl4->flowi4_uid, INVALID_UID) &&
2314 nla_put_u32(skb, RTA_UID,
2315 from_kuid_munged(current_user_ns(), fl4->flowi4_uid)))
2316 goto nla_put_failure;
2318 error = rt->dst.error;
2320 if (rt_is_input_route(rt)) {
2321 #ifdef CONFIG_IP_MROUTE
2322 if (ipv4_is_multicast(dst) && !ipv4_is_local_multicast(dst) &&
2323 IPV4_DEVCONF_ALL(net, MC_FORWARDING)) {
2324 int err = ipmr_get_route(net, skb,
2325 fl4->saddr, fl4->daddr,
2331 goto nla_put_failure;
2333 if (err == -EMSGSIZE)
2334 goto nla_put_failure;
2340 if (nla_put_u32(skb, RTA_IIF, skb->dev->ifindex))
2341 goto nla_put_failure;
2344 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, error) < 0)
2345 goto nla_put_failure;
2347 return nlmsg_end(skb, nlh);
2350 nlmsg_cancel(skb, nlh);
2354 static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh)
2356 struct net *net = sock_net(in_skb->sk);
2358 struct nlattr *tb[RTA_MAX+1];
2359 struct rtable *rt = NULL;
2366 struct sk_buff *skb;
2369 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv4_policy);
2373 rtm = nlmsg_data(nlh);
2375 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2381 /* Reserve room for dummy headers, this skb can pass
2382 through good chunk of routing engine.
2384 skb_reset_mac_header(skb);
2385 skb_reset_network_header(skb);
2387 /* Bugfix: need to give ip_route_input enough of an IP header to not gag. */
2388 ip_hdr(skb)->protocol = IPPROTO_ICMP;
2389 skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));
2391 src = tb[RTA_SRC] ? nla_get_be32(tb[RTA_SRC]) : 0;
2392 dst = tb[RTA_DST] ? nla_get_be32(tb[RTA_DST]) : 0;
2393 iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
2394 mark = tb[RTA_MARK] ? nla_get_u32(tb[RTA_MARK]) : 0;
2396 uid = make_kuid(current_user_ns(), nla_get_u32(tb[RTA_UID]));
2398 uid = (iif ? INVALID_UID : current_uid());
2400 memset(&fl4, 0, sizeof(fl4));
2403 fl4.flowi4_tos = rtm->rtm_tos;
2404 fl4.flowi4_oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0;
2405 fl4.flowi4_mark = mark;
2406 fl4.flowi4_uid = uid;
2409 struct net_device *dev;
2411 dev = __dev_get_by_index(net, iif);
2417 skb->protocol = htons(ETH_P_IP);
2421 err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
2424 rt = skb_rtable(skb);
2425 if (err == 0 && rt->dst.error)
2426 err = -rt->dst.error;
2428 rt = ip_route_output_key(net, &fl4);
2438 skb_dst_set(skb, &rt->dst);
2439 if (rtm->rtm_flags & RTM_F_NOTIFY)
2440 rt->rt_flags |= RTCF_NOTIFY;
2442 err = rt_fill_info(net, dst, src, &fl4, skb,
2443 NETLINK_CB(in_skb).portid, nlh->nlmsg_seq,
2444 RTM_NEWROUTE, 0, 0);
2448 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2457 int ip_rt_dump(struct sk_buff *skb, struct netlink_callback *cb)
2462 void ip_rt_multicast_event(struct in_device *in_dev)
2464 rt_cache_flush(dev_net(in_dev->dev));
2467 #ifdef CONFIG_SYSCTL
2468 static int ip_rt_gc_timeout __read_mostly = RT_GC_TIMEOUT;
2469 static int ip_rt_gc_interval __read_mostly = 60 * HZ;
2470 static int ip_rt_gc_min_interval __read_mostly = HZ / 2;
2471 static int ip_rt_gc_elasticity __read_mostly = 8;
2473 static int ipv4_sysctl_rtcache_flush(ctl_table *__ctl, int write,
2474 void __user *buffer,
2475 size_t *lenp, loff_t *ppos)
2478 rt_cache_flush((struct net *)__ctl->extra1);
2485 static ctl_table ipv4_route_table[] = {
2487 .procname = "gc_thresh",
2488 .data = &ipv4_dst_ops.gc_thresh,
2489 .maxlen = sizeof(int),
2491 .proc_handler = proc_dointvec,
2494 .procname = "max_size",
2495 .data = &ip_rt_max_size,
2496 .maxlen = sizeof(int),
2498 .proc_handler = proc_dointvec,
2501 /* Deprecated. Use gc_min_interval_ms */
2503 .procname = "gc_min_interval",
2504 .data = &ip_rt_gc_min_interval,
2505 .maxlen = sizeof(int),
2507 .proc_handler = proc_dointvec_jiffies,
2510 .procname = "gc_min_interval_ms",
2511 .data = &ip_rt_gc_min_interval,
2512 .maxlen = sizeof(int),
2514 .proc_handler = proc_dointvec_ms_jiffies,
2517 .procname = "gc_timeout",
2518 .data = &ip_rt_gc_timeout,
2519 .maxlen = sizeof(int),
2521 .proc_handler = proc_dointvec_jiffies,
2524 .procname = "gc_interval",
2525 .data = &ip_rt_gc_interval,
2526 .maxlen = sizeof(int),
2528 .proc_handler = proc_dointvec_jiffies,
2531 .procname = "redirect_load",
2532 .data = &ip_rt_redirect_load,
2533 .maxlen = sizeof(int),
2535 .proc_handler = proc_dointvec,
2538 .procname = "redirect_number",
2539 .data = &ip_rt_redirect_number,
2540 .maxlen = sizeof(int),
2542 .proc_handler = proc_dointvec,
2545 .procname = "redirect_silence",
2546 .data = &ip_rt_redirect_silence,
2547 .maxlen = sizeof(int),
2549 .proc_handler = proc_dointvec,
2552 .procname = "error_cost",
2553 .data = &ip_rt_error_cost,
2554 .maxlen = sizeof(int),
2556 .proc_handler = proc_dointvec,
2559 .procname = "error_burst",
2560 .data = &ip_rt_error_burst,
2561 .maxlen = sizeof(int),
2563 .proc_handler = proc_dointvec,
2566 .procname = "gc_elasticity",
2567 .data = &ip_rt_gc_elasticity,
2568 .maxlen = sizeof(int),
2570 .proc_handler = proc_dointvec,
2573 .procname = "mtu_expires",
2574 .data = &ip_rt_mtu_expires,
2575 .maxlen = sizeof(int),
2577 .proc_handler = proc_dointvec_jiffies,
2580 .procname = "min_pmtu",
2581 .data = &ip_rt_min_pmtu,
2582 .maxlen = sizeof(int),
2584 .proc_handler = proc_dointvec,
2587 .procname = "min_adv_mss",
2588 .data = &ip_rt_min_advmss,
2589 .maxlen = sizeof(int),
2591 .proc_handler = proc_dointvec,
2596 static struct ctl_table ipv4_route_flush_table[] = {
2598 .procname = "flush",
2599 .maxlen = sizeof(int),
2601 .proc_handler = ipv4_sysctl_rtcache_flush,
2606 static __net_init int sysctl_route_net_init(struct net *net)
2608 struct ctl_table *tbl;
2610 tbl = ipv4_route_flush_table;
2611 if (!net_eq(net, &init_net)) {
2612 tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
2616 /* Don't export sysctls to unprivileged users */
2617 if (net->user_ns != &init_user_ns)
2618 tbl[0].procname = NULL;
2620 tbl[0].extra1 = net;
2622 net->ipv4.route_hdr = register_net_sysctl(net, "net/ipv4/route", tbl);
2623 if (net->ipv4.route_hdr == NULL)
2628 if (tbl != ipv4_route_flush_table)
2634 static __net_exit void sysctl_route_net_exit(struct net *net)
2636 struct ctl_table *tbl;
2638 tbl = net->ipv4.route_hdr->ctl_table_arg;
2639 unregister_net_sysctl_table(net->ipv4.route_hdr);
2640 BUG_ON(tbl == ipv4_route_flush_table);
2644 static __net_initdata struct pernet_operations sysctl_route_ops = {
2645 .init = sysctl_route_net_init,
2646 .exit = sysctl_route_net_exit,
2650 static __net_init int rt_genid_init(struct net *net)
2652 atomic_set(&net->rt_genid, 0);
2653 get_random_bytes(&net->ipv4.dev_addr_genid,
2654 sizeof(net->ipv4.dev_addr_genid));
2658 static __net_initdata struct pernet_operations rt_genid_ops = {
2659 .init = rt_genid_init,
2662 static int __net_init ipv4_inetpeer_init(struct net *net)
2664 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
2668 inet_peer_base_init(bp);
2669 net->ipv4.peers = bp;
2673 static void __net_exit ipv4_inetpeer_exit(struct net *net)
2675 struct inet_peer_base *bp = net->ipv4.peers;
2677 net->ipv4.peers = NULL;
2678 inetpeer_invalidate_tree(bp);
2682 static __net_initdata struct pernet_operations ipv4_inetpeer_ops = {
2683 .init = ipv4_inetpeer_init,
2684 .exit = ipv4_inetpeer_exit,
2687 #ifdef CONFIG_IP_ROUTE_CLASSID
2688 struct ip_rt_acct __percpu *ip_rt_acct __read_mostly;
2689 #endif /* CONFIG_IP_ROUTE_CLASSID */
2691 int __init ip_rt_init(void)
2695 ip_idents = kmalloc(IP_IDENTS_SZ * sizeof(*ip_idents), GFP_KERNEL);
2697 panic("IP: failed to allocate ip_idents\n");
2699 prandom_bytes(ip_idents, IP_IDENTS_SZ * sizeof(*ip_idents));
2701 #ifdef CONFIG_IP_ROUTE_CLASSID
2702 ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
2704 panic("IP: failed to allocate ip_rt_acct\n");
2707 ipv4_dst_ops.kmem_cachep =
2708 kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
2709 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
2711 ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
2713 if (dst_entries_init(&ipv4_dst_ops) < 0)
2714 panic("IP: failed to allocate ipv4_dst_ops counter\n");
2716 if (dst_entries_init(&ipv4_dst_blackhole_ops) < 0)
2717 panic("IP: failed to allocate ipv4_dst_blackhole_ops counter\n");
2719 ipv4_dst_ops.gc_thresh = ~0;
2720 ip_rt_max_size = INT_MAX;
2725 if (ip_rt_proc_init())
2726 pr_err("Unable to create route proc files\n");
2731 rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL, NULL);
2733 #ifdef CONFIG_SYSCTL
2734 register_pernet_subsys(&sysctl_route_ops);
2736 register_pernet_subsys(&rt_genid_ops);
2737 register_pernet_subsys(&ipv4_inetpeer_ops);
2741 #ifdef CONFIG_SYSCTL
2743 * We really need to sanitize the damn ipv4 init order, then all
2744 * this nonsense will go away.
2746 void __init ip_static_sysctl_init(void)
2748 register_net_sysctl(&init_net, "net/ipv4/route", ipv4_route_table);