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:
  79                 barrier_nospec();
  80                 __get_user_asm(*(u8 *)dst, (u8 __user *)src,
  81                               ret, "b", "b", "=q", 1);
  82                 return ret;
  83         case 2:
  84                 barrier_nospec();
  85                 __get_user_asm(*(u16 *)dst, (u16 __user *)src,
  86                               ret, "w", "w", "=r", 2);
  87                 return ret;
  88         case 4:
  89                 barrier_nospec();
  90                 __get_user_asm(*(u32 *)dst, (u32 __user *)src,
  91                               ret, "l", "k", "=r", 4);
  92                 return ret;
  93         case 8:
  94                 barrier_nospec();
  95                 __get_user_asm(*(u64 *)dst, (u64 __user *)src,
  96                               ret, "q", "", "=r", 8);
  97                 return ret;
  98         case 10:
  99                 barrier_nospec();
 100                 __get_user_asm(*(u64 *)dst, (u64 __user *)src,
 101                                ret, "q", "", "=r", 10);
 102                 if (unlikely(ret))
 103                         return ret;
 104                 __get_user_asm(*(u16 *)(8 + (char *)dst),
 105                                (u16 __user *)(8 + (char __user *)src),
 106                                ret, "w", "w", "=r", 2);
 107                 return ret;
 108         case 16:
 109                 barrier_nospec();
 110                 __get_user_asm(*(u64 *)dst, (u64 __user *)src,
 111                                ret, "q", "", "=r", 16);
 112                 if (unlikely(ret))
 113                         return ret;
 114                 __get_user_asm(*(u64 *)(8 + (char *)dst),
 115                                (u64 __user *)(8 + (char __user *)src),
 116                                ret, "q", "", "=r", 8);
 117                 return ret;
 118         default:
 119                 return copy_user_generic(dst, (__force void *)src, size);
 120         }
 121 }
 122
 123 static __always_inline __must_check
 124 int __copy_from_user(void *dst, const void __user *src, unsigned size)
 125 {
 126         might_fault();
 127         return __copy_from_user_nocheck(dst, src, size);
 128 }
 129
 130 static __always_inline __must_check
 131 int __copy_to_user_nocheck(void __user *dst, const void *src, unsigned size)
 132 {
 133         int ret = 0;
 134
 135         if (!__builtin_constant_p(size))
 136                 return copy_user_generic((__force void *)dst, src, size);
 137         switch (size) {
 138         case 1:__put_user_asm(*(u8 *)src, (u8 __user *)dst,
 139                               ret, "b", "b", "iq", 1);
 140                 return ret;
 141         case 2:__put_user_asm(*(u16 *)src, (u16 __user *)dst,
 142                               ret, "w", "w", "ir", 2);
 143                 return ret;
 144         case 4:__put_user_asm(*(u32 *)src, (u32 __user *)dst,
 145                               ret, "l", "k", "ir", 4);
 146                 return ret;
 147         case 8:__put_user_asm(*(u64 *)src, (u64 __user *)dst,
 148                               ret, "q", "", "er", 8);
 149                 return ret;
 150         case 10:
 151                 __put_user_asm(*(u64 *)src, (u64 __user *)dst,
 152                                ret, "q", "", "er", 10);
 153                 if (unlikely(ret))
 154                         return ret;
 155                 asm("":::"memory");
 156                 __put_user_asm(4[(u16 *)src], 4 + (u16 __user *)dst,
 157                                ret, "w", "w", "ir", 2);
 158                 return ret;
 159         case 16:
 160                 __put_user_asm(*(u64 *)src, (u64 __user *)dst,
 161                                ret, "q", "", "er", 16);
 162                 if (unlikely(ret))
 163                         return ret;
 164                 asm("":::"memory");
 165                 __put_user_asm(1[(u64 *)src], 1 + (u64 __user *)dst,
 166                                ret, "q", "", "er", 8);
 167                 return ret;
 168         default:
 169                 return copy_user_generic((__force void *)dst, src, size);
 170         }
 171 }
 172
 173 static __always_inline __must_check
 174 int __copy_to_user(void __user *dst, const void *src, unsigned size)
 175 {
 176         might_fault();
 177         return __copy_to_user_nocheck(dst, src, size);
 178 }
 179
 180 static __always_inline __must_check
 181 int __copy_in_user(void __user *dst, const void __user *src, unsigned size)
 182 {
 183         int ret = 0;
 184
 185         might_fault();
 186         if (!__builtin_constant_p(size))
 187                 return copy_user_generic((__force void *)dst,
 188                                          (__force void *)src, size);
 189         switch (size) {
 190         case 1: {
 191                 u8 tmp;
 192                 barrier_nospec();
 193                 __get_user_asm(tmp, (u8 __user *)src,
 194                                ret, "b", "b", "=q", 1);
 195                 if (likely(!ret))
 196                         __put_user_asm(tmp, (u8 __user *)dst,
 197                                        ret, "b", "b", "iq", 1);
 198                 return ret;
 199         }
 200         case 2: {
 201                 u16 tmp;
 202                 barrier_nospec();
 203                 __get_user_asm(tmp, (u16 __user *)src,
 204                                ret, "w", "w", "=r", 2);
 205                 if (likely(!ret))
 206                         __put_user_asm(tmp, (u16 __user *)dst,
 207                                        ret, "w", "w", "ir", 2);
 208                 return ret;
 209         }
 210
 211         case 4: {
 212                 u32 tmp;
 213                 barrier_nospec();
 214                 __get_user_asm(tmp, (u32 __user *)src,
 215                                ret, "l", "k", "=r", 4);
 216                 if (likely(!ret))
 217                         __put_user_asm(tmp, (u32 __user *)dst,
 218                                        ret, "l", "k", "ir", 4);
 219                 return ret;
 220         }
 221         case 8: {
 222                 u64 tmp;
 223                 barrier_nospec();
 224                 __get_user_asm(tmp, (u64 __user *)src,
 225                                ret, "q", "", "=r", 8);
 226                 if (likely(!ret))
 227                         __put_user_asm(tmp, (u64 __user *)dst,
 228                                        ret, "q", "", "er", 8);
 229                 return ret;
 230         }
 231         default:
 232                 return copy_user_generic((__force void *)dst,
 233                                          (__force void *)src, size);
 234         }
 235 }
 236
 237 __must_check long
 238 strncpy_from_user(char *dst, const char __user *src, long count);
 239 __must_check long
 240 __strncpy_from_user(char *dst, const char __user *src, long count);
 241 __must_check long strnlen_user(const char __user *str, long n);
 242 __must_check long __strnlen_user(const char __user *str, long n);
 243 __must_check long strlen_user(const char __user *str);
 244 __must_check unsigned long clear_user(void __user *mem, unsigned long len);
 245 __must_check unsigned long __clear_user(void __user *mem, unsigned long len);
 246
 247 static __must_check __always_inline int
 248 __copy_from_user_inatomic(void *dst, const void __user *src, unsigned size)
 249 {
 250         return __copy_from_user_nocheck(dst, src, size);
 251 }
 252
 253 static __must_check __always_inline int
 254 __copy_to_user_inatomic(void __user *dst, const void *src, unsigned size)
 255 {
 256         return __copy_to_user_nocheck(dst, src, size);
 257 }
 258
 259 extern long __copy_user_nocache(void *dst, const void __user *src,
 260                                 unsigned size, int zerorest);
 261
 262 static inline int
 263 __copy_from_user_nocache(void *dst, const void __user *src, unsigned size)
 264 {
 265         might_sleep();
 266         return __copy_user_nocache(dst, src, size, 1);
 267 }
 268
 269 static inline int
 270 __copy_from_user_inatomic_nocache(void *dst, const void __user *src,
 271                                   unsigned size)
 272 {
 273         return __copy_user_nocache(dst, src, size, 0);
 274 }
 275
 276 unsigned long
 277 copy_user_handle_tail(char *to, char *from, unsigned len, unsigned zerorest);
 278
 279 #endif /* _ASM_X86_UACCESS_64_H */