arch/x86/include/asm/uaccess_64.h

   1 #ifndef _ASM_X86_UACCESS_64_H
   2 #define _ASM_X86_UACCESS_64_H
   3
   4 /*
   5  * User space memory access functions
   6  */
   7 #include <linux/compiler.h>
   8 #include <linux/errno.h>
   9 #include <linux/lockdep.h>
  10 #include <asm/alternative.h>
  11 #include <asm/cpufeature.h>
  12 #include <asm/page.h>
  13
  14 /*
  15  * Copy To/From Userspace
  16  */
  17
  18 /* Handles exceptions in both to and from, but doesn't do access_ok */
  19 __must_check unsigned long
  20 copy_user_generic_string(void *to, const void *from, unsigned len);
  21 __must_check unsigned long
  22 copy_user_generic_unrolled(void *to, const void *from, unsigned len);
  23
  24 static __always_inline __must_check unsigned long
  25 copy_user_generic(void *to, const void *from, unsigned len)
  26 {
  27         unsigned ret;
  28
  29         alternative_call(copy_user_generic_unrolled,
  30                          copy_user_generic_string,
  31                          X86_FEATURE_REP_GOOD,
  32                          ASM_OUTPUT2("=a" (ret), "=D" (to), "=S" (from),
  33                                      "=d" (len)),
  34                          "1" (to), "2" (from), "3" (len)
  35                          : "memory", "rcx", "r8", "r9", "r10", "r11");
  36         return ret;
  37 }
  38
  39 __must_check unsigned long
  40 _copy_to_user(void __user *to, const void *from, unsigned len);
  41 __must_check unsigned long
  42 _copy_from_user(void *to, const void __user *from, unsigned len);
  43 __must_check unsigned long
  44 copy_in_user(void __user *to, const void __user *from, unsigned len);
  45
  46 static inline unsigned long __must_check copy_from_user(void *to,
  47                                           const void __user *from,
  48                                           unsigned long n)
  49 {
  50         int sz = __compiletime_object_size(to);
  51
  52         might_fault();
  53         if (likely(sz == -1 || sz >= n))
  54                 n = _copy_from_user(to, from, n);
  55 #ifdef CONFIG_DEBUG_VM
  56         else
  57                 WARN(1, "Buffer overflow detected!\n");
  58 #endif
  59         return n;
  60 }
  61
  62 static __always_inline __must_check
  63 int copy_to_user(void __user *dst, const void *src, unsigned size)
  64 {
  65         might_fault();
  66
  67         return _copy_to_user(dst, src, size);
  68 }
  69
  70 static __always_inline __must_check
  71 int __copy_from_user_nocheck(void *dst, const void __user *src, unsigned size)
  72 {
  73         int ret = 0;
  74
  75         if (!__builtin_constant_p(size))
  76                 return copy_user_generic(dst, (__force void *)src, size);
  77         switch (size) {
  78         case 1:__get_user_asm(*(u8 *)dst, (u8 __user *)src,
  79                               ret, "b", "b", "=q", 1);
  80                 return ret;
  81         case 2:__get_user_asm(*(u16 *)dst, (u16 __user *)src,
  82                               ret, "w", "w", "=r", 2);
  83                 return ret;
  84         case 4:__get_user_asm(*(u32 *)dst, (u32 __user *)src,
  85                               ret, "l", "k", "=r", 4);
  86                 return ret;
  87         case 8:__get_user_asm(*(u64 *)dst, (u64 __user *)src,
  88                               ret, "q", "", "=r", 8);
  89                 return ret;
  90         case 10:
  91                 __get_user_asm(*(u64 *)dst, (u64 __user *)src,
  92                                ret, "q", "", "=r", 10);
  93                 if (unlikely(ret))
  94                         return ret;
  95                 __get_user_asm(*(u16 *)(8 + (char *)dst),
  96                                (u16 __user *)(8 + (char __user *)src),
  97                                ret, "w", "w", "=r", 2);
  98                 return ret;
  99         case 16:
 100                 __get_user_asm(*(u64 *)dst, (u64 __user *)src,
 101                                ret, "q", "", "=r", 16);
 102                 if (unlikely(ret))
 103                         return ret;
 104                 __get_user_asm(*(u64 *)(8 + (char *)dst),
 105                                (u64 __user *)(8 + (char __user *)src),
 106                                ret, "q", "", "=r", 8);
 107                 return ret;
 108         default:
 109                 return copy_user_generic(dst, (__force void *)src, size);
 110         }
 111 }
 112
 113 static __always_inline __must_check
 114 int __copy_from_user(void *dst, const void __user *src, unsigned size)
 115 {
 116         might_fault();
 117         return __copy_from_user_nocheck(dst, src, size);
 118 }
 119
 120 static __always_inline __must_check
 121 int __copy_to_user_nocheck(void __user *dst, const void *src, unsigned size)
 122 {
 123         int ret = 0;
 124
 125         if (!__builtin_constant_p(size))
 126                 return copy_user_generic((__force void *)dst, src, size);
 127         switch (size) {
 128         case 1:__put_user_asm(*(u8 *)src, (u8 __user *)dst,
 129                               ret, "b", "b", "iq", 1);
 130                 return ret;
 131         case 2:__put_user_asm(*(u16 *)src, (u16 __user *)dst,
 132                               ret, "w", "w", "ir", 2);
 133                 return ret;
 134         case 4:__put_user_asm(*(u32 *)src, (u32 __user *)dst,
 135                               ret, "l", "k", "ir", 4);
 136                 return ret;
 137         case 8:__put_user_asm(*(u64 *)src, (u64 __user *)dst,
 138                               ret, "q", "", "er", 8);
 139                 return ret;
 140         case 10:
 141                 __put_user_asm(*(u64 *)src, (u64 __user *)dst,
 142                                ret, "q", "", "er", 10);
 143                 if (unlikely(ret))
 144                         return ret;
 145                 asm("":::"memory");
 146                 __put_user_asm(4[(u16 *)src], 4 + (u16 __user *)dst,
 147                                ret, "w", "w", "ir", 2);
 148                 return ret;
 149         case 16:
 150                 __put_user_asm(*(u64 *)src, (u64 __user *)dst,
 151                                ret, "q", "", "er", 16);
 152                 if (unlikely(ret))
 153                         return ret;
 154                 asm("":::"memory");
 155                 __put_user_asm(1[(u64 *)src], 1 + (u64 __user *)dst,
 156                                ret, "q", "", "er", 8);
 157                 return ret;
 158         default:
 159                 return copy_user_generic((__force void *)dst, src, size);
 160         }
 161 }
 162
 163 static __always_inline __must_check
 164 int __copy_to_user(void __user *dst, const void *src, unsigned size)
 165 {
 166         might_fault();
 167         return __copy_to_user_nocheck(dst, src, size);
 168 }
 169
 170 static __always_inline __must_check
 171 int __copy_in_user(void __user *dst, const void __user *src, unsigned size)
 172 {
 173         int ret = 0;
 174
 175         might_fault();
 176         if (!__builtin_constant_p(size))
 177                 return copy_user_generic((__force void *)dst,
 178                                          (__force void *)src, size);
 179         switch (size) {
 180         case 1: {
 181                 u8 tmp;
 182                 __get_user_asm(tmp, (u8 __user *)src,
 183                                ret, "b", "b", "=q", 1);
 184                 if (likely(!ret))
 185                         __put_user_asm(tmp, (u8 __user *)dst,
 186                                        ret, "b", "b", "iq", 1);
 187                 return ret;
 188         }
 189         case 2: {
 190                 u16 tmp;
 191                 __get_user_asm(tmp, (u16 __user *)src,
 192                                ret, "w", "w", "=r", 2);
 193                 if (likely(!ret))
 194                         __put_user_asm(tmp, (u16 __user *)dst,
 195                                        ret, "w", "w", "ir", 2);
 196                 return ret;
 197         }
 198
 199         case 4: {
 200                 u32 tmp;
 201                 __get_user_asm(tmp, (u32 __user *)src,
 202                                ret, "l", "k", "=r", 4);
 203                 if (likely(!ret))
 204                         __put_user_asm(tmp, (u32 __user *)dst,
 205                                        ret, "l", "k", "ir", 4);
 206                 return ret;
 207         }
 208         case 8: {
 209                 u64 tmp;
 210                 __get_user_asm(tmp, (u64 __user *)src,
 211                                ret, "q", "", "=r", 8);
 212                 if (likely(!ret))
 213                         __put_user_asm(tmp, (u64 __user *)dst,
 214                                        ret, "q", "", "er", 8);
 215                 return ret;
 216         }
 217         default:
 218                 return copy_user_generic((__force void *)dst,
 219                                          (__force void *)src, size);
 220         }
 221 }
 222
 223 __must_check long
 224 strncpy_from_user(char *dst, const char __user *src, long count);
 225 __must_check long
 226 __strncpy_from_user(char *dst, const char __user *src, long count);
 227 __must_check long strnlen_user(const char __user *str, long n);
 228 __must_check long __strnlen_user(const char __user *str, long n);
 229 __must_check long strlen_user(const char __user *str);
 230 __must_check unsigned long clear_user(void __user *mem, unsigned long len);
 231 __must_check unsigned long __clear_user(void __user *mem, unsigned long len);
 232
 233 static __must_check __always_inline int
 234 __copy_from_user_inatomic(void *dst, const void __user *src, unsigned size)
 235 {
 236         return __copy_from_user_nocheck(dst, (__force const void *)src, size);
 237 }
 238
 239 static __must_check __always_inline int
 240 __copy_to_user_inatomic(void __user *dst, const void *src, unsigned size)
 241 {
 242         return __copy_to_user_nocheck((__force void *)dst, src, size);
 243 }
 244
 245 extern long __copy_user_nocache(void *dst, const void __user *src,
 246                                 unsigned size, int zerorest);
 247
 248 static inline int
 249 __copy_from_user_nocache(void *dst, const void __user *src, unsigned size)
 250 {
 251         might_sleep();
 252         return __copy_user_nocache(dst, src, size, 1);
 253 }
 254
 255 static inline int
 256 __copy_from_user_inatomic_nocache(void *dst, const void __user *src,
 257                                   unsigned size)
 258 {
 259         return __copy_user_nocache(dst, src, size, 0);
 260 }
 261
 262 unsigned long
 263 copy_user_handle_tail(char *to, char *from, unsigned len, unsigned zerorest);
 264
 265 #endif /* _ASM_X86_UACCESS_64_H */