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

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

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ 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 #ifndef _ASM_M32R_UACCESS_H
  2 #define _ASM_M32R_UACCESS_H
  3 
  4 /*
  5  *  linux/include/asm-m32r/uaccess.h
  6  *
  7  *  M32R version.
  8  *    Copyright (C) 2004, 2006  Hirokazu Takata <takata at linux-m32r.org>
  9  */
 10 
 11 /*
 12  * User space memory access functions
 13  */
 14 #include <linux/errno.h>
 15 #include <linux/thread_info.h>
 16 #include <asm/page.h>
 17 #include <asm/setup.h>
 18 
 19 #define VERIFY_READ 0
 20 #define VERIFY_WRITE 1
 21 
 22 /*
 23  * The fs value determines whether argument validity checking should be
 24  * performed or not.  If get_fs() == USER_DS, checking is performed, with
 25  * get_fs() == KERNEL_DS, checking is bypassed.
 26  *
 27  * For historical reasons, these macros are grossly misnamed.
 28  */
 29 
 30 #define MAKE_MM_SEG(s)  ((mm_segment_t) { (s) })
 31 
 32 #ifdef CONFIG_MMU
 33 
 34 #define KERNEL_DS       MAKE_MM_SEG(0xFFFFFFFF)
 35 #define USER_DS         MAKE_MM_SEG(PAGE_OFFSET)
 36 #define get_ds()        (KERNEL_DS)
 37 #define get_fs()        (current_thread_info()->addr_limit)
 38 #define set_fs(x)       (current_thread_info()->addr_limit = (x))
 39 
 40 #else /* not CONFIG_MMU */
 41 
 42 #define KERNEL_DS       MAKE_MM_SEG(0xFFFFFFFF)
 43 #define USER_DS         MAKE_MM_SEG(0xFFFFFFFF)
 44 #define get_ds()        (KERNEL_DS)
 45 
 46 static inline mm_segment_t get_fs(void)
 47 {
 48         return USER_DS;
 49 }
 50 
 51 static inline void set_fs(mm_segment_t s)
 52 {
 53 }
 54 
 55 #endif /* not CONFIG_MMU */
 56 
 57 #define segment_eq(a, b)        ((a).seg == (b).seg)
 58 
 59 #define __addr_ok(addr) \
 60         ((unsigned long)(addr) < (current_thread_info()->addr_limit.seg))
 61 
 62 /*
 63  * Test whether a block of memory is a valid user space address.
 64  * Returns 0 if the range is valid, nonzero otherwise.
 65  *
 66  * This is equivalent to the following test:
 67  * (u33)addr + (u33)size >= (u33)current->addr_limit.seg
 68  *
 69  * This needs 33-bit arithmetic. We have a carry...
 70  */
 71 #define __range_ok(addr, size) ({                                       \
 72         unsigned long flag, roksum;                                     \
 73         __chk_user_ptr(addr);                                           \
 74         asm (                                                           \
 75                 "       cmpu    %1, %1    ; clear cbit\n"               \
 76                 "       addx    %1, %3    ; set cbit if overflow\n"     \
 77                 "       subx    %0, %0\n"                               \
 78                 "       cmpu    %4, %1\n"                               \
 79                 "       subx    %0, %5\n"                               \
 80                 : "=&r" (flag), "=r" (roksum)                           \
 81                 : "1" (addr), "r" ((int)(size)),                        \
 82                   "r" (current_thread_info()->addr_limit.seg), "r" (0)  \
 83                 : "cbit" );                                             \
 84         flag; })
 85 
 86 /**
 87  * access_ok: - Checks if a user space pointer is valid
 88  * @type: Type of access: %VERIFY_READ or %VERIFY_WRITE.  Note that
 89  *        %VERIFY_WRITE is a superset of %VERIFY_READ - if it is safe
 90  *        to write to a block, it is always safe to read from it.
 91  * @addr: User space pointer to start of block to check
 92  * @size: Size of block to check
 93  *
 94  * Context: User context only. This function may sleep if pagefaults are
 95  *          enabled.
 96  *
 97  * Checks if a pointer to a block of memory in user space is valid.
 98  *
 99  * Returns true (nonzero) if the memory block may be valid, false (zero)
100  * if it is definitely invalid.
101  *
102  * Note that, depending on architecture, this function probably just
103  * checks that the pointer is in the user space range - after calling
104  * this function, memory access functions may still return -EFAULT.
105  */
106 #ifdef CONFIG_MMU
107 #define access_ok(type, addr, size) (likely(__range_ok(addr, size) == 0))
108 #else
109 static inline int access_ok(int type, const void *addr, unsigned long size)
110 {
111         unsigned long val = (unsigned long)addr;
112 
113         return ((val >= memory_start) && ((val + size) < memory_end));
114 }
115 #endif /* CONFIG_MMU */
116 
117 /*
118  * The exception table consists of pairs of addresses: the first is the
119  * address of an instruction that is allowed to fault, and the second is
120  * the address at which the program should continue.  No registers are
121  * modified, so it is entirely up to the continuation code to figure out
122  * what to do.
123  *
124  * All the routines below use bits of fixup code that are out of line
125  * with the main instruction path.  This means when everything is well,
126  * we don't even have to jump over them.  Further, they do not intrude
127  * on our cache or tlb entries.
128  */
129 
130 struct exception_table_entry
131 {
132         unsigned long insn, fixup;
133 };
134 
135 extern int fixup_exception(struct pt_regs *regs);
136 
137 /*
138  * These are the main single-value transfer routines.  They automatically
139  * use the right size if we just have the right pointer type.
140  *
141  * This gets kind of ugly. We want to return _two_ values in "get_user()"
142  * and yet we don't want to do any pointers, because that is too much
143  * of a performance impact. Thus we have a few rather ugly macros here,
144  * and hide all the uglyness from the user.
145  *
146  * The "__xxx" versions of the user access functions are versions that
147  * do not verify the address space, that must have been done previously
148  * with a separate "access_ok()" call (this is used when we do multiple
149  * accesses to the same area of user memory).
150  */
151 
152 /* Careful: we have to cast the result to the type of the pointer for sign
153    reasons */
154 /**
155  * get_user: - Get a simple variable from user space.
156  * @x:   Variable to store result.
157  * @ptr: Source address, in user space.
158  *
159  * Context: User context only. This function may sleep if pagefaults are
160  *          enabled.
161  *
162  * This macro copies a single simple variable from user space to kernel
163  * space.  It supports simple types like char and int, but not larger
164  * data types like structures or arrays.
165  *
166  * @ptr must have pointer-to-simple-variable type, and the result of
167  * dereferencing @ptr must be assignable to @x without a cast.
168  *
169  * Returns zero on success, or -EFAULT on error.
170  * On error, the variable @x is set to zero.
171  */
172 #define get_user(x, ptr)                                                        \
173         __get_user_check((x), (ptr), sizeof(*(ptr)))
174 
175 /**
176  * put_user: - Write a simple value into user space.
177  * @x:   Value to copy to user space.
178  * @ptr: Destination address, in user space.
179  *
180  * Context: User context only. This function may sleep if pagefaults are
181  *          enabled.
182  *
183  * This macro copies a single simple value from kernel space to user
184  * space.  It supports simple types like char and int, but not larger
185  * data types like structures or arrays.
186  *
187  * @ptr must have pointer-to-simple-variable type, and @x must be assignable
188  * to the result of dereferencing @ptr.
189  *
190  * Returns zero on success, or -EFAULT on error.
191  */
192 #define put_user(x, ptr)                                                        \
193         __put_user_check((__typeof__(*(ptr)))(x), (ptr), sizeof(*(ptr)))
194 
195 /**
196  * __get_user: - Get a simple variable from user space, with less checking.
197  * @x:   Variable to store result.
198  * @ptr: Source address, in user space.
199  *
200  * Context: User context only. This function may sleep if pagefaults are
201  *          enabled.
202  *
203  * This macro copies a single simple variable from user space to kernel
204  * space.  It supports simple types like char and int, but not larger
205  * data types like structures or arrays.
206  *
207  * @ptr must have pointer-to-simple-variable type, and the result of
208  * dereferencing @ptr must be assignable to @x without a cast.
209  *
210  * Caller must check the pointer with access_ok() before calling this
211  * function.
212  *
213  * Returns zero on success, or -EFAULT on error.
214  * On error, the variable @x is set to zero.
215  */
216 #define __get_user(x, ptr) \
217         __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
218 
219 #define __get_user_nocheck(x, ptr, size)                                \
220 ({                                                                      \
221         long __gu_err = 0;                                              \
222         unsigned long __gu_val = 0;                                     \
223         might_fault();                                                  \
224         __get_user_size(__gu_val, (ptr), (size), __gu_err);             \
225         (x) = (__force __typeof__(*(ptr)))__gu_val;                     \
226         __gu_err;                                                       \
227 })
228 
229 #define __get_user_check(x, ptr, size)                                  \
230 ({                                                                      \
231         long __gu_err = -EFAULT;                                        \
232         unsigned long __gu_val = 0;                                     \
233         const __typeof__(*(ptr)) __user *__gu_addr = (ptr);             \
234         might_fault();                                                  \
235         if (access_ok(VERIFY_READ, __gu_addr, size))                    \
236                 __get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
237         (x) = (__force __typeof__(*(ptr)))__gu_val;                     \
238         __gu_err;                                                       \
239 })
240 
241 extern long __get_user_bad(void);
242 
243 #define __get_user_size(x, ptr, size, retval)                           \
244 do {                                                                    \
245         retval = 0;                                                     \
246         __chk_user_ptr(ptr);                                            \
247         switch (size) {                                                 \
248           case 1: __get_user_asm(x, ptr, retval, "ub"); break;          \
249           case 2: __get_user_asm(x, ptr, retval, "uh"); break;          \
250           case 4: __get_user_asm(x, ptr, retval, ""); break;            \
251           default: (x) = __get_user_bad();                              \
252         }                                                               \
253 } while (0)
254 
255 #define __get_user_asm(x, addr, err, itype)                             \
256         __asm__ __volatile__(                                           \
257                 "       .fillinsn\n"                                    \
258                 "1:     ld"itype" %1,@%2\n"                             \
259                 "       .fillinsn\n"                                    \
260                 "2:\n"                                                  \
261                 ".section .fixup,\"ax\"\n"                              \
262                 "       .balign 4\n"                                    \
263                 "3:     ldi %0,%3\n"                                    \
264                 "       seth r14,#high(2b)\n"                           \
265                 "       or3 r14,r14,#low(2b)\n"                         \
266                 "       jmp r14\n"                                      \
267                 ".previous\n"                                           \
268                 ".section __ex_table,\"a\"\n"                           \
269                 "       .balign 4\n"                                    \
270                 "       .long 1b,3b\n"                                  \
271                 ".previous"                                             \
272                 : "=&r" (err), "=&r" (x)                                \
273                 : "r" (addr), "i" (-EFAULT), "" (err)                  \
274                 : "r14", "memory")
275 
276 /**
277  * __put_user: - Write a simple value into user space, with less checking.
278  * @x:   Value to copy to user space.
279  * @ptr: Destination address, in user space.
280  *
281  * Context: User context only. This function may sleep if pagefaults are
282  *          enabled.
283  *
284  * This macro copies a single simple value from kernel space to user
285  * space.  It supports simple types like char and int, but not larger
286  * data types like structures or arrays.
287  *
288  * @ptr must have pointer-to-simple-variable type, and @x must be assignable
289  * to the result of dereferencing @ptr.
290  *
291  * Caller must check the pointer with access_ok() before calling this
292  * function.
293  *
294  * Returns zero on success, or -EFAULT on error.
295  */
296 #define __put_user(x, ptr) \
297         __put_user_nocheck((__typeof__(*(ptr)))(x), (ptr), sizeof(*(ptr)))
298 
299 
300 #define __put_user_nocheck(x, ptr, size)                                \
301 ({                                                                      \
302         long __pu_err;                                                  \
303         might_fault();                                                  \
304         __put_user_size((x), (ptr), (size), __pu_err);                  \
305         __pu_err;                                                       \
306 })
307 
308 
309 #define __put_user_check(x, ptr, size)                                  \
310 ({                                                                      \
311         long __pu_err = -EFAULT;                                        \
312         __typeof__(*(ptr)) __user *__pu_addr = (ptr);                   \
313         might_fault();                                                  \
314         if (access_ok(VERIFY_WRITE, __pu_addr, size))                   \
315                 __put_user_size((x), __pu_addr, (size), __pu_err);      \
316         __pu_err;                                                       \
317 })
318 
319 #if defined(__LITTLE_ENDIAN__)
320 #define __put_user_u64(x, addr, err)                                    \
321         __asm__ __volatile__(                                           \
322                 "       .fillinsn\n"                                    \
323                 "1:     st %L1,@%2\n"                                   \
324                 "       .fillinsn\n"                                    \
325                 "2:     st %H1,@(4,%2)\n"                               \
326                 "       .fillinsn\n"                                    \
327                 "3:\n"                                                  \
328                 ".section .fixup,\"ax\"\n"                              \
329                 "       .balign 4\n"                                    \
330                 "4:     ldi %0,%3\n"                                    \
331                 "       seth r14,#high(3b)\n"                           \
332                 "       or3 r14,r14,#low(3b)\n"                         \
333                 "       jmp r14\n"                                      \
334                 ".previous\n"                                           \
335                 ".section __ex_table,\"a\"\n"                           \
336                 "       .balign 4\n"                                    \
337                 "       .long 1b,4b\n"                                  \
338                 "       .long 2b,4b\n"                                  \
339                 ".previous"                                             \
340                 : "=&r" (err)                                           \
341                 : "r" (x), "r" (addr), "i" (-EFAULT), "" (err)         \
342                 : "r14", "memory")
343 
344 #elif defined(__BIG_ENDIAN__)
345 #define __put_user_u64(x, addr, err)                                    \
346         __asm__ __volatile__(                                           \
347                 "       .fillinsn\n"                                    \
348                 "1:     st %H1,@%2\n"                                   \
349                 "       .fillinsn\n"                                    \
350                 "2:     st %L1,@(4,%2)\n"                               \
351                 "       .fillinsn\n"                                    \
352                 "3:\n"                                                  \
353                 ".section .fixup,\"ax\"\n"                              \
354                 "       .balign 4\n"                                    \
355                 "4:     ldi %0,%3\n"                                    \
356                 "       seth r14,#high(3b)\n"                           \
357                 "       or3 r14,r14,#low(3b)\n"                         \
358                 "       jmp r14\n"                                      \
359                 ".previous\n"                                           \
360                 ".section __ex_table,\"a\"\n"                           \
361                 "       .balign 4\n"                                    \
362                 "       .long 1b,4b\n"                                  \
363                 "       .long 2b,4b\n"                                  \
364                 ".previous"                                             \
365                 : "=&r" (err)                                           \
366                 : "r" (x), "r" (addr), "i" (-EFAULT), "" (err)         \
367                 : "r14", "memory")
368 #else
369 #error no endian defined
370 #endif
371 
372 extern void __put_user_bad(void);
373 
374 #define __put_user_size(x, ptr, size, retval)                           \
375 do {                                                                    \
376         retval = 0;                                                     \
377         __chk_user_ptr(ptr);                                            \
378         switch (size) {                                                 \
379           case 1: __put_user_asm(x, ptr, retval, "b"); break;           \
380           case 2: __put_user_asm(x, ptr, retval, "h"); break;           \
381           case 4: __put_user_asm(x, ptr, retval, ""); break;            \
382           case 8: __put_user_u64((__typeof__(*ptr))(x), ptr, retval); break;\
383           default: __put_user_bad();                                    \
384         }                                                               \
385 } while (0)
386 
387 struct __large_struct { unsigned long buf[100]; };
388 #define __m(x) (*(struct __large_struct *)(x))
389 
390 /*
391  * Tell gcc we read from memory instead of writing: this is because
392  * we do not write to any memory gcc knows about, so there are no
393  * aliasing issues.
394  */
395 #define __put_user_asm(x, addr, err, itype)                             \
396         __asm__ __volatile__(                                           \
397                 "       .fillinsn\n"                                    \
398                 "1:     st"itype" %1,@%2\n"                             \
399                 "       .fillinsn\n"                                    \
400                 "2:\n"                                                  \
401                 ".section .fixup,\"ax\"\n"                              \
402                 "       .balign 4\n"                                    \
403                 "3:     ldi %0,%3\n"                                    \
404                 "       seth r14,#high(2b)\n"                           \
405                 "       or3 r14,r14,#low(2b)\n"                         \
406                 "       jmp r14\n"                                      \
407                 ".previous\n"                                           \
408                 ".section __ex_table,\"a\"\n"                           \
409                 "       .balign 4\n"                                    \
410                 "       .long 1b,3b\n"                                  \
411                 ".previous"                                             \
412                 : "=&r" (err)                                           \
413                 : "r" (x), "r" (addr), "i" (-EFAULT), "" (err)         \
414                 : "r14", "memory")
415 
416 /*
417  * Here we special-case 1, 2 and 4-byte copy_*_user invocations.  On a fault
418  * we return the initial request size (1, 2 or 4), as copy_*_user should do.
419  * If a store crosses a page boundary and gets a fault, the m32r will not write
420  * anything, so this is accurate.
421  */
422 
423 /*
424  * Copy To/From Userspace
425  */
426 
427 /* Generic arbitrary sized copy.  */
428 /* Return the number of bytes NOT copied.  */
429 #define __copy_user(to, from, size)                                     \
430 do {                                                                    \
431         unsigned long __dst, __src, __c;                                \
432         __asm__ __volatile__ (                                          \
433                 "       mv      r14, %0\n"                              \
434                 "       or      r14, %1\n"                              \
435                 "       beq     %0, %1, 9f\n"                           \
436                 "       beqz    %2, 9f\n"                               \
437                 "       and3    r14, r14, #3\n"                         \
438                 "       bnez    r14, 2f\n"                              \
439                 "       and3    %2, %2, #3\n"                           \
440                 "       beqz    %3, 2f\n"                               \
441                 "       addi    %0, #-4         ; word_copy \n"         \
442                 "       .fillinsn\n"                                    \
443                 "0:     ld      r14, @%1+\n"                            \
444                 "       addi    %3, #-1\n"                              \
445                 "       .fillinsn\n"                                    \
446                 "1:     st      r14, @+%0\n"                            \
447                 "       bnez    %3, 0b\n"                               \
448                 "       beqz    %2, 9f\n"                               \
449                 "       addi    %0, #4\n"                               \
450                 "       .fillinsn\n"                                    \
451                 "2:     ldb     r14, @%1        ; byte_copy \n"         \
452                 "       .fillinsn\n"                                    \
453                 "3:     stb     r14, @%0\n"                             \
454                 "       addi    %1, #1\n"                               \
455                 "       addi    %2, #-1\n"                              \
456                 "       addi    %0, #1\n"                               \
457                 "       bnez    %2, 2b\n"                               \
458                 "       .fillinsn\n"                                    \
459                 "9:\n"                                                  \
460                 ".section .fixup,\"ax\"\n"                              \
461                 "       .balign 4\n"                                    \
462                 "5:     addi    %3, #1\n"                               \
463                 "       addi    %1, #-4\n"                              \
464                 "       .fillinsn\n"                                    \
465                 "6:     slli    %3, #2\n"                               \
466                 "       add     %2, %3\n"                               \
467                 "       addi    %0, #4\n"                               \
468                 "       .fillinsn\n"                                    \
469                 "7:     seth    r14, #high(9b)\n"                       \
470                 "       or3     r14, r14, #low(9b)\n"                   \
471                 "       jmp     r14\n"                                  \
472                 ".previous\n"                                           \
473                 ".section __ex_table,\"a\"\n"                           \
474                 "       .balign 4\n"                                    \
475                 "       .long 0b,6b\n"                                  \
476                 "       .long 1b,5b\n"                                  \
477                 "       .long 2b,9b\n"                                  \
478                 "       .long 3b,9b\n"                                  \
479                 ".previous\n"                                           \
480                 : "=&r" (__dst), "=&r" (__src), "=&r" (size),           \
481                   "=&r" (__c)                                           \
482                 : "" (to), "1" (from), "2" (size), "3" (size / 4)      \
483                 : "r14", "memory");                                     \
484 } while (0)
485 
486 #define __copy_user_zeroing(to, from, size)                             \
487 do {                                                                    \
488         unsigned long __dst, __src, __c;                                \
489         __asm__ __volatile__ (                                          \
490                 "       mv      r14, %0\n"                              \
491                 "       or      r14, %1\n"                              \
492                 "       beq     %0, %1, 9f\n"                           \
493                 "       beqz    %2, 9f\n"                               \
494                 "       and3    r14, r14, #3\n"                         \
495                 "       bnez    r14, 2f\n"                              \
496                 "       and3    %2, %2, #3\n"                           \
497                 "       beqz    %3, 2f\n"                               \
498                 "       addi    %0, #-4         ; word_copy \n"         \
499                 "       .fillinsn\n"                                    \
500                 "0:     ld      r14, @%1+\n"                            \
501                 "       addi    %3, #-1\n"                              \
502                 "       .fillinsn\n"                                    \
503                 "1:     st      r14, @+%0\n"                            \
504                 "       bnez    %3, 0b\n"                               \
505                 "       beqz    %2, 9f\n"                               \
506                 "       addi    %0, #4\n"                               \
507                 "       .fillinsn\n"                                    \
508                 "2:     ldb     r14, @%1        ; byte_copy \n"         \
509                 "       .fillinsn\n"                                    \
510                 "3:     stb     r14, @%0\n"                             \
511                 "       addi    %1, #1\n"                               \
512                 "       addi    %2, #-1\n"                              \
513                 "       addi    %0, #1\n"                               \
514                 "       bnez    %2, 2b\n"                               \
515                 "       .fillinsn\n"                                    \
516                 "9:\n"                                                  \
517                 ".section .fixup,\"ax\"\n"                              \
518                 "       .balign 4\n"                                    \
519                 "5:     addi    %3, #1\n"                               \
520                 "       addi    %1, #-4\n"                              \
521                 "       .fillinsn\n"                                    \
522                 "6:     slli    %3, #2\n"                               \
523                 "       add     %2, %3\n"                               \
524                 "       addi    %0, #4\n"                               \
525                 "       .fillinsn\n"                                    \
526                 "7:     ldi     r14, #0         ; store zero \n"        \
527                 "       .fillinsn\n"                                    \
528                 "8:     addi    %2, #-1\n"                              \
529                 "       stb     r14, @%0        ; ACE? \n"              \
530                 "       addi    %0, #1\n"                               \
531                 "       bnez    %2, 8b\n"                               \
532                 "       seth    r14, #high(9b)\n"                       \
533                 "       or3     r14, r14, #low(9b)\n"                   \
534                 "       jmp     r14\n"                                  \
535                 ".previous\n"                                           \
536                 ".section __ex_table,\"a\"\n"                           \
537                 "       .balign 4\n"                                    \
538                 "       .long 0b,6b\n"                                  \
539                 "       .long 1b,5b\n"                                  \
540                 "       .long 2b,7b\n"                                  \
541                 "       .long 3b,7b\n"                                  \
542                 ".previous\n"                                           \
543                 : "=&r" (__dst), "=&r" (__src), "=&r" (size),           \
544                   "=&r" (__c)                                           \
545                 : "" (to), "1" (from), "2" (size), "3" (size / 4)      \
546                 : "r14", "memory");                                     \
547 } while (0)
548 
549 
550 /* We let the __ versions of copy_from/to_user inline, because they're often
551  * used in fast paths and have only a small space overhead.
552  */
553 static inline unsigned long __generic_copy_from_user_nocheck(void *to,
554         const void __user *from, unsigned long n)
555 {
556         __copy_user_zeroing(to, from, n);
557         return n;
558 }
559 
560 static inline unsigned long __generic_copy_to_user_nocheck(void __user *to,
561         const void *from, unsigned long n)
562 {
563         __copy_user(to, from, n);
564         return n;
565 }
566 
567 unsigned long __generic_copy_to_user(void __user *, const void *, unsigned long);
568 unsigned long __generic_copy_from_user(void *, const void __user *, unsigned long);
569 
570 /**
571  * __copy_to_user: - Copy a block of data into user space, with less checking.
572  * @to:   Destination address, in user space.
573  * @from: Source address, in kernel space.
574  * @n:    Number of bytes to copy.
575  *
576  * Context: User context only. This function may sleep if pagefaults are
577  *          enabled.
578  *
579  * Copy data from kernel space to user space.  Caller must check
580  * the specified block with access_ok() before calling this function.
581  *
582  * Returns number of bytes that could not be copied.
583  * On success, this will be zero.
584  */
585 #define __copy_to_user(to, from, n)                     \
586         __generic_copy_to_user_nocheck((to), (from), (n))
587 
588 #define __copy_to_user_inatomic __copy_to_user
589 #define __copy_from_user_inatomic __copy_from_user
590 
591 /**
592  * copy_to_user: - Copy a block of data into user space.
593  * @to:   Destination address, in user space.
594  * @from: Source address, in kernel space.
595  * @n:    Number of bytes to copy.
596  *
597  * Context: User context only. This function may sleep if pagefaults are
598  *          enabled.
599  *
600  * Copy data from kernel space to user space.
601  *
602  * Returns number of bytes that could not be copied.
603  * On success, this will be zero.
604  */
605 #define copy_to_user(to, from, n)                       \
606 ({                                                      \
607         might_fault();                                  \
608         __generic_copy_to_user((to), (from), (n));      \
609 })
610 
611 /**
612  * __copy_from_user: - Copy a block of data from user space, with less checking. * @to:   Destination address, in kernel space.
613  * @from: Source address, in user space.
614  * @n:    Number of bytes to copy.
615  *
616  * Context: User context only. This function may sleep if pagefaults are
617  *          enabled.
618  *
619  * Copy data from user space to kernel space.  Caller must check
620  * the specified block with access_ok() before calling this function.
621  *
622  * Returns number of bytes that could not be copied.
623  * On success, this will be zero.
624  *
625  * If some data could not be copied, this function will pad the copied
626  * data to the requested size using zero bytes.
627  */
628 #define __copy_from_user(to, from, n)                   \
629         __generic_copy_from_user_nocheck((to), (from), (n))
630 
631 /**
632  * copy_from_user: - Copy a block of data from user space.
633  * @to:   Destination address, in kernel space.
634  * @from: Source address, in user space.
635  * @n:    Number of bytes to copy.
636  *
637  * Context: User context only. This function may sleep if pagefaults are
638  *          enabled.
639  *
640  * Copy data from user space to kernel space.
641  *
642  * Returns number of bytes that could not be copied.
643  * On success, this will be zero.
644  *
645  * If some data could not be copied, this function will pad the copied
646  * data to the requested size using zero bytes.
647  */
648 #define copy_from_user(to, from, n)                     \
649 ({                                                      \
650         might_fault();                                  \
651         __generic_copy_from_user((to), (from), (n));    \
652 })
653 
654 long __must_check strncpy_from_user(char *dst, const char __user *src,
655                                 long count);
656 long __must_check __strncpy_from_user(char *dst,
657                                 const char __user *src, long count);
658 
659 /**
660  * __clear_user: - Zero a block of memory in user space, with less checking.
661  * @to:   Destination address, in user space.
662  * @n:    Number of bytes to zero.
663  *
664  * Zero a block of memory in user space.  Caller must check
665  * the specified block with access_ok() before calling this function.
666  *
667  * Returns number of bytes that could not be cleared.
668  * On success, this will be zero.
669  */
670 unsigned long __clear_user(void __user *mem, unsigned long len);
671 
672 /**
673  * clear_user: - Zero a block of memory in user space.
674  * @to:   Destination address, in user space.
675  * @n:    Number of bytes to zero.
676  *
677  * Zero a block of memory in user space.  Caller must check
678  * the specified block with access_ok() before calling this function.
679  *
680  * Returns number of bytes that could not be cleared.
681  * On success, this will be zero.
682  */
683 unsigned long clear_user(void __user *mem, unsigned long len);
684 
685 /**
686  * strlen_user: - Get the size of a string in user space.
687  * @str: The string to measure.
688  *
689  * Context: User context only. This function may sleep if pagefaults are
690  *          enabled.
691  *
692  * Get the size of a NUL-terminated string in user space.
693  *
694  * Returns the size of the string INCLUDING the terminating NUL.
695  * On exception, returns 0.
696  *
697  * If there is a limit on the length of a valid string, you may wish to
698  * consider using strnlen_user() instead.
699  */
700 #define strlen_user(str) strnlen_user(str, ~0UL >> 1)
701 long strnlen_user(const char __user *str, long n);
702 
703 #endif /* _ASM_M32R_UACCESS_H */
704 

~ [ 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