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>
93 #include <net/net_namespace.h>
94 #include <net/protocol.h>
96 #include <net/route.h>
97 #include <net/inetpeer.h>
99 #include <net/ip_fib.h>
102 #include <net/icmp.h>
103 #include <net/xfrm.h>
104 #include <net/netevent.h>
105 #include <net/rtnetlink.h>
107 #include <linux/sysctl.h>
108 #include <linux/kmemleak.h>
110 #include <net/secure_seq.h>
112 #define RT_FL_TOS(oldflp4) \
113 ((oldflp4)->flowi4_tos & (IPTOS_RT_MASK | RTO_ONLINK))
115 #define IP_MAX_MTU 0xFFF0
117 #define RT_GC_TIMEOUT (300*HZ)
119 static int ip_rt_max_size;
120 static int ip_rt_gc_timeout __read_mostly = RT_GC_TIMEOUT;
121 static int ip_rt_gc_interval __read_mostly = 60 * HZ;
122 static int ip_rt_gc_min_interval __read_mostly = HZ / 2;
123 static int ip_rt_redirect_number __read_mostly = 9;
124 static int ip_rt_redirect_load __read_mostly = HZ / 50;
125 static int ip_rt_redirect_silence __read_mostly = ((HZ / 50) << (9 + 1));
126 static int ip_rt_error_cost __read_mostly = HZ;
127 static int ip_rt_error_burst __read_mostly = 5 * HZ;
128 static int ip_rt_gc_elasticity __read_mostly = 8;
129 static int ip_rt_mtu_expires __read_mostly = 10 * 60 * HZ;
130 static int ip_rt_min_pmtu __read_mostly = 512 + 20 + 20;
131 static int ip_rt_min_advmss __read_mostly = 256;
134 * Interface to generic destination cache.
137 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie);
138 static unsigned int ipv4_default_advmss(const struct dst_entry *dst);
139 static unsigned int ipv4_mtu(const struct dst_entry *dst);
140 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst);
141 static void ipv4_link_failure(struct sk_buff *skb);
142 static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
143 struct sk_buff *skb, u32 mtu);
144 static void ip_do_redirect(struct dst_entry *dst, struct sock *sk,
145 struct sk_buff *skb);
146 static void ipv4_dst_destroy(struct dst_entry *dst);
148 static void ipv4_dst_ifdown(struct dst_entry *dst, struct net_device *dev,
153 static u32 *ipv4_cow_metrics(struct dst_entry *dst, unsigned long old)
159 static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
163 static struct dst_ops ipv4_dst_ops = {
165 .protocol = cpu_to_be16(ETH_P_IP),
166 .check = ipv4_dst_check,
167 .default_advmss = ipv4_default_advmss,
169 .cow_metrics = ipv4_cow_metrics,
170 .destroy = ipv4_dst_destroy,
171 .ifdown = ipv4_dst_ifdown,
172 .negative_advice = ipv4_negative_advice,
173 .link_failure = ipv4_link_failure,
174 .update_pmtu = ip_rt_update_pmtu,
175 .redirect = ip_do_redirect,
176 .local_out = __ip_local_out,
177 .neigh_lookup = ipv4_neigh_lookup,
180 #define ECN_OR_COST(class) TC_PRIO_##class
182 const __u8 ip_tos2prio[16] = {
184 ECN_OR_COST(BESTEFFORT),
186 ECN_OR_COST(BESTEFFORT),
192 ECN_OR_COST(INTERACTIVE),
194 ECN_OR_COST(INTERACTIVE),
195 TC_PRIO_INTERACTIVE_BULK,
196 ECN_OR_COST(INTERACTIVE_BULK),
197 TC_PRIO_INTERACTIVE_BULK,
198 ECN_OR_COST(INTERACTIVE_BULK)
200 EXPORT_SYMBOL(ip_tos2prio);
202 static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
203 #define RT_CACHE_STAT_INC(field) __this_cpu_inc(rt_cache_stat.field)
205 static inline int rt_genid(struct net *net)
207 return atomic_read(&net->ipv4.rt_genid);
210 #ifdef CONFIG_PROC_FS
211 static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos)
215 return SEQ_START_TOKEN;
218 static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos)
224 static void rt_cache_seq_stop(struct seq_file *seq, void *v)
228 static int rt_cache_seq_show(struct seq_file *seq, void *v)
230 if (v == SEQ_START_TOKEN)
231 seq_printf(seq, "%-127s\n",
232 "Iface\tDestination\tGateway \tFlags\t\tRefCnt\tUse\t"
233 "Metric\tSource\t\tMTU\tWindow\tIRTT\tTOS\tHHRef\t"
238 static const struct seq_operations rt_cache_seq_ops = {
239 .start = rt_cache_seq_start,
240 .next = rt_cache_seq_next,
241 .stop = rt_cache_seq_stop,
242 .show = rt_cache_seq_show,
245 static int rt_cache_seq_open(struct inode *inode, struct file *file)
247 return seq_open(file, &rt_cache_seq_ops);
250 static const struct file_operations rt_cache_seq_fops = {
251 .owner = THIS_MODULE,
252 .open = rt_cache_seq_open,
255 .release = seq_release,
259 static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos)
264 return SEQ_START_TOKEN;
266 for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
267 if (!cpu_possible(cpu))
270 return &per_cpu(rt_cache_stat, cpu);
275 static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos)
279 for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
280 if (!cpu_possible(cpu))
283 return &per_cpu(rt_cache_stat, cpu);
289 static void rt_cpu_seq_stop(struct seq_file *seq, void *v)
294 static int rt_cpu_seq_show(struct seq_file *seq, void *v)
296 struct rt_cache_stat *st = v;
298 if (v == SEQ_START_TOKEN) {
299 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");
303 seq_printf(seq,"%08x %08x %08x %08x %08x %08x %08x %08x "
304 " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n",
305 dst_entries_get_slow(&ipv4_dst_ops),
328 static const struct seq_operations rt_cpu_seq_ops = {
329 .start = rt_cpu_seq_start,
330 .next = rt_cpu_seq_next,
331 .stop = rt_cpu_seq_stop,
332 .show = rt_cpu_seq_show,
336 static int rt_cpu_seq_open(struct inode *inode, struct file *file)
338 return seq_open(file, &rt_cpu_seq_ops);
341 static const struct file_operations rt_cpu_seq_fops = {
342 .owner = THIS_MODULE,
343 .open = rt_cpu_seq_open,
346 .release = seq_release,
349 #ifdef CONFIG_IP_ROUTE_CLASSID
350 static int rt_acct_proc_show(struct seq_file *m, void *v)
352 struct ip_rt_acct *dst, *src;
355 dst = kcalloc(256, sizeof(struct ip_rt_acct), GFP_KERNEL);
359 for_each_possible_cpu(i) {
360 src = (struct ip_rt_acct *)per_cpu_ptr(ip_rt_acct, i);
361 for (j = 0; j < 256; j++) {
362 dst[j].o_bytes += src[j].o_bytes;
363 dst[j].o_packets += src[j].o_packets;
364 dst[j].i_bytes += src[j].i_bytes;
365 dst[j].i_packets += src[j].i_packets;
369 seq_write(m, dst, 256 * sizeof(struct ip_rt_acct));
374 static int rt_acct_proc_open(struct inode *inode, struct file *file)
376 return single_open(file, rt_acct_proc_show, NULL);
379 static const struct file_operations rt_acct_proc_fops = {
380 .owner = THIS_MODULE,
381 .open = rt_acct_proc_open,
384 .release = single_release,
388 static int __net_init ip_rt_do_proc_init(struct net *net)
390 struct proc_dir_entry *pde;
392 pde = proc_net_fops_create(net, "rt_cache", S_IRUGO,
397 pde = proc_create("rt_cache", S_IRUGO,
398 net->proc_net_stat, &rt_cpu_seq_fops);
402 #ifdef CONFIG_IP_ROUTE_CLASSID
403 pde = proc_create("rt_acct", 0, net->proc_net, &rt_acct_proc_fops);
409 #ifdef CONFIG_IP_ROUTE_CLASSID
411 remove_proc_entry("rt_cache", net->proc_net_stat);
414 remove_proc_entry("rt_cache", net->proc_net);
419 static void __net_exit ip_rt_do_proc_exit(struct net *net)
421 remove_proc_entry("rt_cache", net->proc_net_stat);
422 remove_proc_entry("rt_cache", net->proc_net);
423 #ifdef CONFIG_IP_ROUTE_CLASSID
424 remove_proc_entry("rt_acct", net->proc_net);
428 static struct pernet_operations ip_rt_proc_ops __net_initdata = {
429 .init = ip_rt_do_proc_init,
430 .exit = ip_rt_do_proc_exit,
433 static int __init ip_rt_proc_init(void)
435 return register_pernet_subsys(&ip_rt_proc_ops);
439 static inline int ip_rt_proc_init(void)
443 #endif /* CONFIG_PROC_FS */
445 static inline bool rt_is_expired(const struct rtable *rth)
447 return rth->rt_genid != rt_genid(dev_net(rth->dst.dev));
451 * Perturbation of rt_genid by a small quantity [1..256]
452 * Using 8 bits of shuffling ensure we can call rt_cache_invalidate()
453 * many times (2^24) without giving recent rt_genid.
454 * Jenkins hash is strong enough that litle changes of rt_genid are OK.
456 static void rt_cache_invalidate(struct net *net)
458 unsigned char shuffle;
460 get_random_bytes(&shuffle, sizeof(shuffle));
461 atomic_add(shuffle + 1U, &net->ipv4.rt_genid);
465 * delay < 0 : invalidate cache (fast : entries will be deleted later)
466 * delay >= 0 : invalidate & flush cache (can be long)
468 void rt_cache_flush(struct net *net, int delay)
470 rt_cache_invalidate(net);
473 static struct neighbour *ipv4_neigh_lookup(const struct dst_entry *dst,
477 struct net_device *dev = dst->dev;
478 const __be32 *pkey = daddr;
479 const struct rtable *rt;
482 rt = (const struct rtable *) dst;
484 pkey = (const __be32 *) &rt->rt_gateway;
486 pkey = &ip_hdr(skb)->daddr;
488 n = __ipv4_neigh_lookup(dev, *(__force u32 *)pkey);
491 return neigh_create(&arp_tbl, pkey, dev);
495 * Peer allocation may fail only in serious out-of-memory conditions. However
496 * we still can generate some output.
497 * Random ID selection looks a bit dangerous because we have no chances to
498 * select ID being unique in a reasonable period of time.
499 * But broken packet identifier may be better than no packet at all.
501 static void ip_select_fb_ident(struct iphdr *iph)
503 static DEFINE_SPINLOCK(ip_fb_id_lock);
504 static u32 ip_fallback_id;
507 spin_lock_bh(&ip_fb_id_lock);
508 salt = secure_ip_id((__force __be32)ip_fallback_id ^ iph->daddr);
509 iph->id = htons(salt & 0xFFFF);
510 ip_fallback_id = salt;
511 spin_unlock_bh(&ip_fb_id_lock);
514 void __ip_select_ident(struct iphdr *iph, struct dst_entry *dst, int more)
516 struct net *net = dev_net(dst->dev);
517 struct inet_peer *peer;
519 peer = inet_getpeer_v4(net->ipv4.peers, iph->daddr, 1);
521 iph->id = htons(inet_getid(peer, more));
526 ip_select_fb_ident(iph);
528 EXPORT_SYMBOL(__ip_select_ident);
530 static void __build_flow_key(struct flowi4 *fl4, const struct sock *sk,
531 const struct iphdr *iph,
533 u8 prot, u32 mark, int flow_flags)
536 const struct inet_sock *inet = inet_sk(sk);
538 oif = sk->sk_bound_dev_if;
540 tos = RT_CONN_FLAGS(sk);
541 prot = inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol;
543 flowi4_init_output(fl4, oif, mark, tos,
544 RT_SCOPE_UNIVERSE, prot,
546 iph->daddr, iph->saddr, 0, 0);
549 static void build_skb_flow_key(struct flowi4 *fl4, const struct sk_buff *skb,
550 const struct sock *sk)
552 const struct iphdr *iph = ip_hdr(skb);
553 int oif = skb->dev->ifindex;
554 u8 tos = RT_TOS(iph->tos);
555 u8 prot = iph->protocol;
556 u32 mark = skb->mark;
558 __build_flow_key(fl4, sk, iph, oif, tos, prot, mark, 0);
561 static void build_sk_flow_key(struct flowi4 *fl4, const struct sock *sk)
563 const struct inet_sock *inet = inet_sk(sk);
564 const struct ip_options_rcu *inet_opt;
565 __be32 daddr = inet->inet_daddr;
568 inet_opt = rcu_dereference(inet->inet_opt);
569 if (inet_opt && inet_opt->opt.srr)
570 daddr = inet_opt->opt.faddr;
571 flowi4_init_output(fl4, sk->sk_bound_dev_if, sk->sk_mark,
572 RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE,
573 inet->hdrincl ? IPPROTO_RAW : sk->sk_protocol,
574 inet_sk_flowi_flags(sk),
575 daddr, inet->inet_saddr, 0, 0);
579 static void ip_rt_build_flow_key(struct flowi4 *fl4, const struct sock *sk,
580 const struct sk_buff *skb)
583 build_skb_flow_key(fl4, skb, sk);
585 build_sk_flow_key(fl4, sk);
588 static inline void rt_free(struct rtable *rt)
590 call_rcu(&rt->dst.rcu_head, dst_rcu_free);
593 static DEFINE_SPINLOCK(fnhe_lock);
595 static struct fib_nh_exception *fnhe_oldest(struct fnhe_hash_bucket *hash)
597 struct fib_nh_exception *fnhe, *oldest;
600 oldest = rcu_dereference(hash->chain);
601 for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe;
602 fnhe = rcu_dereference(fnhe->fnhe_next)) {
603 if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp))
606 orig = rcu_dereference(oldest->fnhe_rth);
608 RCU_INIT_POINTER(oldest->fnhe_rth, NULL);
614 static inline u32 fnhe_hashfun(__be32 daddr)
618 hval = (__force u32) daddr;
619 hval ^= (hval >> 11) ^ (hval >> 22);
621 return hval & (FNHE_HASH_SIZE - 1);
624 static void update_or_create_fnhe(struct fib_nh *nh, __be32 daddr, __be32 gw,
625 u32 pmtu, unsigned long expires)
627 struct fnhe_hash_bucket *hash;
628 struct fib_nh_exception *fnhe;
630 u32 hval = fnhe_hashfun(daddr);
632 spin_lock_bh(&fnhe_lock);
634 hash = nh->nh_exceptions;
636 hash = kzalloc(FNHE_HASH_SIZE * sizeof(*hash), GFP_ATOMIC);
639 nh->nh_exceptions = hash;
645 for (fnhe = rcu_dereference(hash->chain); fnhe;
646 fnhe = rcu_dereference(fnhe->fnhe_next)) {
647 if (fnhe->fnhe_daddr == daddr)
656 fnhe->fnhe_pmtu = pmtu;
657 fnhe->fnhe_expires = expires;
660 if (depth > FNHE_RECLAIM_DEPTH)
661 fnhe = fnhe_oldest(hash);
663 fnhe = kzalloc(sizeof(*fnhe), GFP_ATOMIC);
667 fnhe->fnhe_next = hash->chain;
668 rcu_assign_pointer(hash->chain, fnhe);
670 fnhe->fnhe_daddr = daddr;
672 fnhe->fnhe_pmtu = pmtu;
673 fnhe->fnhe_expires = expires;
676 fnhe->fnhe_stamp = jiffies;
679 spin_unlock_bh(&fnhe_lock);
683 static void __ip_do_redirect(struct rtable *rt, struct sk_buff *skb, struct flowi4 *fl4,
686 __be32 new_gw = icmp_hdr(skb)->un.gateway;
687 __be32 old_gw = ip_hdr(skb)->saddr;
688 struct net_device *dev = skb->dev;
689 struct in_device *in_dev;
690 struct fib_result res;
694 switch (icmp_hdr(skb)->code & 7) {
696 case ICMP_REDIR_NETTOS:
697 case ICMP_REDIR_HOST:
698 case ICMP_REDIR_HOSTTOS:
705 if (rt->rt_gateway != old_gw)
708 in_dev = __in_dev_get_rcu(dev);
713 if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) ||
714 ipv4_is_multicast(new_gw) || ipv4_is_lbcast(new_gw) ||
715 ipv4_is_zeronet(new_gw))
716 goto reject_redirect;
718 if (!IN_DEV_SHARED_MEDIA(in_dev)) {
719 if (!inet_addr_onlink(in_dev, new_gw, old_gw))
720 goto reject_redirect;
721 if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev))
722 goto reject_redirect;
724 if (inet_addr_type(net, new_gw) != RTN_UNICAST)
725 goto reject_redirect;
728 n = ipv4_neigh_lookup(&rt->dst, NULL, &new_gw);
730 if (!(n->nud_state & NUD_VALID)) {
731 neigh_event_send(n, NULL);
733 if (fib_lookup(net, fl4, &res) == 0) {
734 struct fib_nh *nh = &FIB_RES_NH(res);
736 update_or_create_fnhe(nh, fl4->daddr, new_gw,
740 rt->dst.obsolete = DST_OBSOLETE_KILL;
741 call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, n);
748 #ifdef CONFIG_IP_ROUTE_VERBOSE
749 if (IN_DEV_LOG_MARTIANS(in_dev)) {
750 const struct iphdr *iph = (const struct iphdr *) skb->data;
751 __be32 daddr = iph->daddr;
752 __be32 saddr = iph->saddr;
754 net_info_ratelimited("Redirect from %pI4 on %s about %pI4 ignored\n"
755 " Advised path = %pI4 -> %pI4\n",
756 &old_gw, dev->name, &new_gw,
763 static void ip_do_redirect(struct dst_entry *dst, struct sock *sk, struct sk_buff *skb)
768 rt = (struct rtable *) dst;
770 ip_rt_build_flow_key(&fl4, sk, skb);
771 __ip_do_redirect(rt, skb, &fl4, true);
774 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst)
776 struct rtable *rt = (struct rtable *)dst;
777 struct dst_entry *ret = dst;
780 if (dst->obsolete > 0) {
783 } else if ((rt->rt_flags & RTCF_REDIRECTED) ||
794 * 1. The first ip_rt_redirect_number redirects are sent
795 * with exponential backoff, then we stop sending them at all,
796 * assuming that the host ignores our redirects.
797 * 2. If we did not see packets requiring redirects
798 * during ip_rt_redirect_silence, we assume that the host
799 * forgot redirected route and start to send redirects again.
801 * This algorithm is much cheaper and more intelligent than dumb load limiting
804 * NOTE. Do not forget to inhibit load limiting for redirects (redundant)
805 * and "frag. need" (breaks PMTU discovery) in icmp.c.
808 void ip_rt_send_redirect(struct sk_buff *skb)
810 struct rtable *rt = skb_rtable(skb);
811 struct in_device *in_dev;
812 struct inet_peer *peer;
817 in_dev = __in_dev_get_rcu(rt->dst.dev);
818 if (!in_dev || !IN_DEV_TX_REDIRECTS(in_dev)) {
822 log_martians = IN_DEV_LOG_MARTIANS(in_dev);
825 net = dev_net(rt->dst.dev);
826 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, 1);
828 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, rt->rt_gateway);
832 /* No redirected packets during ip_rt_redirect_silence;
833 * reset the algorithm.
835 if (time_after(jiffies, peer->rate_last + ip_rt_redirect_silence))
836 peer->rate_tokens = 0;
838 /* Too many ignored redirects; do not send anything
839 * set dst.rate_last to the last seen redirected packet.
841 if (peer->rate_tokens >= ip_rt_redirect_number) {
842 peer->rate_last = jiffies;
846 /* Check for load limit; set rate_last to the latest sent
849 if (peer->rate_tokens == 0 ||
852 (ip_rt_redirect_load << peer->rate_tokens)))) {
853 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, rt->rt_gateway);
854 peer->rate_last = jiffies;
856 #ifdef CONFIG_IP_ROUTE_VERBOSE
858 peer->rate_tokens == ip_rt_redirect_number)
859 net_warn_ratelimited("host %pI4/if%d ignores redirects for %pI4 to %pI4\n",
860 &ip_hdr(skb)->saddr, inet_iif(skb),
861 &ip_hdr(skb)->daddr, &rt->rt_gateway);
868 static int ip_error(struct sk_buff *skb)
870 struct in_device *in_dev = __in_dev_get_rcu(skb->dev);
871 struct rtable *rt = skb_rtable(skb);
872 struct inet_peer *peer;
878 net = dev_net(rt->dst.dev);
879 if (!IN_DEV_FORWARD(in_dev)) {
880 switch (rt->dst.error) {
882 IP_INC_STATS_BH(net, IPSTATS_MIB_INADDRERRORS);
886 IP_INC_STATS_BH(net, IPSTATS_MIB_INNOROUTES);
892 switch (rt->dst.error) {
897 code = ICMP_HOST_UNREACH;
900 code = ICMP_NET_UNREACH;
901 IP_INC_STATS_BH(net, IPSTATS_MIB_INNOROUTES);
904 code = ICMP_PKT_FILTERED;
908 peer = inet_getpeer_v4(net->ipv4.peers, ip_hdr(skb)->saddr, 1);
913 peer->rate_tokens += now - peer->rate_last;
914 if (peer->rate_tokens > ip_rt_error_burst)
915 peer->rate_tokens = ip_rt_error_burst;
916 peer->rate_last = now;
917 if (peer->rate_tokens >= ip_rt_error_cost)
918 peer->rate_tokens -= ip_rt_error_cost;
924 icmp_send(skb, ICMP_DEST_UNREACH, code, 0);
930 static u32 __ip_rt_update_pmtu(struct rtable *rt, struct flowi4 *fl4, u32 mtu)
932 struct fib_result res;
934 if (mtu < ip_rt_min_pmtu)
935 mtu = ip_rt_min_pmtu;
937 if (fib_lookup(dev_net(rt->dst.dev), fl4, &res) == 0) {
938 struct fib_nh *nh = &FIB_RES_NH(res);
940 update_or_create_fnhe(nh, fl4->daddr, 0, mtu,
941 jiffies + ip_rt_mtu_expires);
946 static void ip_rt_update_pmtu(struct dst_entry *dst, struct sock *sk,
947 struct sk_buff *skb, u32 mtu)
949 struct rtable *rt = (struct rtable *) dst;
952 ip_rt_build_flow_key(&fl4, sk, skb);
953 mtu = __ip_rt_update_pmtu(rt, &fl4, mtu);
956 dst->obsolete = DST_OBSOLETE_KILL;
959 rt->dst.expires = max(1UL, jiffies + ip_rt_mtu_expires);
963 void ipv4_update_pmtu(struct sk_buff *skb, struct net *net, u32 mtu,
964 int oif, u32 mark, u8 protocol, int flow_flags)
966 const struct iphdr *iph = (const struct iphdr *) skb->data;
970 __build_flow_key(&fl4, NULL, iph, oif,
971 RT_TOS(iph->tos), protocol, mark, flow_flags);
972 rt = __ip_route_output_key(net, &fl4);
974 __ip_rt_update_pmtu(rt, &fl4, mtu);
978 EXPORT_SYMBOL_GPL(ipv4_update_pmtu);
980 void ipv4_sk_update_pmtu(struct sk_buff *skb, struct sock *sk, u32 mtu)
982 const struct iphdr *iph = (const struct iphdr *) skb->data;
986 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
987 rt = __ip_route_output_key(sock_net(sk), &fl4);
989 __ip_rt_update_pmtu(rt, &fl4, mtu);
993 EXPORT_SYMBOL_GPL(ipv4_sk_update_pmtu);
995 void ipv4_redirect(struct sk_buff *skb, struct net *net,
996 int oif, u32 mark, u8 protocol, int flow_flags)
998 const struct iphdr *iph = (const struct iphdr *) skb->data;
1002 __build_flow_key(&fl4, NULL, iph, oif,
1003 RT_TOS(iph->tos), protocol, mark, flow_flags);
1004 rt = __ip_route_output_key(net, &fl4);
1006 __ip_do_redirect(rt, skb, &fl4, false);
1010 EXPORT_SYMBOL_GPL(ipv4_redirect);
1012 void ipv4_sk_redirect(struct sk_buff *skb, struct sock *sk)
1014 const struct iphdr *iph = (const struct iphdr *) skb->data;
1018 __build_flow_key(&fl4, sk, iph, 0, 0, 0, 0, 0);
1019 rt = __ip_route_output_key(sock_net(sk), &fl4);
1021 __ip_do_redirect(rt, skb, &fl4, false);
1025 EXPORT_SYMBOL_GPL(ipv4_sk_redirect);
1027 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie)
1029 struct rtable *rt = (struct rtable *) dst;
1031 /* All IPV4 dsts are created with ->obsolete set to the value
1032 * DST_OBSOLETE_FORCE_CHK which forces validation calls down
1033 * into this function always.
1035 * When a PMTU/redirect information update invalidates a
1036 * route, this is indicated by setting obsolete to
1037 * DST_OBSOLETE_KILL.
1039 if (dst->obsolete == DST_OBSOLETE_KILL || rt_is_expired(rt))
1044 static void ipv4_link_failure(struct sk_buff *skb)
1048 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
1050 rt = skb_rtable(skb);
1052 dst_set_expires(&rt->dst, 0);
1055 static int ip_rt_bug(struct sk_buff *skb)
1057 pr_debug("%s: %pI4 -> %pI4, %s\n",
1058 __func__, &ip_hdr(skb)->saddr, &ip_hdr(skb)->daddr,
1059 skb->dev ? skb->dev->name : "?");
1066 We do not cache source address of outgoing interface,
1067 because it is used only by IP RR, TS and SRR options,
1068 so that it out of fast path.
1070 BTW remember: "addr" is allowed to be not aligned
1074 void ip_rt_get_source(u8 *addr, struct sk_buff *skb, struct rtable *rt)
1078 if (rt_is_output_route(rt))
1079 src = ip_hdr(skb)->saddr;
1081 struct fib_result res;
1087 memset(&fl4, 0, sizeof(fl4));
1088 fl4.daddr = iph->daddr;
1089 fl4.saddr = iph->saddr;
1090 fl4.flowi4_tos = RT_TOS(iph->tos);
1091 fl4.flowi4_oif = rt->dst.dev->ifindex;
1092 fl4.flowi4_iif = skb->dev->ifindex;
1093 fl4.flowi4_mark = skb->mark;
1096 if (fib_lookup(dev_net(rt->dst.dev), &fl4, &res) == 0)
1097 src = FIB_RES_PREFSRC(dev_net(rt->dst.dev), res);
1099 src = inet_select_addr(rt->dst.dev,
1100 rt_nexthop(rt, iph->daddr),
1104 memcpy(addr, &src, 4);
1107 #ifdef CONFIG_IP_ROUTE_CLASSID
1108 static void set_class_tag(struct rtable *rt, u32 tag)
1110 if (!(rt->dst.tclassid & 0xFFFF))
1111 rt->dst.tclassid |= tag & 0xFFFF;
1112 if (!(rt->dst.tclassid & 0xFFFF0000))
1113 rt->dst.tclassid |= tag & 0xFFFF0000;
1117 static unsigned int ipv4_default_advmss(const struct dst_entry *dst)
1119 unsigned int advmss = dst_metric_raw(dst, RTAX_ADVMSS);
1122 advmss = max_t(unsigned int, dst->dev->mtu - 40,
1124 if (advmss > 65535 - 40)
1125 advmss = 65535 - 40;
1130 static unsigned int ipv4_mtu(const struct dst_entry *dst)
1132 const struct rtable *rt = (const struct rtable *) dst;
1133 unsigned int mtu = rt->rt_pmtu;
1135 if (mtu && time_after_eq(jiffies, rt->dst.expires))
1139 mtu = dst_metric_raw(dst, RTAX_MTU);
1141 if (mtu && rt_is_output_route(rt))
1144 mtu = dst->dev->mtu;
1146 if (unlikely(dst_metric_locked(dst, RTAX_MTU))) {
1147 if (rt->rt_gateway && mtu > 576)
1151 if (mtu > IP_MAX_MTU)
1157 static struct fib_nh_exception *find_exception(struct fib_nh *nh, __be32 daddr)
1159 struct fnhe_hash_bucket *hash = nh->nh_exceptions;
1160 struct fib_nh_exception *fnhe;
1166 hval = fnhe_hashfun(daddr);
1168 for (fnhe = rcu_dereference(hash[hval].chain); fnhe;
1169 fnhe = rcu_dereference(fnhe->fnhe_next)) {
1170 if (fnhe->fnhe_daddr == daddr)
1176 static bool rt_bind_exception(struct rtable *rt, struct fib_nh_exception *fnhe,
1181 spin_lock_bh(&fnhe_lock);
1183 if (daddr == fnhe->fnhe_daddr) {
1184 struct rtable *orig;
1186 if (fnhe->fnhe_pmtu) {
1187 unsigned long expires = fnhe->fnhe_expires;
1188 unsigned long diff = expires - jiffies;
1190 if (time_before(jiffies, expires)) {
1191 rt->rt_pmtu = fnhe->fnhe_pmtu;
1192 dst_set_expires(&rt->dst, diff);
1195 if (fnhe->fnhe_gw) {
1196 rt->rt_flags |= RTCF_REDIRECTED;
1197 rt->rt_gateway = fnhe->fnhe_gw;
1200 orig = rcu_dereference(fnhe->fnhe_rth);
1201 rcu_assign_pointer(fnhe->fnhe_rth, rt);
1205 fnhe->fnhe_stamp = jiffies;
1208 /* Routes we intend to cache in nexthop exception have
1209 * the DST_NOCACHE bit clear. However, if we are
1210 * unsuccessful at storing this route into the cache
1211 * we really need to set it.
1213 rt->dst.flags |= DST_NOCACHE;
1215 spin_unlock_bh(&fnhe_lock);
1220 static bool rt_cache_route(struct fib_nh *nh, struct rtable *rt)
1222 struct rtable *orig, *prev, **p;
1225 if (rt_is_input_route(rt)) {
1226 p = (struct rtable **)&nh->nh_rth_input;
1228 if (!nh->nh_pcpu_rth_output)
1230 p = (struct rtable **)__this_cpu_ptr(nh->nh_pcpu_rth_output);
1234 prev = cmpxchg(p, orig, rt);
1239 /* Routes we intend to cache in the FIB nexthop have
1240 * the DST_NOCACHE bit clear. However, if we are
1241 * unsuccessful at storing this route into the cache
1242 * we really need to set it.
1245 rt->dst.flags |= DST_NOCACHE;
1252 static DEFINE_SPINLOCK(rt_uncached_lock);
1253 static LIST_HEAD(rt_uncached_list);
1255 static void rt_add_uncached_list(struct rtable *rt)
1257 spin_lock_bh(&rt_uncached_lock);
1258 list_add_tail(&rt->rt_uncached, &rt_uncached_list);
1259 spin_unlock_bh(&rt_uncached_lock);
1262 static void ipv4_dst_destroy(struct dst_entry *dst)
1264 struct rtable *rt = (struct rtable *) dst;
1266 if (dst->flags & DST_NOCACHE) {
1267 spin_lock_bh(&rt_uncached_lock);
1268 list_del(&rt->rt_uncached);
1269 spin_unlock_bh(&rt_uncached_lock);
1273 void rt_flush_dev(struct net_device *dev)
1275 if (!list_empty(&rt_uncached_list)) {
1276 struct net *net = dev_net(dev);
1279 spin_lock_bh(&rt_uncached_lock);
1280 list_for_each_entry(rt, &rt_uncached_list, rt_uncached) {
1281 if (rt->dst.dev != dev)
1283 rt->dst.dev = net->loopback_dev;
1284 dev_hold(rt->dst.dev);
1287 spin_unlock_bh(&rt_uncached_lock);
1291 static bool rt_cache_valid(const struct rtable *rt)
1294 rt->dst.obsolete == DST_OBSOLETE_FORCE_CHK &&
1298 static void rt_set_nexthop(struct rtable *rt, __be32 daddr,
1299 const struct fib_result *res,
1300 struct fib_nh_exception *fnhe,
1301 struct fib_info *fi, u16 type, u32 itag)
1303 bool cached = false;
1306 struct fib_nh *nh = &FIB_RES_NH(*res);
1308 if (nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK)
1309 rt->rt_gateway = nh->nh_gw;
1310 dst_init_metrics(&rt->dst, fi->fib_metrics, true);
1311 #ifdef CONFIG_IP_ROUTE_CLASSID
1312 rt->dst.tclassid = nh->nh_tclassid;
1315 cached = rt_bind_exception(rt, fnhe, daddr);
1316 else if (!(rt->dst.flags & DST_NOCACHE))
1317 cached = rt_cache_route(nh, rt);
1319 if (unlikely(!cached))
1320 rt_add_uncached_list(rt);
1322 #ifdef CONFIG_IP_ROUTE_CLASSID
1323 #ifdef CONFIG_IP_MULTIPLE_TABLES
1324 set_class_tag(rt, res->tclassid);
1326 set_class_tag(rt, itag);
1330 static struct rtable *rt_dst_alloc(struct net_device *dev,
1331 bool nopolicy, bool noxfrm, bool will_cache)
1333 return dst_alloc(&ipv4_dst_ops, dev, 1, DST_OBSOLETE_FORCE_CHK,
1334 (will_cache ? 0 : (DST_HOST | DST_NOCACHE)) |
1335 (nopolicy ? DST_NOPOLICY : 0) |
1336 (noxfrm ? DST_NOXFRM : 0));
1339 /* called in rcu_read_lock() section */
1340 static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1341 u8 tos, struct net_device *dev, int our)
1344 struct in_device *in_dev = __in_dev_get_rcu(dev);
1348 /* Primary sanity checks. */
1353 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
1354 skb->protocol != htons(ETH_P_IP))
1357 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
1358 if (ipv4_is_loopback(saddr))
1361 if (ipv4_is_zeronet(saddr)) {
1362 if (!ipv4_is_local_multicast(daddr))
1365 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1370 rth = rt_dst_alloc(dev_net(dev)->loopback_dev,
1371 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, false);
1375 #ifdef CONFIG_IP_ROUTE_CLASSID
1376 rth->dst.tclassid = itag;
1378 rth->dst.output = ip_rt_bug;
1380 rth->rt_genid = rt_genid(dev_net(dev));
1381 rth->rt_flags = RTCF_MULTICAST;
1382 rth->rt_type = RTN_MULTICAST;
1383 rth->rt_is_input= 1;
1386 rth->rt_gateway = 0;
1387 INIT_LIST_HEAD(&rth->rt_uncached);
1389 rth->dst.input= ip_local_deliver;
1390 rth->rt_flags |= RTCF_LOCAL;
1393 #ifdef CONFIG_IP_MROUTE
1394 if (!ipv4_is_local_multicast(daddr) && IN_DEV_MFORWARD(in_dev))
1395 rth->dst.input = ip_mr_input;
1397 RT_CACHE_STAT_INC(in_slow_mc);
1399 skb_dst_set(skb, &rth->dst);
1411 static void ip_handle_martian_source(struct net_device *dev,
1412 struct in_device *in_dev,
1413 struct sk_buff *skb,
1417 RT_CACHE_STAT_INC(in_martian_src);
1418 #ifdef CONFIG_IP_ROUTE_VERBOSE
1419 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) {
1421 * RFC1812 recommendation, if source is martian,
1422 * the only hint is MAC header.
1424 pr_warn("martian source %pI4 from %pI4, on dev %s\n",
1425 &daddr, &saddr, dev->name);
1426 if (dev->hard_header_len && skb_mac_header_was_set(skb)) {
1427 print_hex_dump(KERN_WARNING, "ll header: ",
1428 DUMP_PREFIX_OFFSET, 16, 1,
1429 skb_mac_header(skb),
1430 dev->hard_header_len, true);
1436 /* called in rcu_read_lock() section */
1437 static int __mkroute_input(struct sk_buff *skb,
1438 const struct fib_result *res,
1439 struct in_device *in_dev,
1440 __be32 daddr, __be32 saddr, u32 tos)
1444 struct in_device *out_dev;
1445 unsigned int flags = 0;
1449 /* get a working reference to the output device */
1450 out_dev = __in_dev_get_rcu(FIB_RES_DEV(*res));
1451 if (out_dev == NULL) {
1452 net_crit_ratelimited("Bug in ip_route_input_slow(). Please report.\n");
1457 err = fib_validate_source(skb, saddr, daddr, tos, FIB_RES_OIF(*res),
1458 in_dev->dev, in_dev, &itag);
1460 ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr,
1466 if (out_dev == in_dev && err &&
1467 (IN_DEV_SHARED_MEDIA(out_dev) ||
1468 inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
1469 flags |= RTCF_DOREDIRECT;
1471 if (skb->protocol != htons(ETH_P_IP)) {
1472 /* Not IP (i.e. ARP). Do not create route, if it is
1473 * invalid for proxy arp. DNAT routes are always valid.
1475 * Proxy arp feature have been extended to allow, ARP
1476 * replies back to the same interface, to support
1477 * Private VLAN switch technologies. See arp.c.
1479 if (out_dev == in_dev &&
1480 IN_DEV_PROXY_ARP_PVLAN(in_dev) == 0) {
1489 rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input);
1490 if (rt_cache_valid(rth)) {
1491 skb_dst_set_noref(skb, &rth->dst);
1498 rth = rt_dst_alloc(out_dev->dev,
1499 IN_DEV_CONF_GET(in_dev, NOPOLICY),
1500 IN_DEV_CONF_GET(out_dev, NOXFRM), do_cache);
1506 rth->rt_genid = rt_genid(dev_net(rth->dst.dev));
1507 rth->rt_flags = flags;
1508 rth->rt_type = res->type;
1509 rth->rt_is_input = 1;
1512 rth->rt_gateway = 0;
1513 INIT_LIST_HEAD(&rth->rt_uncached);
1515 rth->dst.input = ip_forward;
1516 rth->dst.output = ip_output;
1518 rt_set_nexthop(rth, daddr, res, NULL, res->fi, res->type, itag);
1519 skb_dst_set(skb, &rth->dst);
1526 static int ip_mkroute_input(struct sk_buff *skb,
1527 struct fib_result *res,
1528 const struct flowi4 *fl4,
1529 struct in_device *in_dev,
1530 __be32 daddr, __be32 saddr, u32 tos)
1532 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1533 if (res->fi && res->fi->fib_nhs > 1)
1534 fib_select_multipath(res);
1537 /* create a routing cache entry */
1538 return __mkroute_input(skb, res, in_dev, daddr, saddr, tos);
1542 * NOTE. We drop all the packets that has local source
1543 * addresses, because every properly looped back packet
1544 * must have correct destination already attached by output routine.
1546 * Such approach solves two big problems:
1547 * 1. Not simplex devices are handled properly.
1548 * 2. IP spoofing attempts are filtered with 100% of guarantee.
1549 * called with rcu_read_lock()
1552 static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1553 u8 tos, struct net_device *dev)
1555 struct fib_result res;
1556 struct in_device *in_dev = __in_dev_get_rcu(dev);
1558 unsigned int flags = 0;
1562 struct net *net = dev_net(dev);
1565 /* IP on this device is disabled. */
1570 /* Check for the most weird martians, which can be not detected
1574 if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr))
1575 goto martian_source;
1578 if (ipv4_is_lbcast(daddr) || (saddr == 0 && daddr == 0))
1581 /* Accept zero addresses only to limited broadcast;
1582 * I even do not know to fix it or not. Waiting for complains :-)
1584 if (ipv4_is_zeronet(saddr))
1585 goto martian_source;
1587 if (ipv4_is_zeronet(daddr))
1588 goto martian_destination;
1590 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev))) {
1591 if (ipv4_is_loopback(daddr))
1592 goto martian_destination;
1594 if (ipv4_is_loopback(saddr))
1595 goto martian_source;
1599 * Now we are ready to route packet.
1602 fl4.flowi4_iif = dev->ifindex;
1603 fl4.flowi4_mark = skb->mark;
1604 fl4.flowi4_tos = tos;
1605 fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
1608 err = fib_lookup(net, &fl4, &res);
1612 RT_CACHE_STAT_INC(in_slow_tot);
1614 if (res.type == RTN_BROADCAST)
1617 if (res.type == RTN_LOCAL) {
1618 err = fib_validate_source(skb, saddr, daddr, tos,
1619 net->loopback_dev->ifindex,
1620 dev, in_dev, &itag);
1622 goto martian_source_keep_err;
1626 if (!IN_DEV_FORWARD(in_dev))
1628 if (res.type != RTN_UNICAST)
1629 goto martian_destination;
1631 err = ip_mkroute_input(skb, &res, &fl4, in_dev, daddr, saddr, tos);
1635 if (skb->protocol != htons(ETH_P_IP))
1638 if (!ipv4_is_zeronet(saddr)) {
1639 err = fib_validate_source(skb, saddr, 0, tos, 0, dev,
1642 goto martian_source_keep_err;
1644 flags |= RTCF_BROADCAST;
1645 res.type = RTN_BROADCAST;
1646 RT_CACHE_STAT_INC(in_brd);
1652 rth = rcu_dereference(FIB_RES_NH(res).nh_rth_input);
1653 if (rt_cache_valid(rth)) {
1654 skb_dst_set_noref(skb, &rth->dst);
1662 rth = rt_dst_alloc(net->loopback_dev,
1663 IN_DEV_CONF_GET(in_dev, NOPOLICY), false, do_cache);
1667 rth->dst.input= ip_local_deliver;
1668 rth->dst.output= ip_rt_bug;
1669 #ifdef CONFIG_IP_ROUTE_CLASSID
1670 rth->dst.tclassid = itag;
1673 rth->rt_genid = rt_genid(net);
1674 rth->rt_flags = flags|RTCF_LOCAL;
1675 rth->rt_type = res.type;
1676 rth->rt_is_input = 1;
1679 rth->rt_gateway = 0;
1680 INIT_LIST_HEAD(&rth->rt_uncached);
1681 if (res.type == RTN_UNREACHABLE) {
1682 rth->dst.input= ip_error;
1683 rth->dst.error= -err;
1684 rth->rt_flags &= ~RTCF_LOCAL;
1687 rt_cache_route(&FIB_RES_NH(res), rth);
1688 skb_dst_set(skb, &rth->dst);
1693 RT_CACHE_STAT_INC(in_no_route);
1694 res.type = RTN_UNREACHABLE;
1700 * Do not cache martian addresses: they should be logged (RFC1812)
1702 martian_destination:
1703 RT_CACHE_STAT_INC(in_martian_dst);
1704 #ifdef CONFIG_IP_ROUTE_VERBOSE
1705 if (IN_DEV_LOG_MARTIANS(in_dev))
1706 net_warn_ratelimited("martian destination %pI4 from %pI4, dev %s\n",
1707 &daddr, &saddr, dev->name);
1720 martian_source_keep_err:
1721 ip_handle_martian_source(dev, in_dev, skb, daddr, saddr);
1725 int ip_route_input_noref(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1726 u8 tos, struct net_device *dev)
1732 /* Multicast recognition logic is moved from route cache to here.
1733 The problem was that too many Ethernet cards have broken/missing
1734 hardware multicast filters :-( As result the host on multicasting
1735 network acquires a lot of useless route cache entries, sort of
1736 SDR messages from all the world. Now we try to get rid of them.
1737 Really, provided software IP multicast filter is organized
1738 reasonably (at least, hashed), it does not result in a slowdown
1739 comparing with route cache reject entries.
1740 Note, that multicast routers are not affected, because
1741 route cache entry is created eventually.
1743 if (ipv4_is_multicast(daddr)) {
1744 struct in_device *in_dev = __in_dev_get_rcu(dev);
1747 int our = ip_check_mc_rcu(in_dev, daddr, saddr,
1748 ip_hdr(skb)->protocol);
1750 #ifdef CONFIG_IP_MROUTE
1752 (!ipv4_is_local_multicast(daddr) &&
1753 IN_DEV_MFORWARD(in_dev))
1756 int res = ip_route_input_mc(skb, daddr, saddr,
1765 res = ip_route_input_slow(skb, daddr, saddr, tos, dev);
1769 EXPORT_SYMBOL(ip_route_input_noref);
1771 /* called with rcu_read_lock() */
1772 static struct rtable *__mkroute_output(const struct fib_result *res,
1773 const struct flowi4 *fl4, int orig_oif,
1774 struct net_device *dev_out,
1777 struct fib_info *fi = res->fi;
1778 struct fib_nh_exception *fnhe;
1779 struct in_device *in_dev;
1780 u16 type = res->type;
1783 in_dev = __in_dev_get_rcu(dev_out);
1785 return ERR_PTR(-EINVAL);
1787 if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
1788 if (ipv4_is_loopback(fl4->saddr) && !(dev_out->flags & IFF_LOOPBACK))
1789 return ERR_PTR(-EINVAL);
1791 if (ipv4_is_lbcast(fl4->daddr))
1792 type = RTN_BROADCAST;
1793 else if (ipv4_is_multicast(fl4->daddr))
1794 type = RTN_MULTICAST;
1795 else if (ipv4_is_zeronet(fl4->daddr))
1796 return ERR_PTR(-EINVAL);
1798 if (dev_out->flags & IFF_LOOPBACK)
1799 flags |= RTCF_LOCAL;
1801 if (type == RTN_BROADCAST) {
1802 flags |= RTCF_BROADCAST | RTCF_LOCAL;
1804 } else if (type == RTN_MULTICAST) {
1805 flags |= RTCF_MULTICAST | RTCF_LOCAL;
1806 if (!ip_check_mc_rcu(in_dev, fl4->daddr, fl4->saddr,
1808 flags &= ~RTCF_LOCAL;
1809 /* If multicast route do not exist use
1810 * default one, but do not gateway in this case.
1813 if (fi && res->prefixlen < 4)
1819 struct rtable __rcu **prth;
1821 fnhe = find_exception(&FIB_RES_NH(*res), fl4->daddr);
1823 prth = &fnhe->fnhe_rth;
1825 prth = __this_cpu_ptr(FIB_RES_NH(*res).nh_pcpu_rth_output);
1826 rth = rcu_dereference(*prth);
1827 if (rt_cache_valid(rth)) {
1828 dst_hold(&rth->dst);
1832 rth = rt_dst_alloc(dev_out,
1833 IN_DEV_CONF_GET(in_dev, NOPOLICY),
1834 IN_DEV_CONF_GET(in_dev, NOXFRM),
1837 return ERR_PTR(-ENOBUFS);
1839 rth->dst.output = ip_output;
1841 rth->rt_genid = rt_genid(dev_net(dev_out));
1842 rth->rt_flags = flags;
1843 rth->rt_type = type;
1844 rth->rt_is_input = 0;
1845 rth->rt_iif = orig_oif ? : 0;
1847 rth->rt_gateway = 0;
1848 INIT_LIST_HEAD(&rth->rt_uncached);
1850 RT_CACHE_STAT_INC(out_slow_tot);
1852 if (flags & RTCF_LOCAL)
1853 rth->dst.input = ip_local_deliver;
1854 if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
1855 if (flags & RTCF_LOCAL &&
1856 !(dev_out->flags & IFF_LOOPBACK)) {
1857 rth->dst.output = ip_mc_output;
1858 RT_CACHE_STAT_INC(out_slow_mc);
1860 #ifdef CONFIG_IP_MROUTE
1861 if (type == RTN_MULTICAST) {
1862 if (IN_DEV_MFORWARD(in_dev) &&
1863 !ipv4_is_local_multicast(fl4->daddr)) {
1864 rth->dst.input = ip_mr_input;
1865 rth->dst.output = ip_mc_output;
1871 rt_set_nexthop(rth, fl4->daddr, res, fnhe, fi, type, 0);
1877 * Major route resolver routine.
1880 struct rtable *__ip_route_output_key(struct net *net, struct flowi4 *fl4)
1882 struct net_device *dev_out = NULL;
1883 __u8 tos = RT_FL_TOS(fl4);
1884 unsigned int flags = 0;
1885 struct fib_result res;
1893 orig_oif = fl4->flowi4_oif;
1895 fl4->flowi4_iif = net->loopback_dev->ifindex;
1896 fl4->flowi4_tos = tos & IPTOS_RT_MASK;
1897 fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
1898 RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);
1902 rth = ERR_PTR(-EINVAL);
1903 if (ipv4_is_multicast(fl4->saddr) ||
1904 ipv4_is_lbcast(fl4->saddr) ||
1905 ipv4_is_zeronet(fl4->saddr))
1908 /* I removed check for oif == dev_out->oif here.
1909 It was wrong for two reasons:
1910 1. ip_dev_find(net, saddr) can return wrong iface, if saddr
1911 is assigned to multiple interfaces.
1912 2. Moreover, we are allowed to send packets with saddr
1913 of another iface. --ANK
1916 if (fl4->flowi4_oif == 0 &&
1917 (ipv4_is_multicast(fl4->daddr) ||
1918 ipv4_is_lbcast(fl4->daddr))) {
1919 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
1920 dev_out = __ip_dev_find(net, fl4->saddr, false);
1921 if (dev_out == NULL)
1924 /* Special hack: user can direct multicasts
1925 and limited broadcast via necessary interface
1926 without fiddling with IP_MULTICAST_IF or IP_PKTINFO.
1927 This hack is not just for fun, it allows
1928 vic,vat and friends to work.
1929 They bind socket to loopback, set ttl to zero
1930 and expect that it will work.
1931 From the viewpoint of routing cache they are broken,
1932 because we are not allowed to build multicast path
1933 with loopback source addr (look, routing cache
1934 cannot know, that ttl is zero, so that packet
1935 will not leave this host and route is valid).
1936 Luckily, this hack is good workaround.
1939 fl4->flowi4_oif = dev_out->ifindex;
1943 if (!(fl4->flowi4_flags & FLOWI_FLAG_ANYSRC)) {
1944 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */
1945 if (!__ip_dev_find(net, fl4->saddr, false))
1951 if (fl4->flowi4_oif) {
1952 dev_out = dev_get_by_index_rcu(net, fl4->flowi4_oif);
1953 rth = ERR_PTR(-ENODEV);
1954 if (dev_out == NULL)
1957 /* RACE: Check return value of inet_select_addr instead. */
1958 if (!(dev_out->flags & IFF_UP) || !__in_dev_get_rcu(dev_out)) {
1959 rth = ERR_PTR(-ENETUNREACH);
1962 if (ipv4_is_local_multicast(fl4->daddr) ||
1963 ipv4_is_lbcast(fl4->daddr)) {
1965 fl4->saddr = inet_select_addr(dev_out, 0,
1970 if (ipv4_is_multicast(fl4->daddr))
1971 fl4->saddr = inet_select_addr(dev_out, 0,
1973 else if (!fl4->daddr)
1974 fl4->saddr = inet_select_addr(dev_out, 0,
1980 fl4->daddr = fl4->saddr;
1982 fl4->daddr = fl4->saddr = htonl(INADDR_LOOPBACK);
1983 dev_out = net->loopback_dev;
1984 fl4->flowi4_oif = net->loopback_dev->ifindex;
1985 res.type = RTN_LOCAL;
1986 flags |= RTCF_LOCAL;
1990 if (fib_lookup(net, fl4, &res)) {
1993 if (fl4->flowi4_oif) {
1994 /* Apparently, routing tables are wrong. Assume,
1995 that the destination is on link.
1998 Because we are allowed to send to iface
1999 even if it has NO routes and NO assigned
2000 addresses. When oif is specified, routing
2001 tables are looked up with only one purpose:
2002 to catch if destination is gatewayed, rather than
2003 direct. Moreover, if MSG_DONTROUTE is set,
2004 we send packet, ignoring both routing tables
2005 and ifaddr state. --ANK
2008 We could make it even if oif is unknown,
2009 likely IPv6, but we do not.
2012 if (fl4->saddr == 0)
2013 fl4->saddr = inet_select_addr(dev_out, 0,
2015 res.type = RTN_UNICAST;
2018 rth = ERR_PTR(-ENETUNREACH);
2022 if (res.type == RTN_LOCAL) {
2024 if (res.fi->fib_prefsrc)
2025 fl4->saddr = res.fi->fib_prefsrc;
2027 fl4->saddr = fl4->daddr;
2029 dev_out = net->loopback_dev;
2030 fl4->flowi4_oif = dev_out->ifindex;
2031 flags |= RTCF_LOCAL;
2035 #ifdef CONFIG_IP_ROUTE_MULTIPATH
2036 if (res.fi->fib_nhs > 1 && fl4->flowi4_oif == 0)
2037 fib_select_multipath(&res);
2040 if (!res.prefixlen &&
2041 res.table->tb_num_default > 1 &&
2042 res.type == RTN_UNICAST && !fl4->flowi4_oif)
2043 fib_select_default(&res);
2046 fl4->saddr = FIB_RES_PREFSRC(net, res);
2048 dev_out = FIB_RES_DEV(res);
2049 fl4->flowi4_oif = dev_out->ifindex;
2053 rth = __mkroute_output(&res, fl4, orig_oif, dev_out, flags);
2059 EXPORT_SYMBOL_GPL(__ip_route_output_key);
2061 static struct dst_entry *ipv4_blackhole_dst_check(struct dst_entry *dst, u32 cookie)
2066 static unsigned int ipv4_blackhole_mtu(const struct dst_entry *dst)
2068 unsigned int mtu = dst_metric_raw(dst, RTAX_MTU);
2070 return mtu ? : dst->dev->mtu;
2073 static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, struct sock *sk,
2074 struct sk_buff *skb, u32 mtu)
2078 static void ipv4_rt_blackhole_redirect(struct dst_entry *dst, struct sock *sk,
2079 struct sk_buff *skb)
2083 static u32 *ipv4_rt_blackhole_cow_metrics(struct dst_entry *dst,
2089 static struct dst_ops ipv4_dst_blackhole_ops = {
2091 .protocol = cpu_to_be16(ETH_P_IP),
2092 .check = ipv4_blackhole_dst_check,
2093 .mtu = ipv4_blackhole_mtu,
2094 .default_advmss = ipv4_default_advmss,
2095 .update_pmtu = ipv4_rt_blackhole_update_pmtu,
2096 .redirect = ipv4_rt_blackhole_redirect,
2097 .cow_metrics = ipv4_rt_blackhole_cow_metrics,
2098 .neigh_lookup = ipv4_neigh_lookup,
2101 struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig)
2103 struct rtable *ort = (struct rtable *) dst_orig;
2106 rt = dst_alloc(&ipv4_dst_blackhole_ops, NULL, 1, DST_OBSOLETE_NONE, 0);
2108 struct dst_entry *new = &rt->dst;
2111 new->input = dst_discard;
2112 new->output = dst_discard;
2114 new->dev = ort->dst.dev;
2118 rt->rt_is_input = ort->rt_is_input;
2119 rt->rt_iif = ort->rt_iif;
2120 rt->rt_pmtu = ort->rt_pmtu;
2122 rt->rt_genid = rt_genid(net);
2123 rt->rt_flags = ort->rt_flags;
2124 rt->rt_type = ort->rt_type;
2125 rt->rt_gateway = ort->rt_gateway;
2127 INIT_LIST_HEAD(&rt->rt_uncached);
2132 dst_release(dst_orig);
2134 return rt ? &rt->dst : ERR_PTR(-ENOMEM);
2137 struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4,
2140 struct rtable *rt = __ip_route_output_key(net, flp4);
2145 if (flp4->flowi4_proto)
2146 rt = (struct rtable *) xfrm_lookup(net, &rt->dst,
2147 flowi4_to_flowi(flp4),
2152 EXPORT_SYMBOL_GPL(ip_route_output_flow);
2154 static int rt_fill_info(struct net *net, __be32 dst, __be32 src,
2155 struct flowi4 *fl4, struct sk_buff *skb, u32 pid,
2156 u32 seq, int event, int nowait, unsigned int flags)
2158 struct rtable *rt = skb_rtable(skb);
2160 struct nlmsghdr *nlh;
2161 unsigned long expires = 0;
2163 u32 metrics[RTAX_MAX];
2165 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*r), flags);
2169 r = nlmsg_data(nlh);
2170 r->rtm_family = AF_INET;
2171 r->rtm_dst_len = 32;
2173 r->rtm_tos = fl4->flowi4_tos;
2174 r->rtm_table = RT_TABLE_MAIN;
2175 if (nla_put_u32(skb, RTA_TABLE, RT_TABLE_MAIN))
2176 goto nla_put_failure;
2177 r->rtm_type = rt->rt_type;
2178 r->rtm_scope = RT_SCOPE_UNIVERSE;
2179 r->rtm_protocol = RTPROT_UNSPEC;
2180 r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED;
2181 if (rt->rt_flags & RTCF_NOTIFY)
2182 r->rtm_flags |= RTM_F_NOTIFY;
2184 if (nla_put_be32(skb, RTA_DST, dst))
2185 goto nla_put_failure;
2187 r->rtm_src_len = 32;
2188 if (nla_put_be32(skb, RTA_SRC, src))
2189 goto nla_put_failure;
2192 nla_put_u32(skb, RTA_OIF, rt->dst.dev->ifindex))
2193 goto nla_put_failure;
2194 #ifdef CONFIG_IP_ROUTE_CLASSID
2195 if (rt->dst.tclassid &&
2196 nla_put_u32(skb, RTA_FLOW, rt->dst.tclassid))
2197 goto nla_put_failure;
2199 if (!rt_is_input_route(rt) &&
2200 fl4->saddr != src) {
2201 if (nla_put_be32(skb, RTA_PREFSRC, fl4->saddr))
2202 goto nla_put_failure;
2204 if (rt->rt_gateway &&
2205 nla_put_be32(skb, RTA_GATEWAY, rt->rt_gateway))
2206 goto nla_put_failure;
2208 memcpy(metrics, dst_metrics_ptr(&rt->dst), sizeof(metrics));
2210 metrics[RTAX_MTU - 1] = rt->rt_pmtu;
2211 if (rtnetlink_put_metrics(skb, metrics) < 0)
2212 goto nla_put_failure;
2214 if (fl4->flowi4_mark &&
2215 nla_put_be32(skb, RTA_MARK, fl4->flowi4_mark))
2216 goto nla_put_failure;
2218 error = rt->dst.error;
2219 expires = rt->dst.expires;
2221 if (time_before(jiffies, expires))
2227 if (rt_is_input_route(rt)) {
2228 if (nla_put_u32(skb, RTA_IIF, rt->rt_iif))
2229 goto nla_put_failure;
2232 if (rtnl_put_cacheinfo(skb, &rt->dst, 0, expires, error) < 0)
2233 goto nla_put_failure;
2235 return nlmsg_end(skb, nlh);
2238 nlmsg_cancel(skb, nlh);
2242 static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh, void *arg)
2244 struct net *net = sock_net(in_skb->sk);
2246 struct nlattr *tb[RTA_MAX+1];
2247 struct rtable *rt = NULL;
2254 struct sk_buff *skb;
2256 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv4_policy);
2260 rtm = nlmsg_data(nlh);
2262 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2268 /* Reserve room for dummy headers, this skb can pass
2269 through good chunk of routing engine.
2271 skb_reset_mac_header(skb);
2272 skb_reset_network_header(skb);
2274 /* Bugfix: need to give ip_route_input enough of an IP header to not gag. */
2275 ip_hdr(skb)->protocol = IPPROTO_ICMP;
2276 skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr));
2278 src = tb[RTA_SRC] ? nla_get_be32(tb[RTA_SRC]) : 0;
2279 dst = tb[RTA_DST] ? nla_get_be32(tb[RTA_DST]) : 0;
2280 iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0;
2281 mark = tb[RTA_MARK] ? nla_get_u32(tb[RTA_MARK]) : 0;
2283 memset(&fl4, 0, sizeof(fl4));
2286 fl4.flowi4_tos = rtm->rtm_tos;
2287 fl4.flowi4_oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0;
2288 fl4.flowi4_mark = mark;
2291 struct net_device *dev;
2293 dev = __dev_get_by_index(net, iif);
2299 skb->protocol = htons(ETH_P_IP);
2303 err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev);
2306 rt = skb_rtable(skb);
2307 if (err == 0 && rt->dst.error)
2308 err = -rt->dst.error;
2310 rt = ip_route_output_key(net, &fl4);
2320 skb_dst_set(skb, &rt->dst);
2321 if (rtm->rtm_flags & RTM_F_NOTIFY)
2322 rt->rt_flags |= RTCF_NOTIFY;
2324 err = rt_fill_info(net, dst, src, &fl4, skb,
2325 NETLINK_CB(in_skb).pid, nlh->nlmsg_seq,
2326 RTM_NEWROUTE, 0, 0);
2330 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).pid);
2339 int ip_rt_dump(struct sk_buff *skb, struct netlink_callback *cb)
2344 void ip_rt_multicast_event(struct in_device *in_dev)
2346 rt_cache_flush(dev_net(in_dev->dev), 0);
2349 #ifdef CONFIG_SYSCTL
2350 static int ipv4_sysctl_rtcache_flush(ctl_table *__ctl, int write,
2351 void __user *buffer,
2352 size_t *lenp, loff_t *ppos)
2359 memcpy(&ctl, __ctl, sizeof(ctl));
2360 ctl.data = &flush_delay;
2361 proc_dointvec(&ctl, write, buffer, lenp, ppos);
2363 net = (struct net *)__ctl->extra1;
2364 rt_cache_flush(net, flush_delay);
2371 static ctl_table ipv4_route_table[] = {
2373 .procname = "gc_thresh",
2374 .data = &ipv4_dst_ops.gc_thresh,
2375 .maxlen = sizeof(int),
2377 .proc_handler = proc_dointvec,
2380 .procname = "max_size",
2381 .data = &ip_rt_max_size,
2382 .maxlen = sizeof(int),
2384 .proc_handler = proc_dointvec,
2387 /* Deprecated. Use gc_min_interval_ms */
2389 .procname = "gc_min_interval",
2390 .data = &ip_rt_gc_min_interval,
2391 .maxlen = sizeof(int),
2393 .proc_handler = proc_dointvec_jiffies,
2396 .procname = "gc_min_interval_ms",
2397 .data = &ip_rt_gc_min_interval,
2398 .maxlen = sizeof(int),
2400 .proc_handler = proc_dointvec_ms_jiffies,
2403 .procname = "gc_timeout",
2404 .data = &ip_rt_gc_timeout,
2405 .maxlen = sizeof(int),
2407 .proc_handler = proc_dointvec_jiffies,
2410 .procname = "gc_interval",
2411 .data = &ip_rt_gc_interval,
2412 .maxlen = sizeof(int),
2414 .proc_handler = proc_dointvec_jiffies,
2417 .procname = "redirect_load",
2418 .data = &ip_rt_redirect_load,
2419 .maxlen = sizeof(int),
2421 .proc_handler = proc_dointvec,
2424 .procname = "redirect_number",
2425 .data = &ip_rt_redirect_number,
2426 .maxlen = sizeof(int),
2428 .proc_handler = proc_dointvec,
2431 .procname = "redirect_silence",
2432 .data = &ip_rt_redirect_silence,
2433 .maxlen = sizeof(int),
2435 .proc_handler = proc_dointvec,
2438 .procname = "error_cost",
2439 .data = &ip_rt_error_cost,
2440 .maxlen = sizeof(int),
2442 .proc_handler = proc_dointvec,
2445 .procname = "error_burst",
2446 .data = &ip_rt_error_burst,
2447 .maxlen = sizeof(int),
2449 .proc_handler = proc_dointvec,
2452 .procname = "gc_elasticity",
2453 .data = &ip_rt_gc_elasticity,
2454 .maxlen = sizeof(int),
2456 .proc_handler = proc_dointvec,
2459 .procname = "mtu_expires",
2460 .data = &ip_rt_mtu_expires,
2461 .maxlen = sizeof(int),
2463 .proc_handler = proc_dointvec_jiffies,
2466 .procname = "min_pmtu",
2467 .data = &ip_rt_min_pmtu,
2468 .maxlen = sizeof(int),
2470 .proc_handler = proc_dointvec,
2473 .procname = "min_adv_mss",
2474 .data = &ip_rt_min_advmss,
2475 .maxlen = sizeof(int),
2477 .proc_handler = proc_dointvec,
2482 static struct ctl_table ipv4_route_flush_table[] = {
2484 .procname = "flush",
2485 .maxlen = sizeof(int),
2487 .proc_handler = ipv4_sysctl_rtcache_flush,
2492 static __net_init int sysctl_route_net_init(struct net *net)
2494 struct ctl_table *tbl;
2496 tbl = ipv4_route_flush_table;
2497 if (!net_eq(net, &init_net)) {
2498 tbl = kmemdup(tbl, sizeof(ipv4_route_flush_table), GFP_KERNEL);
2502 tbl[0].extra1 = net;
2504 net->ipv4.route_hdr = register_net_sysctl(net, "net/ipv4/route", tbl);
2505 if (net->ipv4.route_hdr == NULL)
2510 if (tbl != ipv4_route_flush_table)
2516 static __net_exit void sysctl_route_net_exit(struct net *net)
2518 struct ctl_table *tbl;
2520 tbl = net->ipv4.route_hdr->ctl_table_arg;
2521 unregister_net_sysctl_table(net->ipv4.route_hdr);
2522 BUG_ON(tbl == ipv4_route_flush_table);
2526 static __net_initdata struct pernet_operations sysctl_route_ops = {
2527 .init = sysctl_route_net_init,
2528 .exit = sysctl_route_net_exit,
2532 static __net_init int rt_genid_init(struct net *net)
2534 get_random_bytes(&net->ipv4.rt_genid,
2535 sizeof(net->ipv4.rt_genid));
2536 get_random_bytes(&net->ipv4.dev_addr_genid,
2537 sizeof(net->ipv4.dev_addr_genid));
2541 static __net_initdata struct pernet_operations rt_genid_ops = {
2542 .init = rt_genid_init,
2545 static int __net_init ipv4_inetpeer_init(struct net *net)
2547 struct inet_peer_base *bp = kmalloc(sizeof(*bp), GFP_KERNEL);
2551 inet_peer_base_init(bp);
2552 net->ipv4.peers = bp;
2556 static void __net_exit ipv4_inetpeer_exit(struct net *net)
2558 struct inet_peer_base *bp = net->ipv4.peers;
2560 net->ipv4.peers = NULL;
2561 inetpeer_invalidate_tree(bp);
2565 static __net_initdata struct pernet_operations ipv4_inetpeer_ops = {
2566 .init = ipv4_inetpeer_init,
2567 .exit = ipv4_inetpeer_exit,
2570 #ifdef CONFIG_IP_ROUTE_CLASSID
2571 struct ip_rt_acct __percpu *ip_rt_acct __read_mostly;
2572 #endif /* CONFIG_IP_ROUTE_CLASSID */
2574 int __init ip_rt_init(void)
2578 #ifdef CONFIG_IP_ROUTE_CLASSID
2579 ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
2581 panic("IP: failed to allocate ip_rt_acct\n");
2584 ipv4_dst_ops.kmem_cachep =
2585 kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
2586 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
2588 ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
2590 if (dst_entries_init(&ipv4_dst_ops) < 0)
2591 panic("IP: failed to allocate ipv4_dst_ops counter\n");
2593 if (dst_entries_init(&ipv4_dst_blackhole_ops) < 0)
2594 panic("IP: failed to allocate ipv4_dst_blackhole_ops counter\n");
2596 ipv4_dst_ops.gc_thresh = ~0;
2597 ip_rt_max_size = INT_MAX;
2602 if (ip_rt_proc_init())
2603 pr_err("Unable to create route proc files\n");
2606 xfrm4_init(ip_rt_max_size);
2608 rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL, NULL);
2610 #ifdef CONFIG_SYSCTL
2611 register_pernet_subsys(&sysctl_route_ops);
2613 register_pernet_subsys(&rt_genid_ops);
2614 register_pernet_subsys(&ipv4_inetpeer_ops);
2618 #ifdef CONFIG_SYSCTL
2620 * We really need to sanitize the damn ipv4 init order, then all
2621 * this nonsense will go away.
2623 void __init ip_static_sysctl_init(void)
2625 register_net_sysctl(&init_net, "net/ipv4/route", ipv4_route_table);