aboutsummaryrefslogtreecommitdiffstats
path: root/include/asm-s390/uaccess.h
diff options
context:
space:
mode:
Diffstat (limited to 'include/asm-s390/uaccess.h')
-rw-r--r--include/asm-s390/uaccess.h436
1 files changed, 436 insertions, 0 deletions
diff --git a/include/asm-s390/uaccess.h b/include/asm-s390/uaccess.h
new file mode 100644
index 000000000000..a7f43a251f81
--- /dev/null
+++ b/include/asm-s390/uaccess.h
@@ -0,0 +1,436 @@
1/*
2 * include/asm-s390/uaccess.h
3 *
4 * S390 version
5 * Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
6 * Author(s): Hartmut Penner (hp@de.ibm.com),
7 * Martin Schwidefsky (schwidefsky@de.ibm.com)
8 *
9 * Derived from "include/asm-i386/uaccess.h"
10 */
11#ifndef __S390_UACCESS_H
12#define __S390_UACCESS_H
13
14/*
15 * User space memory access functions
16 */
17#include <linux/sched.h>
18#include <linux/errno.h>
19
20#define VERIFY_READ 0
21#define VERIFY_WRITE 1
22
23
24/*
25 * The fs value determines whether argument validity checking should be
26 * performed or not. If get_fs() == USER_DS, checking is performed, with
27 * get_fs() == KERNEL_DS, checking is bypassed.
28 *
29 * For historical reasons, these macros are grossly misnamed.
30 */
31
32#define MAKE_MM_SEG(a) ((mm_segment_t) { (a) })
33
34
35#define KERNEL_DS MAKE_MM_SEG(0)
36#define USER_DS MAKE_MM_SEG(1)
37
38#define get_ds() (KERNEL_DS)
39#define get_fs() (current->thread.mm_segment)
40
41#ifdef __s390x__
42#define set_fs(x) \
43({ \
44 unsigned long __pto; \
45 current->thread.mm_segment = (x); \
46 __pto = current->thread.mm_segment.ar4 ? \
47 S390_lowcore.user_asce : S390_lowcore.kernel_asce; \
48 asm volatile ("lctlg 7,7,%0" : : "m" (__pto) ); \
49})
50#else
51#define set_fs(x) \
52({ \
53 unsigned long __pto; \
54 current->thread.mm_segment = (x); \
55 __pto = current->thread.mm_segment.ar4 ? \
56 S390_lowcore.user_asce : S390_lowcore.kernel_asce; \
57 asm volatile ("lctl 7,7,%0" : : "m" (__pto) ); \
58})
59#endif
60
61#define segment_eq(a,b) ((a).ar4 == (b).ar4)
62
63
64#define __access_ok(addr,size) (1)
65
66#define access_ok(type,addr,size) __access_ok(addr,size)
67
68/* this function will go away soon - use access_ok() instead */
69extern inline int __deprecated verify_area(int type, const void __user *addr,
70 unsigned long size)
71{
72 return access_ok(type, addr, size) ? 0 : -EFAULT;
73}
74
75/*
76 * The exception table consists of pairs of addresses: the first is the
77 * address of an instruction that is allowed to fault, and the second is
78 * the address at which the program should continue. No registers are
79 * modified, so it is entirely up to the continuation code to figure out
80 * what to do.
81 *
82 * All the routines below use bits of fixup code that are out of line
83 * with the main instruction path. This means when everything is well,
84 * we don't even have to jump over them. Further, they do not intrude
85 * on our cache or tlb entries.
86 */
87
88struct exception_table_entry
89{
90 unsigned long insn, fixup;
91};
92
93#ifndef __s390x__
94#define __uaccess_fixup \
95 ".section .fixup,\"ax\"\n" \
96 "2: lhi %0,%4\n" \
97 " bras 1,3f\n" \
98 " .long 1b\n" \
99 "3: l 1,0(1)\n" \
100 " br 1\n" \
101 ".previous\n" \
102 ".section __ex_table,\"a\"\n" \
103 " .align 4\n" \
104 " .long 0b,2b\n" \
105 ".previous"
106#define __uaccess_clobber "cc", "1"
107#else /* __s390x__ */
108#define __uaccess_fixup \
109 ".section .fixup,\"ax\"\n" \
110 "2: lghi %0,%4\n" \
111 " jg 1b\n" \
112 ".previous\n" \
113 ".section __ex_table,\"a\"\n" \
114 " .align 8\n" \
115 " .quad 0b,2b\n" \
116 ".previous"
117#define __uaccess_clobber "cc"
118#endif /* __s390x__ */
119
120/*
121 * These are the main single-value transfer routines. They automatically
122 * use the right size if we just have the right pointer type.
123 */
124#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 2)
125#define __put_user_asm(x, ptr, err) \
126({ \
127 err = 0; \
128 asm volatile( \
129 "0: mvcs 0(%1,%2),%3,%0\n" \
130 "1:\n" \
131 __uaccess_fixup \
132 : "+&d" (err) \
133 : "d" (sizeof(*(ptr))), "a" (ptr), "Q" (x), \
134 "K" (-EFAULT) \
135 : __uaccess_clobber ); \
136})
137#else
138#define __put_user_asm(x, ptr, err) \
139({ \
140 err = 0; \
141 asm volatile( \
142 "0: mvcs 0(%1,%2),0(%3),%0\n" \
143 "1:\n" \
144 __uaccess_fixup \
145 : "+&d" (err) \
146 : "d" (sizeof(*(ptr))), "a" (ptr), "a" (&(x)), \
147 "K" (-EFAULT), "m" (x) \
148 : __uaccess_clobber ); \
149})
150#endif
151
152#ifndef __CHECKER__
153#define __put_user(x, ptr) \
154({ \
155 __typeof__(*(ptr)) __x = (x); \
156 int __pu_err; \
157 switch (sizeof (*(ptr))) { \
158 case 1: \
159 case 2: \
160 case 4: \
161 case 8: \
162 __put_user_asm(__x, ptr, __pu_err); \
163 break; \
164 default: \
165 __put_user_bad(); \
166 break; \
167 } \
168 __pu_err; \
169})
170#else
171#define __put_user(x, ptr) \
172({ \
173 void __user *p; \
174 p = (ptr); \
175 0; \
176})
177#endif
178
179#define put_user(x, ptr) \
180({ \
181 might_sleep(); \
182 __put_user(x, ptr); \
183})
184
185
186extern int __put_user_bad(void) __attribute__((noreturn));
187
188#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 2)
189#define __get_user_asm(x, ptr, err) \
190({ \
191 err = 0; \
192 asm volatile ( \
193 "0: mvcp %O1(%2,%R1),0(%3),%0\n" \
194 "1:\n" \
195 __uaccess_fixup \
196 : "+&d" (err), "=Q" (x) \
197 : "d" (sizeof(*(ptr))), "a" (ptr), \
198 "K" (-EFAULT) \
199 : __uaccess_clobber ); \
200})
201#else
202#define __get_user_asm(x, ptr, err) \
203({ \
204 err = 0; \
205 asm volatile ( \
206 "0: mvcp 0(%2,%5),0(%3),%0\n" \
207 "1:\n" \
208 __uaccess_fixup \
209 : "+&d" (err), "=m" (x) \
210 : "d" (sizeof(*(ptr))), "a" (ptr), \
211 "K" (-EFAULT), "a" (&(x)) \
212 : __uaccess_clobber ); \
213})
214#endif
215
216#ifndef __CHECKER__
217#define __get_user(x, ptr) \
218({ \
219 __typeof__(*(ptr)) __x; \
220 int __gu_err; \
221 switch (sizeof(*(ptr))) { \
222 case 1: \
223 case 2: \
224 case 4: \
225 case 8: \
226 __get_user_asm(__x, ptr, __gu_err); \
227 break; \
228 default: \
229 __get_user_bad(); \
230 break; \
231 } \
232 (x) = __x; \
233 __gu_err; \
234})
235#else
236#define __get_user(x, ptr) \
237({ \
238 void __user *p; \
239 p = (ptr); \
240 0; \
241})
242#endif
243
244
245#define get_user(x, ptr) \
246({ \
247 might_sleep(); \
248 __get_user(x, ptr); \
249})
250
251extern int __get_user_bad(void) __attribute__((noreturn));
252
253#define __put_user_unaligned __put_user
254#define __get_user_unaligned __get_user
255
256extern long __copy_to_user_asm(const void *from, long n, void __user *to);
257
258/**
259 * __copy_to_user: - Copy a block of data into user space, with less checking.
260 * @to: Destination address, in user space.
261 * @from: Source address, in kernel space.
262 * @n: Number of bytes to copy.
263 *
264 * Context: User context only. This function may sleep.
265 *
266 * Copy data from kernel space to user space. Caller must check
267 * the specified block with access_ok() before calling this function.
268 *
269 * Returns number of bytes that could not be copied.
270 * On success, this will be zero.
271 */
272static inline unsigned long
273__copy_to_user(void __user *to, const void *from, unsigned long n)
274{
275 return __copy_to_user_asm(from, n, to);
276}
277
278#define __copy_to_user_inatomic __copy_to_user
279#define __copy_from_user_inatomic __copy_from_user
280
281/**
282 * copy_to_user: - Copy a block of data into user space.
283 * @to: Destination address, in user space.
284 * @from: Source address, in kernel space.
285 * @n: Number of bytes to copy.
286 *
287 * Context: User context only. This function may sleep.
288 *
289 * Copy data from kernel space to user space.
290 *
291 * Returns number of bytes that could not be copied.
292 * On success, this will be zero.
293 */
294static inline unsigned long
295copy_to_user(void __user *to, const void *from, unsigned long n)
296{
297 might_sleep();
298 if (access_ok(VERIFY_WRITE, to, n))
299 n = __copy_to_user(to, from, n);
300 return n;
301}
302
303extern long __copy_from_user_asm(void *to, long n, const void __user *from);
304
305/**
306 * __copy_from_user: - Copy a block of data from user space, with less checking.
307 * @to: Destination address, in kernel space.
308 * @from: Source address, in user space.
309 * @n: Number of bytes to copy.
310 *
311 * Context: User context only. This function may sleep.
312 *
313 * Copy data from user space to kernel space. Caller must check
314 * the specified block with access_ok() before calling this function.
315 *
316 * Returns number of bytes that could not be copied.
317 * On success, this will be zero.
318 *
319 * If some data could not be copied, this function will pad the copied
320 * data to the requested size using zero bytes.
321 */
322static inline unsigned long
323__copy_from_user(void *to, const void __user *from, unsigned long n)
324{
325 return __copy_from_user_asm(to, n, from);
326}
327
328/**
329 * copy_from_user: - Copy a block of data from user space.
330 * @to: Destination address, in kernel space.
331 * @from: Source address, in user space.
332 * @n: Number of bytes to copy.
333 *
334 * Context: User context only. This function may sleep.
335 *
336 * Copy data from user space to kernel space.
337 *
338 * Returns number of bytes that could not be copied.
339 * On success, this will be zero.
340 *
341 * If some data could not be copied, this function will pad the copied
342 * data to the requested size using zero bytes.
343 */
344static inline unsigned long
345copy_from_user(void *to, const void __user *from, unsigned long n)
346{
347 might_sleep();
348 if (access_ok(VERIFY_READ, from, n))
349 n = __copy_from_user(to, from, n);
350 else
351 memset(to, 0, n);
352 return n;
353}
354
355extern unsigned long __copy_in_user_asm(const void __user *from, long n,
356 void __user *to);
357
358static inline unsigned long
359__copy_in_user(void __user *to, const void __user *from, unsigned long n)
360{
361 return __copy_in_user_asm(from, n, to);
362}
363
364static inline unsigned long
365copy_in_user(void __user *to, const void __user *from, unsigned long n)
366{
367 might_sleep();
368 if (__access_ok(from,n) && __access_ok(to,n))
369 n = __copy_in_user_asm(from, n, to);
370 return n;
371}
372
373/*
374 * Copy a null terminated string from userspace.
375 */
376extern long __strncpy_from_user_asm(long count, char *dst,
377 const char __user *src);
378
379static inline long
380strncpy_from_user(char *dst, const char __user *src, long count)
381{
382 long res = -EFAULT;
383 might_sleep();
384 if (access_ok(VERIFY_READ, src, 1))
385 res = __strncpy_from_user_asm(count, dst, src);
386 return res;
387}
388
389
390extern long __strnlen_user_asm(long count, const char __user *src);
391
392static inline unsigned long
393strnlen_user(const char __user * src, unsigned long n)
394{
395 might_sleep();
396 return __strnlen_user_asm(n, src);
397}
398
399/**
400 * strlen_user: - Get the size of a string in user space.
401 * @str: The string to measure.
402 *
403 * Context: User context only. This function may sleep.
404 *
405 * Get the size of a NUL-terminated string in user space.
406 *
407 * Returns the size of the string INCLUDING the terminating NUL.
408 * On exception, returns 0.
409 *
410 * If there is a limit on the length of a valid string, you may wish to
411 * consider using strnlen_user() instead.
412 */
413#define strlen_user(str) strnlen_user(str, ~0UL)
414
415/*
416 * Zero Userspace
417 */
418
419extern long __clear_user_asm(void __user *to, long n);
420
421static inline unsigned long
422__clear_user(void __user *to, unsigned long n)
423{
424 return __clear_user_asm(to, n);
425}
426
427static inline unsigned long
428clear_user(void __user *to, unsigned long n)
429{
430 might_sleep();
431 if (access_ok(VERIFY_WRITE, to, n))
432 n = __clear_user_asm(to, n);
433 return n;
434}
435
436#endif /* __S390_UACCESS_H */
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-16 06:02:15 -0500