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