err.no Git - linux-2.6/blob - include/asm-x86/uaccess_32.h

   1 #ifndef __i386_UACCESS_H
   2 #define __i386_UACCESS_H
   3
   4 /*
   5  * User space memory access functions
   6  */
   7 #include <linux/errno.h>
   8 #include <linux/thread_info.h>
   9 #include <linux/prefetch.h>
  10 #include <linux/string.h>
  11 #include <asm/asm.h>
  12 #include <asm/page.h>
  13
  14 /*
  15  * movsl can be slow when source and dest are not both 8-byte aligned
  16  */
  17 #ifdef CONFIG_X86_INTEL_USERCOPY
  18 extern struct movsl_mask {
  19         int mask;
  20 } ____cacheline_aligned_in_smp movsl_mask;
  21 #endif
  22
  23 extern void __put_user_bad(void);
  24
  25 /*
  26  * Strange magic calling convention: pointer in %ecx,
  27  * value in %eax(:%edx), return value in %eax, no clobbers.
  28  */
  29 extern void __put_user_1(void);
  30 extern void __put_user_2(void);
  31 extern void __put_user_4(void);
  32 extern void __put_user_8(void);
  33
  34 #define __put_user_x(size, x, ptr)                              \
  35         asm volatile("call __put_user_" #size : "=a" (__ret_pu) \
  36                      :"0" ((typeof(*(ptr)))(x)), "c" (ptr) : "ebx")
  37
  38 #define __put_user_8(x, ptr)                                    \
  39         asm volatile("call __put_user_8" : "=a" (__ret_pu)      \
  40                      : "A" ((typeof(*(ptr)))(x)), "c" (ptr) : "ebx")
  41
  42
  43 /**
  44  * put_user: - Write a simple value into user space.
  45  * @x:   Value to copy to user space.
  46  * @ptr: Destination address, in user space.
  47  *
  48  * Context: User context only.  This function may sleep.
  49  *
  50  * This macro copies a single simple value from kernel space to user
  51  * space.  It supports simple types like char and int, but not larger
  52  * data types like structures or arrays.
  53  *
  54  * @ptr must have pointer-to-simple-variable type, and @x must be assignable
  55  * to the result of dereferencing @ptr.
  56  *
  57  * Returns zero on success, or -EFAULT on error.
  58  */
  59 #ifdef CONFIG_X86_WP_WORKS_OK
  60
  61 #define put_user(x, ptr)                                        \
  62 ({                                                              \
  63         int __ret_pu;                                           \
  64         __typeof__(*(ptr)) __pu_val;                            \
  65         __chk_user_ptr(ptr);                                    \
  66         __pu_val = x;                                           \
  67         switch (sizeof(*(ptr))) {                               \
  68         case 1:                                                 \
  69                 __put_user_x(1, __pu_val, ptr);                 \
  70                 break;                                          \
  71         case 2:                                                 \
  72                 __put_user_x(2, __pu_val, ptr);                 \
  73                 break;                                          \
  74         case 4:                                                 \
  75                 __put_user_x(4, __pu_val, ptr);                 \
  76                 break;                                          \
  77         case 8:                                                 \
  78                 __put_user_8(__pu_val, ptr);                    \
  79                 break;                                          \
  80         default:                                                \
  81                 __put_user_x(X, __pu_val, ptr);                 \
  82                 break;                                          \
  83         }                                                       \
  84         __ret_pu;                                               \
  85 })
  86
  87 #else
  88 #define put_user(x, ptr)                                        \
  89 ({                                                              \
  90         int __ret_pu;                                           \
  91         __typeof__(*(ptr))__pus_tmp = x;                        \
  92         __ret_pu = 0;                                           \
  93         if (unlikely(__copy_to_user_ll(ptr, &__pus_tmp,         \
  94                                        sizeof(*(ptr))) != 0))   \
  95                 __ret_pu = -EFAULT;                             \
  96         __ret_pu;                                               \
  97 })
  98
  99
 100 #endif
 101
 102 /**
 103  * __get_user: - Get a simple variable from user space, with less checking.
 104  * @x:   Variable to store result.
 105  * @ptr: Source address, in user space.
 106  *
 107  * Context: User context only.  This function may sleep.
 108  *
 109  * This macro copies a single simple variable from user space to kernel
 110  * space.  It supports simple types like char and int, but not larger
 111  * data types like structures or arrays.
 112  *
 113  * @ptr must have pointer-to-simple-variable type, and the result of
 114  * dereferencing @ptr must be assignable to @x without a cast.
 115  *
 116  * Caller must check the pointer with access_ok() before calling this
 117  * function.
 118  *
 119  * Returns zero on success, or -EFAULT on error.
 120  * On error, the variable @x is set to zero.
 121  */
 122 #define __get_user(x, ptr)                              \
 123         __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
 124
 125
 126 /**
 127  * __put_user: - Write a simple value into user space, with less checking.
 128  * @x:   Value to copy to user space.
 129  * @ptr: Destination address, in user space.
 130  *
 131  * Context: User context only.  This function may sleep.
 132  *
 133  * This macro copies a single simple value from kernel space to user
 134  * space.  It supports simple types like char and int, but not larger
 135  * data types like structures or arrays.
 136  *
 137  * @ptr must have pointer-to-simple-variable type, and @x must be assignable
 138  * to the result of dereferencing @ptr.
 139  *
 140  * Caller must check the pointer with access_ok() before calling this
 141  * function.
 142  *
 143  * Returns zero on success, or -EFAULT on error.
 144  */
 145 #define __put_user(x, ptr)                                              \
 146         __put_user_nocheck((__typeof__(*(ptr)))(x), (ptr), sizeof(*(ptr)))
 147
 148 unsigned long __must_check __copy_to_user_ll
 149                 (void __user *to, const void *from, unsigned long n);
 150 unsigned long __must_check __copy_from_user_ll
 151                 (void *to, const void __user *from, unsigned long n);
 152 unsigned long __must_check __copy_from_user_ll_nozero
 153                 (void *to, const void __user *from, unsigned long n);
 154 unsigned long __must_check __copy_from_user_ll_nocache
 155                 (void *to, const void __user *from, unsigned long n);
 156 unsigned long __must_check __copy_from_user_ll_nocache_nozero
 157                 (void *to, const void __user *from, unsigned long n);
 158
 159 /**
 160  * __copy_to_user_inatomic: - Copy a block of data into user space, with less checking.
 161  * @to:   Destination address, in user space.
 162  * @from: Source address, in kernel space.
 163  * @n:    Number of bytes to copy.
 164  *
 165  * Context: User context only.
 166  *
 167  * Copy data from kernel space to user space.  Caller must check
 168  * the specified block with access_ok() before calling this function.
 169  * The caller should also make sure he pins the user space address
 170  * so that the we don't result in page fault and sleep.
 171  *
 172  * Here we special-case 1, 2 and 4-byte copy_*_user invocations.  On a fault
 173  * we return the initial request size (1, 2 or 4), as copy_*_user should do.
 174  * If a store crosses a page boundary and gets a fault, the x86 will not write
 175  * anything, so this is accurate.
 176  */
 177
 178 static __always_inline unsigned long __must_check
 179 __copy_to_user_inatomic(void __user *to, const void *from, unsigned long n)
 180 {
 181         if (__builtin_constant_p(n)) {
 182                 unsigned long ret;
 183
 184                 switch (n) {
 185                 case 1:
 186                         __put_user_size(*(u8 *)from, (u8 __user *)to,
 187                                         1, ret, 1);
 188                         return ret;
 189                 case 2:
 190                         __put_user_size(*(u16 *)from, (u16 __user *)to,
 191                                         2, ret, 2);
 192                         return ret;
 193                 case 4:
 194                         __put_user_size(*(u32 *)from, (u32 __user *)to,
 195                                         4, ret, 4);
 196                         return ret;
 197                 }
 198         }
 199         return __copy_to_user_ll(to, from, n);
 200 }
 201
 202 /**
 203  * __copy_to_user: - Copy a block of data into user space, with less checking.
 204  * @to:   Destination address, in user space.
 205  * @from: Source address, in kernel space.
 206  * @n:    Number of bytes to copy.
 207  *
 208  * Context: User context only.  This function may sleep.
 209  *
 210  * Copy data from kernel space to user space.  Caller must check
 211  * the specified block with access_ok() before calling this function.
 212  *
 213  * Returns number of bytes that could not be copied.
 214  * On success, this will be zero.
 215  */
 216 static __always_inline unsigned long __must_check
 217 __copy_to_user(void __user *to, const void *from, unsigned long n)
 218 {
 219        might_sleep();
 220        return __copy_to_user_inatomic(to, from, n);
 221 }
 222
 223 static __always_inline unsigned long
 224 __copy_from_user_inatomic(void *to, const void __user *from, unsigned long n)
 225 {
 226         /* Avoid zeroing the tail if the copy fails..
 227          * If 'n' is constant and 1, 2, or 4, we do still zero on a failure,
 228          * but as the zeroing behaviour is only significant when n is not
 229          * constant, that shouldn't be a problem.
 230          */
 231         if (__builtin_constant_p(n)) {
 232                 unsigned long ret;
 233
 234                 switch (n) {
 235                 case 1:
 236                         __get_user_size(*(u8 *)to, from, 1, ret, 1);
 237                         return ret;
 238                 case 2:
 239                         __get_user_size(*(u16 *)to, from, 2, ret, 2);
 240                         return ret;
 241                 case 4:
 242                         __get_user_size(*(u32 *)to, from, 4, ret, 4);
 243                         return ret;
 244                 }
 245         }
 246         return __copy_from_user_ll_nozero(to, from, n);
 247 }
 248
 249 /**
 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.
 254  *
 255  * Context: User context only.  This function may sleep.
 256  *
 257  * Copy data from user space to kernel space.  Caller must check
 258  * the specified block with access_ok() before calling this function.
 259  *
 260  * Returns number of bytes that could not be copied.
 261  * On success, this will be zero.
 262  *
 263  * If some data could not be copied, this function will pad the copied
 264  * data to the requested size using zero bytes.
 265  *
 266  * An alternate version - __copy_from_user_inatomic() - may be called from
 267  * atomic context and will fail rather than sleep.  In this case the
 268  * uncopied bytes will *NOT* be padded with zeros.  See fs/filemap.h
 269  * for explanation of why this is needed.
 270  */
 271 static __always_inline unsigned long
 272 __copy_from_user(void *to, const void __user *from, unsigned long n)
 273 {
 274         might_sleep();
 275         if (__builtin_constant_p(n)) {
 276                 unsigned long ret;
 277
 278                 switch (n) {
 279                 case 1:
 280                         __get_user_size(*(u8 *)to, from, 1, ret, 1);
 281                         return ret;
 282                 case 2:
 283                         __get_user_size(*(u16 *)to, from, 2, ret, 2);
 284                         return ret;
 285                 case 4:
 286                         __get_user_size(*(u32 *)to, from, 4, ret, 4);
 287                         return ret;
 288                 }
 289         }
 290         return __copy_from_user_ll(to, from, n);
 291 }
 292
 293 #define ARCH_HAS_NOCACHE_UACCESS
 294
 295 static __always_inline unsigned long __copy_from_user_nocache(void *to,
 296                                 const void __user *from, unsigned long n)
 297 {
 298         might_sleep();
 299         if (__builtin_constant_p(n)) {
 300                 unsigned long ret;
 301
 302                 switch (n) {
 303                 case 1:
 304                         __get_user_size(*(u8 *)to, from, 1, ret, 1);
 305                         return ret;
 306                 case 2:
 307                         __get_user_size(*(u16 *)to, from, 2, ret, 2);
 308                         return ret;
 309                 case 4:
 310                         __get_user_size(*(u32 *)to, from, 4, ret, 4);
 311                         return ret;
 312                 }
 313         }
 314         return __copy_from_user_ll_nocache(to, from, n);
 315 }
 316
 317 static __always_inline unsigned long
 318 __copy_from_user_inatomic_nocache(void *to, const void __user *from,
 319                                   unsigned long n)
 320 {
 321        return __copy_from_user_ll_nocache_nozero(to, from, n);
 322 }
 323
 324 unsigned long __must_check copy_to_user(void __user *to,
 325                                         const void *from, unsigned long n);
 326 unsigned long __must_check copy_from_user(void *to,
 327                                           const void __user *from,
 328                                           unsigned long n);
 329 long __must_check strncpy_from_user(char *dst, const char __user *src,
 330                                     long count);
 331 long __must_check __strncpy_from_user(char *dst,
 332                                       const char __user *src, long count);
 333
 334 /**
 335  * strlen_user: - Get the size of a string in user space.
 336  * @str: The string to measure.
 337  *
 338  * Context: User context only.  This function may sleep.
 339  *
 340  * Get the size of a NUL-terminated string in user space.
 341  *
 342  * Returns the size of the string INCLUDING the terminating NUL.
 343  * On exception, returns 0.
 344  *
 345  * If there is a limit on the length of a valid string, you may wish to
 346  * consider using strnlen_user() instead.
 347  */
 348 #define strlen_user(str) strnlen_user(str, LONG_MAX)
 349
 350 long strnlen_user(const char __user *str, long n);
 351 unsigned long __must_check clear_user(void __user *mem, unsigned long len);
 352 unsigned long __must_check __clear_user(void __user *mem, unsigned long len);
 353
 354 #endif /* __i386_UACCESS_H */