patch-2.1.15 linux/include/net/route.h

• Lines: 274
• Date: Thu Dec 12 16:54:21 1996
• Orig file: v2.1.14/linux/include/net/route.h
• Orig date: Mon Sep 30 11:24:39 1996

diff -u --recursive --new-file v2.1.14/linux/include/net/route.h linux/include/net/route.h
@@ -14,9 +14,6 @@
  *		Alan Cox	:	Support for TCP parameters.
  *		Alexey Kuznetsov:	Major changes for new routing code.
  *
- *	FIXME:
- *		Make atomic ops more generic and hide them in asm/...
- *
  *		This program is free software; you can redistribute it and/or
  *		modify it under the terms of the GNU General Public License
  *		as published by the Free Software Foundation; either version
@@ -25,25 +22,12 @@
 #ifndef _ROUTE_H
 #define _ROUTE_H
 
-#include <linux/config.h>
+#include <net/ip_fib.h>
+#include <net/dst.h>
 
-/*
- * 0 - no debugging messages
- * 1 - rare events and bugs situations (default)
- * 2 - trace mode.
- */
-#define RT_CACHE_DEBUG		0
 
 #define RT_HASH_DIVISOR	    	256
-#define RT_CACHE_SIZE_MAX    	256
-
-#define RTZ_HASH_DIVISOR	256
-
-#if RT_CACHE_DEBUG >= 2
-#define RTZ_HASHING_LIMIT 0
-#else
-#define RTZ_HASHING_LIMIT 16
-#endif
+#define RT_CACHE_MAX_SIZE    	256
 
 /*
  * Maximal time to live for unused entry.
@@ -51,127 +35,140 @@
 #define RT_CACHE_TIMEOUT		(HZ*300)
 
 /*
+ * Cache invalidations can be delayed by:
+ */
+#define RT_FLUSH_DELAY (2*HZ)
+
+#define RT_REDIRECT_NUMBER		9
+#define RT_REDIRECT_LOAD		(HZ/50)	/* 20 msec */
+#define RT_REDIRECT_SILENCE		(RT_REDIRECT_LOAD<<(RT_REDIRECT_NUMBER+1))
+                                                /* 20sec */
+
+#define RT_ERROR_LOAD			(1*HZ)
+
+
+/*
  * Prevents LRU trashing, entries considered equivalent,
  * if the difference between last use times is less then this number.
  */
-#define RT_CACHE_BUBBLE_THRESHOLD	(HZ*5)
+#define RT_CACHE_BUBBLE_THRESHOLD	(5*HZ)
 
 #include <linux/route.h>
 
-#ifdef __KERNEL__
-#define RTF_LOCAL 0x8000
-#endif
-
 struct rtable 
 {
-	struct rtable		*rt_next;
-	__u32			rt_dst;
-	__u32			rt_src;
-	__u32			rt_gateway;
-	atomic_t		rt_refcnt;
-	atomic_t		rt_use;
-	unsigned long		rt_window;
-	atomic_t		rt_lastuse;
-	struct hh_cache		*rt_hh;
-	struct device		*rt_dev;
-	unsigned short		rt_flags;
-	unsigned short		rt_mtu;
-	unsigned short		rt_irtt;
-	unsigned char		rt_tos;
+	union
+	{
+		struct dst_entry	dst;
+		struct rtable		*rt_next;
+	} u;
+
+	unsigned		rt_flags;
+
+	u32			rt_dst;		/* Path destination	*/
+	u32			rt_src;		/* Path source		*/
+	struct device		*rt_src_dev;	/* Path source device	*/
+
+	/* Info on neighbour */
+	u32			rt_gateway;
+
+	/* Cache lookup keys */
+	struct
+	{
+		u32			dst;
+		u32			src;
+		struct device		*src_dev;
+		struct device		*dst_dev;
+		u8			tos;
+	} key;
+
+	/* Miscellaneous cached information */
+	u32			rt_spec_dst;	/* RFC1122 specific destination */
+	u32			rt_src_map;
+	u32			rt_dst_map;
+
+	/* ICMP statistics */
+	unsigned long		last_error;
+	unsigned long		errors;
 };
 
-extern void		ip_rt_flush(struct device *dev);
-extern void		ip_rt_update(int event, struct device *dev);
-extern void		ip_rt_redirect(__u32 src, __u32 dst, __u32 gw, struct device *dev);
-extern struct rtable	*ip_rt_slow_route(__u32 daddr, int local);
-extern int		rt_get_info(char * buffer, char **start, off_t offset, int length, int dummy);
-extern int		rt_cache_get_info(char *buffer, char **start, off_t offset, int length, int dummy);
-extern int		ip_rt_ioctl(unsigned int cmd, void *arg);
-extern int		ip_rt_new(struct rtentry *rt);
-extern int		ip_rt_kill(struct rtentry *rt);
-extern void		ip_rt_check_expire(void);
-extern void		ip_rt_advice(struct rtable **rp, int advice);
 
-extern void		ip_rt_run_bh(void);
-extern atomic_t	    	ip_rt_lock;
-extern unsigned		ip_rt_bh_mask;
-extern struct rtable 	*ip_rt_hash_table[RT_HASH_DIVISOR];
+#define RTF_IFBRD	(RTF_UP|RTF_MAGIC|RTF_LOCAL|RTF_BROADCAST)
+#define RTF_IFLOCAL	(RTF_UP|RTF_MAGIC|RTF_LOCAL|RTF_INTERFACE)
+#define RTF_IFPREFIX	(RTF_UP|RTF_MAGIC|RTF_INTERFACE)
 
