arch/s390/include/asm/uaccess.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  *  S390 version
   4  *    Copyright IBM Corp. 1999, 2000
   5  *    Author(s): Hartmut Penner ([email protected]),
   6  *               Martin Schwidefsky ([email protected])
   7  *
   8  *  Derived from "include/asm-i386/uaccess.h"
   9  */
  10 #ifndef __S390_UACCESS_H
  11 #define __S390_UACCESS_H
  12
  13 /*
  14  * User space memory access functions
  15  */
  16 #include <asm/processor.h>
  17 #include <asm/ctl_reg.h>
  18 #include <asm/extable.h>
  19 #include <asm/facility.h>
  20
  21 void debug_user_asce(int exit);
  22
  23 static inline int __range_ok(unsigned long addr, unsigned long size)
  24 {
  25         return 1;
  26 }
  27
  28 #define __access_ok(addr, size)                         \
  29 ({                                                      \
  30         __chk_user_ptr(addr);                           \
  31         __range_ok((unsigned long)(addr), (size));      \
  32 })
  33
  34 #define access_ok(addr, size) __access_ok(addr, size)
  35
  36 unsigned long __must_check
  37 raw_copy_from_user(void *to, const void __user *from, unsigned long n);
  38
  39 unsigned long __must_check
  40 raw_copy_to_user(void __user *to, const void *from, unsigned long n);
  41
  42 #ifndef CONFIG_KASAN
  43 #define INLINE_COPY_FROM_USER
  44 #define INLINE_COPY_TO_USER
  45 #endif
  46
  47 int __put_user_bad(void) __attribute__((noreturn));
  48 int __get_user_bad(void) __attribute__((noreturn));
  49
  50 #ifdef CONFIG_HAVE_MARCH_Z10_FEATURES
  51
  52 #define __put_get_user_asm(to, from, size, insn)                \
  53 ({                                                              \
  54         int __rc;                                               \
  55                                                                 \
  56         asm volatile(                                           \
  57                 insn "          0,%[spec]\n"                    \
  58                 "0:     mvcos   %[_to],%[_from],%[_size]\n"     \
  59                 "1:     xr      %[rc],%[rc]\n"                  \
  60                 "2:\n"                                          \
  61                 ".pushsection .fixup, \"ax\"\n"                 \
  62                 "3:     lhi     %[rc],%[retval]\n"              \
  63                 "       jg      2b\n"                           \
  64                 ".popsection\n"                                 \
  65                 EX_TABLE(0b,3b) EX_TABLE(1b,3b)                 \
  66                 : [rc] "=&d" (__rc), [_to] "+Q" (*(to))         \
  67                 : [_size] "d" (size), [_from] "Q" (*(from)),    \
  68                   [retval] "K" (-EFAULT), [spec] "K" (0x81UL)   \
  69                 : "cc", "0");                                   \
  70         __rc;                                                   \
  71 })
  72
  73 static __always_inline int __put_user_fn(void *x, void __user *ptr, unsigned long size)
  74 {
  75         int rc;
  76
  77         switch (size) {
  78         case 1:
  79                 rc = __put_get_user_asm((unsigned char __user *)ptr,
  80                                         (unsigned char *)x,
  81                                         size, "llilh");
  82                 break;
  83         case 2:
  84                 rc = __put_get_user_asm((unsigned short __user *)ptr,
  85                                         (unsigned short *)x,
  86                                         size, "llilh");
  87                 break;
  88         case 4:
  89                 rc = __put_get_user_asm((unsigned int __user *)ptr,
  90                                         (unsigned int *)x,
  91                                         size, "llilh");
  92                 break;
  93         case 8:
  94                 rc = __put_get_user_asm((unsigned long __user *)ptr,
  95                                         (unsigned long *)x,
  96                                         size, "llilh");
  97                 break;
  98         default:
  99                 __put_user_bad();
 100                 break;
 101         }
 102         return rc;
 103 }
 104
 105 static __always_inline int __get_user_fn(void *x, const void __user *ptr, unsigned long size)
 106 {
 107         int rc;
 108
 109         switch (size) {
 110         case 1:
 111                 rc = __put_get_user_asm((unsigned char *)x,
 112                                         (unsigned char __user *)ptr,
 113                                         size, "lghi");
 114                 break;
 115         case 2:
 116                 rc = __put_get_user_asm((unsigned short *)x,
 117                                         (unsigned short __user *)ptr,
 118                                         size, "lghi");
 119                 break;
 120         case 4:
 121                 rc = __put_get_user_asm((unsigned int *)x,
 122                                         (unsigned int __user *)ptr,
 123                                         size, "lghi");
 124                 break;
 125         case 8:
 126                 rc = __put_get_user_asm((unsigned long *)x,
 127                                         (unsigned long __user *)ptr,
 128                                         size, "lghi");
 129                 break;
 130         default:
 131                 __get_user_bad();
 132                 break;
 133         }
 134         return rc;
 135 }
 136
 137 #else /* CONFIG_HAVE_MARCH_Z10_FEATURES */
 138
 139 static inline int __put_user_fn(void *x, void __user *ptr, unsigned long size)
 140 {
 141         size = raw_copy_to_user(ptr, x, size);
 142         return size ? -EFAULT : 0;
 143 }
 144
 145 static inline int __get_user_fn(void *x, const void __user *ptr, unsigned long size)
 146 {
 147         size = raw_copy_from_user(x, ptr, size);
 148         return size ? -EFAULT : 0;
 149 }
 150
 151 #endif /* CONFIG_HAVE_MARCH_Z10_FEATURES */
 152
 153 /*
 154  * These are the main single-value transfer routines.  They automatically
 155  * use the right size if we just have the right pointer type.
 156  */
 157 #define __put_user(x, ptr) \
 158 ({                                                              \
 159         __typeof__(*(ptr)) __x = (x);                           \
 160         int __pu_err = -EFAULT;                                 \
 161         __chk_user_ptr(ptr);                                    \
 162         switch (sizeof (*(ptr))) {                              \
 163         case 1:                                                 \
 164         case 2:                                                 \
 165         case 4:                                                 \
 166         case 8:                                                 \
 167                 __pu_err = __put_user_fn(&__x, ptr,             \
 168                                          sizeof(*(ptr)));       \
 169                 break;                                          \
 170         default:                                                \
 171                 __put_user_bad();                               \
 172                 break;                                          \
 173         }                                                       \
 174         __builtin_expect(__pu_err, 0);                          \
 175 })
 176
 177 #define put_user(x, ptr)                                        \
 178 ({                                                              \
 179         might_fault();                                          \
 180         __put_user(x, ptr);                                     \
 181 })
 182
 183
 184 #define __get_user(x, ptr)                                      \
 185 ({                                                              \
 186         int __gu_err = -EFAULT;                                 \
 187         __chk_user_ptr(ptr);                                    \
 188         switch (sizeof(*(ptr))) {                               \
 189         case 1: {                                               \
 190                 unsigned char __x = 0;                          \
 191                 __gu_err = __get_user_fn(&__x, ptr,             \
 192                                          sizeof(*(ptr)));       \
 193                 (x) = *(__force __typeof__(*(ptr)) *) &__x;     \
 194                 break;                                          \
 195         };                                                      \
 196         case 2: {                                               \
 197                 unsigned short __x = 0;                         \
 198                 __gu_err = __get_user_fn(&__x, ptr,             \
 199                                          sizeof(*(ptr)));       \
 200                 (x) = *(__force __typeof__(*(ptr)) *) &__x;     \
 201                 break;                                          \
 202         };                                                      \
 203         case 4: {                                               \
 204                 unsigned int __x = 0;                           \
 205                 __gu_err = __get_user_fn(&__x, ptr,             \
 206                                          sizeof(*(ptr)));       \
 207                 (x) = *(__force __typeof__(*(ptr)) *) &__x;     \
 208                 break;                                          \
 209         };                                                      \
 210         case 8: {                                               \
 211                 unsigned long long __x = 0;                     \
 212                 __gu_err = __get_user_fn(&__x, ptr,             \
 213                                          sizeof(*(ptr)));       \
 214                 (x) = *(__force __typeof__(*(ptr)) *) &__x;     \
 215                 break;                                          \
 216         };                                                      \
 217         default:                                                \
 218                 __get_user_bad();                               \
 219                 break;                                          \
 220         }                                                       \
 221         __builtin_expect(__gu_err, 0);                          \
 222 })
 223
 224 #define get_user(x, ptr)                                        \
 225 ({                                                              \
 226         might_fault();                                          \
 227         __get_user(x, ptr);                                     \
 228 })
 229
 230 /*
 231  * Copy a null terminated string from userspace.
 232  */
 233 long __must_check strncpy_from_user(char *dst, const char __user *src, long count);
 234
 235 long __must_check strnlen_user(const char __user *src, long count);
 236
 237 /*
 238  * Zero Userspace
 239  */
 240 unsigned long __must_check __clear_user(void __user *to, unsigned long size);
 241
 242 static inline unsigned long __must_check clear_user(void __user *to, unsigned long n)
 243 {
 244         might_fault();
 245         return __clear_user(to, n);
 246 }
 247
 248 int copy_to_user_real(void __user *dest, void *src, unsigned long count);
 249 void *s390_kernel_write(void *dst, const void *src, size_t size);
 250
 251 #define HAVE_GET_KERNEL_NOFAULT
 252
 253 int __noreturn __put_kernel_bad(void);
 254
 255 #define __put_kernel_asm(val, to, insn)                                 \
 256 ({                                                                      \
 257         int __rc;                                                       \
 258                                                                         \
 259         asm volatile(                                                   \
 260                 "0:   " insn "  %2,%1\n"                                \
 261                 "1:     xr      %0,%0\n"                                \
 262                 "2:\n"                                                  \
 263                 ".pushsection .fixup, \"ax\"\n"                         \
 264                 "3:     lhi     %0,%3\n"                                \
 265                 "       jg      2b\n"                                   \
 266                 ".popsection\n"                                         \
 267                 EX_TABLE(0b,3b) EX_TABLE(1b,3b)                         \
 268                 : "=d" (__rc), "+Q" (*(to))                             \
 269                 : "d" (val), "K" (-EFAULT)                              \
 270                 : "cc");                                                \
 271         __rc;                                                           \
 272 })
 273
 274 #define __put_kernel_nofault(dst, src, type, err_label)                 \
 275 do {                                                                    \
 276         u64 __x = (u64)(*((type *)(src)));                              \
 277         int __pk_err;                                                   \
 278                                                                         \
 279         switch (sizeof(type)) {                                         \
 280         case 1:                                                         \
 281                 __pk_err = __put_kernel_asm(__x, (type *)(dst), "stc"); \
 282                 break;                                                  \
 283         case 2:                                                         \
 284                 __pk_err = __put_kernel_asm(__x, (type *)(dst), "sth"); \
 285                 break;                                                  \
 286         case 4:                                                         \
 287                 __pk_err = __put_kernel_asm(__x, (type *)(dst), "st");  \
 288                 break;                                                  \
 289         case 8:                                                         \
 290                 __pk_err = __put_kernel_asm(__x, (type *)(dst), "stg"); \
 291                 break;                                                  \
 292         default:                                                        \
 293                 __pk_err = __put_kernel_bad();                          \
 294                 break;                                                  \
 295         }                                                               \
 296         if (unlikely(__pk_err))                                         \
 297                 goto err_label;                                         \
 298 } while (0)
 299
 300 int __noreturn __get_kernel_bad(void);
 301
 302 #define __get_kernel_asm(val, from, insn)                               \
 303 ({                                                                      \
 304         int __rc;                                                       \
 305                                                                         \
 306         asm volatile(                                                   \
 307                 "0:   " insn "  %1,%2\n"                                \
 308                 "1:     xr      %0,%0\n"                                \
 309                 "2:\n"                                                  \
 310                 ".pushsection .fixup, \"ax\"\n"                         \
 311                 "3:     lhi     %0,%3\n"                                \
 312                 "       jg      2b\n"                                   \
 313                 ".popsection\n"                                         \
 314                 EX_TABLE(0b,3b) EX_TABLE(1b,3b)                         \
 315                 : "=d" (__rc), "+d" (val)                               \
 316                 : "Q" (*(from)), "K" (-EFAULT)                          \
 317                 : "cc");                                                \
 318         __rc;                                                           \
 319 })
 320
 321 #define __get_kernel_nofault(dst, src, type, err_label)                 \
 322 do {                                                                    \
 323         int __gk_err;                                                   \
 324                                                                         \
 325         switch (sizeof(type)) {                                         \
 326         case 1: {                                                       \
 327                 u8 __x = 0;                                             \
 328                                                                         \
 329                 __gk_err = __get_kernel_asm(__x, (type *)(src), "ic");  \
 330                 *((type *)(dst)) = (type)__x;                           \
 331                 break;                                                  \
 332         };                                                              \
 333         case 2: {                                                       \
 334                 u16 __x = 0;                                            \
 335                                                                         \
 336                 __gk_err = __get_kernel_asm(__x, (type *)(src), "lh");  \
 337                 *((type *)(dst)) = (type)__x;                           \
 338                 break;                                                  \
 339         };                                                              \
 340         case 4: {                                                       \
 341                 u32 __x = 0;                                            \
 342                                                                         \
 343                 __gk_err = __get_kernel_asm(__x, (type *)(src), "l");   \
 344                 *((type *)(dst)) = (type)__x;                           \
 345                 break;                                                  \
 346         };                                                              \
 347         case 8: {                                                       \
 348                 u64 __x = 0;                                            \
 349                                                                         \
 350                 __gk_err = __get_kernel_asm(__x, (type *)(src), "lg");  \
 351                 *((type *)(dst)) = (type)__x;                           \
 352                 break;                                                  \
 353         };                                                              \
 354         default:                                                        \
 355                 __gk_err = __get_kernel_bad();                          \
 356                 break;                                                  \
 357         }                                                               \
 358         if (unlikely(__gk_err))                                         \
 359                 goto err_label;                                         \
 360 } while (0)
 361
 362 #endif /* __S390_UACCESS_H */