include/asm-i386/uaccess.h
13137 #ifndef __i386_UACCESS_H
13138 #define __i386_UACCESS_H
13139
13140 /* User space memory access functions */
13141 #include <linux/config.h>
13142 #include <linux/sched.h>
13143 #include <asm/page.h>
13144
13145 #define VERIFY_READ 0
13146 #define VERIFY_WRITE 1
13147
13148 /* The fs value determines whether argument validity
13149 * checking should be performed or not. If get_fs() ==
13150 * USER_DS, checking is performed, with get_fs() ==
13151 * KERNEL_DS, checking is bypassed.
13152 *
13153 * For historical reasons, these macros are grossly
13154 * misnamed. */
13155
13156 #define MAKE_MM_SEG(s) ((mm_segment_t) { (s) })
13157
13158
13159 #define KERNEL_DS MAKE_MM_SEG(0xFFFFFFFF)
13160 #define USER_DS MAKE_MM_SEG(PAGE_OFFSET)
13161
13162 #define get_ds() (KERNEL_DS)
13163 #define get_fs() (current->addr_limit)
13164 #define set_fs(x) (current->addr_limit = (x))
13165
13166 #define segment_eq(a,b) ((a).seg == (b).seg)
13167
13168 extern int __verify_write(const void *, unsigned long);
13169
13170 #define __addr_ok(addr) \
13171 ((unsigned long)(addr) < (current->addr_limit.seg))
13172
13173 /* Uhhuh, this needs 33-bit arithmetic. We have a carry*/
13174 #define __range_ok(addr,size) ({ \
13175 unsigned long flag,sum; \
13176 asm("addl %3,%1 ; sbbl %0,%0; cmpl %1,%4; sbbl $0,%0" \
13177 :"=&r" (flag), "=r" (sum) \
13178 :"1" (addr),"g" (size),"g" \
13179 (current->addr_limit.seg)); \
13180 flag; })
13181
13182 #ifdef CONFIG_X86_WP_WORKS_OK
13183
13184 #define access_ok(type,addr,size) \
13185 (__range_ok(addr,size) == 0)
13186
13187 #else
13188
13189 #define access_ok(type,addr,size) \
13190 ((__range_ok(addr,size) == 0) && \
13191 ((type) == VERIFY_READ || boot_cpu_data.wp_works_ok ||\
13192 segment_eq(get_fs(),KERNEL_DS) || \
13193 __verify_write((void *)(addr),(size))))
13194
13195 #endif /* CPU */
13196
13197 extern inline int verify_area(int type, const void * addr
13198 , unsigned long size)
13199 {
13200 return access_ok(type,addr,size) ? 0 : -EFAULT;
13201 }
13202
13203
13204 /* The exception table consists of pairs of addresses:
13205 * the first is the address of an instruction that is
13206 * allowed to fault, and the second is the address at
13207 * which the program should continue. No registers are
13208 * modified, so it is entirely up to the continuation
13209 * code to figure out what to do.
13210 *
13211 * All the routines below use bits of fixup code that are
13212 * out of line with the main instruction path. This
13213 * means when everything is well, we don't even have to
13214 * jump over them. Further, they do not intrude on our
13215 * cache or tlb entries. */
13216
13217 struct exception_table_entry
13218 {
13219 unsigned long insn, fixup;
13220 };
13221
13222 /* Returns 0 if exception not found, fixup otherwise. */
13223 extern unsigned long search_exception_table(
13224 unsigned long);
13225
13226
13227 /* These are the main single-value transfer routines.
13228 * They automatically use the right size if we just have
13229 * the right pointer type.
13230 *
13231 * This gets kind of ugly. We want to return _two_ values
13232 * in "get_user()" and yet we don't want to do any
13233 * pointers, because that is too much of a performance
13234 * impact. Thus we have a few rather ugly macros here,
13235 * and hide all the uglyness from the user.
13236 *
13237 * The "__xxx" versions of the user access functions are
13238 * versions that do not verify the address space, that
13239 * must have been done previously with a separate
13240 * "access_ok()" call (this is used when we do multiple
13241 * accesses to the same area of user memory). */
13242
13243 extern void __get_user_1(void);
13244 extern void __get_user_2(void);
13245 extern void __get_user_4(void);
13246
13247 #define __get_user_x(size,ret,x,ptr) \
13248 __asm__ __volatile__("call __get_user_" #size \
13249 :"=a" (ret),"=d" (x) \
13250 :"0" (ptr))
13251
13252 /* Careful: we have to cast the result to the type of the
13253 * pointer for sign reasons */
13254 #define get_user(x,ptr) \
13255 ({ int __ret_gu,__val_gu; \
13256 switch(sizeof (*(ptr))) { \
13257 case 1: __get_user_x(1,__ret_gu,__val_gu,ptr); break;\
13258 case 2: __get_user_x(2,__ret_gu,__val_gu,ptr); break;\
13259 case 4: __get_user_x(4,__ret_gu,__val_gu,ptr); break;\
13260 default: __get_user_x(X,__ret_gu,__val_gu,ptr); break;\
13261 } \
13262 (x) = (__typeof__(*(ptr)))__val_gu; \
13263 __ret_gu; \
13264 })
13265
13266 extern void __put_user_1(void);
13267 extern void __put_user_2(void);
13268 extern void __put_user_4(void);
13269
13270 extern void __put_user_bad(void);
13271
13272 #define __put_user_x(size,ret,x,ptr) \
13273 __asm__ __volatile__("call __put_user_" #size \
13274 :"=a" (ret) \
13275 :"0" (ptr),"d" (x) \
13276 :"cx")
13277
13278 #define put_user(x,ptr) \
13279 ({ int __ret_pu; \
13280 switch(sizeof (*(ptr))) { \
13281 case 1: __put_user_x(1,__ret_pu, \
13282 (__typeof__(*(ptr)))(x),ptr); \
13283 break; \
13284 case 2: __put_user_x(2,__ret_pu, \
13285 (__typeof__(*(ptr)))(x),ptr); \
13286 break; \
13287 case 4: __put_user_x(4,__ret_pu, \
13288 (__typeof__(*(ptr)))(x),ptr); \
13289 break; \
13290 default: __put_user_x(X,__ret_pu,x,ptr); break; \
13291 } \
13292 __ret_pu; \
13293 })
13294
13295 #define __get_user(x,ptr) \
13296 __get_user_nocheck((x),(ptr),sizeof(*(ptr)))
13297 #define __put_user(x,ptr) \
13298 __put_user_nocheck((__typeof__(*(ptr)))(x),(ptr), \
13299 sizeof(*(ptr)))
13300
13301 #define __put_user_nocheck(x,ptr,size) \
13302 ({ \
13303 long __pu_err; \
13304 __put_user_size((x),(ptr),(size),__pu_err); \
13305 __pu_err; \
13306 })
13307
13308 #define __put_user_size(x,ptr,size,retval) \
13309 do { \
13310 retval = 0; \
13311 switch (size) { \
13312 case 1: __put_user_asm(x,ptr,retval,"b","b","iq"); \
13313 break; \
13314 case 2: __put_user_asm(x,ptr,retval,"w","w","ir"); \
13315 break; \
13316 case 4: __put_user_asm(x,ptr,retval,"l","","ir"); \
13317 break; \
13318 default: __put_user_bad(); \
13319 } \
13320 } while (0)
13321
13322 struct __large_struct { unsigned long buf[100]; };
13323 #define __m(x) (*(struct __large_struct *)(x))
13324
13325 /* Tell gcc we read from memory instead of writing: this
13326 * is because we do not write to any memory gcc knows
13327 * about, so there are no aliasing issues. */
13328 #define __put_user_asm(x,addr,err,itype,rtype,ltype) \
13329 __asm__ __volatile__( \
13330 "1: mov"itype" %"rtype"1,%2\n" \
13331 "2:\n" \
13332 ".section .fixup,\"ax\"\n" \
13333 "3: movl %3,%0\n" \
13334 " jmp 2b\n" \
13335 ".previous\n" \
13336 ".section __ex_table,\"a\"\n" \
13337 " .align 4\n" \
13338 " .long 1b,3b\n" \
13339 ".previous" \
13340 : "=r"(err) \
13341 : ltype (x), "m"(__m(addr)), "i"(-EFAULT), "0"(err))
13342
13343
13344 #define __get_user_nocheck(x,ptr,size) \
13345 ({ \
13346 long __gu_err, __gu_val; \
13347 __get_user_size(__gu_val,(ptr),(size),__gu_err); \
13348 (x) = (__typeof__(*(ptr)))__gu_val; \
13349 __gu_err; \
13350 })
13351
13352 extern long __get_user_bad(void);
13353
13354 #define __get_user_size(x,ptr,size,retval) \
13355 do { \
13356 retval = 0; \
13357 switch (size) { \
13358 case 1: __get_user_asm(x,ptr,retval,"b","b","=q"); \
13359 break; \
13360 case 2: __get_user_asm(x,ptr,retval,"w","w","=r"); \
13361 break; \
13362 case 4: __get_user_asm(x,ptr,retval,"l","","=r"); \
13363 break; \
13364 default: (x) = __get_user_bad(); \
13365 } \
13366 } while (0)
13367
13368 #define __get_user_asm(x,addr,err,itype,rtype,ltype) \
13369 __asm__ __volatile__( \
13370 "1: mov"itype" %2,%"rtype"1\n" \
13371 "2:\n" \
13372 ".section .fixup,\"ax\"\n" \
13373 "3: movl %3,%0\n" \
13374 " xor"itype" %"rtype"1,%"rtype"1\n" \
13375 " jmp 2b\n" \
13376 ".previous\n" \
13377 ".section __ex_table,\"a\"\n" \
13378 " .align 4\n" \
13379 " .long 1b,3b\n" \
13380 ".previous" \
13381 : "=r"(err), ltype (x) \
13382 : "m"(__m(addr)), "i"(-EFAULT), "0"(err))
13383
13384 /* The "xxx_ret" versions return constant specified in
13385 * third argument, if something bad happens. These macros
13386 * can be optimized for the case of just returning from
13387 * the function xxx_ret is used. */
13388
13389 #define put_user_ret(x,ptr,ret) \
13390 ({ if (put_user(x,ptr)) return ret; })
13391
13392 #define get_user_ret(x,ptr,ret) \
13393 ({ if (get_user(x,ptr)) return ret; })
13394
13395 #define __put_user_ret(x,ptr,ret) \
13396 ({ if (__put_user(x,ptr)) return ret; })
13397
13398 #define __get_user_ret(x,ptr,ret) \
13399 ({ if (__get_user(x,ptr)) return ret; })
13400
13401 /* Copy To/From Userspace */
13402
13403 /* Generic arbitrary sized copy. */
13404 #define __copy_user(to,from,size) \
13405 do { \
13406 int __d0, __d1; \
13407 __asm__ __volatile__( \
13408 "0: rep; movsl\n" \
13409 " movl %3,%0\n" \
13410 "1: rep; movsb\n" \
13411 "2:\n" \
13412 ".section .fixup,\"ax\"\n" \
13413 "3: lea 0(%3,%0,4),%0\n" \
13414 " jmp 2b\n" \
13415 ".previous\n" \
13416 ".section __ex_table,\"a\"\n" \
13417 " .align 4\n" \
13418 " .long 0b,3b\n" \
13419 " .long 1b,2b\n" \
13420 ".previous" \
13421 : "=&c"(size), "=&D" (__d0), "=&S" (__d1) \
13422 : "r"(size & 3), "0"(size / 4), "1"(to), "2"(from) \
13423 : "memory"); \
13424 } while (0)
13425
13426 #define __copy_user_zeroing(to,from,size) \
13427 do { \
13428 int __d0, __d1; \
13429 __asm__ __volatile__( \
13430 "0: rep; movsl\n" \
13431 " movl %3,%0\n" \
13432 "1: rep; movsb\n" \
13433 "2:\n" \
13434 ".section .fixup,\"ax\"\n" \
13435 "3: lea 0(%3,%0,4),%0\n" \
13436 "4: pushl %0\n" \
13437 " pushl %%eax\n" \
13438 " xorl %%eax,%%eax\n" \
13439 " rep; stosb\n" \
13440 " popl %%eax\n" \
13441 " popl %0\n" \
13442 " jmp 2b\n" \
13443 ".previous\n" \
13444 ".section __ex_table,\"a\"\n" \
13445 " .align 4\n" \
13446 " .long 0b,3b\n" \
13447 " .long 1b,4b\n" \
13448 ".previous" \
13449 : "=&c"(size), "=&D" (__d0), "=&S" (__d1) \
13450 : "r"(size & 3), "0"(size / 4), "1"(to), "2"(from) \
13451 : "memory"); \
13452 } while (0)
13453
13454 /* We let the __ versions of copy_from/to_user inline,
13455 * because they're often used in fast paths and have only
13456 * a small space overhead. */
13457 static inline unsigned long
13458 __generic_copy_from_user_nocheck(
13459 void *to, const void *from, unsigned long n)
13460 {
13461 __copy_user_zeroing(to,from,n);
13462 return n;
13463 }
13464
13465 static inline unsigned long
13466 __generic_copy_to_user_nocheck(
13467 void *to, const void *from, unsigned long n)
13468 {
13469 __copy_user(to,from,n);
13470 return n;
13471 }
13472
13473
13474 /* Optimize just a little bit when we know the size of
13475 * the move. */
13476 #define __constant_copy_user(to, from, size) \
13477 do { \
13478 int __d0, __d1; \
13479 switch (size & 3) { \
13480 default: \
13481 __asm__ __volatile__( \
13482 "0: rep; movsl\n" \
13483 "1:\n" \
13484 ".section .fixup,\"ax\"\n" \
13485 "2: shl $2,%0\n" \
13486 " jmp 1b\n" \
13487 ".previous\n" \
13488 ".section __ex_table,\"a\"\n" \
13489 " .align 4\n" \
13490 " .long 0b,2b\n" \
13491 ".previous" \
13492 : "=c"(size), "=&S" (__d0), "=&D" (__d1) \
13493 : "1"(from), "2"(to), "0"(size/4) \
13494 : "memory"); \
13495 break; \
13496 case 1: \
13497 __asm__ __volatile__( \
13498 "0: rep; movsl\n" \
13499 "1: movsb\n" \
13500 "2:\n" \
13501 ".section .fixup,\"ax\"\n" \
13502 "3: shl $2,%0\n" \
13503 "4: incl %0\n" \
13504 " jmp 2b\n" \
13505 ".previous\n" \
13506 ".section __ex_table,\"a\"\n" \
13507 " .align 4\n" \
13508 " .long 0b,3b\n" \
13509 " .long 1b,4b\n" \
13510 ".previous" \
13511 : "=c"(size), "=&S" (__d0), "=&D" (__d1) \
13512 : "1"(from), "2"(to), "0"(size/4) \
13513 : "memory"); \
13514 break; \
13515 case 2: \
13516 __asm__ __volatile__( \
13517 "0: rep; movsl\n" \
13518 "1: movsw\n" \
13519 "2:\n" \
13520 ".section .fixup,\"ax\"\n" \
13521 "3: shl $2,%0\n" \
13522 "4: addl $2,%0\n" \
13523 " jmp 2b\n" \
13524 ".previous\n" \
13525 ".section __ex_table,\"a\"\n" \
13526 " .align 4\n" \
13527 " .long 0b,3b\n" \
13528 " .long 1b,4b\n" \
13529 ".previous" \
13530 : "=c"(size), "=&S" (__d0), "=&D" (__d1) \
13531 : "1"(from), "2"(to), "0"(size/4) \
13532 : "memory"); \
13533 break; \
13534 case 3: \
13535 __asm__ __volatile__( \
13536 "0: rep; movsl\n" \
13537 "1: movsw\n" \
13538 "2: movsb\n" \
13539 "3:\n" \
13540 ".section .fixup,\"ax\"\n" \
13541 "4: shl $2,%0\n" \
13542 "5: addl $2,%0\n" \
13543 "6: incl %0\n" \
13544 " jmp 3b\n" \
13545 ".previous\n" \
13546 ".section __ex_table,\"a\"\n" \
13547 " .align 4\n" \
13548 " .long 0b,4b\n" \
13549 " .long 1b,5b\n" \
13550 " .long 2b,6b\n" \
13551 ".previous" \
13552 : "=c"(size), "=&S" (__d0), "=&D" (__d1) \
13553 : "1"(from), "2"(to), "0"(size/4) \
13554 : "memory"); \
13555 break; \
13556 } \
13557 } while (0)
13558
13559 /* Optimize just a little bit when we know the size of
13560 * the move. */
13561 #define __constant_copy_user_zeroing(to, from, size) \
13562 do { \
13563 int __d0, __d1; \
13564 switch (size & 3) { \
13565 default: \
13566 __asm__ __volatile__( \
13567 "0: rep; movsl\n" \
13568 "1:\n" \
13569 ".section .fixup,\"ax\"\n" \
13570 "2: pushl %0\n" \
13571 " pushl %%eax\n" \
13572 " xorl %%eax,%%eax\n" \
13573 " rep; stosl\n" \
13574 " popl %%eax\n" \
13575 " popl %0\n" \
13576 " shl $2,%0\n" \
13577 " jmp 1b\n" \
13578 ".previous\n" \
13579 ".section __ex_table,\"a\"\n" \
13580 " .align 4\n" \
13581 " .long 0b,2b\n" \
13582 ".previous" \
13583 : "=c"(size), "=&S" (__d0), "=&D" (__d1) \
13584 : "1"(from), "2"(to), "0"(size/4) \
13585 : "memory"); \
13586 break; \
13587 case 1: \
13588 __asm__ __volatile__( \
13589 "0: rep; movsl\n" \
13590 "1: movsb\n" \
13591 "2:\n" \
13592 ".section .fixup,\"ax\"\n" \
13593 "3: pushl %0\n" \
13594 " pushl %%eax\n" \
13595 " xorl %%eax,%%eax\n" \
13596 " rep; stosl\n" \
13597 " stosb\n" \
13598 " popl %%eax\n" \
13599 " popl %0\n" \
13600 " shl $2,%0\n" \
13601 " incl %0\n" \
13602 " jmp 2b\n" \
13603 "4: pushl %%eax\n" \
13604 " xorl %%eax,%%eax\n" \
13605 " stosb\n" \
13606 " popl %%eax\n" \
13607 " incl %0\n" \
13608 " jmp 2b\n" \
13609 ".previous\n" \
13610 ".section __ex_table,\"a\"\n" \
13611 " .align 4\n" \
13612 " .long 0b,3b\n" \
13613 " .long 1b,4b\n" \
13614 ".previous" \
13615 : "=c"(size), "=&S" (__d0), "=&D" (__d1) \
13616 : "1"(from), "2"(to), "0"(size/4) \
13617 : "memory"); \
13618 break; \
13619 case 2: \
13620 __asm__ __volatile__( \
13621 "0: rep; movsl\n" \
13622 "1: movsw\n" \
13623 "2:\n" \
13624 ".section .fixup,\"ax\"\n" \
13625 "3: pushl %0\n" \
13626 " pushl %%eax\n" \
13627 " xorl %%eax,%%eax\n" \
13628 " rep; stosl\n" \
13629 " stosw\n" \
13630 " popl %%eax\n" \
13631 " popl %0\n" \
13632 " shl $2,%0\n" \
13633 " addl $2,%0\n" \
13634 " jmp 2b\n" \
13635 "4: pushl %%eax\n" \
13636 " xorl %%eax,%%eax\n" \
13637 " stosw\n" \
13638 " popl %%eax\n" \
13639 " addl $2,%0\n" \
13640 " jmp 2b\n" \
13641 ".previous\n" \
13642 ".section __ex_table,\"a\"\n" \
13643 " .align 4\n" \
13644 " .long 0b,3b\n" \
13645 " .long 1b,4b\n" \
13646 ".previous" \
13647 : "=c"(size), "=&S" (__d0), "=&D" (__d1) \
13648 : "1"(from), "2"(to), "0"(size/4) \
13649 : "memory"); \
13650 break; \
13651 case 3: \
13652 __asm__ __volatile__( \
13653 "0: rep; movsl\n" \
13654 "1: movsw\n" \
13655 "2: movsb\n" \
13656 "3:\n" \
13657 ".section .fixup,\"ax\"\n" \
13658 "4: pushl %0\n" \
13659 " pushl %%eax\n" \
13660 " xorl %%eax,%%eax\n" \
13661 " rep; stosl\n" \
13662 " stosw\n" \
13663 " stosb\n" \
13664 " popl %%eax\n" \
13665 " popl %0\n" \
13666 " shl $2,%0\n" \
13667 " addl $3,%0\n" \
13668 " jmp 2b\n" \
13669 "5: pushl %%eax\n" \
13670 " xorl %%eax,%%eax\n" \
13671 " stosw\n" \
13672 " stosb\n" \
13673 " popl %%eax\n" \
13674 " addl $3,%0\n" \
13675 " jmp 2b\n" \
13676 "6: pushl %%eax\n" \
13677 " xorl %%eax,%%eax\n" \
13678 " stosb\n" \
13679 " popl %%eax\n" \
13680 " incl %0\n" \
13681 " jmp 2b\n" \
13682 ".previous\n" \
13683 ".section __ex_table,\"a\"\n" \
13684 " .align 4\n" \
13685 " .long 0b,4b\n" \
13686 " .long 1b,5b\n" \
13687 " .long 2b,6b\n" \
13688 ".previous" \
13689 : "=c"(size), "=&S" (__d0), "=&D" (__d1) \
13690 : "1"(from), "2"(to), "0"(size/4) \
13691 : "memory"); \
13692 break; \
13693 } \
13694 } while (0)
13695
13696 unsigned long __generic_copy_to_user(
13697 void *, const void *, unsigned long);
13698 unsigned long __generic_copy_from_user(
13699 void *, const void *, unsigned long);
13700
13701 static inline unsigned long
13702 __constant_copy_to_user(
13703 void *to, const void *from, unsigned long n)
13704 {
13705 if (access_ok(VERIFY_WRITE, to, n))
13706 __constant_copy_user(to,from,n);
13707 return n;
13708 }
13709
13710 static inline unsigned long
13711 __constant_copy_from_user(
13712 void *to, const void *from, unsigned long n)
13713 {
13714 if (access_ok(VERIFY_READ, from, n))
13715 __constant_copy_user_zeroing(to,from,n);
13716 return n;
13717 }
13718
13719 static inline unsigned long
13720 __constant_copy_to_user_nocheck(
13721 void *to, const void *from, unsigned long n)
13722 {
13723 __constant_copy_user(to,from,n);
13724 return n;
13725 }
13726
13727 static inline unsigned long
13728 __constant_copy_from_user_nocheck(
13729 void *to, const void *from, unsigned long n)
13730 {
13731 __constant_copy_user_zeroing(to,from,n);
13732 return n;
13733 }
13734
13735 #define copy_to_user(to,from,n) \
13736 (__builtin_constant_p(n) ? \
13737 __constant_copy_to_user((to),(from),(n)) : \
13738 __generic_copy_to_user((to),(from),(n)))
13739
13740 #define copy_from_user(to,from,n) \
13741 (__builtin_constant_p(n) ? \
13742 __constant_copy_from_user((to),(from),(n)) : \
13743 __generic_copy_from_user((to),(from),(n)))
13744
13745 #define copy_to_user_ret(to,from,n,retval) \
13746 ({ if (copy_to_user(to,from,n)) return retval; })
13747
13748 #define copy_from_user_ret(to,from,n,retval) \
13749 ({ if (copy_from_user(to,from,n)) return retval; })
13750
13751 #define __copy_to_user(to,from,n) \
13752 (__builtin_constant_p(n) ? \
13753 __constant_copy_to_user_nocheck((to),(from),(n)) : \
13754 __generic_copy_to_user_nocheck((to),(from),(n)))
13755
13756 #define __copy_from_user(to,from,n) \
13757 (__builtin_constant_p(n) ? \
13758 __constant_copy_from_user_nocheck((to),(from),(n)) : \
13759 __generic_copy_from_user_nocheck((to),(from),(n)))
13760
13761 long strncpy_from_user(char *dst, const char *src,
13762 long count);
13763 long __strncpy_from_user(char *dst, const char *src,
13764 long count);
13765 long strlen_user(const char *str);
13766 unsigned long clear_user(void *mem, unsigned long len);
13767 unsigned long __clear_user(void *mem, unsigned long len);
13768
13769 #endif /* __i386_UACCESS_H */
Сайт управляется системой
uCoz