-extern __inline__ void ip_rt_fast_lock(void)
-{
-	atomic_inc(&ip_rt_lock);
-}
+/*
+ *	Flags not visible at user level.
+ */
+#define RTF_INTERNAL	0xFFFF0000
 
-extern __inline__ void ip_rt_fast_unlock(void)
-{
-	atomic_dec(&ip_rt_lock);
-}
+/*
+ *	Flags saved in FIB.
+ */
+#define RTF_FIB		(RTF_UP|RTF_GATEWAY|RTF_REJECT|RTF_THROW|RTF_STATIC|\
+			 RTF_XRESOLVE|RTF_NOPMTUDISC|RTF_NOFORWARD|RTF_INTERNAL)
 
-extern __inline__ void ip_rt_unlock(void)
+extern void		ip_rt_init(void);
+extern void		ip_rt_redirect(u32 old_gw, u32 dst, u32 new_gw,
+				       u32 src, u8 tos, struct device *dev);
+extern void		ip_rt_check_expire(void);
+extern void		ip_rt_advice(struct rtable **rp, int advice);
+extern void		rt_cache_flush(int how);
+extern int		ip_route_output(struct rtable **, u32 dst, u32 src, u8 tos, struct device *devout);
+extern int		ip_route_output_dev(struct rtable **, u32 dst, u32 src, u8 tos, char *devname);
+extern int		ip_route_input(struct sk_buff*, u32 dst, u32 src, u8 tos, struct device *devin);
+extern unsigned short	ip_rt_frag_needed(struct iphdr *iph, unsigned short new_mtu);
+extern void		ip_rt_send_redirect(struct sk_buff *skb);
+
+static __inline__ void ip_rt_put(struct rtable * rt)
 {
-	if (atomic_dec_and_test(&ip_rt_lock) && ip_rt_bh_mask)
-		ip_rt_run_bh();
+	if (rt)
+		dst_release(&rt->u.dst);
 }
 
-extern __inline__ unsigned ip_rt_hash_code(__u32 addr)
+static __inline__ char rt_tos2priority(u8 tos)
 {
-	unsigned tmp = addr + (addr>>16);
-	return (tmp + (tmp>>8)) & 0xFF;
+	if (tos & IPTOS_LOWDELAY)
+		return SOPRI_INTERACTIVE;
+	if (tos & (IPTOS_THROUGHPUT|IPTOS_MINCOST))
+		return SOPRI_BACKGROUND;
+	return SOPRI_NORMAL;
 }
 
 
-extern __inline__ void ip_rt_put(struct rtable * rt)
-#ifndef MODULE
+static __inline__ int ip_route_connect(struct rtable **rp, u32 dst, u32 src, u32 tos)
 {
-	if (rt)
-		atomic_dec(&rt->rt_refcnt);
+	int err;
+	err = ip_route_output(rp, dst, src, tos, NULL);
+	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, NULL);
 }
-#else
-;
-#endif
-
-#ifdef CONFIG_KERNELD
-extern struct rtable * ip_rt_route(__u32 daddr, int local);
-#else
-extern __inline__ struct rtable * ip_rt_route(__u32 daddr, int local)
-#ifndef MODULE
+
+static __inline__ void ip_ll_header(struct sk_buff *skb)
 {
-	struct rtable * rth;
+	struct rtable *rt = (struct rtable*)skb->dst;
+	struct device *dev = rt->u.dst.dev;
+	struct hh_cache *hh = rt->u.dst.hh;
+	int hh_len = dev->hard_header_len;
 
-	ip_rt_fast_lock();
+	skb->dev = dev;
+	skb->arp = 1;
+	skb->protocol = htons(ETH_P_IP);
 
-	for (rth=ip_rt_hash_table[ip_rt_hash_code(daddr)^local]; rth; rth=rth->rt_next)
-	{
-		if (rth->rt_dst == daddr)
-		{
-			rth->rt_lastuse = jiffies;
-			atomic_inc(&rth->rt_use);
-			atomic_inc(&rth->rt_refcnt);
-			ip_rt_unlock();
-			return rth;
-		}
-	}
-	return ip_rt_slow_route (daddr, local);
+	if (hh) {
+		memcpy(skb_push(skb, hh_len), hh->hh_data, hh_len);
+		skb->arp = hh->hh_uptodate;
+	} else if (dev->hard_header &&
+		   dev->hard_header(skb, dev, ETH_P_IP, NULL, NULL, 0)<0)
+		skb->arp = 0;
+		
+	skb->mac.raw = skb->data;
 }
-#else
-;
-#endif
-#endif
-
-extern __inline__ struct rtable * ip_check_route(struct rtable ** rp,
-						       __u32 daddr, int local)
-{
-	struct rtable * rt = *rp;
-
-	if (!rt || rt->rt_dst != daddr || !(rt->rt_flags&RTF_UP)
-	    || ((local==1)^((rt->rt_flags&RTF_LOCAL) != 0)))
-	{
-		ip_rt_put(rt);
-		rt = ip_rt_route(daddr, local);
-		*rp = rt;
-	}
-	return rt;
-}	
 
 
 #endif	/* _ROUTE_H */