arch/m68k/include/asm/uaccess_mm.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef __M68K_UACCESS_H
   3 #define __M68K_UACCESS_H
   4
   5 /*
   6  * User space memory access functions
   7  */
   8 #include <linux/compiler.h>
   9 #include <linux/types.h>
  10 #include <asm/segment.h>
  11
  12 /* We let the MMU do all checking */
  13 static inline int access_ok(const void __user *addr,
  14                             unsigned long size)
  15 {
  16         return 1;
  17 }
  18
  19 /*
  20  * Not all varients of the 68k family support the notion of address spaces.
  21  * The traditional 680x0 parts do, and they use the sfc/dfc registers and
  22  * the "moves" instruction to access user space from kernel space. Other
  23  * family members like ColdFire don't support this, and only have a single
  24  * address space, and use the usual "move" instruction for user space access.
  25  *
  26  * Outside of this difference the user space access functions are the same.
  27  * So lets keep the code simple and just define in what we need to use.
  28  */
  29 #ifdef CONFIG_CPU_HAS_ADDRESS_SPACES
  30 #define MOVES   "moves"
  31 #else
  32 #define MOVES   "move"
  33 #endif
  34
  35 extern int __put_user_bad(void);
  36 extern int __get_user_bad(void);
  37
  38 #define __put_user_asm(res, x, ptr, bwl, reg, err)      \
  39 asm volatile ("\n"                                      \
  40         "1:     "MOVES"."#bwl"  %2,%1\n"                \
  41         "2:\n"                                          \
  42         "       .section .fixup,\"ax\"\n"               \
  43         "       .even\n"                                \
  44         "10:    moveq.l %3,%0\n"                        \
  45         "       jra 2b\n"                               \
  46         "       .previous\n"                            \
  47         "\n"                                            \
  48         "       .section __ex_table,\"a\"\n"            \
  49         "       .align  4\n"                            \
  50         "       .long   1b,10b\n"                       \
  51         "       .long   2b,10b\n"                       \
  52         "       .previous"                              \
  53         : "+d" (res), "=m" (*(ptr))                     \
  54         : #reg (x), "i" (err))
  55
  56 /*
  57  * These are the main single-value transfer routines.  They automatically
  58  * use the right size if we just have the right pointer type.
  59  */
  60
  61 #define __put_user(x, ptr)                                              \
  62 ({                                                                      \
  63         typeof(*(ptr)) __pu_val = (x);                                  \
  64         int __pu_err = 0;                                               \
  65         __chk_user_ptr(ptr);                                            \
  66         switch (sizeof (*(ptr))) {                                      \
  67         case 1:                                                         \
  68                 __put_user_asm(__pu_err, __pu_val, ptr, b, d, -EFAULT); \
  69                 break;                                                  \
  70         case 2:                                                         \
  71                 __put_user_asm(__pu_err, __pu_val, ptr, w, r, -EFAULT); \
  72                 break;                                                  \
  73         case 4:                                                         \
  74                 __put_user_asm(__pu_err, __pu_val, ptr, l, r, -EFAULT); \
  75                 break;                                                  \
  76         case 8:                                                         \
  77             {                                                           \
  78                 const void __user *__pu_ptr = (ptr);                    \
  79                 asm volatile ("\n"                                      \
  80                         "1:     "MOVES".l       %2,(%1)+\n"             \
  81                         "2:     "MOVES".l       %R2,(%1)\n"             \
  82                         "3:\n"                                          \
  83                         "       .section .fixup,\"ax\"\n"               \
  84                         "       .even\n"                                \
  85                         "10:    movel %3,%0\n"                          \
  86                         "       jra 3b\n"                               \
  87                         "       .previous\n"                            \
  88                         "\n"                                            \
  89                         "       .section __ex_table,\"a\"\n"            \
  90                         "       .align 4\n"                             \
  91                         "       .long 1b,10b\n"                         \
  92                         "       .long 2b,10b\n"                         \
  93                         "       .long 3b,10b\n"                         \
  94                         "       .previous"                              \
  95                         : "+d" (__pu_err), "+a" (__pu_ptr)              \
  96                         : "r" (__pu_val), "i" (-EFAULT)                 \
  97                         : "memory");                                    \
  98                 break;                                                  \
  99             }                                                           \
 100         default:                                                        \
 101                 __pu_err = __put_user_bad();                            \
 102                 break;                                                  \
 103         }                                                               \
 104         __pu_err;                                                       \
 105 })
 106 #define put_user(x, ptr)        __put_user(x, ptr)
 107
 108
 109 #define __get_user_asm(res, x, ptr, type, bwl, reg, err) ({             \
 110         type __gu_val;                                                  \
 111         asm volatile ("\n"                                              \
 112                 "1:     "MOVES"."#bwl"  %2,%1\n"                        \
 113                 "2:\n"                                                  \
 114                 "       .section .fixup,\"ax\"\n"                       \
 115                 "       .even\n"                                        \
 116                 "10:    move.l  %3,%0\n"                                \
 117                 "       sub.l   %1,%1\n"                                \
 118                 "       jra     2b\n"                                   \
 119                 "       .previous\n"                                    \
 120                 "\n"                                                    \
 121                 "       .section __ex_table,\"a\"\n"                    \
 122                 "       .align  4\n"                                    \
 123                 "       .long   1b,10b\n"                               \
 124                 "       .previous"                                      \
 125                 : "+d" (res), "=&" #reg (__gu_val)                      \
 126                 : "m" (*(ptr)), "i" (err));                             \
 127         (x) = (__force typeof(*(ptr)))(__force unsigned long)__gu_val;  \
 128 })
 129
 130 #define __get_user(x, ptr)                                              \
 131 ({                                                                      \
 132         int __gu_err = 0;                                               \
 133         __chk_user_ptr(ptr);                                            \
 134         switch (sizeof(*(ptr))) {                                       \
 135         case 1:                                                         \
 136                 __get_user_asm(__gu_err, x, ptr, u8, b, d, -EFAULT);    \
 137                 break;                                                  \
 138         case 2:                                                         \
 139                 __get_user_asm(__gu_err, x, ptr, u16, w, r, -EFAULT);   \
 140                 break;                                                  \
 141         case 4:                                                         \
 142                 __get_user_asm(__gu_err, x, ptr, u32, l, r, -EFAULT);   \
 143                 break;                                                  \
 144         case 8: {                                                       \
 145                 const void *__gu_ptr = (ptr);                           \
 146                 union {                                                 \
 147                         u64 l;                                          \
 148                         __typeof__(*(ptr)) t;                           \
 149                 } __gu_val;                                             \
 150                 asm volatile ("\n"                                      \
 151                         "1:     "MOVES".l       (%2)+,%1\n"             \
 152                         "2:     "MOVES".l       (%2),%R1\n"             \
 153                         "3:\n"                                          \
 154                         "       .section .fixup,\"ax\"\n"               \
 155                         "       .even\n"                                \
 156                         "10:    move.l  %3,%0\n"                        \
 157                         "       sub.l   %1,%1\n"                        \
 158                         "       sub.l   %R1,%R1\n"                      \
 159                         "       jra     3b\n"                           \
 160                         "       .previous\n"                            \
 161                         "\n"                                            \
 162                         "       .section __ex_table,\"a\"\n"            \
 163                         "       .align  4\n"                            \
 164                         "       .long   1b,10b\n"                       \
 165                         "       .long   2b,10b\n"                       \
 166                         "       .previous"                              \
 167                         : "+d" (__gu_err), "=&r" (__gu_val.l),          \
 168                           "+a" (__gu_ptr)                               \
 169                         : "i" (-EFAULT)                                 \
 170                         : "memory");                                    \
 171                 (x) = __gu_val.t;                                       \
 172                 break;                                                  \
 173         }                                                               \
 174         default:                                                        \
 175                 __gu_err = __get_user_bad();                            \
 176                 break;                                                  \
 177         }                                                               \
 178         __gu_err;                                                       \
 179 })
 180 #define get_user(x, ptr) __get_user(x, ptr)
 181
 182 unsigned long __generic_copy_from_user(void *to, const void __user *from, unsigned long n);
 183 unsigned long __generic_copy_to_user(void __user *to, const void *from, unsigned long n);
 184
 185 #define __suffix0
 186 #define __suffix1 b
 187 #define __suffix2 w
 188 #define __suffix4 l
 189
 190 #define ____constant_copy_from_user_asm(res, to, from, tmp, n1, n2, n3, s1, s2, s3)\
 191         asm volatile ("\n"                                              \
 192                 "1:     "MOVES"."#s1"   (%2)+,%3\n"                     \
 193                 "       move."#s1"      %3,(%1)+\n"                     \
 194                 "       .ifnc   \""#s2"\",\"\"\n"                       \
 195                 "2:     "MOVES"."#s2"   (%2)+,%3\n"                     \
 196                 "       move."#s2"      %3,(%1)+\n"                     \
 197                 "       .ifnc   \""#s3"\",\"\"\n"                       \
 198                 "3:     "MOVES"."#s3"   (%2)+,%3\n"                     \
 199                 "       move."#s3"      %3,(%1)+\n"                     \
 200                 "       .endif\n"                                       \
 201                 "       .endif\n"                                       \
 202                 "4:\n"                                                  \
 203                 "       .section __ex_table,\"a\"\n"                    \
 204                 "       .align  4\n"                                    \
 205                 "       .long   1b,10f\n"                               \
 206                 "       .ifnc   \""#s2"\",\"\"\n"                       \
 207                 "       .long   2b,20f\n"                               \
 208                 "       .ifnc   \""#s3"\",\"\"\n"                       \
 209                 "       .long   3b,30f\n"                               \
 210                 "       .endif\n"                                       \
 211                 "       .endif\n"                                       \
 212                 "       .previous\n"                                    \
 213                 "\n"                                                    \
 214                 "       .section .fixup,\"ax\"\n"                       \
 215                 "       .even\n"                                        \
 216                 "10:    addq.l #"#n1",%0\n"                             \
 217                 "       .ifnc   \""#s2"\",\"\"\n"                       \
 218                 "20:    addq.l #"#n2",%0\n"                             \
 219                 "       .ifnc   \""#s3"\",\"\"\n"                       \
 220                 "30:    addq.l #"#n3",%0\n"                             \
 221                 "       .endif\n"                                       \
 222                 "       .endif\n"                                       \
 223                 "       jra     4b\n"                                   \
 224                 "       .previous\n"                                    \
 225                 : "+d" (res), "+&a" (to), "+a" (from), "=&d" (tmp)      \
 226                 : : "memory")
 227
 228 #define ___constant_copy_from_user_asm(res, to, from, tmp, n1, n2, n3, s1, s2, s3)\
 229         ____constant_copy_from_user_asm(res, to, from, tmp, n1, n2, n3, s1, s2, s3)
 230 #define __constant_copy_from_user_asm(res, to, from, tmp, n1, n2, n3)   \
 231         ___constant_copy_from_user_asm(res, to, from, tmp, n1, n2, n3,  \
 232                                         __suffix##n1, __suffix##n2, __suffix##n3)
 233
 234 static __always_inline unsigned long
 235 __constant_copy_from_user(void *to, const void __user *from, unsigned long n)
 236 {
 237         unsigned long res = 0, tmp;
 238
 239         switch (n) {
 240         case 1:
 241                 __constant_copy_from_user_asm(res, to, from, tmp, 1, 0, 0);
 242                 break;
 243         case 2:
 244                 __constant_copy_from_user_asm(res, to, from, tmp, 2, 0, 0);
 245                 break;
 246         case 3:
 247                 __constant_copy_from_user_asm(res, to, from, tmp, 2, 1, 0);
 248                 break;
 249         case 4:
 250                 __constant_copy_from_user_asm(res, to, from, tmp, 4, 0, 0);
 251                 break;
 252         case 5:
 253                 __constant_copy_from_user_asm(res, to, from, tmp, 4, 1, 0);
 254                 break;
 255         case 6:
 256                 __constant_copy_from_user_asm(res, to, from, tmp, 4, 2, 0);
 257                 break;
 258         case 7:
 259                 __constant_copy_from_user_asm(res, to, from, tmp, 4, 2, 1);
 260                 break;
 261         case 8:
 262                 __constant_copy_from_user_asm(res, to, from, tmp, 4, 4, 0);
 263                 break;
 264         case 9:
 265                 __constant_copy_from_user_asm(res, to, from, tmp, 4, 4, 1);
 266                 break;
 267         case 10:
 268                 __constant_copy_from_user_asm(res, to, from, tmp, 4, 4, 2);
 269                 break;
 270         case 12:
 271                 __constant_copy_from_user_asm(res, to, from, tmp, 4, 4, 4);
 272                 break;
 273         default:
 274                 /* we limit the inlined version to 3 moves */
 275                 return __generic_copy_from_user(to, from, n);
 276         }
 277
 278         return res;
 279 }
 280
 281 #define __constant_copy_to_user_asm(res, to, from, tmp, n, s1, s2, s3)  \
 282         asm volatile ("\n"                                              \
 283                 "       move."#s1"      (%2)+,%3\n"                     \
 284                 "11:    "MOVES"."#s1"   %3,(%1)+\n"                     \
 285                 "12:    move."#s2"      (%2)+,%3\n"                     \
 286                 "21:    "MOVES"."#s2"   %3,(%1)+\n"                     \
 287                 "22:\n"                                                 \
 288                 "       .ifnc   \""#s3"\",\"\"\n"                       \
 289                 "       move."#s3"      (%2)+,%3\n"                     \
 290                 "31:    "MOVES"."#s3"   %3,(%1)+\n"                     \
 291                 "32:\n"                                                 \
 292                 "       .endif\n"                                       \
 293                 "4:\n"                                                  \
 294                 "\n"                                                    \
 295                 "       .section __ex_table,\"a\"\n"                    \
 296                 "       .align  4\n"                                    \
 297                 "       .long   11b,5f\n"                               \
 298                 "       .long   12b,5f\n"                               \
 299                 "       .long   21b,5f\n"                               \
 300                 "       .long   22b,5f\n"                               \
 301                 "       .ifnc   \""#s3"\",\"\"\n"                       \
 302                 "       .long   31b,5f\n"                               \
 303                 "       .long   32b,5f\n"                               \
 304                 "       .endif\n"                                       \
 305                 "       .previous\n"                                    \
 306                 "\n"                                                    \
 307                 "       .section .fixup,\"ax\"\n"                       \
 308                 "       .even\n"                                        \
 309                 "5:     moveq.l #"#n",%0\n"                             \
 310                 "       jra     4b\n"                                   \
 311                 "       .previous\n"                                    \
 312                 : "+d" (res), "+a" (to), "+a" (from), "=&d" (tmp)       \
 313                 : : "memory")
 314
 315 static __always_inline unsigned long
 316 __constant_copy_to_user(void __user *to, const void *from, unsigned long n)
 317 {
 318         unsigned long res = 0, tmp;
 319
 320         switch (n) {
 321         case 1:
 322                 __put_user_asm(res, *(u8 *)from, (u8 __user *)to, b, d, 1);
 323                 break;
 324         case 2:
 325                 __put_user_asm(res, *(u16 *)from, (u16 __user *)to, w, r, 2);
 326                 break;
 327         case 3:
 328                 __constant_copy_to_user_asm(res, to, from, tmp, 3, w, b,);
 329                 break;
 330         case 4:
 331                 __put_user_asm(res, *(u32 *)from, (u32 __user *)to, l, r, 4);
 332                 break;
 333         case 5:
 334                 __constant_copy_to_user_asm(res, to, from, tmp, 5, l, b,);
 335                 break;
 336         case 6:
 337                 __constant_copy_to_user_asm(res, to, from, tmp, 6, l, w,);
 338                 break;
 339         case 7:
 340                 __constant_copy_to_user_asm(res, to, from, tmp, 7, l, w, b);
 341                 break;
 342         case 8:
 343                 __constant_copy_to_user_asm(res, to, from, tmp, 8, l, l,);
 344                 break;
 345         case 9:
 346                 __constant_copy_to_user_asm(res, to, from, tmp, 9, l, l, b);
 347                 break;
 348         case 10:
 349                 __constant_copy_to_user_asm(res, to, from, tmp, 10, l, l, w);
 350                 break;
 351         case 12:
 352                 __constant_copy_to_user_asm(res, to, from, tmp, 12, l, l, l);
 353                 break;
 354         default:
 355                 /* limit the inlined version to 3 moves */
 356                 return __generic_copy_to_user(to, from, n);
 357         }
 358
 359         return res;
 360 }
 361
 362 static inline unsigned long
 363 raw_copy_from_user(void *to, const void __user *from, unsigned long n)
 364 {
 365         if (__builtin_constant_p(n))
 366                 return __constant_copy_from_user(to, from, n);
 367         return __generic_copy_from_user(to, from, n);
 368 }
 369
 370 static inline unsigned long
 371 raw_copy_to_user(void __user *to, const void *from, unsigned long n)
 372 {
 373         if (__builtin_constant_p(n))
 374                 return __constant_copy_to_user(to, from, n);
 375         return __generic_copy_to_user(to, from, n);
 376 }
 377 #define INLINE_COPY_FROM_USER
 378 #define INLINE_COPY_TO_USER
 379
 380 #define user_addr_max() \
 381         (uaccess_kernel() ? ~0UL : TASK_SIZE)
 382
 383 extern long strncpy_from_user(char *dst, const char __user *src, long count);
 384 extern __must_check long strnlen_user(const char __user *str, long n);
 385
 386 unsigned long __clear_user(void __user *to, unsigned long n);
 387
 388 #define clear_user      __clear_user
 389
 390 #endif /* _M68K_UACCESS_H */