1/* $Id: uaccess.h,v 1.1.1.1 2008/10/15 03:29:17 james26_jang Exp $ 2 * uaccess.h: User space memore access functions. 3 * 4 * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu) 5 * Copyright (C) 1996,1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz) 6 */ 7#ifndef _ASM_UACCESS_H 8#define _ASM_UACCESS_H 9 10#ifdef __KERNEL__ 11#include <linux/sched.h> 12#include <linux/string.h> 13#include <asm/vac-ops.h> 14#include <asm/a.out.h> 15#endif 16 17#ifndef __ASSEMBLY__ 18 19/* Sparc is not segmented, however we need to be able to fool verify_area() 20 * when doing system calls from kernel mode legitimately. 21 * 22 * "For historical reasons, these macros are grossly misnamed." -Linus 23 */ 24 25#define KERNEL_DS ((mm_segment_t) { 0 }) 26#define USER_DS ((mm_segment_t) { -1 }) 27 28#define VERIFY_READ 0 29#define VERIFY_WRITE 1 30 31#define get_ds() (KERNEL_DS) 32#define get_fs() (current->thread.current_ds) 33#define set_fs(val) ((current->thread.current_ds) = (val)) 34 35#define segment_eq(a,b) ((a).seg == (b).seg) 36 37/* We have there a nice not-mapped page at PAGE_OFFSET - PAGE_SIZE, so that this test 38 * can be fairly lightweight. 39 * No one can read/write anything from userland in the kernel space by setting 40 * large size and address near to PAGE_OFFSET - a fault will break his intentions. 41 */ 42#define __user_ok(addr,size) ((addr) < STACK_TOP) 43#define __kernel_ok (segment_eq(get_fs(), KERNEL_DS)) 44#define __access_ok(addr,size) (__user_ok((addr) & get_fs().seg,(size))) 45#define access_ok(type,addr,size) __access_ok((unsigned long)(addr),(size)) 46 47extern inline int verify_area(int type, const void * addr, unsigned long size) 48{ 49 return access_ok(type,addr,size)?0:-EFAULT; 50} 51 52/* 53 * The exception table consists of pairs of addresses: the first is the 54 * address of an instruction that is allowed to fault, and the second is 55 * the address at which the program should continue. No registers are 56 * modified, so it is entirely up to the continuation code to figure out 57 * what to do. 58 * 59 * All the routines below use bits of fixup code that are out of line 60 * with the main instruction path. This means when everything is well, 61 * we don't even have to jump over them. Further, they do not intrude 62 * on our cache or tlb entries. 63 * 64 * There is a special way how to put a range of potentially faulting 65 * insns (like twenty ldd/std's with now intervening other instructions) 66 * You specify address of first in insn and 0 in fixup and in the next 67 * exception_table_entry you specify last potentially faulting insn + 1 68 * and in fixup the routine which should handle the fault. 69 * That fixup code will get 70 * (faulting_insn_address - first_insn_in_the_range_address)/4 71 * in %g2 (ie. index of the faulting instruction in the range). 72 */ 73 74struct exception_table_entry 75{ 76 unsigned long insn, fixup; 77}; 78 79/* Returns 0 if exception not found and fixup otherwise. */ 80extern unsigned long search_exception_table(unsigned long, unsigned long *); 81 82extern void __ret_efault(void); 83 84/* Uh, these should become the main single-value transfer routines.. 85 * They automatically use the right size if we just have the right 86 * pointer type.. 87 * 88 * This gets kind of ugly. We want to return _two_ values in "get_user()" 89 * and yet we don't want to do any pointers, because that is too much 90 * of a performance impact. Thus we have a few rather ugly macros here, 91 * and hide all the uglyness from the user. 92 */ 93#define put_user(x,ptr) ({ \ 94unsigned long __pu_addr = (unsigned long)(ptr); \ 95__put_user_check((__typeof__(*(ptr)))(x),__pu_addr,sizeof(*(ptr))); }) 96 97#define get_user(x,ptr) ({ \ 98unsigned long __gu_addr = (unsigned long)(ptr); \ 99__get_user_check((x),__gu_addr,sizeof(*(ptr)),__typeof__(*(ptr))); }) 100 101/* 102 * The "__xxx" versions do not do address space checking, useful when 103 * doing multiple accesses to the same area (the user has to do the 104 * checks by hand with "access_ok()") 105 */ 106#define __put_user(x,ptr) __put_user_nocheck((x),(ptr),sizeof(*(ptr))) 107#define __get_user(x,ptr) __get_user_nocheck((x),(ptr),sizeof(*(ptr)),__typeof__(*(ptr))) 108 109struct __large_struct { unsigned long buf[100]; }; 110#define __m(x) ((struct __large_struct *)(x)) 111 112#define __put_user_check(x,addr,size) ({ \ 113register int __pu_ret; \ 114if (__access_ok(addr,size)) { \ 115switch (size) { \ 116case 1: __put_user_asm(x,b,addr,__pu_ret); break; \ 117case 2: __put_user_asm(x,h,addr,__pu_ret); break; \ 118case 4: __put_user_asm(x,,addr,__pu_ret); break; \ 119case 8: __put_user_asm(x,d,addr,__pu_ret); break; \ 120default: __pu_ret = __put_user_bad(); break; \ 121} } else { __pu_ret = -EFAULT; } __pu_ret; }) 122 123#define __put_user_check_ret(x,addr,size,retval) ({ \ 124register int __foo __asm__ ("l1"); \ 125if (__access_ok(addr,size)) { \ 126switch (size) { \ 127case 1: __put_user_asm_ret(x,b,addr,retval,__foo); break; \ 128case 2: __put_user_asm_ret(x,h,addr,retval,__foo); break; \ 129case 4: __put_user_asm_ret(x,,addr,retval,__foo); break; \ 130case 8: __put_user_asm_ret(x,d,addr,retval,__foo); break; \ 131default: if (__put_user_bad()) return retval; break; \ 132} } else return retval; }) 133 134#define __put_user_nocheck(x,addr,size) ({ \ 135register int __pu_ret; \ 136switch (size) { \ 137case 1: __put_user_asm(x,b,addr,__pu_ret); break; \ 138case 2: __put_user_asm(x,h,addr,__pu_ret); break; \ 139case 4: __put_user_asm(x,,addr,__pu_ret); break; \ 140case 8: __put_user_asm(x,d,addr,__pu_ret); break; \ 141default: __pu_ret = __put_user_bad(); break; \ 142} __pu_ret; }) 143 144#define __put_user_nocheck_ret(x,addr,size,retval) ({ \ 145register int __foo __asm__ ("l1"); \ 146switch (size) { \ 147case 1: __put_user_asm_ret(x,b,addr,retval,__foo); break; \ 148case 2: __put_user_asm_ret(x,h,addr,retval,__foo); break; \ 149case 4: __put_user_asm_ret(x,,addr,retval,__foo); break; \ 150case 8: __put_user_asm_ret(x,d,addr,retval,__foo); break; \ 151default: if (__put_user_bad()) return retval; break; \ 152} }) 153 154#define __put_user_asm(x,size,addr,ret) \ 155__asm__ __volatile__( \ 156 "/* Put user asm, inline. */\n" \ 157"1:\t" "st"#size " %1, %2\n\t" \ 158 "clr %0\n" \ 159"2:\n\n\t" \ 160 ".section .fixup,#alloc,#execinstr\n\t" \ 161 ".align 4\n" \ 162"3:\n\t" \ 163 "b 2b\n\t" \ 164 " mov %3, %0\n\t" \ 165 ".previous\n\n\t" \ 166 ".section __ex_table,#alloc\n\t" \ 167 ".align 4\n\t" \ 168 ".word 1b, 3b\n\t" \ 169 ".previous\n\n\t" \ 170 : "=&r" (ret) : "r" (x), "m" (*__m(addr)), \ 171 "i" (-EFAULT)) 172 173#define __put_user_asm_ret(x,size,addr,ret,foo) \ 174if (__builtin_constant_p(ret) && ret == -EFAULT) \ 175__asm__ __volatile__( \ 176 "/* Put user asm ret, inline. */\n" \ 177"1:\t" "st"#size " %1, %2\n\n\t" \ 178 ".section __ex_table,#alloc\n\t" \ 179 ".align 4\n\t" \ 180 ".word 1b, __ret_efault\n\n\t" \ 181 ".previous\n\n\t" \ 182 : "=r" (foo) : "r" (x), "m" (*__m(addr))); \ 183else \ 184__asm__ __volatile( \ 185 "/* Put user asm ret, inline. */\n" \ 186"1:\t" "st"#size " %1, %2\n\n\t" \ 187 ".section .fixup,#alloc,#execinstr\n\t" \ 188 ".align 4\n" \ 189"3:\n\t" \ 190 "ret\n\t" \ 191 " restore %%g0, %3, %%o0\n\t" \ 192 ".previous\n\n\t" \ 193 ".section __ex_table,#alloc\n\t" \ 194 ".align 4\n\t" \ 195 ".word 1b, 3b\n\n\t" \ 196 ".previous\n\n\t" \ 197 : "=r" (foo) : "r" (x), "m" (*__m(addr)), "i" (ret)) 198 199extern int __put_user_bad(void); 200 201#define __get_user_check(x,addr,size,type) ({ \ 202register int __gu_ret; \ 203register unsigned long __gu_val; \ 204if (__access_ok(addr,size)) { \ 205switch (size) { \ 206case 1: __get_user_asm(__gu_val,ub,addr,__gu_ret); break; \ 207case 2: __get_user_asm(__gu_val,uh,addr,__gu_ret); break; \ 208case 4: __get_user_asm(__gu_val,,addr,__gu_ret); break; \ 209case 8: __get_user_asm(__gu_val,d,addr,__gu_ret); break; \ 210default: __gu_val = 0; __gu_ret = __get_user_bad(); break; \ 211} } else { __gu_val = 0; __gu_ret = -EFAULT; } x = (type) __gu_val; __gu_ret; }) 212 213#define __get_user_check_ret(x,addr,size,type,retval) ({ \ 214register unsigned long __gu_val __asm__ ("l1"); \ 215if (__access_ok(addr,size)) { \ 216switch (size) { \ 217case 1: __get_user_asm_ret(__gu_val,ub,addr,retval); break; \ 218case 2: __get_user_asm_ret(__gu_val,uh,addr,retval); break; \ 219case 4: __get_user_asm_ret(__gu_val,,addr,retval); break; \ 220case 8: __get_user_asm_ret(__gu_val,d,addr,retval); break; \ 221default: if (__get_user_bad()) return retval; \ 222} x = (type) __gu_val; } else return retval; }) 223 224#define __get_user_nocheck(x,addr,size,type) ({ \ 225register int __gu_ret; \ 226register unsigned long __gu_val; \ 227switch (size) { \ 228case 1: __get_user_asm(__gu_val,ub,addr,__gu_ret); break; \ 229case 2: __get_user_asm(__gu_val,uh,addr,__gu_ret); break; \ 230case 4: __get_user_asm(__gu_val,,addr,__gu_ret); break; \ 231case 8: __get_user_asm(__gu_val,d,addr,__gu_ret); break; \ 232default: __gu_val = 0; __gu_ret = __get_user_bad(); break; \ 233} x = (type) __gu_val; __gu_ret; }) 234 235#define __get_user_nocheck_ret(x,addr,size,type,retval) ({ \ 236register unsigned long __gu_val __asm__ ("l1"); \ 237switch (size) { \ 238case 1: __get_user_asm_ret(__gu_val,ub,addr,retval); break; \ 239case 2: __get_user_asm_ret(__gu_val,uh,addr,retval); break; \ 240case 4: __get_user_asm_ret(__gu_val,,addr,retval); break; \ 241case 8: __get_user_asm_ret(__gu_val,d,addr,retval); break; \ 242default: if (__get_user_bad()) return retval; \ 243} x = (type) __gu_val; }) 244 245#define __get_user_asm(x,size,addr,ret) \ 246__asm__ __volatile__( \ 247 "/* Get user asm, inline. */\n" \ 248"1:\t" "ld"#size " %2, %1\n\t" \ 249 "clr %0\n" \ 250"2:\n\n\t" \ 251 ".section .fixup,#alloc,#execinstr\n\t" \ 252 ".align 4\n" \ 253"3:\n\t" \ 254 "clr %1\n\t" \ 255 "b 2b\n\t" \ 256 " mov %3, %0\n\n\t" \ 257 ".previous\n\t" \ 258 ".section __ex_table,#alloc\n\t" \ 259 ".align 4\n\t" \ 260 ".word 1b, 3b\n\n\t" \ 261 ".previous\n\t" \ 262 : "=&r" (ret), "=&r" (x) : "m" (*__m(addr)), \ 263 "i" (-EFAULT)) 264 265#define __get_user_asm_ret(x,size,addr,retval) \ 266if (__builtin_constant_p(retval) && retval == -EFAULT) \ 267__asm__ __volatile__( \ 268 "/* Get user asm ret, inline. */\n" \ 269"1:\t" "ld"#size " %1, %0\n\n\t" \ 270 ".section __ex_table,#alloc\n\t" \ 271 ".align 4\n\t" \ 272 ".word 1b,__ret_efault\n\n\t" \ 273 ".previous\n\t" \ 274 : "=&r" (x) : "m" (*__m(addr))); \ 275else \ 276__asm__ __volatile__( \ 277 "/* Get user asm ret, inline. */\n" \ 278"1:\t" "ld"#size " %1, %0\n\n\t" \ 279 ".section .fixup,#alloc,#execinstr\n\t" \ 280 ".align 4\n" \ 281"3:\n\t" \ 282 "ret\n\t" \ 283 " restore %%g0, %2, %%o0\n\n\t" \ 284 ".previous\n\t" \ 285 ".section __ex_table,#alloc\n\t" \ 286 ".align 4\n\t" \ 287 ".word 1b, 3b\n\n\t" \ 288 ".previous\n\t" \ 289 : "=&r" (x) : "m" (*__m(addr)), "i" (retval)) 290 291extern int __get_user_bad(void); 292 293extern __kernel_size_t __copy_user(void *to, void *from, __kernel_size_t size); 294 295#define copy_to_user(to,from,n) ({ \ 296void *__copy_to = (void *) (to); \ 297__kernel_size_t __copy_size = (__kernel_size_t) (n); \ 298__kernel_size_t __copy_res; \ 299if(__copy_size && __access_ok((unsigned long)__copy_to, __copy_size)) { \ 300__copy_res = __copy_user(__copy_to, (void *) (from), __copy_size); \ 301} else __copy_res = __copy_size; \ 302__copy_res; }) 303 304#define __copy_to_user(to,from,n) \ 305 __copy_user((void *)(to), \ 306 (void *)(from), n) 307 308#define copy_from_user(to,from,n) ({ \ 309void *__copy_to = (void *) (to); \ 310void *__copy_from = (void *) (from); \ 311__kernel_size_t __copy_size = (__kernel_size_t) (n); \ 312__kernel_size_t __copy_res; \ 313if(__copy_size && __access_ok((unsigned long)__copy_from, __copy_size)) { \ 314__copy_res = __copy_user(__copy_to, __copy_from, __copy_size); \ 315} else __copy_res = __copy_size; \ 316__copy_res; }) 317 318#define __copy_from_user(to,from,n) \ 319 __copy_user((void *)(to), \ 320 (void *)(from), n) 321 322extern __inline__ __kernel_size_t __clear_user(void *addr, __kernel_size_t size) 323{ 324 __kernel_size_t ret; 325 __asm__ __volatile__ ( 326 ".section __ex_table,#alloc\n\t" 327 ".align 4\n\t" 328 ".word 1f,3\n\t" 329 ".previous\n\t" 330 "mov %2, %%o1\n" 331 "1:\n\t" 332 "call __bzero\n\t" 333 " mov %1, %%o0\n\t" 334 "mov %%o0, %0\n" 335 : "=r" (ret) : "r" (addr), "r" (size) : 336 "o0", "o1", "o2", "o3", "o4", "o5", "o7", 337 "g1", "g2", "g3", "g4", "g5", "g7", "cc"); 338 return ret; 339} 340 341#define clear_user(addr,n) ({ \ 342void *__clear_addr = (void *) (addr); \ 343__kernel_size_t __clear_size = (__kernel_size_t) (n); \ 344__kernel_size_t __clear_res; \ 345if(__clear_size && __access_ok((unsigned long)__clear_addr, __clear_size)) { \ 346__clear_res = __clear_user(__clear_addr, __clear_size); \ 347} else __clear_res = __clear_size; \ 348__clear_res; }) 349 350extern int __strncpy_from_user(unsigned long dest, unsigned long src, int count); 351 352#define strncpy_from_user(dest,src,count) ({ \ 353unsigned long __sfu_src = (unsigned long) (src); \ 354int __sfu_count = (int) (count); \ 355long __sfu_res = -EFAULT; \ 356if(__access_ok(__sfu_src, __sfu_count)) { \ 357__sfu_res = __strncpy_from_user((unsigned long) (dest), __sfu_src, __sfu_count); \ 358} __sfu_res; }) 359 360extern int __strlen_user(const char *); 361extern int __strnlen_user(const char *, long len); 362 363extern __inline__ int strlen_user(const char *str) 364{ 365 if(!access_ok(VERIFY_READ, str, 0)) 366 return 0; 367 else 368 return __strlen_user(str); 369} 370 371extern __inline__ int strnlen_user(const char *str, long len) 372{ 373 if(!access_ok(VERIFY_READ, str, 0)) 374 return 0; 375 else 376 return __strnlen_user(str, len); 377} 378 379#endif /* __ASSEMBLY__ */ 380 381#endif /* _ASM_UACCESS_H */ 382