?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / arch / s390 / include / asm / uaccess.h
blobc6707885e7c238962f451c5c6062767a55bacb1f
1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3 * S390 version
4 * Copyright IBM Corp. 1999, 2000
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 */
16 #include <asm/processor.h>
17 #include <asm/ctl_reg.h>
18 #include <asm/extable.h>
19 #include <asm/facility.h>
20
21 void debug_user_asce(void);
22
23 static inline int __range_ok(unsigned long addr, unsigned long size)
24 {
25 return 1;
26 }
27
28 #define __access_ok(addr, size) \
29 ({ \
30 __chk_user_ptr(addr); \
31 __range_ok((unsigned long)(addr), (size)); \
32 })
33
34 #define access_ok(addr, size) __access_ok(addr, size)
35
36 unsigned long __must_check
37 raw_copy_from_user(void *to, const void __user *from, unsigned long n);
38
39 unsigned long __must_check
40 raw_copy_to_user(void __user *to, const void *from, unsigned long n);
41
42 #ifndef CONFIG_KASAN
43 #define INLINE_COPY_FROM_USER
44 #define INLINE_COPY_TO_USER
45 #endif
46
47 int __put_user_bad(void) __attribute__((noreturn));
48 int __get_user_bad(void) __attribute__((noreturn));
49
50 #ifdef CONFIG_HAVE_MARCH_Z10_FEATURES
51
52 #define __put_get_user_asm(to, from, size, spec) \
53 ({ \
54 register unsigned long __reg0 asm("0") = spec; \
55 int __rc; \
56 \
57 asm volatile( \
58 "0: mvcos %1,%3,%2\n" \
59 "1: xr %0,%0\n" \
60 "2:\n" \
61 ".pushsection .fixup, \"ax\"\n" \
62 "3: lhi %0,%5\n" \
63 " jg 2b\n" \
64 ".popsection\n" \
65 EX_TABLE(0b,3b) EX_TABLE(1b,3b) \
66 : "=d" (__rc), "+Q" (*(to)) \
67 : "d" (size), "Q" (*(from)), \
68 "d" (__reg0), "K" (-EFAULT) \
69 : "cc"); \
70 __rc; \
71 })
72
73 static __always_inline int __put_user_fn(void *x, void __user *ptr, unsigned long size)
74 {
75 unsigned long spec = 0x810000UL;
76 int rc;
77
78 switch (size) {
79 case 1:
80 rc = __put_get_user_asm((unsigned char __user *)ptr,
81 (unsigned char *)x,
82 size, spec);
83 break;
84 case 2:
85 rc = __put_get_user_asm((unsigned short __user *)ptr,
86 (unsigned short *)x,
87 size, spec);
88 break;
89 case 4:
90 rc = __put_get_user_asm((unsigned int __user *)ptr,
91 (unsigned int *)x,
92 size, spec);
93 break;
94 case 8:
95 rc = __put_get_user_asm((unsigned long __user *)ptr,
96 (unsigned long *)x,
97 size, spec);
98 break;
99 default:
100 __put_user_bad();
101 break;
102 }
103 return rc;
104 }
105
106 static __always_inline int __get_user_fn(void *x, const void __user *ptr, unsigned long size)
107 {
108 unsigned long spec = 0x81UL;
109 int rc;
110
111 switch (size) {
112 case 1:
113 rc = __put_get_user_asm((unsigned char *)x,
114 (unsigned char __user *)ptr,
115 size, spec);
116 break;
117 case 2:
118 rc = __put_get_user_asm((unsigned short *)x,
119 (unsigned short __user *)ptr,
120 size, spec);
121 break;
122 case 4:
123 rc = __put_get_user_asm((unsigned int *)x,
124 (unsigned int __user *)ptr,
125 size, spec);
126 break;
127 case 8:
128 rc = __put_get_user_asm((unsigned long *)x,
129 (unsigned long __user *)ptr,
130 size, spec);
131 break;
132 default:
133 __get_user_bad();
134 break;
135 }
136 return rc;
137 }
138
139 #else /* CONFIG_HAVE_MARCH_Z10_FEATURES */
140
141 static inline int __put_user_fn(void *x, void __user *ptr, unsigned long size)
142 {
143 size = raw_copy_to_user(ptr, x, size);
144 return size ? -EFAULT : 0;
145 }
146
147 static inline int __get_user_fn(void *x, const void __user *ptr, unsigned long size)
148 {
149 size = raw_copy_from_user(x, ptr, size);
150 return size ? -EFAULT : 0;
151 }
152
153 #endif /* CONFIG_HAVE_MARCH_Z10_FEATURES */
154
155 /*
156 * These are the main single-value transfer routines. They automatically
157 * use the right size if we just have the right pointer type.
158 */
159 #define __put_user(x, ptr) \
160 ({ \
161 __typeof__(*(ptr)) __x = (x); \
162 int __pu_err = -EFAULT; \
163 __chk_user_ptr(ptr); \
164 switch (sizeof (*(ptr))) { \
165 case 1: \
166 case 2: \
167 case 4: \
168 case 8: \
169 __pu_err = __put_user_fn(&__x, ptr, \
170 sizeof(*(ptr))); \
171 break; \
172 default: \
173 __put_user_bad(); \
174 break; \
175 } \
176 __builtin_expect(__pu_err, 0); \
177 })
178
179 #define put_user(x, ptr) \
180 ({ \
181 might_fault(); \
182 __put_user(x, ptr); \
183 })
184
185
186 #define __get_user(x, ptr) \
187 ({ \
188 int __gu_err = -EFAULT; \
189 __chk_user_ptr(ptr); \
190 switch (sizeof(*(ptr))) { \
191 case 1: { \
192 unsigned char __x = 0; \
193 __gu_err = __get_user_fn(&__x, ptr, \
194 sizeof(*(ptr))); \
195 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
196 break; \
197 }; \
198 case 2: { \
199 unsigned short __x = 0; \
200 __gu_err = __get_user_fn(&__x, ptr, \
201 sizeof(*(ptr))); \
202 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
203 break; \
204 }; \
205 case 4: { \
206 unsigned int __x = 0; \
207 __gu_err = __get_user_fn(&__x, ptr, \
208 sizeof(*(ptr))); \
209 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
210 break; \
211 }; \
212 case 8: { \
213 unsigned long long __x = 0; \
214 __gu_err = __get_user_fn(&__x, ptr, \
215 sizeof(*(ptr))); \
216 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
217 break; \
218 }; \
219 default: \
220 __get_user_bad(); \
221 break; \
222 } \
223 __builtin_expect(__gu_err, 0); \
224 })
225
226 #define get_user(x, ptr) \
227 ({ \
228 might_fault(); \
229 __get_user(x, ptr); \
230 })
231
232 unsigned long __must_check
233 raw_copy_in_user(void __user *to, const void __user *from, unsigned long n);
234
235 /*
236 * Copy a null terminated string from userspace.
237 */
238
239 long __strncpy_from_user(char *dst, const char __user *src, long count);
240
241 static inline long __must_check
242 strncpy_from_user(char *dst, const char __user *src, long count)
243 {
244 might_fault();
245 return __strncpy_from_user(dst, src, count);
246 }
247
248 unsigned long __must_check __strnlen_user(const char __user *src, unsigned long count);
249
250 static inline unsigned long strnlen_user(const char __user *src, unsigned long n)
251 {
252 might_fault();
253 return __strnlen_user(src, n);
254 }
255
256 /*
257 * Zero Userspace
258 */
259 unsigned long __must_check __clear_user(void __user *to, unsigned long size);
260
261 static inline unsigned long __must_check clear_user(void __user *to, unsigned long n)
262 {
263 might_fault();
264 return __clear_user(to, n);
265 }
266
267 int copy_to_user_real(void __user *dest, void *src, unsigned long count);
268 void *s390_kernel_write(void *dst, const void *src, size_t size);
269
270 #define HAVE_GET_KERNEL_NOFAULT
271
272 int __noreturn __put_kernel_bad(void);
273
274 #define __put_kernel_asm(val, to, insn) \
275 ({ \
276 int __rc; \
277 \
278 asm volatile( \
279 "0: " insn " %2,%1\n" \
280 "1: xr %0,%0\n" \
281 "2:\n" \
282 ".pushsection .fixup, \"ax\"\n" \
283 "3: lhi %0,%3\n" \
284 " jg 2b\n" \
285 ".popsection\n" \
286 EX_TABLE(0b,3b) EX_TABLE(1b,3b) \
287 : "=d" (__rc), "+Q" (*(to)) \
288 : "d" (val), "K" (-EFAULT) \
289 : "cc"); \
290 __rc; \
291 })
292
293 #define __put_kernel_nofault(dst, src, type, err_label) \
294 do { \
295 u64 __x = (u64)(*((type *)(src))); \
296 int __pk_err; \
297 \
298 switch (sizeof(type)) { \
299 case 1: \
300 __pk_err = __put_kernel_asm(__x, (type *)(dst), "stc"); \
301 break; \
302 case 2: \
303 __pk_err = __put_kernel_asm(__x, (type *)(dst), "sth"); \
304 break; \
305 case 4: \
306 __pk_err = __put_kernel_asm(__x, (type *)(dst), "st"); \
307 break; \
308 case 8: \
309 __pk_err = __put_kernel_asm(__x, (type *)(dst), "stg"); \
310 break; \
311 default: \
312 __pk_err = __put_kernel_bad(); \
313 break; \
314 } \
315 if (unlikely(__pk_err)) \
316 goto err_label; \
317 } while (0)
318
319 int __noreturn __get_kernel_bad(void);
320
321 #define __get_kernel_asm(val, from, insn) \
322 ({ \
323 int __rc; \
324 \
325 asm volatile( \
326 "0: " insn " %1,%2\n" \
327 "1: xr %0,%0\n" \
328 "2:\n" \
329 ".pushsection .fixup, \"ax\"\n" \
330 "3: lhi %0,%3\n" \
331 " jg 2b\n" \
332 ".popsection\n" \
333 EX_TABLE(0b,3b) EX_TABLE(1b,3b) \
334 : "=d" (__rc), "+d" (val) \
335 : "Q" (*(from)), "K" (-EFAULT) \
336 : "cc"); \
337 __rc; \
338 })
339
340 #define __get_kernel_nofault(dst, src, type, err_label) \
341 do { \
342 int __gk_err; \
343 \
344 switch (sizeof(type)) { \
345 case 1: { \
346 u8 __x = 0; \
347 \
348 __gk_err = __get_kernel_asm(__x, (type *)(src), "ic"); \
349 *((type *)(dst)) = (type)__x; \
350 break; \
351 }; \
352 case 2: { \
353 u16 __x = 0; \
354 \
355 __gk_err = __get_kernel_asm(__x, (type *)(src), "lh"); \
356 *((type *)(dst)) = (type)__x; \
357 break; \
358 }; \
359 case 4: { \
360 u32 __x = 0; \
361 \
362 __gk_err = __get_kernel_asm(__x, (type *)(src), "l"); \
363 *((type *)(dst)) = (type)__x; \
364 break; \
365 }; \
366 case 8: { \
367 u64 __x = 0; \
368 \
369 __gk_err = __get_kernel_asm(__x, (type *)(src), "lg"); \
370 *((type *)(dst)) = (type)__x; \
371 break; \
372 }; \
373 default: \
374 __gk_err = __get_kernel_bad(); \
375 break; \
376 } \
377 if (unlikely(__gk_err)) \
378 goto err_label; \
379 } while (0)
380
381 #endif /* __S390_UACCESS_H */
Linux with added FPC-III support