1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * csum_partial_copy - do IP checksumming and copy
4 *
5 * (C) Copyright 1996 Linus Torvalds
6 * accelerated versions (and 21264 assembly versions ) contributed by
7 * Rick Gorton <rick.gorton@alpha-processor.com>
8 *
9 * Don't look at this too closely - you'll go mad. The things
10 * we do for performance..
11 */
12
13 #include <linux/types.h>
14 #include <linux/string.h>
15 #include <linux/uaccess.h>
16 #include <net/checksum.h>
17
18
19 #define ldq_u(x,y) \
20 __asm__ __volatile__("ldq_u %0,%1":"=r" (x):"m" (*(const unsigned long *)(y)))
21
22 #define stq_u(x,y) \
23 __asm__ __volatile__("stq_u %1,%0":"=m" (*(unsigned long *)(y)):"r" (x))
24
25 #define extql(x,y,z) \
26 __asm__ __volatile__("extql %1,%2,%0":"=r" (z):"r" (x),"r" (y))
27
28 #define extqh(x,y,z) \
29 __asm__ __volatile__("extqh %1,%2,%0":"=r" (z):"r" (x),"r" (y))
30
31 #define mskql(x,y,z) \
32 __asm__ __volatile__("mskql %1,%2,%0":"=r" (z):"r" (x),"r" (y))
33
34 #define mskqh(x,y,z) \
35 __asm__ __volatile__("mskqh %1,%2,%0":"=r" (z):"r" (x),"r" (y))
36
37 #define insql(x,y,z) \
38 __asm__ __volatile__("insql %1,%2,%0":"=r" (z):"r" (x),"r" (y))
39
40 #define insqh(x,y,z) \
41 __asm__ __volatile__("insqh %1,%2,%0":"=r" (z):"r" (x),"r" (y))
42
43 #define __get_word(insn,x,ptr) \
44 ({ \
45 long __guu_err; \
46 __asm__ __volatile__( \
47 "1: "#insn" %0,%2\n" \
48 "2:\n" \
49 EXC(1b,2b,%0,%1) \
50 : "=r"(x), "=r"(__guu_err) \
51 : "m"(__m(ptr)), "1"(0)); \
52 __guu_err; \
53 })
54
55 static inline unsigned short from64to16(unsigned long x)
56 {
57 /* Using extract instructions is a bit more efficient
58 than the original shift/bitmask version. */
59
60 union {
61 unsigned long ul;
62 unsigned int ui[2];
63 unsigned short us[4];
64 } in_v, tmp_v, out_v;
65
66 in_v.ul = x;
67 tmp_v.ul = (unsigned long) in_v.ui[0] + (unsigned long) in_v.ui[1];
68
69 /* Since the bits of tmp_v.sh[3] are going to always be zero,
70 we don't have to bother to add that in. */
71 out_v.ul = (unsigned long) tmp_v.us[0] + (unsigned long) tmp_v.us[1]
72 + (unsigned long) tmp_v.us[2];
73
74 /* Similarly, out_v.us[2] is always zero for the final add. */
75 return out_v.us[0] + out_v.us[1];
76 }
77
78
79
80 /*
81 * Ok. This isn't fun, but this is the EASY case.
82 */
83 static inline unsigned long
84 csum_partial_cfu_aligned(const unsigned long __user *src, unsigned long *dst,
85 long len)
86 {
87 unsigned long checksum = ~0U;
88 unsigned long carry = 0;
89
90 while (len >= 0) {
91 unsigned long word;
92 if (__get_word(ldq, word, src))
93 return 0;
94 checksum += carry;
95 src++;
96 checksum += word;
97 len -= 8;
98 carry = checksum < word;
99 *dst = word;
100 dst++;
101 }
102 len += 8;
103 checksum += carry;
104 if (len) {
105 unsigned long word, tmp;
106 if (__get_word(ldq, word, src))
107 return 0;
108 tmp = *dst;
109 mskql(word, len, word);
110 checksum += word;
111 mskqh(tmp, len, tmp);
112 carry = checksum < word;
113 *dst = word | tmp;
114 checksum += carry;
115 }
116 return checksum;
117 }
118
119 /*
120 * This is even less fun, but this is still reasonably
121 * easy.
122 */
123 static inline unsigned long
124 csum_partial_cfu_dest_aligned(const unsigned long __user *src,
125 unsigned long *dst,
126 unsigned long soff,
127 long len)
128 {
129 unsigned long first;
130 unsigned long word, carry;
131 unsigned long lastsrc = 7+len+(unsigned long)src;
132 unsigned long checksum = ~0U;
133
134 if (__get_word(ldq_u, first,src))
135 return 0;
136 carry = 0;
137 while (len >= 0) {
138 unsigned long second;
139
140 if (__get_word(ldq_u, second, src+1))
141 return 0;
142 extql(first, soff, word);
143 len -= 8;
144 src++;
145 extqh(second, soff, first);
146 checksum += carry;
147 word |= first;
148 first = second;
149 checksum += word;
150 *dst = word;
151 dst++;
152 carry = checksum < word;
153 }
154 len += 8;
155 checksum += carry;
156 if (len) {
157 unsigned long tmp;
158 unsigned long second;
159 if (__get_word(ldq_u, second, lastsrc))
160 return 0;
161 tmp = *dst;
162 extql(first, soff, word);
163 extqh(second, soff, first);
164 word |= first;
165 mskql(word, len, word);
166 checksum += word;
167 mskqh(tmp, len, tmp);
168 carry = checksum < word;
169 *dst = word | tmp;
170 checksum += carry;
171 }
172 return checksum;
173 }
174
175 /*
176 * This is slightly less fun than the above..
177 */
178 static inline unsigned long
179 csum_partial_cfu_src_aligned(const unsigned long __user *src,
180 unsigned long *dst,
181 unsigned long doff,
182 long len,
183 unsigned long partial_dest)
184 {
185 unsigned long carry = 0;
186 unsigned long word;
187 unsigned long second_dest;
188 unsigned long checksum = ~0U;
189
190 mskql(partial_dest, doff, partial_dest);
191 while (len >= 0) {
192 if (__get_word(ldq, word, src))
193 return 0;
194 len -= 8;
195 insql(word, doff, second_dest);
196 checksum += carry;
197 stq_u(partial_dest | second_dest, dst);
198 src++;
199 checksum += word;
200 insqh(word, doff, partial_dest);
201 carry = checksum < word;
202 dst++;
203 }
204 len += 8;
205 if (len) {
206 checksum += carry;
207 if (__get_word(ldq, word, src))
208 return 0;
209 mskql(word, len, word);
210 len -= 8;
211 checksum += word;
212 insql(word, doff, second_dest);
213 len += doff;
214 carry = checksum < word;
215 partial_dest |= second_dest;
216 if (len >= 0) {
217 stq_u(partial_dest, dst);
218 if (!len) goto out;
219 dst++;
220 insqh(word, doff, partial_dest);
221 }
222 doff = len;
223 }
224 ldq_u(second_dest, dst);
225 mskqh(second_dest, doff, second_dest);
226 stq_u(partial_dest | second_dest, dst);
227 out:
228 checksum += carry;
229 return checksum;
230 }
231
232 /*
233 * This is so totally un-fun that it's frightening. Don't
234 * look at this too closely, you'll go blind.
235 */
236 static inline unsigned long
237 csum_partial_cfu_unaligned(const unsigned long __user * src,
238 unsigned long * dst,
239 unsigned long soff, unsigned long doff,
240 long len, unsigned long partial_dest)
241 {
242 unsigned long carry = 0;
243 unsigned long first;
244 unsigned long lastsrc;
245 unsigned long checksum = ~0U;
246
247 if (__get_word(ldq_u, first, src))
248 return 0;
249 lastsrc = 7+len+(unsigned long)src;
250 mskql(partial_dest, doff, partial_dest);
251 while (len >= 0) {
252 unsigned long second, word;
253 unsigned long second_dest;
254
255 if (__get_word(ldq_u, second, src+1))
256 return 0;
257 extql(first, soff, word);
258 checksum += carry;
259 len -= 8;
260 extqh(second, soff, first);
261 src++;
262 word |= first;
263 first = second;
264 insql(word, doff, second_dest);
265 checksum += word;
266 stq_u(partial_dest | second_dest, dst);
267 carry = checksum < word;
268 insqh(word, doff, partial_dest);
269 dst++;
270 }
271 len += doff;
272 checksum += carry;
273 if (len >= 0) {
274 unsigned long second, word;
275 unsigned long second_dest;
276
277 if (__get_word(ldq_u, second, lastsrc))
278 return 0;
279 extql(first, soff, word);
280 extqh(second, soff, first);
281 word |= first;
282 first = second;
283 mskql(word, len-doff, word);
284 checksum += word;
285 insql(word, doff, second_dest);
286 carry = checksum < word;
287 stq_u(partial_dest | second_dest, dst);
288 if (len) {
289 ldq_u(second_dest, dst+1);
290 insqh(word, doff, partial_dest);
291 mskqh(second_dest, len, second_dest);
292 stq_u(partial_dest | second_dest, dst+1);
293 }
294 checksum += carry;
295 } else {
296 unsigned long second, word;
297 unsigned long second_dest;
298
299 if (__get_word(ldq_u, second, lastsrc))
300 return 0;
301 extql(first, soff, word);
302 extqh(second, soff, first);
303 word |= first;
304 ldq_u(second_dest, dst);
305 mskql(word, len-doff, word);
306 checksum += word;
307 mskqh(second_dest, len, second_dest);
308 carry = checksum < word;
309 insql(word, doff, word);
310 stq_u(partial_dest | word | second_dest, dst);
311 checksum += carry;
312 }
313 return checksum;
314 }
315
316 static __wsum __csum_and_copy(const void __user *src, void *dst, int len)
317 {
318 unsigned long soff = 7 & (unsigned long) src;
319 unsigned long doff = 7 & (unsigned long) dst;
320 unsigned long checksum;
321
322 if (!doff) {
323 if (!soff)
324 checksum = csum_partial_cfu_aligned(
325 (const unsigned long __user *) src,
326 (unsigned long *) dst, len-8);
327 else
328 checksum = csum_partial_cfu_dest_aligned(
329 (const unsigned long __user *) src,
330 (unsigned long *) dst,
331 soff, len-8);
332 } else {
333 unsigned long partial_dest;
334 ldq_u(partial_dest, dst);
335 if (!soff)
336 checksum = csum_partial_cfu_src_aligned(
337 (const unsigned long __user *) src,
338 (unsigned long *) dst,
339 doff, len-8, partial_dest);
340 else
341 checksum = csum_partial_cfu_unaligned(
342 (const unsigned long __user *) src,
343 (unsigned long *) dst,
344 soff, doff, len-8, partial_dest);
345 }
346 return (__force __wsum)from64to16 (checksum);
347 }
348
349 __wsum
350 csum_and_copy_from_user(const void __user *src, void *dst, int len)
351 {
352 if (!access_ok(src, len))
353 return 0;
354 return __csum_and_copy(src, dst, len);
355 }
356
357 __wsum
358 csum_partial_copy_nocheck(const void *src, void *dst, int len)
359 {
360 return __csum_and_copy((__force const void __user *)src,
361 dst, len);
362 }
363 EXPORT_SYMBOL(csum_partial_copy_nocheck);
364
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.