1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef __M68K_UACCESS_H 3 #define __M68K_UACCESS_H 4 5 #ifdef CONFIG_MMU 6 7 /* 8 * User space memory access functions 9 */ 10 #include <linux/compiler.h> 11 #include <linux/types.h> 12 #include <asm/extable.h> 13 #include <asm-generic/access_ok.h> 14 15 /* 16 * Not all varients of the 68k family support the notion of address spaces. 17 * The traditional 680x0 parts do, and they use the sfc/dfc registers and 18 * the "moves" instruction to access user space from kernel space. Other 19 * family members like ColdFire don't support this, and only have a single 20 * address space, and use the usual "move" instruction for user space access. 21 * 22 * Outside of this difference the user space access functions are the same. 23 * So lets keep the code simple and just define in what we need to use. 24 */ 25 #ifdef CONFIG_CPU_HAS_ADDRESS_SPACES 26 #define MOVES "moves" 27 #else 28 #define MOVES "move" 29 #endif 30 31 #define __put_user_asm(inst, res, x, ptr, bwl, reg, err) \ 32 asm volatile ("\n" \ 33 "1: "inst"."#bwl" %2,%1\n" \ 34 "2:\n" \ 35 " .section .fixup,\"ax\"\n" \ 36 " .even\n" \ 37 "10: moveq.l %3,%0\n" \ 38 " jra 2b\n" \ 39 " .previous\n" \ 40 "\n" \ 41 " .section __ex_table,\"a\"\n" \ 42 " .align 4\n" \ 43 " .long 1b,10b\n" \ 44 " .long 2b,10b\n" \ 45 " .previous" \ 46 : "+d" (res), "=m" (*(ptr)) \ 47 : #reg (x), "i" (err)) 48 49 #define __put_user_asm8(inst, res, x, ptr) \ 50 do { \ 51 const void *__pu_ptr = (const void __force *)(ptr); \ 52 \ 53 asm volatile ("\n" \ 54 "1: "inst".l %2,(%1)+\n" \ 55 "2: "inst".l %R2,(%1)\n" \ 56 "3:\n" \ 57 " .section .fixup,\"ax\"\n" \ 58 " .even\n" \ 59 "10: movel %3,%0\n" \ 60 " jra 3b\n" \ 61 " .previous\n" \ 62 "\n" \ 63 " .section __ex_table,\"a\"\n" \ 64 " .align 4\n" \ 65 " .long 1b,10b\n" \ 66 " .long 2b,10b\n" \ 67 " .long 3b,10b\n" \ 68 " .previous" \ 69 : "+d" (res), "+a" (__pu_ptr) \ 70 : "r" (x), "i" (-EFAULT) \ 71 : "memory"); \ 72 } while (0) 73 74 /* 75 * These are the main single-value transfer routines. They automatically 76 * use the right size if we just have the right pointer type. 77 */ 78 79 #define __put_user(x, ptr) \ 80 ({ \ 81 typeof(*(ptr)) __pu_val = (x); \ 82 int __pu_err = 0; \ 83 __chk_user_ptr(ptr); \ 84 switch (sizeof (*(ptr))) { \ 85 case 1: \ 86 __put_user_asm(MOVES, __pu_err, __pu_val, ptr, b, d, -EFAULT); \ 87 break; \ 88 case 2: \ 89 __put_user_asm(MOVES, __pu_err, __pu_val, ptr, w, r, -EFAULT); \ 90 break; \ 91 case 4: \ 92 __put_user_asm(MOVES, __pu_err, __pu_val, ptr, l, r, -EFAULT); \ 93 break; \ 94 case 8: \ 95 __put_user_asm8(MOVES, __pu_err, __pu_val, ptr); \ 96 break; \ 97 default: \ 98 BUILD_BUG(); \ 99 } \ 100 __pu_err; \ 101 }) 102 #define put_user(x, ptr) __put_user(x, ptr) 103 104 105 #define __get_user_asm(inst, res, x, ptr, type, bwl, reg, err) ({ \ 106 type __gu_val; \ 107 asm volatile ("\n" \ 108 "1: "inst"."#bwl" %2,%1\n" \ 109 "2:\n" \ 110 " .section .fixup,\"ax\"\n" \ 111 " .even\n" \ 112 "10: move.l %3,%0\n" \ 113 " sub.l %1,%1\n" \ 114 " jra 2b\n" \ 115 " .previous\n" \ 116 "\n" \ 117 " .section __ex_table,\"a\"\n" \ 118 " .align 4\n" \ 119 " .long 1b,10b\n" \ 120 " .previous" \ 121 : "+d" (res), "=&" #reg (__gu_val) \ 122 : "m" (*(ptr)), "i" (err)); \ 123 (x) = (__force typeof(*(ptr)))(__force unsigned long)__gu_val; \ 124 }) 125 126 #define __get_user_asm8(inst, res, x, ptr) \ 127 do { \ 128 const void *__gu_ptr = (const void __force *)(ptr); \ 129 union { \ 130 u64 l; \ 131 __typeof__(*(ptr)) t; \ 132 } __gu_val; \ 133 \ 134 asm volatile ("\n" \ 135 "1: "inst".l (%2)+,%1\n" \ 136 "2: "inst".l (%2),%R1\n" \ 137 "3:\n" \ 138 " .section .fixup,\"ax\"\n" \ 139 " .even\n" \ 140 "10: move.l %3,%0\n" \ 141 " sub.l %1,%1\n" \ 142 " sub.l %R1,%R1\n" \ 143 " jra 3b\n" \ 144 " .previous\n" \ 145 "\n" \ 146 " .section __ex_table,\"a\"\n" \ 147 " .align 4\n" \ 148 " .long 1b,10b\n" \ 149 " .long 2b,10b\n" \ 150 " .previous" \ 151 : "+d" (res), "=&r" (__gu_val.l), \ 152 "+a" (__gu_ptr) \ 153 : "i" (-EFAULT) \ 154 : "memory"); \ 155 (x) = __gu_val.t; \ 156 } while (0) 157 158 #define __get_user(x, ptr) \ 159 ({ \ 160 int __gu_err = 0; \ 161 __chk_user_ptr(ptr); \ 162 switch (sizeof(*(ptr))) { \ 163 case 1: \ 164 __get_user_asm(MOVES, __gu_err, x, ptr, u8, b, d, -EFAULT); \ 165 break; \ 166 case 2: \ 167 __get_user_asm(MOVES, __gu_err, x, ptr, u16, w, r, -EFAULT); \ 168 break; \ 169 case 4: \ 170 __get_user_asm(MOVES, __gu_err, x, ptr, u32, l, r, -EFAULT); \ 171 break; \ 172 case 8: \ 173 __get_user_asm8(MOVES, __gu_err, x, ptr); \ 174 break; \ 175 default: \ 176 BUILD_BUG(); \ 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(MOVES, res, *(u8 *)from, (u8 __user *)to, 323 b, d, 1); 324 break; 325 case 2: 326 __put_user_asm(MOVES, res, *(u16 *)from, (u16 __user *)to, 327 w, r, 2); 328 break; 329 case 3: 330 __constant_copy_to_user_asm(res, to, from, tmp, 3, w, b,); 331 break; 332 case 4: 333 __put_user_asm(MOVES, res, *(u32 *)from, (u32 __user *)to, 334 l, r, 4); 335 break; 336 case 5: 337 __constant_copy_to_user_asm(res, to, from, tmp, 5, l, b,); 338 break; 339 case 6: 340 __constant_copy_to_user_asm(res, to, from, tmp, 6, l, w,); 341 break; 342 case 7: 343 __constant_copy_to_user_asm(res, to, from, tmp, 7, l, w, b); 344 break; 345 case 8: 346 __constant_copy_to_user_asm(res, to, from, tmp, 8, l, l,); 347 break; 348 case 9: 349 __constant_copy_to_user_asm(res, to, from, tmp, 9, l, l, b); 350 break; 351 case 10: 352 __constant_copy_to_user_asm(res, to, from, tmp, 10, l, l, w); 353 break; 354 case 12: 355 __constant_copy_to_user_asm(res, to, from, tmp, 12, l, l, l); 356 break; 357 default: 358 /* limit the inlined version to 3 moves */ 359 return __generic_copy_to_user(to, from, n); 360 } 361 362 return res; 363 } 364 365 static inline unsigned long 366 raw_copy_from_user(void *to, const void __user *from, unsigned long n) 367 { 368 if (__builtin_constant_p(n)) 369 return __constant_copy_from_user(to, from, n); 370 return __generic_copy_from_user(to, from, n); 371 } 372 373 static inline unsigned long 374 raw_copy_to_user(void __user *to, const void *from, unsigned long n) 375 { 376 if (__builtin_constant_p(n)) 377 return __constant_copy_to_user(to, from, n); 378 return __generic_copy_to_user(to, from, n); 379 } 380 #define INLINE_COPY_FROM_USER 381 #define INLINE_COPY_TO_USER 382 383 #define __get_kernel_nofault(dst, src, type, err_label) \ 384 do { \ 385 type *__gk_dst = (type *)(dst); \ 386 type *__gk_src = (type *)(src); \ 387 int __gk_err = 0; \ 388 \ 389 switch (sizeof(type)) { \ 390 case 1: \ 391 __get_user_asm("move", __gk_err, *__gk_dst, __gk_src, \ 392 u8, b, d, -EFAULT); \ 393 break; \ 394 case 2: \ 395 __get_user_asm("move", __gk_err, *__gk_dst, __gk_src, \ 396 u16, w, r, -EFAULT); \ 397 break; \ 398 case 4: \ 399 __get_user_asm("move", __gk_err, *__gk_dst, __gk_src, \ 400 u32, l, r, -EFAULT); \ 401 break; \ 402 case 8: \ 403 __get_user_asm8("move", __gk_err, *__gk_dst, __gk_src); \ 404 break; \ 405 default: \ 406 BUILD_BUG(); \ 407 } \ 408 if (unlikely(__gk_err)) \ 409 goto err_label; \ 410 } while (0) 411 412 #define __put_kernel_nofault(dst, src, type, err_label) \ 413 do { \ 414 type __pk_src = *(type *)(src); \ 415 type *__pk_dst = (type *)(dst); \ 416 int __pk_err = 0; \ 417 \ 418 switch (sizeof(type)) { \ 419 case 1: \ 420 __put_user_asm("move", __pk_err, __pk_src, __pk_dst, \ 421 b, d, -EFAULT); \ 422 break; \ 423 case 2: \ 424 __put_user_asm("move", __pk_err, __pk_src, __pk_dst, \ 425 w, r, -EFAULT); \ 426 break; \ 427 case 4: \ 428 __put_user_asm("move", __pk_err, __pk_src, __pk_dst, \ 429 l, r, -EFAULT); \ 430 break; \ 431 case 8: \ 432 __put_user_asm8("move", __pk_err, __pk_src, __pk_dst); \ 433 break; \ 434 default: \ 435 BUILD_BUG(); \ 436 } \ 437 if (unlikely(__pk_err)) \ 438 goto err_label; \ 439 } while (0) 440 441 extern long strncpy_from_user(char *dst, const char __user *src, long count); 442 extern __must_check long strnlen_user(const char __user *str, long n); 443 444 unsigned long __clear_user(void __user *to, unsigned long n); 445 446 #define clear_user __clear_user 447 448 #else /* !CONFIG_MMU */ 449 #include <asm-generic/uaccess.h> 450 #endif 451 452 #endif /* _M68K_UACCESS_H */ 453