1/* 2 * Authors: Bjorn Wesen (bjornw@axis.com) 3 * Hans-Peter Nilsson (hp@axis.com) 4 * 5 * $Log: uaccess.h,v $ 6 * Revision 1.1.1.1 2007/08/03 18:53:22 rnuti 7 * Importing Linux MIPS Kernel 2.6.22 8 * 9 * Revision 1.8 2001/10/29 13:01:48 bjornw 10 * Removed unused variable tmp2 in strnlen_user 11 * 12 * Revision 1.7 2001/10/02 12:44:52 hp 13 * Add support for 64-bit put_user/get_user 14 * 15 * Revision 1.6 2001/10/01 14:51:17 bjornw 16 * Added register prefixes and removed underscores 17 * 18 * Revision 1.5 2000/10/25 03:33:21 hp 19 * - Provide implementation for everything else but get_user and put_user; 20 * copying inline to/from user for constant length 0..16, 20, 24, and 21 * clearing for 0..4, 8, 12, 16, 20, 24, strncpy_from_user and strnlen_user 22 * always inline. 23 * - Constraints for destination addr in get_user cannot be memory, only reg. 24 * - Correct labels for PC at expected fault points. 25 * - Nits with assembly code. 26 * - Don't use statement expressions without value; use "do {} while (0)". 27 * - Return correct values from __generic_... functions. 28 * 29 * Revision 1.4 2000/09/12 16:28:25 bjornw 30 * * Removed comments from the get/put user asm code 31 * * Constrains for destination addr in put_user cannot be memory, only reg 32 * 33 * Revision 1.3 2000/09/12 14:30:20 bjornw 34 * MAX_ADDR_USER does not exist anymore 35 * 36 * Revision 1.2 2000/07/13 15:52:48 bjornw 37 * New user-access functions 38 * 39 * Revision 1.1.1.1 2000/07/10 16:32:31 bjornw 40 * CRIS architecture, working draft 41 * 42 * 43 * 44 */ 45 46/* Asm:s have been tweaked (within the domain of correctness) to give 47 satisfactory results for "gcc version 2.96 20000427 (experimental)". 48 49 Check regularly... 50 51 Register $r9 is chosen for temporaries, being a call-clobbered register 52 first in line to be used (notably for local blocks), not colliding with 53 parameter registers. */ 54 55#ifndef _CRIS_UACCESS_H 56#define _CRIS_UACCESS_H 57 58#ifndef __ASSEMBLY__ 59#include <linux/sched.h> 60#include <linux/errno.h> 61#include <asm/processor.h> 62#include <asm/page.h> 63 64#define VERIFY_READ 0 65#define VERIFY_WRITE 1 66 67/* 68 * The fs value determines whether argument validity checking should be 69 * performed or not. If get_fs() == USER_DS, checking is performed, with 70 * get_fs() == KERNEL_DS, checking is bypassed. 71 * 72 * For historical reasons, these macros are grossly misnamed. 73 */ 74 75#define MAKE_MM_SEG(s) ((mm_segment_t) { (s) }) 76 77/* addr_limit is the maximum accessible address for the task. we misuse 78 * the KERNEL_DS and USER_DS values to both assign and compare the 79 * addr_limit values through the equally misnamed get/set_fs macros. 80 * (see above) 81 */ 82 83#define KERNEL_DS MAKE_MM_SEG(0xFFFFFFFF) 84#define USER_DS MAKE_MM_SEG(TASK_SIZE) 85 86#define get_ds() (KERNEL_DS) 87#define get_fs() (current_thread_info()->addr_limit) 88#define set_fs(x) (current_thread_info()->addr_limit = (x)) 89 90#define segment_eq(a,b) ((a).seg == (b).seg) 91 92#define __kernel_ok (segment_eq(get_fs(), KERNEL_DS)) 93#define __user_ok(addr,size) (((size) <= TASK_SIZE)&&((addr) <= TASK_SIZE-(size))) 94#define __access_ok(addr,size) (__kernel_ok || __user_ok((addr),(size))) 95#define access_ok(type,addr,size) __access_ok((unsigned long)(addr),(size)) 96 97#include <asm/arch/uaccess.h> 98 99/* 100 * The exception table consists of pairs of addresses: the first is the 101 * address of an instruction that is allowed to fault, and the second is 102 * the address at which the program should continue. No registers are 103 * modified, so it is entirely up to the continuation code to figure out 104 * what to do. 105 * 106 * All the routines below use bits of fixup code that are out of line 107 * with the main instruction path. This means when everything is well, 108 * we don't even have to jump over them. Further, they do not intrude 109 * on our cache or tlb entries. 110 */ 111 112struct exception_table_entry 113{ 114 unsigned long insn, fixup; 115}; 116 117/* 118 * These are the main single-value transfer routines. They automatically 119 * use the right size if we just have the right pointer type. 120 * 121 * This gets kind of ugly. We want to return _two_ values in "get_user()" 122 * and yet we don't want to do any pointers, because that is too much 123 * of a performance impact. Thus we have a few rather ugly macros here, 124 * and hide all the ugliness from the user. 125 * 126 * The "__xxx" versions of the user access functions are versions that 127 * do not verify the address space, that must have been done previously 128 * with a separate "access_ok()" call (this is used when we do multiple 129 * accesses to the same area of user memory). 130 * 131 * As we use the same address space for kernel and user data on 132 * CRIS, we can just do these as direct assignments. (Of course, the 133 * exception handling means that it's no longer "just"...) 134 */ 135#define get_user(x,ptr) \ 136 __get_user_check((x),(ptr),sizeof(*(ptr))) 137#define put_user(x,ptr) \ 138 __put_user_check((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr))) 139 140#define __get_user(x,ptr) \ 141 __get_user_nocheck((x),(ptr),sizeof(*(ptr))) 142#define __put_user(x,ptr) \ 143 __put_user_nocheck((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr))) 144 145extern long __put_user_bad(void); 146 147#define __put_user_size(x,ptr,size,retval) \ 148do { \ 149 retval = 0; \ 150 switch (size) { \ 151 case 1: __put_user_asm(x,ptr,retval,"move.b"); break; \ 152 case 2: __put_user_asm(x,ptr,retval,"move.w"); break; \ 153 case 4: __put_user_asm(x,ptr,retval,"move.d"); break; \ 154 case 8: __put_user_asm_64(x,ptr,retval); break; \ 155 default: __put_user_bad(); \ 156 } \ 157} while (0) 158 159#define __get_user_size(x,ptr,size,retval) \ 160do { \ 161 retval = 0; \ 162 switch (size) { \ 163 case 1: __get_user_asm(x,ptr,retval,"move.b"); break; \ 164 case 2: __get_user_asm(x,ptr,retval,"move.w"); break; \ 165 case 4: __get_user_asm(x,ptr,retval,"move.d"); break; \ 166 case 8: __get_user_asm_64(x,ptr,retval); break; \ 167 default: (x) = __get_user_bad(); \ 168 } \ 169} while (0) 170 171#define __put_user_nocheck(x,ptr,size) \ 172({ \ 173 long __pu_err; \ 174 __put_user_size((x),(ptr),(size),__pu_err); \ 175 __pu_err; \ 176}) 177 178#define __put_user_check(x,ptr,size) \ 179({ \ 180 long __pu_err = -EFAULT; \ 181 __typeof__(*(ptr)) *__pu_addr = (ptr); \ 182 if (access_ok(VERIFY_WRITE,__pu_addr,size)) \ 183 __put_user_size((x),__pu_addr,(size),__pu_err); \ 184 __pu_err; \ 185}) 186 187struct __large_struct { unsigned long buf[100]; }; 188#define __m(x) (*(struct __large_struct *)(x)) 189 190 191 192#define __get_user_nocheck(x,ptr,size) \ 193({ \ 194 long __gu_err, __gu_val; \ 195 __get_user_size(__gu_val,(ptr),(size),__gu_err); \ 196 (x) = (__typeof__(*(ptr)))__gu_val; \ 197 __gu_err; \ 198}) 199 200#define __get_user_check(x,ptr,size) \ 201({ \ 202 long __gu_err = -EFAULT, __gu_val = 0; \ 203 const __typeof__(*(ptr)) *__gu_addr = (ptr); \ 204 if (access_ok(VERIFY_READ,__gu_addr,size)) \ 205 __get_user_size(__gu_val,__gu_addr,(size),__gu_err); \ 206 (x) = (__typeof__(*(ptr)))__gu_val; \ 207 __gu_err; \ 208}) 209 210extern long __get_user_bad(void); 211 212/* More complex functions. Most are inline, but some call functions that 213 live in lib/usercopy.c */ 214 215extern unsigned long __copy_user(void *to, const void *from, unsigned long n); 216extern unsigned long __copy_user_zeroing(void *to, const void *from, unsigned long n); 217extern unsigned long __do_clear_user(void *to, unsigned long n); 218 219static inline unsigned long 220__generic_copy_to_user(void __user *to, const void *from, unsigned long n) 221{ 222 if (access_ok(VERIFY_WRITE, to, n)) 223 return __copy_user(to,from,n); 224 return n; 225} 226 227static inline unsigned long 228__generic_copy_from_user(void *to, const void __user *from, unsigned long n) 229{ 230 if (access_ok(VERIFY_READ, from, n)) 231 return __copy_user_zeroing(to,from,n); 232 return n; 233} 234 235static inline unsigned long 236__generic_clear_user(void __user *to, unsigned long n) 237{ 238 if (access_ok(VERIFY_WRITE, to, n)) 239 return __do_clear_user(to,n); 240 return n; 241} 242 243static inline long 244__strncpy_from_user(char *dst, const char __user *src, long count) 245{ 246 return __do_strncpy_from_user(dst, src, count); 247} 248 249static inline long 250strncpy_from_user(char *dst, const char __user *src, long count) 251{ 252 long res = -EFAULT; 253 if (access_ok(VERIFY_READ, src, 1)) 254 res = __do_strncpy_from_user(dst, src, count); 255 return res; 256} 257 258 259/* Note that if these expand awfully if made into switch constructs, so 260 don't do that. */ 261 262static inline unsigned long 263__constant_copy_from_user(void *to, const void __user *from, unsigned long n) 264{ 265 unsigned long ret = 0; 266 if (n == 0) 267 ; 268 else if (n == 1) 269 __asm_copy_from_user_1(to, from, ret); 270 else if (n == 2) 271 __asm_copy_from_user_2(to, from, ret); 272 else if (n == 3) 273 __asm_copy_from_user_3(to, from, ret); 274 else if (n == 4) 275 __asm_copy_from_user_4(to, from, ret); 276 else if (n == 5) 277 __asm_copy_from_user_5(to, from, ret); 278 else if (n == 6) 279 __asm_copy_from_user_6(to, from, ret); 280 else if (n == 7) 281 __asm_copy_from_user_7(to, from, ret); 282 else if (n == 8) 283 __asm_copy_from_user_8(to, from, ret); 284 else if (n == 9) 285 __asm_copy_from_user_9(to, from, ret); 286 else if (n == 10) 287 __asm_copy_from_user_10(to, from, ret); 288 else if (n == 11) 289 __asm_copy_from_user_11(to, from, ret); 290 else if (n == 12) 291 __asm_copy_from_user_12(to, from, ret); 292 else if (n == 13) 293 __asm_copy_from_user_13(to, from, ret); 294 else if (n == 14) 295 __asm_copy_from_user_14(to, from, ret); 296 else if (n == 15) 297 __asm_copy_from_user_15(to, from, ret); 298 else if (n == 16) 299 __asm_copy_from_user_16(to, from, ret); 300 else if (n == 20) 301 __asm_copy_from_user_20(to, from, ret); 302 else if (n == 24) 303 __asm_copy_from_user_24(to, from, ret); 304 else 305 ret = __generic_copy_from_user(to, from, n); 306 307 return ret; 308} 309 310/* Ditto, don't make a switch out of this. */ 311 312static inline unsigned long 313__constant_copy_to_user(void __user *to, const void *from, unsigned long n) 314{ 315 unsigned long ret = 0; 316 if (n == 0) 317 ; 318 else if (n == 1) 319 __asm_copy_to_user_1(to, from, ret); 320 else if (n == 2) 321 __asm_copy_to_user_2(to, from, ret); 322 else if (n == 3) 323 __asm_copy_to_user_3(to, from, ret); 324 else if (n == 4) 325 __asm_copy_to_user_4(to, from, ret); 326 else if (n == 5) 327 __asm_copy_to_user_5(to, from, ret); 328 else if (n == 6) 329 __asm_copy_to_user_6(to, from, ret); 330 else if (n == 7) 331 __asm_copy_to_user_7(to, from, ret); 332 else if (n == 8) 333 __asm_copy_to_user_8(to, from, ret); 334 else if (n == 9) 335 __asm_copy_to_user_9(to, from, ret); 336 else if (n == 10) 337 __asm_copy_to_user_10(to, from, ret); 338 else if (n == 11) 339 __asm_copy_to_user_11(to, from, ret); 340 else if (n == 12) 341 __asm_copy_to_user_12(to, from, ret); 342 else if (n == 13) 343 __asm_copy_to_user_13(to, from, ret); 344 else if (n == 14) 345 __asm_copy_to_user_14(to, from, ret); 346 else if (n == 15) 347 __asm_copy_to_user_15(to, from, ret); 348 else if (n == 16) 349 __asm_copy_to_user_16(to, from, ret); 350 else if (n == 20) 351 __asm_copy_to_user_20(to, from, ret); 352 else if (n == 24) 353 __asm_copy_to_user_24(to, from, ret); 354 else 355 ret = __generic_copy_to_user(to, from, n); 356 357 return ret; 358} 359 360/* No switch, please. */ 361 362static inline unsigned long 363__constant_clear_user(void __user *to, unsigned long n) 364{ 365 unsigned long ret = 0; 366 if (n == 0) 367 ; 368 else if (n == 1) 369 __asm_clear_1(to, ret); 370 else if (n == 2) 371 __asm_clear_2(to, ret); 372 else if (n == 3) 373 __asm_clear_3(to, ret); 374 else if (n == 4) 375 __asm_clear_4(to, ret); 376 else if (n == 8) 377 __asm_clear_8(to, ret); 378 else if (n == 12) 379 __asm_clear_12(to, ret); 380 else if (n == 16) 381 __asm_clear_16(to, ret); 382 else if (n == 20) 383 __asm_clear_20(to, ret); 384 else if (n == 24) 385 __asm_clear_24(to, ret); 386 else 387 ret = __generic_clear_user(to, n); 388 389 return ret; 390} 391 392 393#define clear_user(to, n) \ 394(__builtin_constant_p(n) ? \ 395 __constant_clear_user(to, n) : \ 396 __generic_clear_user(to, n)) 397 398#define copy_from_user(to, from, n) \ 399(__builtin_constant_p(n) ? \ 400 __constant_copy_from_user(to, from, n) : \ 401 __generic_copy_from_user(to, from, n)) 402 403#define copy_to_user(to, from, n) \ 404(__builtin_constant_p(n) ? \ 405 __constant_copy_to_user(to, from, n) : \ 406 __generic_copy_to_user(to, from, n)) 407 408/* We let the __ versions of copy_from/to_user inline, because they're often 409 * used in fast paths and have only a small space overhead. 410 */ 411 412static inline unsigned long 413__generic_copy_from_user_nocheck(void *to, const void *from, unsigned long n) 414{ 415 return __copy_user_zeroing(to,from,n); 416} 417 418static inline unsigned long 419__generic_copy_to_user_nocheck(void *to, const void *from, unsigned long n) 420{ 421 return __copy_user(to,from,n); 422} 423 424static inline unsigned long 425__generic_clear_user_nocheck(void *to, unsigned long n) 426{ 427 return __do_clear_user(to,n); 428} 429 430/* without checking */ 431 432#define __copy_to_user(to,from,n) __generic_copy_to_user_nocheck((to),(from),(n)) 433#define __copy_from_user(to,from,n) __generic_copy_from_user_nocheck((to),(from),(n)) 434#define __copy_to_user_inatomic __copy_to_user 435#define __copy_from_user_inatomic __copy_from_user 436#define __clear_user(to,n) __generic_clear_user_nocheck((to),(n)) 437 438#define strlen_user(str) strnlen_user((str), 0x7ffffffe) 439 440#endif /* __ASSEMBLY__ */ 441 442#endif /* _CRIS_UACCESS_H */ 443