Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * Copyright 2002, 2003 Andi Kleen, SuSE Labs.
4 : : *
5 : : * Wrappers of assembly checksum functions for x86-64.
6 : : */
7 : : #include <asm/checksum.h>
8 : : #include <linux/export.h>
9 : : #include <linux/uaccess.h>
10 : : #include <asm/smap.h>
11 : :
12 : : /**
13 : : * csum_partial_copy_from_user - Copy and checksum from user space.
14 : : * @src: source address (user space)
15 : : * @dst: destination address
16 : : * @len: number of bytes to be copied.
17 : : * @isum: initial sum that is added into the result (32bit unfolded)
18 : : * @errp: set to -EFAULT for an bad source address.
19 : : *
20 : : * Returns an 32bit unfolded checksum of the buffer.
21 : : * src and dst are best aligned to 64bits.
22 : : */
23 : : __wsum
24 : 0 : csum_partial_copy_from_user(const void __user *src, void *dst,
25 : : int len, __wsum isum, int *errp)
26 : : {
27 : 0 : might_sleep();
28 : 0 : *errp = 0;
29 : :
30 [ # # # # ]: 0 : if (!likely(access_ok(src, len)))
31 : 0 : goto out_err;
32 : :
33 : : /*
34 : : * Why 6, not 7? To handle odd addresses aligned we
35 : : * would need to do considerable complications to fix the
36 : : * checksum which is defined as an 16bit accumulator. The
37 : : * fix alignment code is primarily for performance
38 : : * compatibility with 32bit and that will handle odd
39 : : * addresses slowly too.
40 : : */
41 [ # # ]: 0 : if (unlikely((unsigned long)src & 6)) {
42 [ # # # # ]: 0 : while (((unsigned long)src & 6) && len >= 2) {
43 : 0 : __u16 val16;
44 : :
45 [ # # ]: 0 : if (__get_user(val16, (const __u16 __user *)src))
46 : 0 : goto out_err;
47 : :
48 : 0 : *(__u16 *)dst = val16;
49 : 0 : isum = (__force __wsum)add32_with_carry(
50 : : (__force unsigned)isum, val16);
51 : 0 : src += 2;
52 : 0 : dst += 2;
53 : 0 : len -= 2;
54 : : }
55 : : }
56 : 0 : stac();
57 : 0 : isum = csum_partial_copy_generic((__force const void *)src,
58 : : dst, len, isum, errp, NULL);
59 : 0 : clac();
60 [ # # ]: 0 : if (unlikely(*errp))
61 : 0 : goto out_err;
62 : :
63 : : return isum;
64 : :
65 : 0 : out_err:
66 : 0 : *errp = -EFAULT;
67 : 0 : memset(dst, 0, len);
68 : :
69 : 0 : return isum;
70 : : }
71 : : EXPORT_SYMBOL(csum_partial_copy_from_user);
72 : :
73 : : /**
74 : : * csum_partial_copy_to_user - Copy and checksum to user space.
75 : : * @src: source address
76 : : * @dst: destination address (user space)
77 : : * @len: number of bytes to be copied.
78 : : * @isum: initial sum that is added into the result (32bit unfolded)
79 : : * @errp: set to -EFAULT for an bad destination address.
80 : : *
81 : : * Returns an 32bit unfolded checksum of the buffer.
82 : : * src and dst are best aligned to 64bits.
83 : : */
84 : : __wsum
85 : 0 : csum_partial_copy_to_user(const void *src, void __user *dst,
86 : : int len, __wsum isum, int *errp)
87 : : {
88 : 0 : __wsum ret;
89 : :
90 : 0 : might_sleep();
91 : :
92 [ # # # # ]: 0 : if (unlikely(!access_ok(dst, len))) {
93 : 0 : *errp = -EFAULT;
94 : 0 : return 0;
95 : : }
96 : :
97 [ # # ]: 0 : if (unlikely((unsigned long)dst & 6)) {
98 [ # # # # ]: 0 : while (((unsigned long)dst & 6) && len >= 2) {
99 : 0 : __u16 val16 = *(__u16 *)src;
100 : :
101 : 0 : isum = (__force __wsum)add32_with_carry(
102 : : (__force unsigned)isum, val16);
103 [ # # ]: 0 : *errp = __put_user(val16, (__u16 __user *)dst);
104 [ # # ]: 0 : if (*errp)
105 : 0 : return isum;
106 : 0 : src += 2;
107 : 0 : dst += 2;
108 : 0 : len -= 2;
109 : : }
110 : : }
111 : :
112 : 0 : *errp = 0;
113 : 0 : stac();
114 : 0 : ret = csum_partial_copy_generic(src, (void __force *)dst,
115 : : len, isum, NULL, errp);
116 : 0 : clac();
117 : 0 : return ret;
118 : : }
119 : : EXPORT_SYMBOL(csum_partial_copy_to_user);
120 : :
121 : : /**
122 : : * csum_partial_copy_nocheck - Copy and checksum.
123 : : * @src: source address
124 : : * @dst: destination address
125 : : * @len: number of bytes to be copied.
126 : : * @sum: initial sum that is added into the result (32bit unfolded)
127 : : *
128 : : * Returns an 32bit unfolded checksum of the buffer.
129 : : */
130 : : __wsum
131 : 0 : csum_partial_copy_nocheck(const void *src, void *dst, int len, __wsum sum)
132 : : {
133 : 0 : return csum_partial_copy_generic(src, dst, len, sum, NULL, NULL);
134 : : }
135 : : EXPORT_SYMBOL(csum_partial_copy_nocheck);
136 : :
137 : 0 : __sum16 csum_ipv6_magic(const struct in6_addr *saddr,
138 : : const struct in6_addr *daddr,
139 : : __u32 len, __u8 proto, __wsum sum)
140 : : {
141 : 0 : __u64 rest, sum64;
142 : :
143 : 0 : rest = (__force __u64)htonl(len) + (__force __u64)htons(proto) +
144 : 0 : (__force __u64)sum;
145 : :
146 : 0 : asm(" addq (%[saddr]),%[sum]\n"
147 : : " adcq 8(%[saddr]),%[sum]\n"
148 : : " adcq (%[daddr]),%[sum]\n"
149 : : " adcq 8(%[daddr]),%[sum]\n"
150 : : " adcq $0,%[sum]\n"
151 : :
152 : : : [sum] "=r" (sum64)
153 : : : "[sum]" (rest), [saddr] "r" (saddr), [daddr] "r" (daddr));
154 : :
155 : 0 : return csum_fold(
156 : 0 : (__force __wsum)add32_with_carry(sum64 & 0xffffffff, sum64>>32));
157 : : }
158 : : EXPORT_SYMBOL(csum_ipv6_magic);
|
