![[BACK]](/icons/back.gif){kind=icon}
Return to in_cksum.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / sparc / sparc|
Return to in_cksum.c CVS log | Up to [local] / sys / arch / sparc / sparc |
1.1 nbrk 1: /* $OpenBSD: in_cksum.c,v 1.11 2005/05/03 00:39:39 brad Exp $ */
2: /* $NetBSD: in_cksum.c,v 1.7 1996/10/05 23:44:34 mrg Exp $ */
3:
4: /*
5: * Copyright (c) 1995 Zubin Dittia.
6: * Copyright (c) 1995 Matthew R. Green.
7: * Copyright (c) 1994 Charles Hannum.
8: * Copyright (c) 1992, 1993
9: * The Regents of the University of California. All rights reserved.
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: * 3. Neither the name of the University nor the names of its contributors
20: * may be used to endorse or promote products derived from this software
21: * without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33: * SUCH DAMAGE.
34: *
35: * @(#)in_cksum.c 8.1 (Berkeley) 6/11/93
36: */
37:
38: #include <sys/param.h>
39: #include <sys/systm.h>
40: #include <sys/mbuf.h>
41: #include <sys/socketvar.h>
42: #include <netinet/in.h>
43: #include <netinet/in_systm.h>
44: #include <netinet/ip.h>
45: #include <netinet/ip_var.h>
46:
47: /*
48: * Checksum routine for Internet Protocol family headers.
49: *
50: * This routine is very heavily used in the network
51: * code and should be modified for each CPU to be as fast as possible.
52: *
53: * SPARC version.
54: */
55:
56: /*
57: * The checksum computation code here is significantly faster than its
58: * vanilla C counterpart (by significantly, I mean 2-3 times faster if
59: * the data is in cache, and 1.5-2 times faster if the data is not in
60: * cache).
61: * We optimize on three fronts:
62: * 1. By using the add-with-carry (addxcc) instruction, we can use
63: * 32-bit operations instead of 16-bit operations.
64: * 2. By unrolling the main loop to reduce branch overheads.
65: * 3. By doing a sequence of load,load,add,add,load,load,add,add,
66: * we can avoid the extra stall cycle which is incurred if the
67: * instruction immediately following a load tries to use the
68: * target register of the load.
69: * Another possible optimization is to replace a pair of 32-bit loads
70: * with a single 64-bit load (ldd) instruction, but I found that although
71: * this improves performance somewhat on Sun4c machines, it actually
72: * reduces performance considerably on Sun4m machines (I don't know why).
73: * So I chose to leave it out.
74: *
75: * Zubin Dittia (zubin@dworkin.wustl.edu)
76: */
77:
78: #define Asm __asm __volatile
79: #define ADD64 Asm(" ld [%4+ 0],%1; ld [%4+ 4],%2; \
80: addcc %0,%1,%0; addxcc %0,%2,%0; \
81: ld [%4+ 8],%1; ld [%4+12],%2; \
82: addxcc %0,%1,%0; addxcc %0,%2,%0; \
83: ld [%4+16],%1; ld [%4+20],%2; \
84: addxcc %0,%1,%0; addxcc %0,%2,%0; \
85: ld [%4+24],%1; ld [%4+28],%2; \
86: addxcc %0,%1,%0; addxcc %0,%2,%0; \
87: ld [%4+32],%1; ld [%4+36],%2; \
88: addxcc %0,%1,%0; addxcc %0,%2,%0; \
89: ld [%4+40],%1; ld [%4+44],%2; \
90: addxcc %0,%1,%0; addxcc %0,%2,%0; \
91: ld [%4+48],%1; ld [%4+52],%2; \
92: addxcc %0,%1,%0; addxcc %0,%2,%0; \
93: ld [%4+56],%1; ld [%4+60],%2; \
94: addxcc %0,%1,%0; addxcc %0,%2,%0; \
95: addxcc %0,0,%0" \
96: : "=r" (sum), "=&r" (tmp1), "=&r" (tmp2)\
97: : "0" (sum), "r" (w))
98: #define ADD32 Asm(" ld [%4+ 0],%1; ld [%4+ 4],%2; \
99: addcc %0,%1,%0; addxcc %0,%2,%0; \
100: ld [%4+ 8],%1; ld [%4+12],%2; \
101: addxcc %0,%1,%0; addxcc %0,%2,%0; \
102: ld [%4+16],%1; ld [%4+20],%2; \
103: addxcc %0,%1,%0; addxcc %0,%2,%0; \
104: ld [%4+24],%1; ld [%4+28],%2; \
105: addxcc %0,%1,%0; addxcc %0,%2,%0; \
106: addxcc %0,0,%0" \
107: : "=r" (sum), "=&r" (tmp1), "=&r" (tmp2)\
108: : "0" (sum), "r" (w))
109: #define ADD16 Asm(" ld [%4+ 0],%1; ld [%4+ 4],%2; \
110: addcc %0,%1,%0; addxcc %0,%2,%0; \
111: ld [%4+ 8],%1; ld [%4+12],%2; \
112: addxcc %0,%1,%0; addxcc %0,%2,%0; \
113: addxcc %0,0,%0" \
114: : "=r" (sum), "=&r" (tmp1), "=&r" (tmp2)\
115: : "0" (sum), "r" (w))
116: #define ADD8 Asm(" ld [%4+ 0],%1; ld [%4+ 4],%2; \
117: addcc %0,%1,%0; addxcc %0,%2,%0; \
118: addxcc %0,0,%0" \
119: : "=r" (sum), "=&r" (tmp1), "=&r" (tmp2)\
120: : "0" (sum), "r" (w))
121: #define ADD4 Asm(" ld [%3+ 0],%1; \
122: addcc %0,%1,%0; \
123: addxcc %0,0,%0" \
124: : "=r" (sum), "=&r" (tmp1) \
125: : "0" (sum), "r" (w))
126:
127: #define REDUCE {sum = (sum & 0xffff) + (sum >> 16);}
128: #define ADDCARRY {if (sum > 0xffff) sum -= 0xffff;}
129: #define ROL {sum = sum << 8;} /* depends on recent REDUCE */
130: #define ADDBYTE {ROL; sum += *w; byte_swapped ^= 1;}
131: #define ADDSHORT {sum += *(u_short *)w;}
132: #define ADVANCE(n) {w += n; mlen -= n;}
133:
134: static __inline__ int
135: in_cksum_internal(struct mbuf *m, int off, int len, u_int sum)
136: {
137: u_char *w;
138: int mlen = 0;
139: int byte_swapped = 0;
140:
141: /*
142: * Declare two temporary registers for use by the asm code. We
143: * allow the compiler to pick which specific machine registers to
144: * use, instead of hard-coding this in the asm code above.
145: */
146: u_int tmp1, tmp2;
147:
148: for (; m && len; m = m->m_next) {
149: if (m->m_len == 0)
150: continue;
151: w = mtod(m, u_char *) + off;
152: mlen = m->m_len - off;
153: off = 0;
154: if (len < mlen)
155: mlen = len;
156: len -= mlen;
157:
158: /*
159: * Ensure that we're aligned on a word boundary here so
160: * that we can do 32 bit operations below.
161: */
162: if ((3 & (long)w) != 0) {
163: REDUCE;
164: if ((1 & (long)w) != 0 && mlen >= 1) {
165: ADDBYTE;
166: ADVANCE(1);
167: }
168: if ((2 & (long)w) != 0 && mlen >= 2) {
169: ADDSHORT;
170: ADVANCE(2);
171: }
172: }
173:
174: /*
175: * Do as many 32 bit operations as possible using the
176: * 64/32/16/8/4 macro's above, using as many as possible of
177: * these.
178: */
179: while (mlen >= 64) {
180: ADD64;
181: ADVANCE(64);
182: }
183: if (mlen >= 32) {
184: ADD32;
185: ADVANCE(32);
186: }
187: if (mlen >= 16) {
188: ADD16;
189: ADVANCE(16);
190: }
191: if (mlen >= 8) {
192: ADD8;
193: ADVANCE(8);
194: }
195: if (mlen >= 4) {
196: ADD4;
197: ADVANCE(4)
198: }
199: if (mlen == 0)
200: continue;
201:
202: REDUCE;
203: if (mlen >= 2) {
204: ADDSHORT;
205: ADVANCE(2);
206: }
207: if (mlen == 1) {
208: ADDBYTE;
209: }
210: }
211: if (byte_swapped) {
212: REDUCE;
213: ROL;
214: }
215: REDUCE;
216: ADDCARRY;
217:
218: return (0xffff ^ sum);
219: }
220:
221: int
222: in_cksum(struct mbuf *m, int len)
223: {
224:
225: return (in_cksum_internal(m, 0, len, 0));
226: }
227:
228: int
229: in4_cksum(struct mbuf *m, u_int8_t nxt, int off, int len)
230: {
231: u_char *w;
232: u_int sum = 0;
233: struct ipovly ipov;
234:
235: /*
236: * Declare two temporary registers for use by the asm code. We
237: * allow the compiler to pick which specific machine registers to
238: * use, instead of hard-coding this in the asm code above.
239: */
240: u_int tmp1, tmp2;
241:
242: if (nxt != 0) {
243: /* pseudo header */
244: memset(&ipov, 0, sizeof(ipov));
245: ipov.ih_len = htons(len);
246: ipov.ih_pr = nxt;
247: ipov.ih_src = mtod(m, struct ip *)->ip_src;
248: ipov.ih_dst = mtod(m, struct ip *)->ip_dst;
249: w = (u_char *)&ipov;
250: /* assumes sizeof(ipov) == 20 */
251: ADD16;
252: w += 16;
253: ADD4;
254: }
255:
256: /* skip unnecessary part */
257: while (m && off > 0) {
258: if (m->m_len > off)
259: break;
260: off -= m->m_len;
261: m = m->m_next;
262: }
263:
264: return (in_cksum_internal(m, off, len, sum));
265: }