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>
19 #include <asm/ctl_reg.h>
22 #define VERIFY_WRITE 1
26 * The fs value determines whether argument validity checking should be
27 * performed or not. If get_fs() == USER_DS, checking is performed, with
28 * get_fs() == KERNEL_DS, checking is bypassed.
30 * For historical reasons, these macros are grossly misnamed.
33 #define MAKE_MM_SEG(a) ((mm_segment_t) { (a) })
36 #define KERNEL_DS MAKE_MM_SEG(0)
37 #define USER_DS MAKE_MM_SEG(1)
39 #define get_ds() (KERNEL_DS)
40 #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 __ctl_load(__pto, 7, 7); \
51 #define segment_eq(a,b) ((a).ar4 == (b).ar4)
53 static inline int __range_ok(unsigned long addr
, unsigned long size
)
58 #define __access_ok(addr, size) \
60 __chk_user_ptr(addr); \
61 __range_ok((unsigned long)(addr), (size)); \
64 #define access_ok(type, addr, size) __access_ok(addr, size)
67 * The exception table consists of pairs of addresses: the first is the
68 * address of an instruction that is allowed to fault, and the second is
69 * the address at which the program should continue. No registers are
70 * modified, so it is entirely up to the continuation code to figure out
73 * All the routines below use bits of fixup code that are out of line
74 * with the main instruction path. This means when everything is well,
75 * we don't even have to jump over them. Further, they do not intrude
76 * on our cache or tlb entries.
79 struct exception_table_entry
81 unsigned long insn
, fixup
;
85 size_t (*copy_from_user
)(size_t, const void __user
*, void *);
86 size_t (*copy_from_user_small
)(size_t, const void __user
*, void *);
87 size_t (*copy_to_user
)(size_t, void __user
*, const void *);
88 size_t (*copy_to_user_small
)(size_t, void __user
*, const void *);
89 size_t (*copy_in_user
)(size_t, void __user
*, const void __user
*);
90 size_t (*clear_user
)(size_t, void __user
*);
91 size_t (*strnlen_user
)(size_t, const char __user
*);
92 size_t (*strncpy_from_user
)(size_t, const char __user
*, char *);
93 int (*futex_atomic_op
)(int op
, u32 __user
*, int oparg
, int *old
);
94 int (*futex_atomic_cmpxchg
)(u32
*, u32 __user
*, u32 old
, u32
new);
97 extern struct uaccess_ops uaccess
;
98 extern struct uaccess_ops uaccess_std
;
99 extern struct uaccess_ops uaccess_mvcos
;
100 extern struct uaccess_ops uaccess_mvcos_switch
;
101 extern struct uaccess_ops uaccess_pt
;
103 extern int __handle_fault(unsigned long, unsigned long, int);
105 static inline int __put_user_fn(size_t size
, void __user
*ptr
, void *x
)
107 size
= uaccess
.copy_to_user_small(size
, ptr
, x
);
108 return size
? -EFAULT
: size
;
111 static inline int __get_user_fn(size_t size
, const void __user
*ptr
, void *x
)
113 size
= uaccess
.copy_from_user_small(size
, ptr
, x
);
114 return size
? -EFAULT
: size
;
118 * These are the main single-value transfer routines. They automatically
119 * use the right size if we just have the right pointer type.
121 #define __put_user(x, ptr) \
123 __typeof__(*(ptr)) __x = (x); \
124 int __pu_err = -EFAULT; \
125 __chk_user_ptr(ptr); \
126 switch (sizeof (*(ptr))) { \
131 __pu_err = __put_user_fn(sizeof (*(ptr)), \
141 #define put_user(x, ptr) \
144 __put_user(x, ptr); \
148 extern int __put_user_bad(void) __attribute__((noreturn
));
150 #define __get_user(x, ptr) \
152 int __gu_err = -EFAULT; \
153 __chk_user_ptr(ptr); \
154 switch (sizeof(*(ptr))) { \
157 __gu_err = __get_user_fn(sizeof (*(ptr)), \
159 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
163 unsigned short __x; \
164 __gu_err = __get_user_fn(sizeof (*(ptr)), \
166 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
171 __gu_err = __get_user_fn(sizeof (*(ptr)), \
173 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
177 unsigned long long __x; \
178 __gu_err = __get_user_fn(sizeof (*(ptr)), \
180 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
190 #define get_user(x, ptr) \
193 __get_user(x, ptr); \
196 extern int __get_user_bad(void) __attribute__((noreturn
));
198 #define __put_user_unaligned __put_user
199 #define __get_user_unaligned __get_user
202 * __copy_to_user: - Copy a block of data into user space, with less checking.
203 * @to: Destination address, in user space.
204 * @from: Source address, in kernel space.
205 * @n: Number of bytes to copy.
207 * Context: User context only. This function may sleep.
209 * Copy data from kernel space to user space. Caller must check
210 * the specified block with access_ok() before calling this function.
212 * Returns number of bytes that could not be copied.
213 * On success, this will be zero.
215 static inline unsigned long __must_check
216 __copy_to_user(void __user
*to
, const void *from
, unsigned long n
)
218 if (__builtin_constant_p(n
) && (n
<= 256))
219 return uaccess
.copy_to_user_small(n
, to
, from
);
221 return uaccess
.copy_to_user(n
, to
, from
);
224 #define __copy_to_user_inatomic __copy_to_user
225 #define __copy_from_user_inatomic __copy_from_user
228 * copy_to_user: - Copy a block of data into user space.
229 * @to: Destination address, in user space.
230 * @from: Source address, in kernel space.
231 * @n: Number of bytes to copy.
233 * Context: User context only. This function may sleep.
235 * Copy data from kernel space to user space.
237 * Returns number of bytes that could not be copied.
238 * On success, this will be zero.
240 static inline unsigned long __must_check
241 copy_to_user(void __user
*to
, const void *from
, unsigned long n
)
244 if (access_ok(VERIFY_WRITE
, to
, n
))
245 n
= __copy_to_user(to
, from
, n
);
250 * __copy_from_user: - Copy a block of data from user space, with less checking.
251 * @to: Destination address, in kernel space.
252 * @from: Source address, in user space.
253 * @n: Number of bytes to copy.
255 * Context: User context only. This function may sleep.
257 * Copy data from user space to kernel space. Caller must check
258 * the specified block with access_ok() before calling this function.
260 * Returns number of bytes that could not be copied.
261 * On success, this will be zero.
263 * If some data could not be copied, this function will pad the copied
264 * data to the requested size using zero bytes.
266 static inline unsigned long __must_check
267 __copy_from_user(void *to
, const void __user
*from
, unsigned long n
)
269 if (__builtin_constant_p(n
) && (n
<= 256))
270 return uaccess
.copy_from_user_small(n
, from
, to
);
272 return uaccess
.copy_from_user(n
, from
, to
);
275 extern void copy_from_user_overflow(void)
276 #ifdef CONFIG_DEBUG_STRICT_USER_COPY_CHECKS
277 __compiletime_warning("copy_from_user() buffer size is not provably correct")
282 * copy_from_user: - Copy a block of data from user space.
283 * @to: Destination address, in kernel space.
284 * @from: Source address, in user space.
285 * @n: Number of bytes to copy.
287 * Context: User context only. This function may sleep.
289 * Copy data from user space to kernel space.
291 * Returns number of bytes that could not be copied.
292 * On success, this will be zero.
294 * If some data could not be copied, this function will pad the copied
295 * data to the requested size using zero bytes.
297 static inline unsigned long __must_check
298 copy_from_user(void *to
, const void __user
*from
, unsigned long n
)
300 unsigned int sz
= __compiletime_object_size(to
);
303 if (unlikely(sz
!= -1 && sz
< n
)) {
304 copy_from_user_overflow();
307 if (access_ok(VERIFY_READ
, from
, n
))
308 n
= __copy_from_user(to
, from
, n
);
314 static inline unsigned long __must_check
315 __copy_in_user(void __user
*to
, const void __user
*from
, unsigned long n
)
317 return uaccess
.copy_in_user(n
, to
, from
);
320 static inline unsigned long __must_check
321 copy_in_user(void __user
*to
, const void __user
*from
, unsigned long n
)
324 if (__access_ok(from
,n
) && __access_ok(to
,n
))
325 n
= __copy_in_user(to
, from
, n
);
330 * Copy a null terminated string from userspace.
332 static inline long __must_check
333 strncpy_from_user(char *dst
, const char __user
*src
, long count
)
337 if (access_ok(VERIFY_READ
, src
, 1))
338 res
= uaccess
.strncpy_from_user(count
, src
, dst
);
342 static inline unsigned long
343 strnlen_user(const char __user
* src
, unsigned long n
)
346 return uaccess
.strnlen_user(n
, src
);
350 * strlen_user: - Get the size of a string in user space.
351 * @str: The string to measure.
353 * Context: User context only. This function may sleep.
355 * Get the size of a NUL-terminated string in user space.
357 * Returns the size of the string INCLUDING the terminating NUL.
358 * On exception, returns 0.
360 * If there is a limit on the length of a valid string, you may wish to
361 * consider using strnlen_user() instead.
363 #define strlen_user(str) strnlen_user(str, ~0UL)
369 static inline unsigned long __must_check
370 __clear_user(void __user
*to
, unsigned long n
)
372 return uaccess
.clear_user(n
, to
);
375 static inline unsigned long __must_check
376 clear_user(void __user
*to
, unsigned long n
)
379 if (access_ok(VERIFY_WRITE
, to
, n
))
380 n
= uaccess
.clear_user(n
, to
);
384 extern int memcpy_real(void *, void *, size_t);
385 extern void memcpy_absolute(void *, void *, size_t);
386 extern int copy_to_user_real(void __user
*dest
, void *src
, size_t count
);
387 extern int copy_from_user_real(void *dest
, void __user
*src
, size_t count
);
389 #endif /* __S390_UACCESS_H */