route.h File Reference

#include <linux/config.h>
#include <net/dst.h>
#include <net/inetpeer.h>
#include <linux/in_route.h>
#include <linux/rtnetlink.h>
#include <linux/route.h>
#include <linux/ip.h>
#include <linux/cache.h>

Go to the source code of this file.

Classes
struct	rt_key
struct	rtable
struct	ip_rt_acct
struct	rt_cache_stat
Defines
#define	RTO_ONLINK   0x01
#define	RTO_CONN   0
#define	RT_CONN_FLAGS(sk)   (RT_TOS(sk->protinfo.af_inet.tos) | sk->localroute)
#define	IPTOS_RT_MASK   (IPTOS_TOS_MASK & ~3)
Functions
void	ip_rt_init (void)
void	ip_rt_redirect (u32 old_gw, u32 dst, u32 new_gw, u32 src, u8 tos, struct net_device *dev)
void	ip_rt_advice (struct rtable **rp, int advice)
void	rt_cache_flush (int how)
int	ip_route_output_key (struct rtable **, const struct rt_key *key)
int	ip_route_input (struct sk_buff *, u32 dst, u32 src, u8 tos, struct net_device *devin)
unsigned short	ip_rt_frag_needed (struct iphdr *iph, unsigned short new_mtu)
void	ip_rt_update_pmtu (struct dst_entry *dst, unsigned mtu)
void	ip_rt_send_redirect (struct sk_buff *skb)
unsigned	inet_addr_type (u32 addr)
void	ip_rt_multicast_event (struct in_device *)
int	ip_rt_ioctl (unsigned int cmd, void *arg)
void	ip_rt_get_source (u8 *src, struct rtable *rt)
int	ip_rt_dump (struct sk_buff *skb, struct netlink_callback *cb)
int	ip_route_output (struct rtable **rp, u32 daddr, u32 saddr, u32 tos, int oif)
void	ip_rt_put (struct rtable *rt)
char	rt_tos2priority (u8 tos)
int	ip_route_connect (struct rtable **rp, u32 dst, u32 src, u32 tos, int oif)
void	rt_bind_peer (struct rtable *rt, int create)
inet_peer *	rt_get_peer (struct rtable *rt)
Variables
rt_cache_stat	____cacheline_aligned_in_smp
ip_rt_acct *	ip_rt_acct
__u8	ip_tos2prio [16]

---

Define Documentation

#define IPTOS_RT_MASK   (IPTOS_TOS_MASK & ~3)

Definition at line 157 of file route.h. Referenced by ip_route_input(), ip_route_output_key(), ip_route_output_slow(), ip_rt_frag_needed(), and ip_rt_redirect().

#define RT_CONN_FLAGS (  sk   )     (RT_TOS(sk->protinfo.af_inet.tos) | sk->localroute)

Definition at line 46 of file route.h. Referenced by cookie_v4_check(), ip_queue_xmit(), tcp_v4_connect(), tcp_v4_rebuild_header(), tcp_v4_route_req(), and udp_connect().

#define RTO_CONN   0

Definition at line 42 of file route.h. Referenced by masquerade_target().

#define RTO_ONLINK   0x01

Definition at line 40 of file route.h. Referenced by arp_req_delete(), arp_req_set(), ip_route_output_key(), ip_route_output_slow(), raw_sendmsg(), and udp_sendmsg().

---

Function Documentation

unsigned inet_addr_type (  u32  addr  )

