~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/s390/include/asm/uaccess.h

Version: ~ [ linux-5.16-rc3 ] ~ [ linux-5.15.5 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.82 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.162 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.218 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.256 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.291 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.293 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  S390 version
  3  *    Copyright IBM Corp. 1999, 2000
  4  *    Author(s): Hartmut Penner (hp@de.ibm.com),
  5  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
  6  *
  7  *  Derived from "include/asm-i386/uaccess.h"
  8  */
  9 #ifndef __S390_UACCESS_H
 10 #define __S390_UACCESS_H
 11 
 12 /*
 13  * User space memory access functions
 14  */
 15 #include <linux/sched.h>
 16 #include <linux/errno.h>
 17 #include <asm/ctl_reg.h>
 18 
 19 #define VERIFY_READ     0
 20 #define VERIFY_WRITE    1
 21 
 22 
 23 /*
 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.
 27  *
 28  * For historical reasons, these macros are grossly misnamed.
 29  */
 30 
 31 #define MAKE_MM_SEG(a)  ((mm_segment_t) { (a) })
 32 
 33 
 34 #define KERNEL_DS       MAKE_MM_SEG(0)
 35 #define USER_DS         MAKE_MM_SEG(1)
 36 
 37 #define get_ds()        (KERNEL_DS)
 38 #define get_fs()        (current->thread.mm_segment)
 39 
 40 #define set_fs(x) \
 41 ({                                                                      \
 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);                                        \
 47 })
 48 
 49 #define segment_eq(a,b) ((a).ar4 == (b).ar4)
 50 
 51 static inline int __range_ok(unsigned long addr, unsigned long size)
 52 {
 53         return 1;
 54 }
 55 
 56 #define __access_ok(addr, size)                         \
 57 ({                                                      \
 58         __chk_user_ptr(addr);                           \
 59         __range_ok((unsigned long)(addr), (size));      \
 60 })
 61 
 62 #define access_ok(type, addr, size) __access_ok(addr, size)
 63 
 64 /*
 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
 69  * what to do.
 70  *
 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.
 75  */
 76 
 77 struct exception_table_entry
 78 {
 79         int insn, fixup;
 80 };
 81 
 82 static inline unsigned long extable_insn(const struct exception_table_entry *x)
 83 {
 84         return (unsigned long)&x->insn + x->insn;
 85 }
 86 
 87 static inline unsigned long extable_fixup(const struct exception_table_entry *x)
 88 {
 89         return (unsigned long)&x->fixup + x->fixup;
 90 }
 91 
 92 #define ARCH_HAS_SORT_EXTABLE
 93 #define ARCH_HAS_SEARCH_EXTABLE
 94 
 95 struct uaccess_ops {
 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);
