arch/csky/include/asm/uaccess.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 // Copyright (C) 2018 Hangzhou C-SKY Microsystems co.,ltd.
   3
   4 #ifndef __ASM_CSKY_UACCESS_H
   5 #define __ASM_CSKY_UACCESS_H
   6
   7 /*
   8  * User space memory access functions
   9  */
  10 #include <linux/compiler.h>
  11 #include <linux/errno.h>
  12 #include <linux/types.h>
  13 #include <linux/sched.h>
  14 #include <linux/mm.h>
  15 #include <linux/string.h>
  16 #include <linux/version.h>
  17 #include <asm/segment.h>
  18
  19 #define VERIFY_READ     0
  20 #define VERIFY_WRITE    1
  21
  22 static inline int access_ok(int type, const void *addr, unsigned long size)
  23 {
  24         unsigned long limit = current_thread_info()->addr_limit.seg;
  25
  26         return (((unsigned long)addr < limit) &&
  27                 ((unsigned long)(addr + size) < limit));
  28 }
  29
  30 static inline int verify_area(int type, const void *addr, unsigned long size)
  31 {
  32         return access_ok(type, addr, size) ? 0 : -EFAULT;
  33 }
  34
  35 #define __addr_ok(addr) (access_ok(VERIFY_READ, addr, 0))
  36
  37 extern int __put_user_bad(void);
  38
  39 /*
  40  * Tell gcc we read from memory instead of writing: this is because
  41  * we do not write to any memory gcc knows about, so there are no
  42  * aliasing issues.
  43  */
  44
  45 /*
  46  * These are the main single-value transfer routines.  They automatically
  47  * use the right size if we just have the right pointer type.
  48  *
  49  * This gets kind of ugly. We want to return _two_ values in "get_user()"
  50  * and yet we don't want to do any pointers, because that is too much
  51  * of a performance impact. Thus we have a few rather ugly macros here,
  52  * and hide all the ugliness from the user.
  53  *
  54  * The "__xxx" versions of the user access functions are versions that
  55  * do not verify the address space, that must have been done previously
  56  * with a separate "access_ok()" call (this is used when we do multiple
  57  * accesses to the same area of user memory).
  58  *
  59  * As we use the same address space for kernel and user data on
  60  * Ckcore, we can just do these as direct assignments.  (Of course, the
  61  * exception handling means that it's no longer "just"...)
  62  */
  63
  64 #define put_user(x, ptr) \
  65         __put_user_check((x), (ptr), sizeof(*(ptr)))
  66
  67 #define __put_user(x, ptr) \
  68         __put_user_nocheck((x), (ptr), sizeof(*(ptr)))
  69
  70 #define __ptr(x) ((unsigned long *)(x))
  71
  72 #define get_user(x, ptr) \
  73         __get_user_check((x), (ptr), sizeof(*(ptr)))
  74
  75 #define __get_user(x, ptr) \
  76         __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
  77
  78 #define __put_user_nocheck(x, ptr, size)                                \
  79 ({                                                                      \
  80         long __pu_err = 0;                                              \
  81         typeof(*(ptr)) *__pu_addr = (ptr);                              \
  82         typeof(*(ptr)) __pu_val = (typeof(*(ptr)))(x);                  \
  83         if (__pu_addr)                                                  \
  84                 __put_user_size(__pu_val, (__pu_addr), (size),          \
  85                                 __pu_err);                              \
  86         __pu_err;                                                       \
  87 })
  88
  89 #define __put_user_check(x, ptr, size)                                  \
  90 ({                                                                      \
  91         long __pu_err = -EFAULT;                                        \
  92         typeof(*(ptr)) *__pu_addr = (ptr);                              \
  93         typeof(*(ptr)) __pu_val = (typeof(*(ptr)))(x);                  \
  94         if (access_ok(VERIFY_WRITE, __pu_addr, size) && __pu_addr)      \
  95                 __put_user_size(__pu_val, __pu_addr, (size), __pu_err); \
  96         __pu_err;                                                       \
  97 })
  98
  99 #define __put_user_size(x, ptr, size, retval)           \
 100 do {                                                    \
 101         retval = 0;                                     \
 102         switch (size) {                                 \
 103         case 1:                                         \
 104                 __put_user_asm_b(x, ptr, retval);       \
 105                 break;                                  \
 106         case 2:                                         \
 107                 __put_user_asm_h(x, ptr, retval);       \
 108                 break;                                  \
 109         case 4:                                         \
 110                 __put_user_asm_w(x, ptr, retval);       \
 111                 break;                                  \
 112         case 8:                                         \
 113                 __put_user_asm_64(x, ptr, retval);      \
 114                 break;                                  \
 115         default:                                        \
 116                 __put_user_bad();                       \
 117         }                                               \
 118 } while (0)
 119
 120 /*
 121  * We don't tell gcc that we are accessing memory, but this is OK
 122  * because we do not write to any memory gcc knows about, so there
 123  * are no aliasing issues.
 124  *
 125  * Note that PC at a fault is the address *after* the faulting
 126  * instruction.
 127  */
 128 #define __put_user_asm_b(x, ptr, err)                   \
 129 do {                                                    \
 130         int errcode;                                    \
 131         asm volatile(                                   \
 132         "1:     stb   %1, (%2,0)        \n"             \
 133         "       br    3f                \n"             \
 134         "2:     mov   %0, %3            \n"             \
 135         "       br    3f                \n"             \
 136         ".section __ex_table, \"a\"     \n"             \
 137         ".align   2                     \n"             \
 138         ".long    1b,2b                 \n"             \
 139         ".previous                      \n"             \
 140         "3:                             \n"             \
 141         : "=r"(err), "=r"(x), "=r"(ptr), "=r"(errcode)  \
 142         : "0"(err), "1"(x), "2"(ptr), "3"(-EFAULT)      \
 143         : "memory");                                    \
 144 } while (0)
 145
 146 #define __put_user_asm_h(x, ptr, err)                   \
 147 do {                                                    \
 148         int errcode;                                    \
 149         asm volatile(                                   \
 150         "1:     sth   %1, (%2,0)        \n"             \
 151         "       br    3f                \n"             \
 152         "2:     mov   %0, %3            \n"             \
 153         "       br    3f                \n"             \
 154         ".section __ex_table, \"a\"     \n"             \
 155         ".align   2                     \n"             \
 156         ".long    1b,2b                 \n"             \
 157         ".previous                      \n"             \
 158         "3:                             \n"             \
 159         : "=r"(err), "=r"(x), "=r"(ptr), "=r"(errcode)  \
 160         : "0"(err), "1"(x), "2"(ptr), "3"(-EFAULT)      \
 161         : "memory");                                    \
 162 } while (0)
 163
 164 #define __put_user_asm_w(x, ptr, err)                   \
 165 do {                                                    \
 166         int errcode;                                    \
 167         asm volatile(                                   \
 168         "1:     stw   %1, (%2,0)        \n"             \
 169         "       br    3f                \n"             \
 170         "2:     mov   %0, %3            \n"             \
 171         "       br    3f                \n"             \
 172         ".section __ex_table,\"a\"      \n"             \
 173         ".align   2                     \n"             \
 174         ".long    1b, 2b                \n"             \
 175         ".previous                      \n"             \
 176         "3:                             \n"             \
 177         : "=r"(err), "=r"(x), "=r"(ptr), "=r"(errcode)  \
 178         : "0"(err), "1"(x), "2"(ptr), "3"(-EFAULT)      \
 179         : "memory");                                    \
 180 } while (0)
 181
 182 #define __put_user_asm_64(x, ptr, err)                          \
 183 do {                                                            \
 184         int tmp;                                                \
 185         int errcode;                                            \
 186         typeof(*(ptr))src = (typeof(*(ptr)))x;                  \
 187         typeof(*(ptr))*psrc = &src;                             \
 188                                                                 \
 189         asm volatile(                                           \
 190         "     ldw     %3, (%1, 0)     \n"                       \
 191         "1:   stw     %3, (%2, 0)     \n"                       \
 192         "     ldw     %3, (%1, 4)     \n"                       \
 193         "2:   stw     %3, (%2, 4)     \n"                       \
 194         "     br      4f              \n"                       \
 195         "3:   mov     %0, %4          \n"                       \
 196         "     br      4f              \n"                       \
 197         ".section __ex_table, \"a\"   \n"                       \
 198         ".align   2                   \n"                       \
 199         ".long    1b, 3b              \n"                       \
 200         ".long    2b, 3b              \n"                       \
 201         ".previous                    \n"                       \
 202         "4:                           \n"                       \
 203         : "=r"(err), "=r"(psrc), "=r"(ptr),                     \
 204           "=r"(tmp), "=r"(errcode)                              \
 205         : "0"(err), "1"(psrc), "2"(ptr), "3"(0), "4"(-EFAULT)   \
 206         : "memory");                                            \
 207 } while (0)
 208
 209 #define __get_user_nocheck(x, ptr, size)                        \
 210 ({                                                              \
 211         long  __gu_err;                                         \
 212         __get_user_size(x, (ptr), (size), __gu_err);            \
 213         __gu_err;                                               \
 214 })
 215
 216 #define __get_user_check(x, ptr, size)                          \
 217 ({                                                              \
 218         int __gu_err = -EFAULT;                                 \
 219         const __typeof__(*(ptr)) __user *__gu_ptr = (ptr);      \
 220         if (access_ok(VERIFY_READ, __gu_ptr, size) && __gu_ptr) \
 221                 __get_user_size(x, __gu_ptr, size, __gu_err);   \
 222         __gu_err;                                               \
 223 })
 224
 225 #define __get_user_size(x, ptr, size, retval)                   \
 226 do {                                                            \
 227         switch (size) {                                         \
 228         case 1:                                                 \
 229                 __get_user_asm_common((x), ptr, "ldb", retval); \
 230                 break;                                          \
 231         case 2:                                                 \
 232                 __get_user_asm_common((x), ptr, "ldh", retval); \
 233                 break;                                          \
 234         case 4:                                                 \
 235                 __get_user_asm_common((x), ptr, "ldw", retval); \
 236                 break;                                          \
 237         default:                                                \
 238                 x = 0;                                          \
 239                 (retval) = __get_user_bad();                    \
 240         }                                                       \
 241 } while (0)
 242
 243 #define __get_user_asm_common(x, ptr, ins, err)                 \
 244 do {                                                            \
 245         int errcode;                                            \
 246         asm volatile(                                           \
 247         "1:   " ins " %1, (%4,0)        \n"                     \
 248         "       br    3f                \n"                     \
 249         /* Fix up codes */                                      \
 250         "2:     mov   %0, %2            \n"                     \
 251         "       movi  %1, 0             \n"                     \
 252         "       br    3f                \n"                     \
 253         ".section __ex_table,\"a\"      \n"                     \
 254         ".align   2                     \n"                     \
 255         ".long    1b, 2b                \n"                     \
 256         ".previous                      \n"                     \
 257         "3:                             \n"                     \
 258         : "=r"(err), "=r"(x), "=r"(errcode)                     \
 259         : "0"(0), "r"(ptr), "2"(-EFAULT)                        \
 260         : "memory");                                            \
 261 } while (0)
 262
 263 extern int __get_user_bad(void);
 264
 265 #define __copy_user(to, from, n)                        \
 266 do {                                                    \
 267         int w0, w1, w2, w3;                             \
 268         asm volatile(                                   \
 269         "0:     cmpnei  %1, 0           \n"             \
 270         "       bf      8f              \n"             \
 271         "       mov     %3, %1          \n"             \
 272         "       or      %3, %2          \n"             \
 273         "       andi    %3, 3           \n"             \
 274         "       cmpnei  %3, 0           \n"             \
 275         "       bf      1f              \n"             \
 276         "       br      5f              \n"             \
 277         "1:     cmplti  %0, 16          \n" /* 4W */    \
 278         "       bt      3f              \n"             \
 279         "       ldw     %3, (%2, 0)     \n"             \
 280         "       ldw     %4, (%2, 4)     \n"             \
 281         "       ldw     %5, (%2, 8)     \n"             \
 282         "       ldw     %6, (%2, 12)    \n"             \
 283         "2:     stw     %3, (%1, 0)     \n"             \
 284         "9:     stw     %4, (%1, 4)     \n"             \
 285         "10:    stw     %5, (%1, 8)     \n"             \
 286         "11:    stw     %6, (%1, 12)    \n"             \
 287         "       addi    %2, 16          \n"             \
 288         "       addi    %1, 16          \n"             \
 289         "       subi    %0, 16          \n"             \
 290         "       br      1b              \n"             \
 291         "3:     cmplti  %0, 4           \n" /* 1W */    \
 292         "       bt      5f              \n"             \
 293         "       ldw     %3, (%2, 0)     \n"             \
 294         "4:     stw     %3, (%1, 0)     \n"             \
 295         "       addi    %2, 4           \n"             \
 296         "       addi    %1, 4           \n"             \
 297         "       subi    %0, 4           \n"             \
 298         "       br      3b              \n"             \
 299         "5:     cmpnei  %0, 0           \n"  /* 1B */   \
 300         "       bf      8f              \n"             \
 301         "       ldb     %3, (%2, 0)     \n"             \
 302         "6:     stb     %3, (%1, 0)     \n"             \
 303         "       addi    %2,  1          \n"             \
 304         "       addi    %1,  1          \n"             \
 305         "       subi    %0,  1          \n"             \
 306         "       br      5b              \n"             \
 307         "7:     br      8f              \n"             \
 308         ".section __ex_table, \"a\"     \n"             \
 309         ".align   2                     \n"             \
 310         ".long    2b, 7b                \n"             \
 311         ".long    9b, 7b                \n"             \
 312         ".long   10b, 7b                \n"             \
 313         ".long   11b, 7b                \n"             \
 314         ".long    4b, 7b                \n"             \
 315         ".long    6b, 7b                \n"             \
 316         ".previous                      \n"             \
 317         "8:                             \n"             \
 318         : "=r"(n), "=r"(to), "=r"(from), "=r"(w0),      \
 319           "=r"(w1), "=r"(w2), "=r"(w3)                  \
 320         : "0"(n), "1"(to), "2"(from)                    \
 321         : "memory");                                    \
 322 } while (0)
 323
 324 #define __copy_user_zeroing(to, from, n)                \
 325 do {                                                    \
 326         int tmp;                                        \
 327         int nsave;                                      \
 328         asm volatile(                                   \
 329         "0:     cmpnei  %1, 0           \n"             \
 330         "       bf      7f              \n"             \
 331         "       mov     %3, %1          \n"             \
 332         "       or      %3, %2          \n"             \
 333         "       andi    %3, 3           \n"             \
 334         "       cmpnei  %3, 0           \n"             \
 335         "       bf      1f              \n"             \
 336         "       br      5f              \n"             \
 337         "1:     cmplti  %0, 16          \n"             \
 338         "       bt      3f              \n"             \
 339         "2:     ldw     %3, (%2, 0)     \n"             \
 340         "10:    ldw     %4, (%2, 4)     \n"             \
 341         "       stw     %3, (%1, 0)     \n"             \
 342         "       stw     %4, (%1, 4)     \n"             \
 343         "11:    ldw     %3, (%2, 8)     \n"             \
 344         "12:    ldw     %4, (%2, 12)    \n"             \
 345         "       stw     %3, (%1, 8)     \n"             \
 346         "       stw     %4, (%1, 12)    \n"             \
 347         "       addi    %2, 16          \n"             \
 348         "       addi    %1, 16          \n"             \
 349         "       subi    %0, 16          \n"             \
 350         "       br      1b              \n"             \
 351         "3:     cmplti  %0, 4           \n"             \
 352         "       bt      5f              \n"             \
 353         "4:     ldw     %3, (%2, 0)     \n"             \
 354         "       stw     %3, (%1, 0)     \n"             \
 355         "       addi    %2, 4           \n"             \
 356         "       addi    %1, 4           \n"             \
 357         "       subi    %0, 4           \n"             \
 358         "       br      3b              \n"             \
 359         "5:     cmpnei  %0, 0           \n"             \
 360         "       bf      7f              \n"             \
 361         "6:     ldb     %3, (%2, 0)     \n"             \
 362         "       stb     %3, (%1, 0)     \n"             \
 363         "       addi    %2,  1          \n"             \
 364         "       addi    %1,  1          \n"             \
 365         "       subi    %0,  1          \n"             \
 366         "       br      5b              \n"             \
 367         "8:     mov     %3, %0          \n"             \
 368         "       movi    %4, 0           \n"             \
 369         "9:     stb     %4, (%1, 0)     \n"             \
 370         "       addi    %1, 1           \n"             \
 371         "       subi    %3, 1           \n"             \
 372         "       cmpnei  %3, 0           \n"             \
 373         "       bt      9b              \n"             \
 374         "       br      7f              \n"             \
 375         ".section __ex_table, \"a\"     \n"             \
 376         ".align   2                     \n"             \
 377         ".long    2b, 8b                \n"             \
 378         ".long   10b, 8b                \n"             \
 379         ".long   11b, 8b                \n"             \
 380         ".long   12b, 8b                \n"             \
 381         ".long    4b, 8b                \n"             \
 382         ".long    6b, 8b                \n"             \
 383         ".previous                      \n"             \
 384         "7:                             \n"             \
 385         : "=r"(n), "=r"(to), "=r"(from), "=r"(nsave),   \
 386           "=r"(tmp)                                     \
 387         : "0"(n), "1"(to), "2"(from)                    \
 388         : "memory");                                    \
 389 } while (0)
 390
 391 unsigned long raw_copy_from_user(void *to, const void *from, unsigned long n);
 392 unsigned long raw_copy_to_user(void *to, const void *from, unsigned long n);
 393
 394 unsigned long clear_user(void *to, unsigned long n);
 395 unsigned long __clear_user(void __user *to, unsigned long n);
 396
 397 long strncpy_from_user(char *dst, const char *src, long count);
 398 long __strncpy_from_user(char *dst, const char *src, long count);
 399
 400 /*
 401  * Return the size of a string (including the ending 0)
 402  *
 403  * Return 0 on exception, a value greater than N if too long
 404  */
 405 long strnlen_user(const char *src, long n);
 406
 407 #define strlen_user(str) strnlen_user(str, 32767)
 408
 409 struct exception_table_entry {
 410         unsigned long insn;
 411         unsigned long nextinsn;
 412 };
 413
 414 extern int fixup_exception(struct pt_regs *regs);
 415
 416 #endif /* __ASM_CSKY_UACCESS_H */