include/asm-m68k/uaccess.h

   1 #ifndef __M68K_UACCESS_H
   2 #define __M68K_UACCESS_H
   3
   4 /*
   5  * User space memory access functions
   6  */
   7 #include <linux/compiler.h>
   8 #include <linux/errno.h>
   9 #include <linux/types.h>
  10 #include <asm/segment.h>
  11
  12 #define VERIFY_READ     0
  13 #define VERIFY_WRITE    1
  14
  15 /* We let the MMU do all checking */
  16 #define access_ok(type,addr,size) 1
  17
  18 /*
  19  * The exception table consists of pairs of addresses: the first is the
  20  * address of an instruction that is allowed to fault, and the second is
  21  * the address at which the program should continue.  No registers are
  22  * modified, so it is entirely up to the continuation code to figure out
  23  * what to do.
  24  *
  25  * All the routines below use bits of fixup code that are out of line
  26  * with the main instruction path.  This means when everything is well,
  27  * we don't even have to jump over them.  Further, they do not intrude
  28  * on our cache or tlb entries.
  29  */
  30
  31 struct exception_table_entry
  32 {
  33         unsigned long insn, fixup;
  34 };
  35
  36 extern int __put_user_bad(void);
  37 extern int __get_user_bad(void);
  38
  39 #define __put_user_asm(res, x, ptr, bwl, reg, err)      \
  40 asm volatile ("\n"                                      \
  41         "1:     moves."#bwl"    %2,%1\n"                \
  42         "2:\n"                                          \
  43         "       .section .fixup,\"ax\"\n"               \
  44         "       .even\n"                                \
  45         "10:    moveq.l %3,%0\n"                        \
  46         "       jra 2b\n"                               \
  47         "       .previous\n"                            \
  48         "\n"                                            \
  49         "       .section __ex_table,\"a\"\n"            \
  50         "       .align  4\n"                            \
  51         "       .long   1b,10b\n"                       \
  52         "       .long   2b,10b\n"                       \
  53         "       .previous"                              \
  54         : "+d" (res), "=m" (*(ptr))                     \
  55         : #reg (x), "i" (err))
  56
  57 /*
  58  * These are the main single-value transfer routines.  They automatically
  59  * use the right size if we just have the right pointer type.
  60  */
  61
  62 #define __put_user(x, ptr)                                              \
  63 ({                                                                      \
  64         typeof(*(ptr)) __pu_val = (x);                                  \
  65         int __pu_err = 0;                                               \
  66         __chk_user_ptr(ptr);                                            \
  67         switch (sizeof (*(ptr))) {                                      \
  68         case 1:                                                         \
  69                 __put_user_asm(__pu_err, __pu_val, ptr, b, d, -EFAULT); \
  70                 break;                                                  \
  71         case 2:                                                         \
  72                 __put_user_asm(__pu_err, __pu_val, ptr, w, d, -EFAULT); \
  73                 break;                                                  \
  74         case 4:                                                         \
  75                 __put_user_asm(__pu_err, __pu_val, ptr, l, r, -EFAULT); \
  76                 break;                                                  \
  77         case 8:                                                         \
  78             {                                                           \
  79                 const void *__pu_ptr = (ptr);                           \
  80                 asm volatile ("\n"                                      \
  81                         "1:     moves.l %2,(%1)+\n"                     \
  82                         "2:     moves.l %R2,(%1)\n"                     \
  83                         "3:\n"                                          \
  84                         "       .section .fixup,\"ax\"\n"               \
  85                         "       .even\n"                                \
  86                         "10:    movel %3,%0\n"                          \
  87                         "       jra 3b\n"                               \
  88                         "       .previous\n"                            \
  89                         "\n"                                            \
  90                         "       .section __ex_table,\"a\"\n"            \
  91                         "       .align 4\n"                             \
  92                         "       .long 1b,10b\n"                         \
  93                         "       .long 2b,10b\n"                         \
  94                         "       .long 3b,10b\n"                         \
  95                         "       .previous"                              \
  96                         : "+d" (__pu_err), "+a" (__pu_ptr)              \
  97                         : "r" (__pu_val), "i" (-EFAULT)                 \
  98                         : "memory");                                    \
  99                 break;                                                  \
 100             }                                                           \
 101         default:                                                        \
 102                 __pu_err = __put_user_bad();                            \
 103                 break;                                                  \
 104         }                                                               \
 105         __pu_err;                                                       \
 106 })
 107 #define put_user(x, ptr)        __put_user(x, ptr)
 108
 109
 110 #define __get_user_asm(res, x, ptr, type, bwl, reg, err) ({     \
 111         type __gu_val;                                          \
 112         asm volatile ("\n"                                      \
 113                 "1:     moves."#bwl"    %2,%1\n"                \
 114                 "2:\n"                                          \
 115                 "       .section .fixup,\"ax\"\n"               \
 116                 "       .even\n"                                \
 117                 "10:    move.l  %3,%0\n"                        \
 118                 "       sub."#bwl"      %1,%1\n"                \
 119                 "       jra     2b\n"                           \
 120                 "       .previous\n"                            \
 121                 "\n"                                            \
 122                 "       .section __ex_table,\"a\"\n"            \
 123                 "       .align  4\n"                            \
 124                 "       .long   1b,10b\n"                       \
 125                 "       .previous"                              \
 126                 : "+d" (res), "=&" #reg (__gu_val)              \
 127                 : "m" (*(ptr)), "i" (err));                     \
 128         (x) = (typeof(*(ptr)))(long)__gu_val;                   \
 129 })
 130
 131 #define __get_user(x, ptr)                                              \
 132 ({                                                                      \
 133         int __gu_err = 0;                                               \
 134         __chk_user_ptr(ptr);                                            \
 135         switch (sizeof(*(ptr))) {                                       \
 136         case 1:                                                         \
 137                 __get_user_asm(__gu_err, x, ptr, u8, b, d, -EFAULT);    \
 138                 break;                                                  \
 139         case 2:                                                         \
 140                 __get_user_asm(__gu_err, x, ptr, u16, w, d, -EFAULT);   \
 141                 break;                                                  \
 142         case 4:                                                         \
 143                 __get_user_asm(__gu_err, x, ptr, u32, l, r, -EFAULT);   \
 144                 break;                                                  \
 145 /*      case 8: disabled because gcc-4.1 has a broken typeof            \
 146             {                                                           \
 147                 const void *__gu_ptr = (ptr);                           \
 148                 u64 __gu_val;                                           \
 149                 asm volatile ("\n"                                      \
 150                         "1:     moves.l (%2)+,%1\n"                     \
 151                         "2:     moves.l (%2),%R1\n"                     \
 152                         "3:\n"                                          \
 153                         "       .section .fixup,\"ax\"\n"               \
 154                         "       .even\n"                                \
 155                         "10:    move.l  %3,%0\n"                        \
 156                         "       sub.l   %1,%1\n"                        \
 157                         "       sub.l   %R1,%R1\n"                      \
 158                         "       jra     3b\n"                           \
 159                         "       .previous\n"                            \
 160                         "\n"                                            \
 161                         "       .section __ex_table,\"a\"\n"            \
 162                         "       .align  4\n"                            \
 163                         "       .long   1b,10b\n"                       \
 164                         "       .long   2b,10b\n"                       \
 165                         "       .previous"                              \
 166                         : "+d" (__gu_err), "=&r" (__gu_val),            \
 167                           "+a" (__gu_ptr)                               \
 168                         : "i" (-EFAULT)                                 \
 169                         : "memory");                                    \
 170                 (x) = (typeof(*(ptr)))__gu_val;                         \
 171                 break;                                                  \
 172             }   */                                                      \
 173         default:                                                        \
 174                 __gu_err = __get_user_bad();                            \
 175                 break;                                                  \
 176         }                                                               \
 177         __gu_err;                                                       \
 178 })
 179 #define get_user(x, ptr) __get_user(x, ptr)
 180
 181 unsigned long __generic_copy_from_user(void *to, const void __user *from, unsigned long n);
 182 unsigned long __generic_copy_to_user(void __user *to, const void *from, unsigned long n);
 183
 184 static __always_inline unsigned long
 185 __constant_copy_from_user(void *to, const void __user *from, unsigned long n)
 186 {
 187         unsigned long res = 0, tmp;
 188
 189         /* limit the inlined version to 3 moves */
 190         if (n == 11 || n > 12)
 191                 return __generic_copy_from_user(to, from, n);
 192
 193         switch (n) {
 194         case 1:
 195                 __get_user_asm(res, *(u8 *)to, (u8 *)from, u8, b, d, 1);
 196                 return res;
 197         case 2:
 198                 __get_user_asm(res, *(u16 *)to, (u16 *)from, u16, w, d, 2);
 199                 return res;
 200         case 4:
 201                 __get_user_asm(res, *(u32 *)to, (u32 *)from, u32, l, r, 4);
 202                 return res;
 203         }
 204
 205         asm volatile ("\n"
 206                 "       .ifndef .Lfrom_user\n"
 207                 "       .set    .Lfrom_user,1\n"
 208                 "       .macro  copy_from_user to,from,tmp\n"
 209                 "       .if     .Lcnt >= 4\n"
 210                 "1:     moves.l (\\from)+,\\tmp\n"
 211                 "       move.l  \\tmp,(\\to)+\n"
 212                 "       .set    .Lcnt,.Lcnt-4\n"
 213                 "       .elseif .Lcnt & 2\n"
 214                 "1:     moves.w (\\from)+,\\tmp\n"
 215                 "       move.w  \\tmp,(\\to)+\n"
 216                 "       .set    .Lcnt,.Lcnt-2\n"
 217                 "       .elseif .Lcnt & 1\n"
 218                 "1:     moves.b (\\from)+,\\tmp\n"
 219                 "       move.b  \\tmp,(\\to)+\n"
 220                 "       .set    .Lcnt,.Lcnt-1\n"
 221                 "       .else\n"
 222                 "       .exitm\n"
 223                 "       .endif\n"
 224                 "\n"
 225                 "       .section __ex_table,\"a\"\n"
 226                 "       .align  4\n"
 227                 "       .long   1b,3f\n"
 228                 "       .previous\n"
 229                 "       .endm\n"
 230                 "       .endif\n"
 231                 "\n"
 232                 "       .set    .Lcnt,%c4\n"
 233                 "       copy_from_user %1,%2,%3\n"
 234                 "       copy_from_user %1,%2,%3\n"
 235                 "       copy_from_user %1,%2,%3\n"
 236                 "2:\n"
 237                 "       .section .fixup,\"ax\"\n"
 238                 "       .even\n"
 239                 "3:     moveq.l %4,%0\n"
 240                 "       move.l  %5,%1\n"
 241                 "       .rept   %c4 / 4\n"
 242                 "       clr.l   (%1)+\n"
 243                 "       .endr\n"
 244                 "       .if     %c4 & 2\n"
 245                 "       clr.w   (%1)+\n"
 246                 "       .endif\n"
 247                 "       .if     %c4 & 1\n"
 248                 "       clr.b   (%1)+\n"
 249                 "       .endif\n"
 250                 "       jra     2b\n"
 251                 "       .previous\n"
 252                 : "+r" (res), "+a" (to), "+a" (from), "=&d" (tmp)
 253                 : "i" (n), "g" (to)
 254                 : "memory");
 255
 256         return res;
 257 }
 258
 259 static __always_inline unsigned long
 260 __constant_copy_to_user(void __user *to, const void *from, unsigned long n)
 261 {
 262         unsigned long res = 0, tmp;
 263
 264         /* limit the inlined version to 3 moves */
 265         if (n == 11 || n > 12)
 266                 return __generic_copy_to_user(to, from, n);
 267
 268         switch (n) {
 269         case 1:
 270                 __put_user_asm(res, *(u8 *)from, (u8 *)to, b, d, 1);
 271                 return res;
 272         case 2:
 273                 __put_user_asm(res, *(u16 *)from, (u16 *)to, w, d, 2);
 274                 return res;
 275         case 4:
 276                 __put_user_asm(res, *(u32 *)from, (u32 *)to, l, r, 4);
 277                 return res;
 278         }
 279
 280         asm volatile ("\n"
 281                 "       .ifndef .Lto_user\n"
 282                 "       .set    .Lto_user,1\n"
 283                 "       .macro  copy_to_user to,from,tmp\n"
 284                 "       .if     .Lcnt >= 4\n"
 285                 "       move.l  (\\from)+,\\tmp\n"
 286                 "11:    moves.l \\tmp,(\\to)+\n"
 287                 "12:    .set    .Lcnt,.Lcnt-4\n"
 288                 "       .elseif .Lcnt & 2\n"
 289                 "       move.w  (\\from)+,\\tmp\n"
 290                 "11:    moves.w \\tmp,(\\to)+\n"
 291                 "12:    .set    .Lcnt,.Lcnt-2\n"
 292                 "       .elseif .Lcnt & 1\n"
 293                 "       move.b  (\\from)+,\\tmp\n"
 294                 "11:    moves.b \\tmp,(\\to)+\n"
 295                 "12:    .set    .Lcnt,.Lcnt-1\n"
 296                 "       .else\n"
 297                 "       .exitm\n"
 298                 "       .endif\n"
 299                 "\n"
 300                 "       .section __ex_table,\"a\"\n"
 301                 "       .align  4\n"
 302                 "       .long   11b,3f\n"
 303                 "       .long   12b,3f\n"
 304                 "       .previous\n"
 305                 "       .endm\n"
 306                 "       .endif\n"
 307                 "\n"
 308                 "       .set    .Lcnt,%c4\n"
 309                 "       copy_to_user %1,%2,%3\n"
 310                 "       copy_to_user %1,%2,%3\n"
 311                 "       copy_to_user %1,%2,%3\n"
 312                 "2:\n"
 313                 "       .section .fixup,\"ax\"\n"
 314                 "       .even\n"
 315                 "3:     moveq.l %4,%0\n"
 316                 "       jra     2b\n"
 317                 "       .previous\n"
 318                 : "+r" (res), "+a" (to), "+a" (from), "=&d" (tmp)
 319                 : "i" (n)
 320                 : "memory");
 321
 322         return res;
 323 }
 324
 325 #define __copy_from_user(to, from, n)           \
 326 (__builtin_constant_p(n) ?                      \
 327  __constant_copy_from_user(to, from, n) :       \
 328  __generic_copy_from_user(to, from, n))
 329
 330 #define __copy_to_user(to, from, n)             \
 331 (__builtin_constant_p(n) ?                      \
 332  __constant_copy_to_user(to, from, n) :         \
 333  __generic_copy_to_user(to, from, n))
 334
 335 #define __copy_to_user_inatomic         __copy_to_user
 336 #define __copy_from_user_inatomic       __copy_from_user
 337
 338 #define copy_from_user(to, from, n)     __copy_from_user(to, from, n)
 339 #define copy_to_user(to, from, n)       __copy_to_user(to, from, n)
 340
 341 long strncpy_from_user(char *dst, const char __user *src, long count);
 342 long strnlen_user(const char __user *src, long n);
 343 unsigned long clear_user(void __user *to, unsigned long n);
 344
 345 #define strlen_user(str) strnlen_user(str, 32767)
 346
 347 #endif /* _M68K_UACCESS_H */