104 };
105 
106 extern struct uaccess_ops uaccess;
107 extern struct uaccess_ops uaccess_mvcos;
108 extern struct uaccess_ops uaccess_pt;
109 
110 extern int __handle_fault(unsigned long, unsigned long, int);
111 
112 static inline int __put_user_fn(size_t size, void __user *ptr, void *x)
113 {
114         size = uaccess.copy_to_user(size, ptr, x);
115         return size ? -EFAULT : size;
116 }
117 
118 static inline int __get_user_fn(size_t size, const void __user *ptr, void *x)
119 {
120         size = uaccess.copy_from_user(size, ptr, x);
121         return size ? -EFAULT : size;
122 }
123 
124 /*
125  * These are the main single-value transfer routines.  They automatically
126  * use the right size if we just have the right pointer type.
127  */
128 #define __put_user(x, ptr) \
129 ({                                                              \
130         __typeof__(*(ptr)) __x = (x);                           \
131         int __pu_err = -EFAULT;                                 \
132         __chk_user_ptr(ptr);                                    \
133         switch (sizeof (*(ptr))) {                              \
134         case 1:                                                 \
135         case 2:                                                 \
136         case 4:                                                 \
137         case 8:                                                 \
138                 __pu_err = __put_user_fn(sizeof (*(ptr)),       \
139                                          ptr, &__x);            \
140                 break;                                          \
141         default:                                                \
142                 __put_user_bad();                               \
143                 break;                                          \
144          }                                                      \
145         __pu_err;                                               \
146 })
147 
148 #define put_user(x, ptr)                                        \
149 ({                                                              \
150         might_fault();                                          \
151         __put_user(x, ptr);                                     \
152 })
153 
154 
155 extern int __put_user_bad(void) __attribute__((noreturn));
156 
157 #define __get_user(x, ptr)                                      \
158 ({                                                              \
159         int __gu_err = -EFAULT;                                 \
160         __chk_user_ptr(ptr);                                    \
161         switch (sizeof(*(ptr))) {                               \
162         case 1: {                                               \
163                 unsigned char __x;                              \
164                 __gu_err = __get_user_fn(sizeof (*(ptr)),       \
165                                          ptr, &__x);            \
166                 (x) = *(__force __typeof__(*(ptr)) *) &__x;     \
167                 break;                                          \
168         };                                                      \
169         case 2: {                                               \
170                 unsigned short __x;                             \
171                 __gu_err = __get_user_fn(sizeof (*(ptr)),       \
172                                          ptr, &__x);            \
173                 (x) = *(__force __typeof__(*(ptr)) *) &__x;     \
174                 break;                                          \
175         };                                                      \
176         case 4: {                                               \
177                 unsigned int __x;                               \
178                 __gu_err = __get_user_fn(sizeof (*(ptr)),       \
179                                          ptr, &__x);            \
180                 (x) = *(__force __typeof__(*(ptr)) *) &__x;     \
181                 break;                                          \
182         };                                                      \
183         case 8: {                                               \
184                 unsigned long long __x;                         \
185                 __gu_err = __get_user_fn(sizeof (*(ptr)),       \
186                                          ptr, &__x);            \
187                 (x) = *(__force __typeof__(*(ptr)) *) &__x;     \
188                 break;                                          \
189         };                                                      \
190         default:                                                \
191                 __get_user_bad();                               \
192                 break;                                          \
193         }                                                       \
194         __gu_err;                                               \
195 })
196 
197 #define get_user(x, ptr)                                        \
198 ({                                                              \
199         might_fault();                                          \
200         __get_user(x, ptr);                                     \
201 })
202 
203 extern int __get_user_bad(void) __attribute__((noreturn));
204 
205 #define __put_user_unaligned __put_user
206 #define __get_user_unaligned __get_user
207 
208 /**
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.
213  *
214  * Context: User context only.  This function may sleep.
215  *
216  * Copy data from kernel space to user space.  Caller must check
217  * the specified block with access_ok() before calling this function.
218  *
219  * Returns number of bytes that could not be copied.
220  * On success, this will be zero.
221  */
222 static inline unsigned long __must_check
223 __copy_to_user(void __user *to, const void *from, unsigned long n)
224 {
225         return uaccess.copy_to_user(n, to, from);
226 }
227 
228 #define __copy_to_user_inatomic __copy_to_user
229 #define __copy_from_user_inatomic __copy_from_user
230 
231 /**
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.
236  *
237  * Context: User context only.  This function may sleep.
238  *
239  * Copy data from kernel space to user space.
240  *
241  * Returns number of bytes that could not be copied.
242  * On success, this will be zero.
243  */
244 static inline unsigned long __must_check
245 copy_to_user(void __user *to, const void *from, unsigned long n)
246 {
247         might_fault();
248         return __copy_to_user(to, from, n);
249 }
250 
251 /**
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.
256  *
257  * Context: User context only.  This function may sleep.
258  *
259  * Copy data from user space to kernel space.  Caller must check
260  * the specified block with access_ok() before calling this function.
261  *
262  * Returns number of bytes that could not be copied.
263  * On success, this will be zero.
264  *
265  * If some data could not be copied, this function will pad the copied
266  * data to the requested size using zero bytes.
267  */
268 static inline unsigned long __must_check
269 __copy_from_user(void *to, const void __user *from, unsigned long n)
270 {
271         return uaccess.copy_from_user(n, from, to);
272 }
273 
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")
277 #endif
278 ;
279 
280 /**
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.
285  *
286  * Context: User context only.  This function may sleep.
287  *
288  * Copy data from user space to kernel space.
289  *
290  * Returns number of bytes that could not be copied.
291  * On success, this will be zero.
292  *
293  * If some data could not be copied, this function will pad the copied
294  * data to the requested size using zero bytes.
295  */
296 static inline unsigned long __must_check
297 copy_from_user(void *to, const void __user *from, unsigned long n)
298 {
299         unsigned int sz = __compiletime_object_size(to);
300 
301         might_fault();
302         if (unlikely(sz != -1 && sz < n)) {
303                 copy_from_user_overflow();
304                 return n;
305         }
306         return __copy_from_user(to, from, n);
307 }
308 
309 static inline unsigned long __must_check
310 __copy_in_user(void __user *to, const void __user *from, unsigned long n)
311 {
312         return uaccess.copy_in_user(n, to, from);
313 }
314 
315 static inline unsigned long __must_check
316 copy_in_user(void __user *to, const void __user *from, unsigned long n)
317 {
318         might_fault();
319         return __copy_in_user(to, from, n);
320 }
321 
322 /*
323  * Copy a null terminated string from userspace.
324  */
325 static inline long __must_check
326 strncpy_from_user(char *dst, const char __user *src, long count)
327 {
328         might_fault();
329         return uaccess.strncpy_from_user(count, src, dst);
330 }
331 
332 static inline unsigned long
333 strnlen_user(const char __user * src, unsigned long n)
334 {
335         might_fault();
336         return uaccess.strnlen_user(n, src);
337 }
338 
339 /**
340  * strlen_user: - Get the size of a string in user space.
341  * @str: The string to measure.
342  *
343  * Context: User context only.  This function may sleep.
344  *
345  * Get the size of a NUL-terminated string in user space.
346  *
347  * Returns the size of the string INCLUDING the terminating NUL.
348  * On exception, returns 0.
349  *
350  * If there is a limit on the length of a valid string, you may wish to
351  * consider using strnlen_user() instead.
352  */
353 #define strlen_user(str) strnlen_user(str, ~0UL)
354 
355 /*
356  * Zero Userspace
357  */
358 
359 static inline unsigned long __must_check
360 __clear_user(void __user *to, unsigned long n)
361 {
362         return uaccess.clear_user(n, to);
363 }
364 
365 static inline unsigned long __must_check
366 clear_user(void __user *to, unsigned long n)
367 {
368         might_fault();
369         return uaccess.clear_user(n, to);
370 }
371 
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);
374 
375 #endif /* __S390_UACCESS_H */
376 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp