3 * Copyright IBM Corp. 1999, 2000
4 * Author(s): Hartmut Penner (hp@de.ibm.com),
5 * Martin Schwidefsky (schwidefsky@de.ibm.com)
7 * Derived from "include/asm-i386/uaccess.h"
9 #ifndef __S390_UACCESS_H
10 #define __S390_UACCESS_H
13 * User space memory access functions
15 #include <linux/sched.h>
16 #include <linux/errno.h>
17 #include <asm/ctl_reg.h>
20 #define VERIFY_WRITE 1
24 * The fs value determines whether argument validity checking should be
25 * performed or not. If get_fs() == USER_DS, checking is performed, with
26 * get_fs() == KERNEL_DS, checking is bypassed.
28 * For historical reasons, these macros are grossly misnamed.
31 #define MAKE_MM_SEG(a) ((mm_segment_t) { (a) })
34 #define KERNEL_DS MAKE_MM_SEG(0)
35 #define USER_DS MAKE_MM_SEG(1)
37 #define get_ds() (KERNEL_DS)
38 #define get_fs() (current->thread.mm_segment)
42 unsigned long __pto; \
43 current->thread.mm_segment = (x); \
44 __pto = current->thread.mm_segment.ar4 ? \
45 S390_lowcore.user_asce : S390_lowcore.kernel_asce; \
46 __ctl_load(__pto, 7, 7); \
49 #define segment_eq(a,b) ((a).ar4 == (b).ar4)
51 static inline int __range_ok(unsigned long addr
, unsigned long size
)
56 #define __access_ok(addr, size) \
58 __chk_user_ptr(addr); \
59 __range_ok((unsigned long)(addr), (size)); \
62 #define access_ok(type, addr, size) __access_ok(addr, size)
65 * The exception table consists of pairs of addresses: the first is the
66 * address of an instruction that is allowed to fault, and the second is
67 * the address at which the program should continue. No registers are
68 * modified, so it is entirely up to the continuation code to figure out
71 * All the routines below use bits of fixup code that are out of line
72 * with the main instruction path. This means when everything is well,
73 * we don't even have to jump over them. Further, they do not intrude
74 * on our cache or tlb entries.
77 struct exception_table_entry
82 static inline unsigned long extable_insn(const struct exception_table_entry
*x
)
84 return (unsigned long)&x
->insn
+ x
->insn
;
87 static inline unsigned long extable_fixup(const struct exception_table_entry
*x
)
89 return (unsigned long)&x
->fixup
+ x
->fixup
;
92 #define ARCH_HAS_SORT_EXTABLE
93 #define ARCH_HAS_SEARCH_EXTABLE
96 size_t (*copy_from_user
)(size_t, const void __user
*, void *);
97 size_t (*copy_to_user
)(size_t, void __user
*, const void *);
98 size_t (*copy_in_user
)(size_t, void __user
*, const void __user
*);
99 size_t (*clear_user
)(size_t, void __user
*);
100 size_t (*strnlen_user
)(size_t, const char __user
*);
101 size_t (*strncpy_from_user
)(size_t, const char __user
*, char *);
102 int (*futex_atomic_op
)(int op
, u32 __user
*, int oparg
, int *old
);
103 int (*futex_atomic_cmpxchg
)(u32
*, u32 __user
*, u32 old
, u32
new);
106 extern struct uaccess_ops uaccess
;
107 extern struct uaccess_ops uaccess_mvcos
;
108 extern struct uaccess_ops uaccess_pt
;
110 extern int __handle_fault(unsigned long, unsigned long, int);
112 static inline int __put_user_fn(size_t size
, void __user
*ptr
, void *x
)
114 size
= uaccess
.copy_to_user(size
, ptr
, x
);
115 return size
? -EFAULT
: size
;
118 static inline int __get_user_fn(size_t size
, const void __user
*ptr
, void *x
)
120 size
= uaccess
.copy_from_user(size
, ptr
, x
);
121 return size
? -EFAULT
: size
;
125 * These are the main single-value transfer routines. They automatically
126 * use the right size if we just have the right pointer type.
128 #define __put_user(x, ptr) \
130 __typeof__(*(ptr)) __x = (x); \
131 int __pu_err = -EFAULT; \
132 __chk_user_ptr(ptr); \
133 switch (sizeof (*(ptr))) { \
138 __pu_err = __put_user_fn(sizeof (*(ptr)), \
148 #define put_user(x, ptr) \
151 __put_user(x, ptr); \
155 extern int __put_user_bad(void) __attribute__((noreturn
));
157 #define __get_user(x, ptr) \
159 int __gu_err = -EFAULT; \
160 __chk_user_ptr(ptr); \
161 switch (sizeof(*(ptr))) { \
164 __gu_err = __get_user_fn(sizeof (*(ptr)), \
166 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
170 unsigned short __x; \
171 __gu_err = __get_user_fn(sizeof (*(ptr)), \
173 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
178 __gu_err = __get_user_fn(sizeof (*(ptr)), \
180 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
184 unsigned long long __x; \
185 __gu_err = __get_user_fn(sizeof (*(ptr)), \
187 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
197 #define get_user(x, ptr) \
200 __get_user(x, ptr); \
203 extern int __get_user_bad(void) __attribute__((noreturn
));
205 #define __put_user_unaligned __put_user
206 #define __get_user_unaligned __get_user
209 * __copy_to_user: - Copy a block of data into user space, with less checking.
210 * @to: Destination address, in user space.
211 * @from: Source address, in kernel space.
212 * @n: Number of bytes to copy.
214 * Context: User context only. This function may sleep.
216 * Copy data from kernel space to user space. Caller must check
217 * the specified block with access_ok() before calling this function.
219 * Returns number of bytes that could not be copied.
220 * On success, this will be zero.
222 static inline unsigned long __must_check
223 __copy_to_user(void __user
*to
, const void *from
, unsigned long n
)
225 return uaccess
.copy_to_user(n
, to
, from
);
228 #define __copy_to_user_inatomic __copy_to_user
229 #define __copy_from_user_inatomic __copy_from_user
232 * copy_to_user: - Copy a block of data into user space.
233 * @to: Destination address, in user space.
234 * @from: Source address, in kernel space.
235 * @n: Number of bytes to copy.
237 * Context: User context only. This function may sleep.
239 * Copy data from kernel space to user space.
241 * Returns number of bytes that could not be copied.
242 * On success, this will be zero.
244 static inline unsigned long __must_check
245 copy_to_user(void __user
*to
, const void *from
, unsigned long n
)
248 return __copy_to_user(to
, from
, n
);
252 * __copy_from_user: - Copy a block of data from user space, with less checking.
253 * @to: Destination address, in kernel space.
254 * @from: Source address, in user space.
255 * @n: Number of bytes to copy.
257 * Context: User context only. This function may sleep.
259 * Copy data from user space to kernel space. Caller must check
260 * the specified block with access_ok() before calling this function.
262 * Returns number of bytes that could not be copied.
263 * On success, this will be zero.
265 * If some data could not be copied, this function will pad the copied
266 * data to the requested size using zero bytes.
268 static inline unsigned long __must_check
269 __copy_from_user(void *to
, const void __user
*from
, unsigned long n
)
271 return uaccess
.copy_from_user(n
, from
, to
);
274 extern void copy_from_user_overflow(void)
275 #ifdef CONFIG_DEBUG_STRICT_USER_COPY_CHECKS
276 __compiletime_warning("copy_from_user() buffer size is not provably correct")
281 * copy_from_user: - Copy a block of data from user space.
282 * @to: Destination address, in kernel space.
283 * @from: Source address, in user space.
284 * @n: Number of bytes to copy.
286 * Context: User context only. This function may sleep.
288 * Copy data from user space to kernel space.
290 * Returns number of bytes that could not be copied.
291 * On success, this will be zero.
293 * If some data could not be copied, this function will pad the copied
294 * data to the requested size using zero bytes.
296 static inline unsigned long __must_check
297 copy_from_user(void *to
, const void __user
*from
, unsigned long n
)
299 unsigned int sz
= __compiletime_object_size(to
);
302 if (unlikely(sz
!= -1 && sz
< n
)) {
303 copy_from_user_overflow();
306 return __copy_from_user(to
, from
, n
);
309 static inline unsigned long __must_check
310 __copy_in_user(void __user
*to
, const void __user
*from
, unsigned long n
)
312 return uaccess
.copy_in_user(n
, to
, from
);
315 static inline unsigned long __must_check
316 copy_in_user(void __user
*to
, const void __user
*from
, unsigned long n
)
319 return __copy_in_user(to
, from
, n
);
323 * Copy a null terminated string from userspace.
325 static inline long __must_check
326 strncpy_from_user(char *dst
, const char __user
*src
, long count
)
329 return uaccess
.strncpy_from_user(count
, src
, dst
);
332 static inline unsigned long
333 strnlen_user(const char __user
* src
, unsigned long n
)
336 return uaccess
.strnlen_user(n
, src
);
340 * strlen_user: - Get the size of a string in user space.
341 * @str: The string to measure.
343 * Context: User context only. This function may sleep.
345 * Get the size of a NUL-terminated string in user space.
347 * Returns the size of the string INCLUDING the terminating NUL.
348 * On exception, returns 0.
350 * If there is a limit on the length of a valid string, you may wish to
351 * consider using strnlen_user() instead.
353 #define strlen_user(str) strnlen_user(str, ~0UL)
359 static inline unsigned long __must_check
360 __clear_user(void __user
*to
, unsigned long n
)
362 return uaccess
.clear_user(n
, to
);
365 static inline unsigned long __must_check
366 clear_user(void __user
*to
, unsigned long n
)
369 return uaccess
.clear_user(n
, to
);
372 extern int copy_to_user_real(void __user
*dest
, void *src
, size_t count
);
373 extern int copy_from_user_real(void *dest
, void __user
*src
, size_t count
);
375 #endif /* __S390_UACCESS_H */