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 extern void copy_from_user_overflow(void)
  47 #ifdef CONFIG_DEBUG_STRICT_USER_COPY_CHECKS
  48         __compiletime_error("copy_from_user() buffer size is not provably correct")
  49 #else
  50         __compiletime_warning("copy_from_user() buffer size is not provably correct")
  51 #endif
  52 ;
  53
  54 static inline unsigned long __must_check copy_from_user(void *to,
  55                                           const void __user *from,
  56                                           unsigned long n)
  57 {
  58         int sz = __compiletime_object_size(to);
  59
  60         might_fault();
  61         if (likely(sz == -1 || sz >= n))
  62                 n = _copy_from_user(to, from, n);
  63         else
  64                 copy_from_user_overflow();
  65         return n;
  66 }
  67
  68 static __always_inline __must_check
  69 int copy_to_user(void __user *dst, const void *src, unsigned size)
  70 {
  71         might_fault();
  72
  73         return _copy_to_user(dst, src, size);
  74 }
  75
  76 static __always_inline __must_check
  77 int __copy_from_user(void *dst, const void __user *src, unsigned size)
  78 {
  79         int ret = 0;
  80
  81         might_fault();
  82         if (!__builtin_constant_p(size))
  83                 return copy_user_generic(dst, (__force void *)src, size);
  84         switch (size) {
  85         case 1:__get_user_asm(*(u8 *)dst, (u8 __user *)src,
  86                               ret, "b", "b", "=q", 1);
  87                 return ret;
  88         case 2:__get_user_asm(*(u16 *)dst, (u16 __user *)src,
  89                               ret, "w", "w", "=r", 2);
  90                 return ret;
  91         case 4:__get_user_asm(*(u32 *)dst, (u32 __user *)src,
  92                               ret, "l", "k", "=r", 4);
  93                 return ret;
  94         case 8:__get_user_asm(*(u64 *)dst, (u64 __user *)src,
  95                               ret, "q", "", "=r", 8);
  96                 return ret;
  97         case 10:
  98                 __get_user_asm(*(u64 *)dst, (u64 __user *)src,
  99                                ret, "q", "", "=r", 10);
 100                 if (unlikely(ret))
 101                         return ret;
 102                 __get_user_asm(*(u16 *)(8 + (char *)dst),
 103                                (u16 __user *)(8 + (char __user *)src),
 104                                ret, "w", "w", "=r", 2);
 105                 return ret;
 106         case 16:
 107                 __get_user_asm(*(u64 *)dst, (u64 __user *)src,
 108                                ret, "q", "", "=r", 16);
 109                 if (unlikely(ret))
 110                         return ret;
 111                 __get_user_asm(*(u64 *)(8 + (char *)dst),
 112                                (u64 __user *)(8 + (char __user *)src),
 113                                ret, "q", "", "=r", 8);
 114                 return ret;
 115         default:
 116                 return copy_user_generic(dst, (__force void *)src, size);
 117         }
 118 }
 119
 120 static __always_inline __must_check
 121 int __copy_to_user(void __user *dst, const void *src, unsigned size)
 122 {
 123         int ret = 0;
 124
 125         might_fault();
 126         if (!__builtin_constant_p(size))
 127                 return copy_user_generic((__force void *)dst, src, size);
 128         switch (size) {
 129         case 1:__put_user_asm(*(u8 *)src, (u8 __user *)dst,
 130                               ret, "b", "b", "iq", 1);
 131                 return ret;
 132         case 2:__put_user_asm(*(u16 *)src, (u16 __user *)dst,
 133                               ret, "w", "w", "ir", 2);
 134                 return ret;
 135         case 4:__put_user_asm(*(u32 *)src, (u32 __user *)dst,
 136                               ret, "l", "k", "ir", 4);
 137                 return ret;
 138         case 8:__put_user_asm(*(u64 *)src, (u64 __user *)dst,
 139                               ret, "q", "", "er", 8);
 140                 return ret;
 141         case 10:
 142                 __put_user_asm(*(u64 *)src, (u64 __user *)dst,
 143                                ret, "q", "", "er", 10);
 144                 if (unlikely(ret))
 145                         return ret;
 146                 asm("":::"memory");
 147                 __put_user_asm(4[(u16 *)src], 4 + (u16 __user *)dst,
 148                                ret, "w", "w", "ir", 2);
 149                 return ret;
 150         case 16:
 151                 __put_user_asm(*(u64 *)src, (u64 __user *)dst,
 152                                ret, "q", "", "er", 16);
 153                 if (unlikely(ret))
 154                         return ret;
 155                 asm("":::"memory");
 156                 __put_user_asm(1[(u64 *)src], 1 + (u64 __user *)dst,
 157                                ret, "q", "", "er", 8);
 158                 return ret;
 159         default:
 160                 return copy_user_generic((__force void *)dst, src, size);
 161         }
 162 }
 163
 164 static __always_inline __must_check
 165 int __copy_in_user(void __user *dst, const void __user *src, unsigned size)
 166 {
 167         int ret = 0;
 168
 169         might_fault();
 170         if (!__builtin_constant_p(size))
 171                 return copy_user_generic((__force void *)dst,
 172                                          (__force void *)src, size);
 173         switch (size) {
 174         case 1: {
 175                 u8 tmp;
 176                 __get_user_asm(tmp, (u8 __user *)src,
 177                                ret, "b", "b", "=q", 1);
 178                 if (likely(!ret))
 179                         __put_user_asm(tmp, (u8 __user *)dst,
 180                                        ret, "b", "b", "iq", 1);
 181                 return ret;
 182         }
 183         case 2: {
 184                 u16 tmp;
 185                 __get_user_asm(tmp, (u16 __user *)src,
 186                                ret, "w", "w", "=r", 2);
 187                 if (likely(!ret))
 188                         __put_user_asm(tmp, (u16 __user *)dst,
 189                                        ret, "w", "w", "ir", 2);
 190                 return ret;
 191         }
 192
 193         case 4: {
 194                 u32 tmp;
 195                 __get_user_asm(tmp, (u32 __user *)src,
 196                                ret, "l", "k", "=r", 4);
 197                 if (likely(!ret))
 198                         __put_user_asm(tmp, (u32 __user *)dst,
 199                                        ret, "l", "k", "ir", 4);
 200                 return ret;
 201         }
 202         case 8: {
 203                 u64 tmp;
 204                 __get_user_asm(tmp, (u64 __user *)src,
 205                                ret, "q", "", "=r", 8);
 206                 if (likely(!ret))
 207                         __put_user_asm(tmp, (u64 __user *)dst,
 208                                        ret, "q", "", "er", 8);
 209                 return ret;
 210         }
 211         default:
 212                 return copy_user_generic((__force void *)dst,
 213                                          (__force void *)src, size);
 214         }
 215 }
 216
 217 __must_check long
 218 strncpy_from_user(char *dst, const char __user *src, long count);
 219 __must_check long
 220 __strncpy_from_user(char *dst, const char __user *src, long count);
 221 __must_check long strnlen_user(const char __user *str, long n);
 222 __must_check long __strnlen_user(const char __user *str, long n);
 223 __must_check long strlen_user(const char __user *str);
 224 __must_check unsigned long clear_user(void __user *mem, unsigned long len);
 225 __must_check unsigned long __clear_user(void __user *mem, unsigned long len);
 226
 227 static __must_check __always_inline int
 228 __copy_from_user_inatomic(void *dst, const void __user *src, unsigned size)
 229 {
 230         return copy_user_generic(dst, (__force const void *)src, size);
 231 }
 232
 233 static __must_check __always_inline int
 234 __copy_to_user_inatomic(void __user *dst, const void *src, unsigned size)
 235 {
 236         return copy_user_generic((__force void *)dst, src, size);
 237 }
 238
 239 extern long __copy_user_nocache(void *dst, const void __user *src,
 240                                 unsigned size, int zerorest);
 241
 242 static inline int
 243 __copy_from_user_nocache(void *dst, const void __user *src, unsigned size)
 244 {
 245         might_sleep();
 246         return __copy_user_nocache(dst, src, size, 1);
 247 }
 248
 249 static inline int
 250 __copy_from_user_inatomic_nocache(void *dst, const void __user *src,
 251                                   unsigned size)
 252 {
 253         return __copy_user_nocache(dst, src, size, 0);
 254 }
 255
 256 unsigned long
 257 copy_user_handle_tail(char *to, char *from, unsigned len, unsigned zerorest);
 258
 259 #endif /* _ASM_X86_UACCESS_64_H */