Definition at line 171 of file fib_frontend.c. References BADCLASS, fib_res_put(), local_table, MULTICAST, fib_table::tb_lookup, fib_result::type, and ZERONET. Referenced by __ip_vs_update_dest(), arp_constructor(), arp_find(), arp_process(), arp_solicit(), fib_check_nh(), fib_convert_rtentry(), fib_create_info(), fib_del_ifaddr(), fib_rules_policy(), icmp_unreach(), inet_bind(), ip_options_compile(), ip_options_echo(), ip_route_me_harder(), ip_rt_redirect(), ip_vs_leave(), ip_vs_new_dest(), and raw_bind(). { struct rt_key key; struct fib_result res; unsigned ret = RTN_BROADCAST; if (ZERONET(addr) || BADCLASS(addr)) return RTN_BROADCAST; if (MULTICAST(addr)) return RTN_MULTICAST; memset(&key, 0, sizeof(key)); key.dst = addr; #ifdef CONFIG_IP_MULTIPLE_TABLES res.r = NULL; #endif if (local_table) { ret = RTN_UNICAST; if (local_table->tb_lookup(local_table, &key, &res) == 0) { ret = res.type; fib_res_put(&res); } } return ret; }

int ip_route_connect (  struct rtable **  rp, u32  dst, u32  src, u32  tos, int  oif )  [inline, static]

Definition at line 166 of file route.h. References ip_route_output(), and ip_rt_put(). Referenced by tcp_v4_connect(), tcp_v4_reselect_saddr(), and udp_connect(). { int err; err = ip_route_output(rp, dst, src, tos, oif); if (err || (dst && src)) return err; dst = (*rp)->rt_dst; src = (*rp)->rt_src; ip_rt_put(*rp); *rp = NULL; return ip_route_output(rp, dst, src, tos, oif); }

int ip_route_input (  struct sk_buff *  skb, u32  daddr, u32  saddr, u8  tos, struct net_device *  dev )

As a side effect, skb->dst (of type struct dst_entry) is assigned the retrieved routing table entry. Because the first part of a routing table entry (struct rtable) is actually struct dst_entry, a routing table entry can be cast to a dst_entry. Definition at line 1712 of file route.c. References __in_dev_get(), rt_hash_bucket::chain, sk_buff::dst, dst_hold(), net_device::ifindex, IN_DEV_MFORWARD, rt_cache_stat::in_hit, rt_cache_stat::in_hlist_search, inetdev_lock, ip_check_mc(), ip_route_input_mc(), ip_route_input_slow(), IPTOS_RT_MASK, LOCAL_MCAST, MULTICAST, rt_cache_stat, rt_hash_code(), rt_hash_table, and rtable::u. Referenced by arp_process(), fw_in(), inet_rtm_getroute(), ip_options_rcv_srr(), ip_rcv_finish(), ip_route_me_harder(), ipgre_err(), ipip_err(), route_mirror(), and route_reverse(). { struct rtable * rth; unsigned hash; int iif = dev->ifindex; tos &= IPTOS_RT_MASK; hash = rt_hash_code(daddr, saddr ^ (iif << 5), tos); read_lock(&rt_hash_table[hash].lock); for (rth = rt_hash_table[hash].chain; rth; rth = rth->u.rt_next) { if (rth->key.dst == daddr && rth->key.src == saddr && rth->key.iif == iif && rth->key.oif == 0 && #ifdef CONFIG_IP_ROUTE_FWMARK rth->key.fwmark == skb->nfmark && #endif rth->key.tos == tos) { rth->u.dst.lastuse = jiffies; dst_hold(&rth->u.dst); rth->u.dst.__use++; rt_cache_stat[smp_processor_id()].in_hit++; read_unlock(&rt_hash_table[hash].lock); skb->dst = (struct dst_entry*)rth; return 0; } rt_cache_stat[smp_processor_id()].in_hlist_search++; } read_unlock(&rt_hash_table[hash].lock); /* Multicast recognition logic is moved from route cache to here. The problem was that too many Ethernet cards have broken/missing hardware multicast filters :-( As result the host on multicasting network acquires a lot of useless route cache entries, sort of SDR messages from all the world. Now we try to get rid of them. Really, provided software IP multicast filter is organized reasonably (at least, hashed), it does not result in a slowdown comparing with route cache reject entries. Note, that multicast routers are not affected, because route cache entry is created eventually. */ if (MULTICAST(daddr)) { struct in_device *in_dev; read_lock(&inetdev_lock); if ((in_dev = __in_dev_get(dev)) != NULL) { int our = ip_check_mc(in_dev, daddr, saddr); if (our #ifdef CONFIG_IP_MROUTE || (!LOCAL_MCAST(daddr) && IN_DEV_MFORWARD(in_dev)) #endif ) { read_unlock(&inetdev_lock); return ip_route_input_mc(skb, daddr, saddr, tos, dev, our); } } read_unlock(&inetdev_lock); return -EINVAL; } return ip_route_input_slow(skb, daddr, saddr, tos, dev); }

int ip_route_output (  struct rtable **  rp, u32  daddr, u32  saddr, u32  tos, int  oif )  [inline, static]

Definition at line 142 of file route.h. References ip_route_output_key(). Referenced by __ip_vs_get_out_rt(), arp_filter(), arp_req_delete(), arp_req_set(), cookie_v4_check(), do_masquerade(), icmp_reply(), icmp_send(), inet_rtm_getroute(), ip_mc_find_dev(), ip_queue_xmit(), ip_route_connect(), ip_send_reply(), ip_vs_bypass_xmit(), ipgre_err(), ipgre_tunnel_init(), ipgre_tunnel_xmit(), ipip_err(), ipip_tunnel_init(), ipip_tunnel_xmit(), ipmr_queue_xmit(), raw_sendmsg(), send_unreach(), tcp_v4_rebuild_header(), tcp_v4_route_req(), and udp_sendmsg(). { struct rt_key key = { dst:daddr, src:saddr, oif:oif, tos:tos }; return ip_route_output_key(rp, &key); }

int ip_route_output_key (  struct rtable **  , const struct rt_key *  key )

Definition at line 2111 of file route.c. References rt_hash_bucket::chain, rt_key::dst, dst_hold(), ip_route_output_slow(), IPTOS_RT_MASK, rt_key::oif, rt_cache_stat::out_hit, rt_cache_stat::out_hlist_search, rt_cache_stat, rt_hash_code(), rt_hash_table, RTO_ONLINK, rt_key::src, rt_key::tos, and rtable::u. Referenced by ip_route_me_harder(), ip_route_output(), masquerade_target(), route_mirror(), and route_reverse(). { unsigned hash; struct rtable *rth; hash = rt_hash_code(key->dst, key->src ^ (key->oif << 5), key->tos); read_lock_bh(&rt_hash_table[hash].lock); for (rth = rt_hash_table[hash].chain; rth; rth = rth->u.rt_next) { if (rth->key.dst == key->dst && rth->key.src == key->src && rth->key.iif == 0 && rth->key.oif == key->oif && #ifdef CONFIG_IP_ROUTE_FWMARK rth->key.fwmark == key->fwmark && #endif !((rth->key.tos ^ key->tos) & (IPTOS_RT_MASK | RTO_ONLINK))) { rth->u.dst.lastuse = jiffies; dst_hold(&rth->u.dst); rth->u.dst.__use++; rt_cache_stat[smp_processor_id()].out_hit++; read_unlock_bh(&rt_hash_table[hash].lock); *rp = rth; return 0; } rt_cache_stat[smp_processor_id()].out_hlist_search++; } read_unlock_bh(&rt_hash_table[hash].lock); return ip_route_output_slow(rp, key); }

void ip_rt_advice (  struct rtable **  rp, int  advice )

int ip_rt_dump (  struct sk_buff *  skb, struct netlink_callback *  cb )

Definition at line 2315 of file route.c. References netlink_callback::args, rt_hash_bucket::chain, sk_buff::dst, dst_clone(), dst_release(), sk_buff::len, NETLINK_CB, netlink_callback::nlh, nlmsghdr::nlmsg_seq, rt_fill_info(), rt_hash_mask, rt_hash_table, netlink_callback::skb, and rtable::u. Referenced by inet_dump_fib(). { struct rtable *rt; int h, s_h; int idx, s_idx; s_h = cb->args[0]; s_idx = idx = cb->args[1]; for (h = 0; h <= rt_hash_mask; h++) { if (h < s_h) continue; if (h > s_h) s_idx = 0; read_lock_bh(&rt_hash_table[h].lock); for (rt = rt_hash_table[h].chain, idx = 0; rt; rt = rt->u.rt_next, idx++) { if (idx < s_idx) continue; skb->dst = dst_clone(&rt->u.dst); if (rt_fill_info(skb, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq, RTM_NEWROUTE, 1) <= 0) { dst_release(xchg(&skb->dst, NULL)); read_unlock_bh(&rt_hash_table[h].lock); goto done; } dst_release(xchg(&skb->dst, NULL)); } read_unlock_bh(&rt_hash_table[h].lock); } done: cb->args[0] = h; cb->args[1] = idx; return skb->len; }

unsigned short ip_rt_frag_needed (  struct iphdr *  iph, unsigned short  new_mtu )

Definition at line 1108 of file route.c. References rt_hash_bucket::chain, iphdr::daddr, dst_confirm(), dst_set_expires(), guess_mtu(), ip_rt_min_pmtu, ip_rt_mtu_expires, IPTOS_RT_MASK, rt_hash_code(), rt_hash_table, iphdr::saddr, iphdr::tos, iphdr::tot_len, and rtable::u. Referenced by icmp_unreach(). { int i; unsigned short old_mtu = ntohs(iph->tot_len); struct rtable *rth; u32 skeys[2] = { iph->saddr, 0, }; u32 daddr = iph->daddr; u8 tos = iph->tos & IPTOS_RT_MASK; unsigned short est_mtu = 0; if (ipv4_config.no_pmtu_disc) return 0; for (i = 0; i < 2; i++) { unsigned hash = rt_hash_code(daddr, skeys[i], tos); read_lock(&rt_hash_table[hash].lock); for (rth = rt_hash_table[hash].chain; rth; rth = rth->u.rt_next) { if (rth->key.dst == daddr && rth->key.src == skeys[i] && rth->rt_dst == daddr && rth->rt_src == iph->saddr && rth->key.tos == tos && rth->key.iif == 0 && !(rth->u.dst.mxlock & (1 << RTAX_MTU))) { unsigned short mtu = new_mtu; if (new_mtu < 68 || new_mtu >= old_mtu) { /* BSD 4.2 compatibility hack :-( */ if (mtu == 0 && old_mtu >= rth->u.dst.pmtu && old_mtu >= 68 + (iph->ihl << 2)) old_mtu -= iph->ihl << 2; mtu = guess_mtu(old_mtu); } if (mtu <= rth->u.dst.pmtu) { if (mtu < rth->u.dst.pmtu) { dst_confirm(&rth->u.dst); if (mtu < ip_rt_min_pmtu) { mtu = ip_rt_min_pmtu; rth->u.dst.mxlock |= (1 << RTAX_MTU); } rth->u.dst.pmtu = mtu; dst_set_expires(&rth->u.dst, ip_rt_mtu_expires); } est_mtu = mtu; } } } read_unlock(&rt_hash_table[hash].lock); } return est_mtu ? : new_mtu; }

void ip_rt_get_source (  u8 *  src, struct rtable *  rt )

Definition at line 1232 of file route.c. References fib_lookup(), FIB_RES_PREFSRC, fib_res_put(), rt_key::iif, inet_select_addr(), rtable::key, rtable::rt_gateway, rtable::rt_src, fib_result::type, and rtable::u. Referenced by ip_forward_options(), and ip_options_build(). { u32 src; struct fib_result res; if (rt->key.iif == 0) src = rt->rt_src; else if (fib_lookup(&rt->key, &res) == 0) { #ifdef CONFIG_IP_ROUTE_NAT if (res.type == RTN_NAT) src = inet_select_addr(rt->u.dst.dev, rt->rt_gateway, RT_SCOPE_UNIVERSE); else #endif src = FIB_RES_PREFSRC(res); fib_res_put(&res); } else src = inet_select_addr(rt->u.dst.dev, rt->rt_gateway, RT_SCOPE_UNIVERSE); memcpy(addr, &src, 4); }

void ip_rt_init (  void   )

Definition at line 2593 of file route.c. References rt_hash_bucket::chain, devinet_init(), dst_ops::gc_thresh, ip_fib_init(), ip_rt_gc_interval, ip_rt_max_size, ip_rt_secret_interval, ipv4_dst_ops, dst_ops::kmem_cachep, rt_hash_bucket::lock, net_random(), rt_cache_get_info(), rt_cache_stat_get_info(), rt_check_expire, rt_flush_timer, rt_hash_log, rt_hash_mask, rt_hash_rnd, rt_hash_table, rt_periodic_timer, rt_run_flush, rt_secret_rebuild(), and rt_secret_timer. Referenced by ip_init(). { int i, order, goal; rt_hash_rnd = (int) ((num_physpages ^ (num_physpages>>8)) ^ (jiffies ^ (jiffies >> 7))); #ifdef CONFIG_NET_CLS_ROUTE for (order = 0; (PAGE_SIZE << order) < 256 * sizeof(struct ip_rt_acct) * NR_CPUS; order++) /* NOTHING */; ip_rt_acct = (struct ip_rt_acct *)__get_free_pages(GFP_KERNEL, order); if (!ip_rt_acct) panic("IP: failed to allocate ip_rt_acct\n"); memset(ip_rt_acct, 0, PAGE_SIZE << order); #endif ipv4_dst_ops.kmem_cachep = kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0, SLAB_HWCACHE_ALIGN, NULL, NULL); if (!ipv4_dst_ops.kmem_cachep) panic("IP: failed to allocate ip_dst_cache\n"); goal = num_physpages >> (26 - PAGE_SHIFT); for (order = 0; (1UL << order) < goal; order++) /* NOTHING */; do { rt_hash_mask = (1UL << order) * PAGE_SIZE / sizeof(struct rt_hash_bucket); while (rt_hash_mask & (rt_hash_mask - 1)) rt_hash_mask--; rt_hash_table = (struct rt_hash_bucket *) __get_free_pages(GFP_ATOMIC, order); } while (rt_hash_table == NULL && --order > 0); if (!rt_hash_table) panic("Failed to allocate IP route cache hash table\n"); printk(KERN_INFO "IP: routing cache hash table of %u buckets, %ldKbytes\n", rt_hash_mask, (long) (rt_hash_mask * sizeof(struct rt_hash_bucket)) / 1024); for (rt_hash_log = 0; (1 << rt_hash_log) != rt_hash_mask; rt_hash_log++) /* NOTHING */; rt_hash_mask--; for (i = 0; i <= rt_hash_mask; i++) { rt_hash_table[i].lock = RW_LOCK_UNLOCKED; rt_hash_table[i].chain = NULL; } ipv4_dst_ops.gc_thresh = (rt_hash_mask + 1); ip_rt_max_size = (rt_hash_mask + 1) * 16; devinet_init(); ip_fib_init(); rt_flush_timer.function = rt_run_flush; rt_periodic_timer.function = rt_check_expire; rt_secret_timer.function = rt_secret_rebuild; /* All the timers, started at system startup tend to synchronize. Perturb it a bit. */ rt_periodic_timer.expires = jiffies + net_random() % ip_rt_gc_interval + ip_rt_gc_interval; add_timer(&rt_periodic_timer); rt_secret_timer.expires = jiffies + net_random() % ip_rt_secret_interval + ip_rt_secret_interval; add_timer(&rt_secret_timer); proc_net_create ("rt_cache", 0, rt_cache_get_info); proc_net_create ("rt_cache_stat", 0, rt_cache_stat_get_info); #ifdef CONFIG_NET_CLS_ROUTE create_proc_read_entry("net/rt_acct", 0, 0, ip_rt_acct_read, NULL); #endif }

int ip_rt_ioctl (  unsigned int  cmd, void *  arg )

Definition at line 292 of file fib_frontend.c. References fib_convert_rtentry(), fib_get_table(), fib_new_table(), kern_rta::rta_mx, rtnl_lock(), and rtnl_unlock(). Referenced by ic_route_ioctl(), and inet_ioctl(). { int err; struct kern_rta rta; struct rtentry r; struct { struct nlmsghdr nlh; struct rtmsg rtm; } req; switch (cmd) { case SIOCADDRT: /* Add a route */ case SIOCDELRT: /* Delete a route */ if (!capable(CAP_NET_ADMIN)) return -EPERM; if (copy_from_user(&r, arg, sizeof(struct rtentry))) return -EFAULT; rtnl_lock(); err = fib_convert_rtentry(cmd, &req.nlh, &req.rtm, &rta, &r); if (err == 0) { if (cmd == SIOCDELRT) { struct fib_table *tb = fib_get_table(req.rtm.rtm_table); err = -ESRCH; if (tb) err = tb->tb_delete(tb, &req.rtm, &rta, &req.nlh, NULL); } else { struct fib_table *tb = fib_new_table(req.rtm.rtm_table); err = -ENOBUFS; if (tb) err = tb->tb_insert(tb, &req.rtm, &rta, &req.nlh, NULL); } if (rta.rta_mx) kfree(rta.rta_mx); } rtnl_unlock(); return err; } return -EINVAL; }

void ip_rt_multicast_event (  struct in_device *   )

Definition at line 2351 of file route.c. References rt_cache_flush(). Referenced by ip_mc_add1_src(), ip_mc_dec_group(), ip_mc_del1_src(), ip_mc_inc_group(), vif_add(), and vif_delete(). { rt_cache_flush(0); }

void ip_rt_put (  struct rtable *  rt  )  [inline, static]

Definition at line 151 of file route.h. References dst_release(), and rtable::u. Referenced by arp_filter(), arp_req_delete(), arp_req_set(), do_masquerade(), icmp_reply(), icmp_send(), ip_mc_find_dev(), ip_options_rcv_srr(), ip_route_connect(), ip_rt_redirect(), ip_send_reply(), ip_vs_bypass_xmit(), ip_vs_dr_xmit(), ip_vs_in_icmp(), ip_vs_nat_xmit(), ip_vs_tunnel_xmit(), ipgre_err(), ipgre_tunnel_init(), ipgre_tunnel_xmit(), ipip_err(), ipip_tunnel_init(), ipip_tunnel_xmit(), ipmr_queue_xmit(), ipv4_negative_advice(), masquerade_target(), raw_sendmsg(), rt_del(), rt_drop(), send_unreach(), tcp_v4_connect(), tcp_v4_route_req(), udp_connect(), and udp_sendmsg(). { if (rt) dst_release(&rt->u.dst); }

void ip_rt_redirect (  u32  old_gw, u32  dst, u32  new_gw, u32  src, u8  tos, struct net_device *  dev )

Definition at line 840 of file route.c. References arp_bind_neighbour(), BADCLASS, rt_hash_bucket::chain, dev_hold, dst_alloc(), dst_confirm(), dst_hold(), net_device::ifindex, in_dev_get(), IN_DEV_LOG_MARTIANS, in_dev_put(), IN_DEV_RX_REDIRECTS, IN_DEV_SEC_REDIRECTS, IN_DEV_SHARED_MEDIA, inet_addr_onlink(), inet_addr_type(), ip_fib_check_default(), ip_rt_put(), IPTOS_RT_MASK, ipv4_dst_ops, MULTICAST, net_device::name, neigh_event_send(), net_ratelimit(), NUD_VALID, rt_del(), rt_drop(), rt_hash_code(), rt_hash_table, rt_intern_hash(), and ZERONET. Referenced by icmp_redirect(). { int i, k; struct in_device *in_dev = in_dev_get(dev); struct rtable *rth, **rthp; u32 skeys[2] = { saddr, 0 }; int ikeys[2] = { dev->ifindex, 0 }; tos &= IPTOS_RT_MASK; if (!in_dev) return; if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) || MULTICAST(new_gw) || BADCLASS(new_gw) || ZERONET(new_gw)) goto reject_redirect; if (!IN_DEV_SHARED_MEDIA(in_dev)) { if (!inet_addr_onlink(in_dev, new_gw, old_gw)) goto reject_redirect; if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev)) goto reject_redirect; } else { if (inet_addr_type(new_gw) != RTN_UNICAST) goto reject_redirect; } for (i = 0; i < 2; i++) { for (k = 0; k < 2; k++) { unsigned hash = rt_hash_code(daddr, skeys[i] ^ (ikeys[k] << 5), tos); rthp=&rt_hash_table[hash].chain; read_lock(&rt_hash_table[hash].lock); while ((rth = *rthp) != NULL) { struct rtable *rt; if (rth->key.dst != daddr || rth->key.src != skeys[i] || rth->key.tos != tos || rth->key.oif != ikeys[k] || rth->key.iif != 0) { rthp = &rth->u.rt_next; continue; } if (rth->rt_dst != daddr || rth->rt_src != saddr || rth->u.dst.error || rth->rt_gateway != old_gw || rth->u.dst.dev != dev) break; dst_hold(&rth->u.dst); read_unlock(&rt_hash_table[hash].lock); rt = dst_alloc(&ipv4_dst_ops); if (rt == NULL) { ip_rt_put(rth); in_dev_put(in_dev); return; } /* Copy all the information. */ *rt = *rth; rt->u.dst.__use = 1; atomic_set(&rt->u.dst.__refcnt, 1); if (rt->u.dst.dev) dev_hold(rt->u.dst.dev); rt->u.dst.lastuse = jiffies; rt->u.dst.neighbour = NULL; rt->u.dst.hh = NULL; rt->u.dst.obsolete = 0; rt->rt_flags |= RTCF_REDIRECTED; /* Gateway is different ... */ rt->rt_gateway = new_gw; /* Redirect received -> path was valid */ dst_confirm(&rth->u.dst); if (rt->peer) atomic_inc(&rt->peer->refcnt); if (arp_bind_neighbour(&rt->u.dst) || !(rt->u.dst.neighbour->nud_state & NUD_VALID)) { if (rt->u.dst.neighbour) neigh_event_send(rt->u.dst.neighbour, NULL); ip_rt_put(rth); rt_drop(rt); goto do_next; } rt_del(hash, rth); if (!rt_intern_hash(hash, rt, &rt)) ip_rt_put(rt); goto do_next; } read_unlock(&rt_hash_table[hash].lock); do_next: ; } } in_dev_put(in_dev); return; reject_redirect: #ifdef CONFIG_IP_ROUTE_VERBOSE if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) printk(KERN_INFO "Redirect from %u.%u.%u.%u on %s about " "%u.%u.%u.%u ignored.\n" " Advised path = %u.%u.%u.%u -> %u.%u.%u.%u, " "tos %02x\n", NIPQUAD(old_gw), dev->name, NIPQUAD(new_gw), NIPQUAD(saddr), NIPQUAD(daddr), tos); #endif in_dev_put(in_dev); }

void ip_rt_send_redirect (  struct sk_buff *  skb  )

Definition at line 1007 of file route.c. References sk_buff::dst, icmp_send(), in_dev_get(), IN_DEV_LOG_MARTIANS, in_dev_put(), IN_DEV_TX_REDIRECTS, ip_rt_redirect_load, ip_rt_redirect_number, ip_rt_redirect_silence, and net_ratelimit(). Referenced by ip_forward(). { struct rtable *rt = (struct rtable*)skb->dst; struct in_device *in_dev = in_dev_get(rt->u.dst.dev); if (!in_dev) return; if (!IN_DEV_TX_REDIRECTS(in_dev)) goto out; /* No redirected packets during ip_rt_redirect_silence; * reset the algorithm. */ if (time_after(jiffies, rt->u.dst.rate_last + ip_rt_redirect_silence)) rt->u.dst.rate_tokens = 0; /* Too many ignored redirects; do not send anything * set u.dst.rate_last to the last seen redirected packet. */ if (rt->u.dst.rate_tokens >= ip_rt_redirect_number) { rt->u.dst.rate_last = jiffies; goto out; } /* Check for load limit; set rate_last to the latest sent * redirect. */ if (time_after(jiffies, (rt->u.dst.rate_last + (ip_rt_redirect_load << rt->u.dst.rate_tokens)))) { icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, rt->rt_gateway); rt->u.dst.rate_last = jiffies; ++rt->u.dst.rate_tokens; #ifdef CONFIG_IP_ROUTE_VERBOSE if (IN_DEV_LOG_MARTIANS(in_dev) && rt->u.dst.rate_tokens == ip_rt_redirect_number && net_ratelimit()) printk(KERN_WARNING "host %u.%u.%u.%u/if%d ignores " "redirects for %u.%u.%u.%u to %u.%u.%u.%u.\n", NIPQUAD(rt->rt_src), rt->rt_iif, NIPQUAD(rt->rt_dst), NIPQUAD(rt->rt_gateway)); #endif } out: in_dev_put(in_dev); }

void ip_rt_update_pmtu (  struct dst_entry *  dst, unsigned  mtu )

Definition at line 1167 of file route.c. References dst_set_expires(), ip_rt_min_pmtu, ip_rt_mtu_expires, dst_entry::mxlock, and dst_entry::pmtu. Referenced by do_pmtu_discovery(). { if (dst->pmtu > mtu && mtu >= 68 && !(dst->mxlock & (1 << RTAX_MTU))) { if (mtu < ip_rt_min_pmtu) { mtu = ip_rt_min_pmtu; dst->mxlock |= (1 << RTAX_MTU); } dst->pmtu = mtu; dst_set_expires(dst, ip_rt_mtu_expires); } }

void rt_bind_peer (  struct rtable *  rt, int  create )

Definition at line 766 of file route.c. References inet_getpeer(), inet_putpeer(), rtable::peer, and rtable::rt_dst. Referenced by __ip_select_ident(), rt_get_peer(), and tcp_v4_remember_stamp(). { static spinlock_t rt_peer_lock = SPIN_LOCK_UNLOCKED; struct inet_peer *peer; peer = inet_getpeer(rt->rt_dst, create); spin_lock_bh(&rt_peer_lock); if (rt->peer == NULL) { rt->peer = peer; peer = NULL; } spin_unlock_bh(&rt_peer_lock); if (peer) inet_putpeer(peer); }

void rt_cache_flush (  int  how  )

Definition at line 468 of file route.c. References ip_rt_max_delay, ip_rt_min_delay, rt_deadline, rt_flush_lock, rt_flush_timer, and rt_run_flush. Referenced by arp_netdev_event(), fib_disable_ip(), fib_flush(), fib_inetaddr_event(), fib_netdev_event(), fn_hash_delete(), fn_hash_insert(), ip_rt_multicast_event(), and rt_secret_rebuild(). { unsigned long now = jiffies; int user_mode = !in_softirq(); if (delay < 0) delay = ip_rt_min_delay; spin_lock_bh(&rt_flush_lock); if (del_timer(&rt_flush_timer) && delay > 0 && rt_deadline) { long tmo = (long)(rt_deadline - now); /* If flush timer is already running and flush request is not immediate (delay > 0): if deadline is not achieved, prolongate timer to "delay", otherwise fire it at deadline time. */ if (user_mode && tmo < ip_rt_max_delay-ip_rt_min_delay) tmo = 0; if (delay > tmo) delay = tmo; } if (delay <= 0) { spin_unlock_bh(&rt_flush_lock); SMP_TIMER_NAME(rt_run_flush)(0); return; } if (rt_deadline == 0) rt_deadline = now + ip_rt_max_delay; mod_timer(&rt_flush_timer, now+delay); spin_unlock_bh(&rt_flush_lock); }

struct inet_peer* rt_get_peer (  struct rtable *  rt  )  [inline, static]

Definition at line 181 of file route.h. References rtable::peer, and rt_bind_peer(). Referenced by tcp_v4_conn_request(), and tcp_v4_connect(). { if (rt->peer) return rt->peer; rt_bind_peer(rt, 0); return rt->peer; }

char rt_tos2priority (  u8  tos  )  [inline, static]

Definition at line 161 of file route.h. References ip_tos2prio, and IPTOS_TOS. Referenced by ip_forward(), and ip_setsockopt(). { return ip_tos2prio[IPTOS_TOS(tos)>>1]; }

---

Variable Documentation

struct rt_cache_stat ____cacheline_aligned_in_smp

struct ip_rt_acct* ip_rt_acct

__u8 ip_tos2prio[16]

Definition at line 157 of file route.c. Referenced by rt_tos2priority().

---