2 * include/asm-s390/uaccess.h
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)
9 * Derived from "include/asm-i386/uaccess.h"
11 #ifndef __S390_UACCESS_H
12 #define __S390_UACCESS_H
15 * User space memory access functions
17 #include <linux/sched.h>
18 #include <linux/errno.h>
21 #define VERIFY_WRITE 1
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.
29 * For historical reasons, these macros are grossly misnamed.
32 #define MAKE_MM_SEG(a) ((mm_segment_t) { (a) })
35 #define KERNEL_DS MAKE_MM_SEG(0)
36 #define USER_DS MAKE_MM_SEG(1)
38 #define get_ds() (KERNEL_DS)
39 #define get_fs() (current->thread.mm_segment)
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) ); \
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) ); \
59 #endif /* __s390x__ */
61 #define segment_eq(a,b) ((a).ar4 == (b).ar4)
64 static inline int __access_ok(const void __user *addr, unsigned long size)
68 #define access_ok(type,addr,size) __access_ok(addr,size)
71 * The exception table consists of pairs of addresses: the first is the
72 * address of an instruction that is allowed to fault, and the second is
73 * the address at which the program should continue. No registers are
74 * modified, so it is entirely up to the continuation code to figure out
77 * All the routines below use bits of fixup code that are out of line
78 * with the main instruction path. This means when everything is well,
79 * we don't even have to jump over them. Further, they do not intrude
80 * on our cache or tlb entries.
83 struct exception_table_entry
85 unsigned long insn, fixup;
89 size_t (*copy_from_user)(size_t, const void __user *, void *);
90 size_t (*copy_from_user_small)(size_t, const void __user *, void *);
91 size_t (*copy_to_user)(size_t, void __user *, const void *);
92 size_t (*copy_to_user_small)(size_t, void __user *, const void *);
93 size_t (*copy_in_user)(size_t, void __user *, const void __user *);
94 size_t (*clear_user)(size_t, void __user *);
95 size_t (*strnlen_user)(size_t, const char __user *);
96 size_t (*strncpy_from_user)(size_t, const char __user *, char *);
97 int (*futex_atomic_op)(int op, int __user *, int oparg, int *old);
98 int (*futex_atomic_cmpxchg)(int __user *, int old, int new);
101 extern struct uaccess_ops uaccess;
102 extern struct uaccess_ops uaccess_std;
104 static inline int __put_user_fn(size_t size, void __user *ptr, void *x)
106 size = uaccess.copy_to_user_small(size, ptr, x);
107 return size ? -EFAULT : size;
110 static inline int __get_user_fn(size_t size, const void __user *ptr, void *x)
112 size = uaccess.copy_from_user_small(size, ptr, x);
113 return size ? -EFAULT : size;
117 * These are the main single-value transfer routines. They automatically
118 * use the right size if we just have the right pointer type.
120 #define __put_user(x, ptr) \
122 __typeof__(*(ptr)) __x = (x); \
123 int __pu_err = -EFAULT; \
124 __chk_user_ptr(ptr); \
125 switch (sizeof (*(ptr))) { \
130 __pu_err = __put_user_fn(sizeof (*(ptr)), \
140 #define put_user(x, ptr) \
143 __put_user(x, ptr); \
147 extern int __put_user_bad(void) __attribute__((noreturn));
149 #define __get_user(x, ptr) \
151 int __gu_err = -EFAULT; \
152 __chk_user_ptr(ptr); \
153 switch (sizeof(*(ptr))) { \
156 __gu_err = __get_user_fn(sizeof (*(ptr)), \
158 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
162 unsigned short __x; \
163 __gu_err = __get_user_fn(sizeof (*(ptr)), \
165 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
170 __gu_err = __get_user_fn(sizeof (*(ptr)), \
172 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
176 unsigned long long __x; \
177 __gu_err = __get_user_fn(sizeof (*(ptr)), \
179 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
189 #define get_user(x, ptr) \
192 __get_user(x, ptr); \
195 extern int __get_user_bad(void) __attribute__((noreturn));
197 #define __put_user_unaligned __put_user
198 #define __get_user_unaligned __get_user
201 * __copy_to_user: - Copy a block of data into user space, with less checking.
202 * @to: Destination address, in user space.
203 * @from: Source address, in kernel space.
204 * @n: Number of bytes to copy.
206 * Context: User context only. This function may sleep.
208 * Copy data from kernel space to user space. Caller must check
209 * the specified block with access_ok() before calling this function.
211 * Returns number of bytes that could not be copied.
212 * On success, this will be zero.
214 static inline unsigned long
215 __copy_to_user(void __user *to, const void *from, unsigned long n)
217 if (__builtin_constant_p(n) && (n <= 256))
218 return uaccess.copy_to_user_small(n, to, from);
220 return uaccess.copy_to_user(n, to, from);
223 #define __copy_to_user_inatomic __copy_to_user
224 #define __copy_from_user_inatomic __copy_from_user
227 * copy_to_user: - Copy a block of data into user space.
228 * @to: Destination address, in user space.
229 * @from: Source address, in kernel space.
230 * @n: Number of bytes to copy.
232 * Context: User context only. This function may sleep.
234 * Copy data from kernel space to user space.
236 * Returns number of bytes that could not be copied.
237 * On success, this will be zero.
239 static inline unsigned long
240 copy_to_user(void __user *to, const void *from, unsigned long n)
243 if (access_ok(VERIFY_WRITE, to, n))
244 n = __copy_to_user(to, from, n);
249 * __copy_from_user: - Copy a block of data from user space, with less checking.
250 * @to: Destination address, in kernel space.
251 * @from: Source address, in user space.
252 * @n: Number of bytes to copy.
254 * Context: User context only. This function may sleep.
256 * Copy data from user space to kernel space. Caller must check
257 * the specified block with access_ok() before calling this function.
259 * Returns number of bytes that could not be copied.
260 * On success, this will be zero.
262 * If some data could not be copied, this function will pad the copied
263 * data to the requested size using zero bytes.
265 static inline unsigned long
266 __copy_from_user(void *to, const void __user *from, unsigned long n)
268 if (__builtin_constant_p(n) && (n <= 256))
269 return uaccess.copy_from_user_small(n, from, to);
271 return uaccess.copy_from_user(n, from, to);
275 * copy_from_user: - Copy a block of data from user space.
276 * @to: Destination address, in kernel space.
277 * @from: Source address, in user space.
278 * @n: Number of bytes to copy.
280 * Context: User context only. This function may sleep.
282 * Copy data from user space to kernel space.
284 * Returns number of bytes that could not be copied.
285 * On success, this will be zero.
287 * If some data could not be copied, this function will pad the copied
288 * data to the requested size using zero bytes.
290 static inline unsigned long
291 copy_from_user(void *to, const void __user *from, unsigned long n)
294 if (access_ok(VERIFY_READ, from, n))
295 n = __copy_from_user(to, from, n);
301 static inline unsigned long
302 __copy_in_user(void __user *to, const void __user *from, unsigned long n)
304 return uaccess.copy_in_user(n, to, from);
307 static inline unsigned long
308 copy_in_user(void __user *to, const void __user *from, unsigned long n)
311 if (__access_ok(from,n) && __access_ok(to,n))
312 n = __copy_in_user(to, from, n);
317 * Copy a null terminated string from userspace.
320 strncpy_from_user(char *dst, const char __user *src, long count)
324 if (access_ok(VERIFY_READ, src, 1))
325 res = uaccess.strncpy_from_user(count, src, dst);
329 static inline unsigned long
330 strnlen_user(const char __user * src, unsigned long n)
333 return uaccess.strnlen_user(n, src);
337 * strlen_user: - Get the size of a string in user space.
338 * @str: The string to measure.
340 * Context: User context only. This function may sleep.
342 * Get the size of a NUL-terminated string in user space.
344 * Returns the size of the string INCLUDING the terminating NUL.
345 * On exception, returns 0.
347 * If there is a limit on the length of a valid string, you may wish to
348 * consider using strnlen_user() instead.
350 #define strlen_user(str) strnlen_user(str, ~0UL)
356 static inline unsigned long
357 __clear_user(void __user *to, unsigned long n)
359 return uaccess.clear_user(n, to);
362 static inline unsigned long
363 clear_user(void __user *to, unsigned long n)
366 if (access_ok(VERIFY_WRITE, to, n))
367 n = uaccess.clear_user(n, to);
371 #endif /* __S390_UACCESS_H */