Commit | Line | Data |
---|---|---|
b2441318 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
1da177e4 | 2 | /* |
1da177e4 | 3 | * S390 version |
a53c8fab | 4 | * Copyright IBM Corp. 1999, 2000 |
1da177e4 LT |
5 | * Author(s): Hartmut Penner (hp@de.ibm.com), |
6 | * Martin Schwidefsky (schwidefsky@de.ibm.com) | |
7 | * | |
8 | * Derived from "include/asm-i386/uaccess.h" | |
9 | */ | |
10 | #ifndef __S390_UACCESS_H | |
11 | #define __S390_UACCESS_H | |
12 | ||
13 | /* | |
14 | * User space memory access functions | |
15 | */ | |
b5a882fc | 16 | #include <asm/processor.h> |
a0616cde | 17 | #include <asm/ctl_reg.h> |
e70f1d59 | 18 | #include <asm/extable.h> |
1da177e4 LT |
19 | |
20 | ||
21 | /* | |
22 | * The fs value determines whether argument validity checking should be | |
23 | * performed or not. If get_fs() == USER_DS, checking is performed, with | |
24 | * get_fs() == KERNEL_DS, checking is bypassed. | |
25 | * | |
26 | * For historical reasons, these macros are grossly misnamed. | |
27 | */ | |
28 | ||
29 | #define MAKE_MM_SEG(a) ((mm_segment_t) { (a) }) | |
30 | ||
31 | ||
32 | #define KERNEL_DS MAKE_MM_SEG(0) | |
33 | #define USER_DS MAKE_MM_SEG(1) | |
34 | ||
35 | #define get_ds() (KERNEL_DS) | |
36 | #define get_fs() (current->thread.mm_segment) | |
1da177e4 LT |
37 | #define segment_eq(a,b) ((a).ar4 == (b).ar4) |
38 | ||
b5a882fc HC |
39 | static inline void set_fs(mm_segment_t fs) |
40 | { | |
41 | current->thread.mm_segment = fs; | |
db68ce10 | 42 | if (uaccess_kernel()) { |
b5a882fc HC |
43 | set_cpu_flag(CIF_ASCE_SECONDARY); |
44 | __ctl_load(S390_lowcore.kernel_asce, 7, 7); | |
45 | } else { | |
46 | clear_cpu_flag(CIF_ASCE_SECONDARY); | |
47 | __ctl_load(S390_lowcore.user_asce, 7, 7); | |
48 | } | |
49 | } | |
50 | ||
491af990 HC |
51 | static inline int __range_ok(unsigned long addr, unsigned long size) |
52 | { | |
53 | return 1; | |
54 | } | |
55 | ||
56 | #define __access_ok(addr, size) \ | |
57 | ({ \ | |
58 | __chk_user_ptr(addr); \ | |
59 | __range_ok((unsigned long)(addr), (size)); \ | |
7683f744 | 60 | }) |
1da177e4 | 61 | |
7683f744 | 62 | #define access_ok(type, addr, size) __access_ok(addr, size) |
1da177e4 | 63 | |
37096003 AV |
64 | unsigned long __must_check |
65 | raw_copy_from_user(void *to, const void __user *from, unsigned long n); | |
eb608fb3 | 66 | |
37096003 AV |
67 | unsigned long __must_check |
68 | raw_copy_to_user(void __user *to, const void *from, unsigned long n); | |
d02765d1 | 69 | |
37096003 AV |
70 | #define INLINE_COPY_FROM_USER |
71 | #define INLINE_COPY_TO_USER | |
6c1e3e79 | 72 | |
c9ca7841 HC |
73 | #ifdef CONFIG_HAVE_MARCH_Z10_FEATURES |
74 | ||
75 | #define __put_get_user_asm(to, from, size, spec) \ | |
76 | ({ \ | |
77 | register unsigned long __reg0 asm("0") = spec; \ | |
78 | int __rc; \ | |
79 | \ | |
80 | asm volatile( \ | |
81 | "0: mvcos %1,%3,%2\n" \ | |
82 | "1: xr %0,%0\n" \ | |
83 | "2:\n" \ | |
84 | ".pushsection .fixup, \"ax\"\n" \ | |
85 | "3: lhi %0,%5\n" \ | |
86 | " jg 2b\n" \ | |
87 | ".popsection\n" \ | |
88 | EX_TABLE(0b,3b) EX_TABLE(1b,3b) \ | |
d09c5373 | 89 | : "=d" (__rc), "+Q" (*(to)) \ |
c9ca7841 HC |
90 | : "d" (size), "Q" (*(from)), \ |
91 | "d" (__reg0), "K" (-EFAULT) \ | |
92 | : "cc"); \ | |
93 | __rc; \ | |
94 | }) | |
95 | ||
dc4aace1 HC |
96 | static inline int __put_user_fn(void *x, void __user *ptr, unsigned long size) |
97 | { | |
98 | unsigned long spec = 0x810000UL; | |
99 | int rc; | |
100 | ||
101 | switch (size) { | |
102 | case 1: | |
103 | rc = __put_get_user_asm((unsigned char __user *)ptr, | |
104 | (unsigned char *)x, | |
105 | size, spec); | |
106 | break; | |
107 | case 2: | |
108 | rc = __put_get_user_asm((unsigned short __user *)ptr, | |
109 | (unsigned short *)x, | |
110 | size, spec); | |
111 | break; | |
112 | case 4: | |
113 | rc = __put_get_user_asm((unsigned int __user *)ptr, | |
114 | (unsigned int *)x, | |
115 | size, spec); | |
116 | break; | |
117 | case 8: | |
118 | rc = __put_get_user_asm((unsigned long __user *)ptr, | |
119 | (unsigned long *)x, | |
120 | size, spec); | |
121 | break; | |
0b925159 | 122 | } |
dc4aace1 HC |
123 | return rc; |
124 | } | |
125 | ||
126 | static inline int __get_user_fn(void *x, const void __user *ptr, unsigned long size) | |
127 | { | |
128 | unsigned long spec = 0x81UL; | |
129 | int rc; | |
130 | ||
131 | switch (size) { | |
132 | case 1: | |
133 | rc = __put_get_user_asm((unsigned char *)x, | |
134 | (unsigned char __user *)ptr, | |
135 | size, spec); | |
136 | break; | |
137 | case 2: | |
138 | rc = __put_get_user_asm((unsigned short *)x, | |
139 | (unsigned short __user *)ptr, | |
140 | size, spec); | |
141 | break; | |
142 | case 4: | |
143 | rc = __put_get_user_asm((unsigned int *)x, | |
144 | (unsigned int __user *)ptr, | |
145 | size, spec); | |
146 | break; | |
147 | case 8: | |
148 | rc = __put_get_user_asm((unsigned long *)x, | |
149 | (unsigned long __user *)ptr, | |
150 | size, spec); | |
151 | break; | |
0b925159 | 152 | } |
dc4aace1 HC |
153 | return rc; |
154 | } | |
c9ca7841 HC |
155 | |
156 | #else /* CONFIG_HAVE_MARCH_Z10_FEATURES */ | |
157 | ||
211deca6 | 158 | static inline int __put_user_fn(void *x, void __user *ptr, unsigned long size) |
d02765d1 | 159 | { |
37096003 | 160 | size = raw_copy_to_user(ptr, x, size); |
4f41c2b4 | 161 | return size ? -EFAULT : 0; |
d02765d1 GS |
162 | } |
163 | ||
211deca6 | 164 | static inline int __get_user_fn(void *x, const void __user *ptr, unsigned long size) |
d02765d1 | 165 | { |
37096003 | 166 | size = raw_copy_from_user(x, ptr, size); |
4f41c2b4 | 167 | return size ? -EFAULT : 0; |
d02765d1 | 168 | } |
1da177e4 | 169 | |
c9ca7841 HC |
170 | #endif /* CONFIG_HAVE_MARCH_Z10_FEATURES */ |
171 | ||
1da177e4 LT |
172 | /* |
173 | * These are the main single-value transfer routines. They automatically | |
174 | * use the right size if we just have the right pointer type. | |
175 | */ | |
1da177e4 LT |
176 | #define __put_user(x, ptr) \ |
177 | ({ \ | |
178 | __typeof__(*(ptr)) __x = (x); \ | |
d02765d1 | 179 | int __pu_err = -EFAULT; \ |
17566c3c | 180 | __chk_user_ptr(ptr); \ |
1da177e4 LT |
181 | switch (sizeof (*(ptr))) { \ |
182 | case 1: \ | |
183 | case 2: \ | |
184 | case 4: \ | |
185 | case 8: \ | |
cfa785e6 HC |
186 | __pu_err = __put_user_fn(&__x, ptr, \ |
187 | sizeof(*(ptr))); \ | |
1da177e4 LT |
188 | break; \ |
189 | default: \ | |
190 | __put_user_bad(); \ | |
191 | break; \ | |
192 | } \ | |
ee64baf4 | 193 | __builtin_expect(__pu_err, 0); \ |
1da177e4 | 194 | }) |
1da177e4 LT |
195 | |
196 | #define put_user(x, ptr) \ | |
197 | ({ \ | |
dab4079d | 198 | might_fault(); \ |
1da177e4 LT |
199 | __put_user(x, ptr); \ |
200 | }) | |
201 | ||
202 | ||
4f41c2b4 | 203 | int __put_user_bad(void) __attribute__((noreturn)); |
1da177e4 | 204 | |
1da177e4 LT |
205 | #define __get_user(x, ptr) \ |
206 | ({ \ | |
d02765d1 GS |
207 | int __gu_err = -EFAULT; \ |
208 | __chk_user_ptr(ptr); \ | |
1da177e4 | 209 | switch (sizeof(*(ptr))) { \ |
1047aa77 | 210 | case 1: { \ |
fd2d2b19 | 211 | unsigned char __x = 0; \ |
cfa785e6 HC |
212 | __gu_err = __get_user_fn(&__x, ptr, \ |
213 | sizeof(*(ptr))); \ | |
97fa5a66 | 214 | (x) = *(__force __typeof__(*(ptr)) *) &__x; \ |
1047aa77 MS |
215 | break; \ |
216 | }; \ | |
217 | case 2: { \ | |
fd2d2b19 | 218 | unsigned short __x = 0; \ |
cfa785e6 HC |
219 | __gu_err = __get_user_fn(&__x, ptr, \ |
220 | sizeof(*(ptr))); \ | |
97fa5a66 | 221 | (x) = *(__force __typeof__(*(ptr)) *) &__x; \ |
1047aa77 MS |
222 | break; \ |
223 | }; \ | |
224 | case 4: { \ | |
fd2d2b19 | 225 | unsigned int __x = 0; \ |
cfa785e6 HC |
226 | __gu_err = __get_user_fn(&__x, ptr, \ |
227 | sizeof(*(ptr))); \ | |
97fa5a66 | 228 | (x) = *(__force __typeof__(*(ptr)) *) &__x; \ |
1047aa77 MS |
229 | break; \ |
230 | }; \ | |
231 | case 8: { \ | |
fd2d2b19 | 232 | unsigned long long __x = 0; \ |
cfa785e6 HC |
233 | __gu_err = __get_user_fn(&__x, ptr, \ |
234 | sizeof(*(ptr))); \ | |
97fa5a66 | 235 | (x) = *(__force __typeof__(*(ptr)) *) &__x; \ |
1da177e4 | 236 | break; \ |
1047aa77 | 237 | }; \ |
1da177e4 LT |
238 | default: \ |
239 | __get_user_bad(); \ | |
240 | break; \ | |
241 | } \ | |
ee64baf4 | 242 | __builtin_expect(__gu_err, 0); \ |
1da177e4 | 243 | }) |
1da177e4 LT |
244 | |
245 | #define get_user(x, ptr) \ | |
246 | ({ \ | |
dab4079d | 247 | might_fault(); \ |
1da177e4 LT |
248 | __get_user(x, ptr); \ |
249 | }) | |
250 | ||
4f41c2b4 | 251 | int __get_user_bad(void) __attribute__((noreturn)); |
1da177e4 | 252 | |
4f41c2b4 | 253 | unsigned long __must_check |
37096003 | 254 | raw_copy_in_user(void __user *to, const void __user *from, unsigned long n); |
1da177e4 LT |
255 | |
256 | /* | |
257 | * Copy a null terminated string from userspace. | |
258 | */ | |
4f41c2b4 HC |
259 | |
260 | long __strncpy_from_user(char *dst, const char __user *src, long count); | |
261 | ||
f7675ad7 | 262 | static inline long __must_check |
1da177e4 LT |
263 | strncpy_from_user(char *dst, const char __user *src, long count) |
264 | { | |
dab4079d | 265 | might_fault(); |
4f41c2b4 | 266 | return __strncpy_from_user(dst, src, count); |
1da177e4 LT |
267 | } |
268 | ||
211deca6 | 269 | unsigned long __must_check __strnlen_user(const char __user *src, unsigned long count); |
4f41c2b4 | 270 | |
211deca6 | 271 | static inline unsigned long strnlen_user(const char __user *src, unsigned long n) |
1da177e4 | 272 | { |
dab4079d | 273 | might_fault(); |
4f41c2b4 | 274 | return __strnlen_user(src, n); |
1da177e4 LT |
275 | } |
276 | ||
1da177e4 LT |
277 | /* |
278 | * Zero Userspace | |
279 | */ | |
211deca6 | 280 | unsigned long __must_check __clear_user(void __user *to, unsigned long size); |
1da177e4 | 281 | |
211deca6 | 282 | static inline unsigned long __must_check clear_user(void __user *to, unsigned long n) |
1da177e4 | 283 | { |
dab4079d | 284 | might_fault(); |
4f41c2b4 | 285 | return __clear_user(to, n); |
1da177e4 LT |
286 | } |
287 | ||
211deca6 | 288 | int copy_to_user_real(void __user *dest, void *src, unsigned long count); |
8a5d8473 | 289 | void s390_kernel_write(void *dst, const void *src, size_t size); |
a0616cde | 290 | |
1da177e4 | 291 | #endif /* __S390_UACCESS_H */ |