![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to route.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / include / net|
Return to route.h CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / include / net |
1.1 root 1: /*
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.
5: *
6: * Definitions for the IP router.
7: *
8: * Version: @(#)route.h 1.0.4 05/27/93
9: *
10: * Authors: Ross Biro, <[email protected]>
11: * Fred N. van Kempen, <[email protected]>
12: * Fixes:
13: * Alan Cox : Reformatted. Added ip_rt_local()
14: * Alan Cox : Support for TCP parameters.
15: * Alexey Kuznetsov: Major changes for new routing code.
16: *
17: * FIXME:
18: * Modules stuff is broken at the moment.
19: * Make atomic ops more generic and hide them in asm/...
20: *
21: * This program is free software; you can redistribute it and/or
22: * modify it under the terms of the GNU General Public License
23: * as published by the Free Software Foundation; either version
24: * 2 of the License, or (at your option) any later version.
25: */
26: #ifndef _ROUTE_H
27: #define _ROUTE_H
28:
29: #include <linux/config.h>
30:
31: /*
32: * 0 - no debugging messages
33: * 1 - rare events and bugs situations (default)
34: * 2 - trace mode.
35: */
36: #define RT_CACHE_DEBUG 1
37:
38: #define RT_HASH_DIVISOR 256
39: #define RT_CACHE_SIZE_MAX 256
40:
41: #define RTZ_HASH_DIVISOR 256
42:
43: #if RT_CACHE_DEBUG >= 2
44: #define RTZ_HASHING_LIMIT 0
45: #else
46: #define RTZ_HASHING_LIMIT 16
47: #endif
48:
49: /*
50: * Maximal time to live for unused entry.
51: */
52: #define RT_CACHE_TIMEOUT (HZ*300)
53:
54: /*
55: * Prevents LRU trashing, entries considered equivalent,
56: * if the difference between last use times is less then this number.
57: */
58: #define RT_CACHE_BUBBLE_THRESHOULD (HZ*5)
59:
60: #include <linux/route.h>
61:
62: #ifdef __KERNEL__
63: #define RTF_LOCAL 0x8000
64: #endif
65:
66: /*
67: * Semaphores.
68: */
69: #if defined(__alpha__)
70:
71: static __inline__ void ATOMIC_INCR(unsigned int * addr)
72: {
73: unsigned tmp;
74:
75: __asm__ __volatile__(
76: "1:\n\
77: ldl_l %1,%2\n\
78: addl %1,1,%1\n\
79: stl_c %1,%0\n\
80: beq %1,1b\n"
81: : "m=" (*addr), "r=&" (tmp)
82: : "m"(*addr));
83: }
84:
85: static __inline__ void ATOMIC_DECR(unsigned int * addr)
86: {
87: unsigned tmp;
88:
89: __asm__ __volatile__(
90: "1:\n\
91: ldl_l %1,%2\n\
92: subl %1,1,%1\n\
93: stl_c %1,%0\n\
94: beq %1,1b\n"
95: : "m=" (*addr), "r=&" (tmp)
96: : "m"(*addr));
97: }
98:
99: static __inline__ int ATOMIC_DECR_AND_CHECK (unsigned int * addr)
100: {
101: unsigned tmp;
102: int result;
103:
104: __asm__ __volatile__(
105: "1:\n\
106: ldl_l %1,%3\n\
107: subl %1,1,%1\n\
108: mov %1,%2\n\
109: stl_c %1,%0\n\
110: beq %1,1b\n"
111: : "m=" (*addr), "r=&" (tmp), "r=&"(result)
112: : "m"(*addr));
113: return result;
114: }
115:
116: #elif defined(__i386__)
117: #include <asm/bitops.h>
118:
119: extern __inline__ void ATOMIC_INCR(void * addr)
120: {
121: __asm__ __volatile__(
122: "incl %0"
123: :"=m" (ADDR));
124: }
125:
126: extern __inline__ void ATOMIC_DECR(void * addr)
127: {
128: __asm__ __volatile__(
129: "decl %0"
130: :"=m" (ADDR));
131: }
132:
133: /*
134: * It is DECR that is ATOMIC, not CHECK!
135: * If you want to do atomic checks, use cli()/sti(). --ANK
136: */
137:
138: extern __inline__ unsigned long ATOMIC_DECR_AND_CHECK(void * addr)
139: {
140: unsigned long retval;
141: __asm__ __volatile__(
142: "decl %0\nmovl %0,%1"
143: : "=m" (ADDR), "=r"(retval));
144: return retval;
145: }
146:
147:
148: #else
149:
150: static __inline__ void ATOMIC_INCR(unsigned int * addr)
151: {
152: (*(__volatile__ unsigned int*)addr)++;
153: }
154:
155: static __inline__ void ATOMIC_DECR(unsigned int * addr)
156: {
157: (*(__volatile__ unsigned int*)addr)--;
158: }
159:
160: static __inline__ int ATOMIC_DECR_AND_CHECK (unsigned int * addr)
161: {
162: ATOMIC_DECR(addr);
163: return *(volatile unsigned int*)addr;
164: }
165:
166: #endif
167:
168:
169:
170: struct rtable
171: {
172: struct rtable *rt_next;
173: __u32 rt_dst;
174: __u32 rt_src;
175: __u32 rt_gateway;
176: unsigned rt_refcnt;
177: unsigned rt_use;
178: unsigned long rt_window;
179: unsigned long rt_lastuse;
180: struct hh_cache *rt_hh;
181: struct device *rt_dev;
182: unsigned short rt_flags;
183: unsigned short rt_mtu;
184: unsigned short rt_irtt;
185: unsigned char rt_tos;
186: };
187:
188: extern void ip_rt_flush(struct device *dev);
189: extern void ip_rt_redirect(__u32 src, __u32 dst, __u32 gw, struct device *dev);
190: extern struct rtable *ip_rt_slow_route(__u32 daddr, int local);
191: extern int rt_get_info(char * buffer, char **start, off_t offset, int length, int dummy);
192: extern int rt_cache_get_info(char *buffer, char **start, off_t offset, int length, int dummy);
193: extern int ip_rt_ioctl(unsigned int cmd, void *arg);
194: extern int ip_rt_new(struct rtentry *rt);
195: extern void ip_rt_check_expire(void);
196: extern void ip_rt_advice(struct rtable **rp, int advice);
197:
198: extern void ip_rt_run_bh(void);
199: extern int ip_rt_lock;
200: extern unsigned ip_rt_bh_mask;
201: extern struct rtable *ip_rt_hash_table[RT_HASH_DIVISOR];
202:
203: extern __inline__ void ip_rt_fast_lock(void)
204: {
205: ATOMIC_INCR(&ip_rt_lock);
206: }
207:
208: extern __inline__ void ip_rt_fast_unlock(void)
209: {
210: ATOMIC_DECR(&ip_rt_lock);
211: }
212:
213: extern __inline__ void ip_rt_unlock(void)
214: {
215: if (!ATOMIC_DECR_AND_CHECK(&ip_rt_lock) && ip_rt_bh_mask)
216: ip_rt_run_bh();
217: }
218:
219: extern __inline__ unsigned ip_rt_hash_code(__u32 addr)
220: {
221: unsigned tmp = addr + (addr>>16);
222: return (tmp + (tmp>>8)) & 0xFF;
223: }
224:
225:
226: extern __inline__ void ip_rt_put(struct rtable * rt)
227: #ifndef MODULE
228: {
229: if (rt)
230: ATOMIC_DECR(&rt->rt_refcnt);
231: }
232: #else
233: ;
234: #endif
235:
236: #ifdef CONFIG_KERNELD
237: extern struct rtable * ip_rt_route(__u32 daddr, int local);
238: #else
239: extern __inline__ struct rtable * ip_rt_route(__u32 daddr, int local)
240: #ifndef MODULE
241: {
242: struct rtable * rth;
243:
244: ip_rt_fast_lock();
245:
246: for (rth=ip_rt_hash_table[ip_rt_hash_code(daddr)^local]; rth; rth=rth->rt_next)
247: {
248: if (rth->rt_dst == daddr)
249: {
250: rth->rt_lastuse = jiffies;
251: ATOMIC_INCR(&rth->rt_use);
252: ATOMIC_INCR(&rth->rt_refcnt);
253: ip_rt_unlock();
254: return rth;
255: }
256: }
257: return ip_rt_slow_route (daddr, local);
258: }
259: #else
260: ;
261: #endif
262: #endif
263:
264: extern __inline__ struct rtable * ip_check_route(struct rtable ** rp,
265: __u32 daddr, int local)
266: {
267: struct rtable * rt = *rp;
268:
269: if (!rt || rt->rt_dst != daddr || !(rt->rt_flags&RTF_UP)
270: || ((local==1)^((rt->rt_flags&RTF_LOCAL) != 0)))
271: {
272: ip_rt_put(rt);
273: rt = ip_rt_route(daddr, local);
274: *rp = rt;
275: }
276: return rt;
277: }
278:
279:
280: #endif /* _ROUTE_H */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.