mk-rootfs.sh

hc

2023-12-11 072de836f53be56a70cecf70b43ae43b7ce17376

 kernel/arch/x86/lib/csum-wrappers_64.c
..
..
@@ -1,6 +1,6 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
1
2
 /*
2
3
  * Copyright 2002, 2003 Andi Kleen, SuSE Labs.
3
- * Subject to the GNU Public License v.2
4
4
  *
5
5
  * Wrappers of assembly checksum functions for x86-64.
6
6
  */
..
..
@@ -10,7 +10,7 @@
10
10
 #include <asm/smap.h>
11
11
 
12
12
 /**
13
- * csum_partial_copy_from_user - Copy and checksum from user space.
13
+ * csum_and_copy_from_user - Copy and checksum from user space.
14
14
  * @src: source address (user space)
15
15
  * @dst: destination address
16
16
  * @len: number of bytes to be copied.
..
..
@@ -21,57 +21,21 @@
21
21
  * src and dst are best aligned to 64bits.
22
22
  */
23
23
 __wsum
24
-csum_partial_copy_from_user(const void __user *src, void *dst,
25
-			    int len, __wsum isum, int *errp)
24
+csum_and_copy_from_user(const void __user *src, void *dst, int len)
26
25
 {
26
+	__wsum sum;
27
+
27
28
 	might_sleep();
28
-	*errp = 0;
29
-
30
-	if (!likely(access_ok(VERIFY_READ, src, len)))
31
-		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
-	if (unlikely((unsigned long)src & 6)) {
42
-		while (((unsigned long)src & 6) && len >= 2) {
43
-			__u16 val16;
44
-
45
-			if (__get_user(val16, (const __u16 __user *)src))
46
-				goto out_err;
47
-
48
-			*(__u16 *)dst = val16;
49
-			isum = (__force __wsum)add32_with_carry(
50
-					(__force unsigned)isum, val16);
51
-			src += 2;
52
-			dst += 2;
53
-			len -= 2;
54
-		}
55
-	}
56
-	stac();
57
-	isum = csum_partial_copy_generic((__force const void *)src,
58
-				dst, len, isum, errp, NULL);
59
-	clac();
60
-	if (unlikely(*errp))
61
-		goto out_err;
62
-
63
-	return isum;
64
-
65
-out_err:
66
-	*errp = -EFAULT;
67
-	memset(dst, 0, len);
68
-
69
-	return isum;
29
+	if (!user_access_begin(src, len))
30
+		return 0;
31
+	sum = csum_partial_copy_generic((__force const void *)src, dst, len);
32
+	user_access_end();
33
+	return sum;
70
34
 }
71
-EXPORT_SYMBOL(csum_partial_copy_from_user);
35
+EXPORT_SYMBOL(csum_and_copy_from_user);
72
36
 
73
37
 /**
74
- * csum_partial_copy_to_user - Copy and checksum to user space.
38
+ * csum_and_copy_to_user - Copy and checksum to user space.
75
39
  * @src: source address
76
40
  * @dst: destination address (user space)
77
41
  * @len: number of bytes to be copied.
..
..
@@ -82,41 +46,18 @@
82
46
  * src and dst are best aligned to 64bits.
83
47
  */
84
48
 __wsum
85
-csum_partial_copy_to_user(const void *src, void __user *dst,
86
-			  int len, __wsum isum, int *errp)
49
+csum_and_copy_to_user(const void *src, void __user *dst, int len)
87
50
 {
88
-	__wsum ret;
51
+	__wsum sum;
89
52
 
90
53
 	might_sleep();
91
-
92
-	if (unlikely(!access_ok(VERIFY_WRITE, dst, len))) {
93
-		*errp = -EFAULT;
54
+	if (!user_access_begin(dst, len))
94
55
 		return 0;
95
-	}
96
-
97
-	if (unlikely((unsigned long)dst & 6)) {
98
-		while (((unsigned long)dst & 6) && len >= 2) {
99
-			__u16 val16 = *(__u16 *)src;
100
-
101
-			isum = (__force __wsum)add32_with_carry(
102
-					(__force unsigned)isum, val16);
103
-			*errp = __put_user(val16, (__u16 __user *)dst);
104
-			if (*errp)
105
-				return isum;
106
-			src += 2;
107
-			dst += 2;
108
-			len -= 2;
109
-		}
110
-	}
111
-
112
-	*errp = 0;
113
-	stac();
114
-	ret = csum_partial_copy_generic(src, (void __force *)dst,
115
-					len, isum, NULL, errp);
116
-	clac();
117
-	return ret;
56
+	sum = csum_partial_copy_generic(src, (void __force *)dst, len);
57
+	user_access_end();
58
+	return sum;
118
59
 }
119
-EXPORT_SYMBOL(csum_partial_copy_to_user);
60
+EXPORT_SYMBOL(csum_and_copy_to_user);
120
61
 
121
62
 /**
122
63
  * csum_partial_copy_nocheck - Copy and checksum.
..
..
@@ -128,9 +69,9 @@
128
69
  * Returns an 32bit unfolded checksum of the buffer.
129
70
  */
130
71
 __wsum
131
-csum_partial_copy_nocheck(const void *src, void *dst, int len, __wsum sum)
72
+csum_partial_copy_nocheck(const void *src, void *dst, int len)
132
73
 {
133
-	return csum_partial_copy_generic(src, dst, len, sum, NULL, NULL);
74
+	return csum_partial_copy_generic(src, dst, len);
134
75
 }
135
76
 EXPORT_SYMBOL(csum_partial_copy_nocheck);
136
77