FreeBSD/Linux Kernel Cross Reference
sys/netns/ns_cksum.c
1 /* $NetBSD: ns_cksum.c,v 1.9 2003/08/07 16:33:45 agc Exp $ */
2
3 /*
4 * Copyright (c) 1982, 1992, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 *
31 * @(#)ns_cksum.c 8.1 (Berkeley) 6/10/93
32 */
33
34 #include <sys/cdefs.h>
35 __KERNEL_RCSID(0, "$NetBSD: ns_cksum.c,v 1.9 2003/08/07 16:33:45 agc Exp $");
36
37 #include <sys/param.h>
38 #include <sys/mbuf.h>
39 #include <netns/ns_var.h>
40
41 /*
42 * Checksum routine for Network Systems Protocol Packets (Big-Endian).
43 *
44 * This routine is very heavily used in the network
45 * code and should be modified for each CPU to be as fast as possible.
46 */
47
48 #define ADDCARRY(x) { if ((x) > 65535) (x) -= 65535; }
49 #define FOLD(x) {l_util.l = (x); (x) = l_util.s[0] + l_util.s[1]; ADDCARRY(x);}
50
51 u_int16_t
52 ns_cksum(m, len)
53 struct mbuf *m;
54 int len;
55 {
56 u_int16_t *w;
57 int sum = 0;
58 int mlen = 0;
59 int sum2;
60
61 union {
62 u_int16_t s[2];
63 int32_t l;
64 } l_util;
65
66 for (;m && len; m = m->m_next) {
67 if (m->m_len == 0)
68 continue;
69 /*
70 * Each trip around loop adds in
71 * word from one mbuf segment.
72 */
73 w = mtod(m, u_int16_t *);
74 if (mlen == -1) {
75 /*
76 * There is a byte left from the last segment;
77 * ones-complement add it into the checksum.
78 */
79 #if BYTE_ORDER == BIG_ENDIAN
80 sum += *(u_int8_t *)w;
81 #else
82 sum += *(u_int8_t *)w << 8;
83 #endif
84 sum += sum;
85 w = (u_int16_t *)(1 + (char *)w);
86 mlen = m->m_len - 1;
87 len--;
88 FOLD(sum);
89 } else
90 mlen = m->m_len;
91 if (len < mlen)
92 mlen = len;
93 len -= mlen;
94 /*
95 * We can do a 16 bit ones complement sum using
96 * 32 bit arithmetic registers for adding,
97 * with carries from the low added
98 * into the high (by normal carry-chaining)
99 * so long as we fold back before 16 carries have occurred.
100 */
101 if (1 & (long) w)
102 goto uuuuglyy;
103 #ifndef TINY
104 /* -DTINY reduces the size from 1250 to 550, but slows it down by 22% */
105 while ((mlen -= 32) >= 0) {
106 sum += w[0]; sum += sum; sum += w[1]; sum += sum;
107 sum += w[2]; sum += sum; sum += w[3]; sum += sum;
108 sum += w[4]; sum += sum; sum += w[5]; sum += sum;
109 sum += w[6]; sum += sum; sum += w[7]; sum += sum;
110 FOLD(sum);
111 sum += w[8]; sum += sum; sum += w[9]; sum += sum;
112 sum += w[10]; sum += sum; sum += w[11]; sum += sum;
113 sum += w[12]; sum += sum; sum += w[13]; sum += sum;
114 sum += w[14]; sum += sum; sum += w[15]; sum += sum;
115 FOLD(sum);
116 w += 16;
117 }
118 mlen += 32;
119 #endif
120 while ((mlen -= 8) >= 0) {
121 sum += w[0]; sum += sum; sum += w[1]; sum += sum;
122 sum += w[2]; sum += sum; sum += w[3]; sum += sum;
123 FOLD(sum);
124 w += 4;
125 }
126 mlen += 8;
127 while ((mlen -= 2) >= 0) {
128 sum += *w++; sum += sum;
129 }
130 goto commoncase;
131 uuuuglyy:
132 #if BYTE_ORDER == BIG_ENDIAN
133 #define ww(n) (((u_int8_t *)w)[n + n + 1])
134 #define vv(n) (((u_int8_t *)w)[n + n])
135 #else
136 #if BYTE_ORDER == LITTLE_ENDIAN
137 #define vv(n) (((u_int8_t *)w)[n + n + 1])
138 #define ww(n) (((u_int8_t *)w)[n + n])
139 #endif
140 #endif
141 sum2 = 0;
142 #ifndef TINY
143 while ((mlen -= 32) >= 0) {
144 sum += ww(0); sum += sum; sum += ww(1); sum += sum;
145 sum += ww(2); sum += sum; sum += ww(3); sum += sum;
146 sum += ww(4); sum += sum; sum += ww(5); sum += sum;
147 sum += ww(6); sum += sum; sum += ww(7); sum += sum;
148 FOLD(sum);
149 sum += ww(8); sum += sum; sum += ww(9); sum += sum;
150 sum += ww(10); sum += sum; sum += ww(11); sum += sum;
151 sum += ww(12); sum += sum; sum += ww(13); sum += sum;
152 sum += ww(14); sum += sum; sum += ww(15); sum += sum;
153 FOLD(sum);
154 sum2 += vv(0); sum2 += sum2; sum2 += vv(1); sum2 += sum2;
155 sum2 += vv(2); sum2 += sum2; sum2 += vv(3); sum2 += sum2;
156 sum2 += vv(4); sum2 += sum2; sum2 += vv(5); sum2 += sum2;
157 sum2 += vv(6); sum2 += sum2; sum2 += vv(7); sum2 += sum2;
158 FOLD(sum2);
159 sum2 += vv(8); sum2 += sum2; sum2 += vv(9); sum2 += sum2;
160 sum2 += vv(10); sum2 += sum2; sum2 += vv(11); sum2 += sum2;
161 sum2 += vv(12); sum2 += sum2; sum2 += vv(13); sum2 += sum2;
162 sum2 += vv(14); sum2 += sum2; sum2 += vv(15); sum2 += sum2;
163 FOLD(sum2);
164 w += 16;
165 }
166 mlen += 32;
167 #endif
168 while ((mlen -= 8) >= 0) {
169 sum += ww(0); sum += sum; sum += ww(1); sum += sum;
170 sum += ww(2); sum += sum; sum += ww(3); sum += sum;
171 FOLD(sum);
172 sum2 += vv(0); sum2 += sum2; sum2 += vv(1); sum2 += sum2;
173 sum2 += vv(2); sum2 += sum2; sum2 += vv(3); sum2 += sum2;
174 FOLD(sum2);
175 w += 4;
176 }
177 mlen += 8;
178 while ((mlen -= 2) >= 0) {
179 sum += ww(0); sum += sum;
180 sum2 += vv(0); sum2 += sum2;
181 w++;
182 }
183 sum += (sum2 << 8);
184 commoncase:
185 if (mlen == -1) {
186 #if BYTE_ORDER == BIG_ENDIAN
187 sum += *(u_int8_t *)w << 8;
188 #else
189 sum += *(u_int8_t *)w;
190 #endif
191 }
192 FOLD(sum);
193 }
194 if (mlen == -1) {
195 /* We had an odd number of bytes to sum; assume a garbage
196 byte of zero and clean up */
197 sum += sum;
198 FOLD(sum);
199 }
200 /*
201 * sum has already been kept to low sixteen bits.
202 * just examine result and exit.
203 */
204 if(sum==0xffff) sum = 0;
205 return (sum);
206 }
Cache object: dce6c1d6c3f5d6d098ccf734d8191740
|