开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
uaccess.h
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：31k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

uaccess.h：源码内容
  1. /* 
  2.  * Authors:    Bjorn Wesen (bjornw@axis.com)
  3.  *        Hans-Peter Nilsson (hp@axis.com)
  4.  *
  5.  * $Log: uaccess.h,v $
  6.  * Revision 1.8  2001/10/29 13:01:48  bjornw
  7.  * Removed unused variable tmp2 in strnlen_user
  8.  *
  9.  * Revision 1.7  2001/10/02 12:44:52  hp
  10.  * Add support for 64-bit put_user/get_user
  11.  *
  12.  * Revision 1.6  2001/10/01 14:51:17  bjornw
  13.  * Added register prefixes and removed underscores
  14.  *
  15.  * Revision 1.5  2000/10/25 03:33:21  hp
  16.  * - Provide implementation for everything else but get_user and put_user;
  17.  *   copying inline to/from user for constant length 0..16, 20, 24, and
  18.  *   clearing for 0..4, 8, 12, 16, 20, 24, strncpy_from_user and strnlen_user
  19.  *   always inline.
  20.  * - Constraints for destination addr in get_user cannot be memory, only reg.
  21.  * - Correct labels for PC at expected fault points.
  22.  * - Nits with assembly code.
  23.  * - Don't use statement expressions without value; use "do {} while (0)".
  24.  * - Return correct values from __generic_... functions.
  25.  *
  26.  * Revision 1.4  2000/09/12 16:28:25  bjornw
  27.  * * Removed comments from the get/put user asm code
  28.  * * Constrains for destination addr in put_user cannot be memory, only reg
  29.  *
  30.  * Revision 1.3  2000/09/12 14:30:20  bjornw
  31.  * MAX_ADDR_USER does not exist anymore
  32.  *
  33.  * Revision 1.2  2000/07/13 15:52:48  bjornw
  34.  * New user-access functions
  35.  *
  36.  * Revision 1.1.1.1  2000/07/10 16:32:31  bjornw
  37.  * CRIS architecture, working draft
  38.  *
  39.  *
  40.  *
  41.  */
  43. /* Asm:s have been tweaked (within the domain of correctness) to give
  44.    satisfactory results for "gcc version 2.96 20000427 (experimental)".
  46.    Check regularly...
  48.    Register $r9 is chosen for temporaries, being a call-clobbered register
  49.    first in line to be used (notably for local blocks), not colliding with
  50.    parameter registers.  */
  52. #ifndef _CRIS_UACCESS_H
  53. #define _CRIS_UACCESS_H
  55. #ifndef __ASSEMBLY__
  56. #include <linux/sched.h>
  57. #include <linux/errno.h>
  58. #include <asm/processor.h>
  59. #include <asm/page.h>
  61. #define VERIFY_READ 0
  62. #define VERIFY_WRITE 1
  64. /*
  65.  * The fs value determines whether argument validity checking should be
  66.  * performed or not.  If get_fs() == USER_DS, checking is performed, with
  67.  * get_fs() == KERNEL_DS, checking is bypassed.
  68.  *
  69.  * For historical reasons, these macros are grossly misnamed.
  70.  */
  72. #define MAKE_MM_SEG(s) ((mm_segment_t) { (s) })
  74. /* addr_limit is the maximum accessible address for the task. we misuse
  75.  * the KERNEL_DS and USER_DS values to both assign and compare the 
  76.  * addr_limit values through the equally misnamed get/set_fs macros.
  77.  * (see above)
  78.  */
  80. #define KERNEL_DS MAKE_MM_SEG(0xFFFFFFFF)
  81. #define USER_DS MAKE_MM_SEG(TASK_SIZE)
  83. #define get_ds() (KERNEL_DS)
  84. #define get_fs() (current->addr_limit)
  85. #define set_fs(x) (current->addr_limit = (x))
  87. #define segment_eq(a,b) ((a).seg == (b).seg)
  89. #define __kernel_ok (segment_eq(get_fs(), KERNEL_DS))
  90. #define __user_ok(addr,size) (((size) <= TASK_SIZE)&&((addr) <= TASK_SIZE-(size)))
  91. #define __access_ok(addr,size) (__kernel_ok || __user_ok((addr),(size)))
  92. #define access_ok(type,addr,size) __access_ok((unsigned long)(addr),(size))
  94. extern inline int verify_area(int type, const void * addr, unsigned long size)
  95. {
  96. return access_ok(type,addr,size) ? 0 : -EFAULT;
  97. }
  100. /*
  101.  * The exception table consists of pairs of addresses: the first is the
  102.  * address of an instruction that is allowed to fault, and the second is
  103.  * the address at which the program should continue.  No registers are
  104.  * modified, so it is entirely up to the continuation code to figure out
  105.  * what to do.
  106.  *
  107.  * All the routines below use bits of fixup code that are out of line
  108.  * with the main instruction path.  This means when everything is well,
  109.  * we don't even have to jump over them.  Further, they do not intrude
  110.  * on our cache or tlb entries.
  111.  */
  113. struct exception_table_entry
  114. {
  115. unsigned long insn, fixup;
  116. };
  118. /* Returns 0 if exception not found and fixup otherwise.  */
  119. extern unsigned long search_exception_table(unsigned long);
  122. /*
  123.  * These are the main single-value transfer routines.  They automatically
  124.  * use the right size if we just have the right pointer type.
  125.  *
  126.  * This gets kind of ugly. We want to return _two_ values in "get_user()"
  127.  * and yet we don't want to do any pointers, because that is too much
  128.  * of a performance impact. Thus we have a few rather ugly macros here,
  129.  * and hide all the uglyness from the user.
  130.  *
  131.  * The "__xxx" versions of the user access functions are versions that
  132.  * do not verify the address space, that must have been done previously
  133.  * with a separate "access_ok()" call (this is used when we do multiple
  134.  * accesses to the same area of user memory).
  135.  *
  136.  * As we use the same address space for kernel and user data on
  137.  * CRIS, we can just do these as direct assignments.  (Of course, the
  138.  * exception handling means that it's no longer "just"...)
  139.  */
  140. #define get_user(x,ptr) 
  141.   __get_user_check((x),(ptr),sizeof(*(ptr)))
  142. #define put_user(x,ptr) 
  143.   __put_user_check((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr)))
  145. #define __get_user(x,ptr) 
  146.   __get_user_nocheck((x),(ptr),sizeof(*(ptr)))
  147. #define __put_user(x,ptr) 
  148.   __put_user_nocheck((__typeof__(*(ptr)))(x),(ptr),sizeof(*(ptr)))
  150. /*
  151.  * The "xxx_ret" versions return constant specified in third argument, if
  152.  * something bad happens. These macros can be optimized for the
  153.  * case of just returning from the function xxx_ret is used.
  154.  */
  156. #define put_user_ret(x,ptr,ret) 
  157. do { if (put_user(x,ptr)) return ret; } while (0)
  159. #define get_user_ret(x,ptr,ret) 
  160. do { if (get_user(x,ptr)) return ret; } while (0)
  162. #define __put_user_ret(x,ptr,ret) 
  163. do { if (__put_user(x,ptr)) return ret; } while (0)
  165. #define __get_user_ret(x,ptr,ret) 
  166. do { if (__get_user(x,ptr)) return ret; } while (0)
  169. extern long __put_user_bad(void);
  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. })
  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. })
  187. #define __put_user_size(x,ptr,size,retval)
  188. do {
  189. retval = 0;
  190. switch (size) {
  191.   case 1: __put_user_asm(x,ptr,retval,"move.b"); break;
  192.   case 2: __put_user_asm(x,ptr,retval,"move.w"); break;
  193.   case 4: __put_user_asm(x,ptr,retval,"move.d"); break;
  194.   case 8: __put_user_asm_64(x,ptr,retval); break;
  195.   default: __put_user_bad();
  196. }
  197. } while (0)
  199. struct __large_struct { unsigned long buf[100]; };
  200. #define __m(x) (*(struct __large_struct *)(x))
  202. /*
  203.  * We don't tell gcc that we are accessing memory, but this is OK
  204.  * because we do not write to any memory gcc knows about, so there
  205.  * are no aliasing issues.
  206.  *
  207.  * Note that PC at a fault is the address *after* the faulting
  208.  * instruction.
  209.  */
  210. #define __put_user_asm(x, addr, err, op)
  211. __asm__ __volatile__(
  212. " "op" %1,[%2]n"
  213. "2:n"
  214. " .section .fixup,"ax"n"
  215. "3: move.d %3,%0n"
  216. " jump 2bn"
  217. " .previousn"
  218. " .section __ex_table,"a"n"
  219. " .dword 2b,3bn"
  220. " .previousn"
  221. : "=r" (err)
  222. : "r" (x), "r" (addr), "g" (-EFAULT), "0" (err))
  224. #define __put_user_asm_64(x, addr, err)
  225. __asm__ __volatile__(
  226. " move.d %M1,[%2]n"
  227. "2: move.d %H1,[%2+4]n"
  228. "4:n"
  229. " .section .fixup,"ax"n"
  230. "3: move.d %3,%0n"
  231. " jump 4bn"
  232. " .previousn"
  233. " .section __ex_table,"a"n"
  234. " .dword 2b,3bn"
  235. " .dword 4b,3bn"
  236. " .previousn"
  237. : "=r" (err)
  238. : "r" (x), "r" (addr), "g" (-EFAULT), "0" (err))
  241. #define __get_user_nocheck(x,ptr,size)
  242. ({
  243. long __gu_err, __gu_val;
  244. __get_user_size(__gu_val,(ptr),(size),__gu_err);
  245. (x) = (__typeof__(*(ptr)))__gu_val;
  246. __gu_err;
  247. })
  249. #define __get_user_check(x,ptr,size)
  250. ({
  251. long __gu_err = -EFAULT, __gu_val = 0;
  252. const __typeof__(*(ptr)) *__gu_addr = (ptr);
  253. if (access_ok(VERIFY_READ,__gu_addr,size))
  254. __get_user_size(__gu_val,__gu_addr,(size),__gu_err);
  255. (x) = (__typeof__(*(ptr)))__gu_val;
  256. __gu_err;
  257. })
  259. extern long __get_user_bad(void);
  261. #define __get_user_size(x,ptr,size,retval)
  262. do {
  263. retval = 0;
  264. switch (size) {
  265.   case 1: __get_user_asm(x,ptr,retval,"move.b"); break;
  266.   case 2: __get_user_asm(x,ptr,retval,"move.w"); break;
  267.   case 4: __get_user_asm(x,ptr,retval,"move.d"); break;
  268.   case 8: __get_user_asm_64(x,ptr,retval); break;
  269.   default: (x) = __get_user_bad();
  270. }
  271. } while (0)
  273. /* See comment before __put_user_asm.  */
  275. #define __get_user_asm(x, addr, err, op)
  276. __asm__ __volatile__(
  277. " "op" [%2],%1n"
  278. "2:n"
  279. " .section .fixup,"ax"n"
  280. "3: move.d %3,%0n"
  281. " moveq 0,%1n"
  282. " jump 2bn"
  283. " .previousn"
  284. " .section __ex_table,"a"n"
  285. " .dword 2b,3bn"
  286. " .previousn"
  287. : "=r" (err), "=r" (x)
  288. : "r" (addr), "g" (-EFAULT), "0" (err))
  290. #define __get_user_asm_64(x, addr, err)
  291. __asm__ __volatile__(
  292. " move.d [%2],%M1n"
  293. "2: move.d [%2+4],%H1n"
  294. "4:n"
  295. " .section .fixup,"ax"n"
  296. "3: move.d %3,%0n"
  297. " moveq 0,%1n"
  298. " jump 4bn"
  299. " .previousn"
  300. " .section __ex_table,"a"n"
  301. " .dword 2b,3bn"
  302. " .dword 4b,3bn"
  303. " .previousn"
  304. : "=r" (err), "=r" (x)
  305. : "r" (addr), "g" (-EFAULT), "0" (err))
  307. /* More complex functions.  Most are inline, but some call functions that
  308.    live in lib/usercopy.c  */
  310. extern unsigned long __copy_user(void *to, const void *from, unsigned long n);
  311. extern unsigned long __copy_user_zeroing(void *to, const void *from, unsigned long n);
  312. extern unsigned long __do_clear_user(void *to, unsigned long n);
  314. /*
  315.  * Copy a null terminated string from userspace.
  316.  *
  317.  * Must return:
  318.  * -EFAULT for an exception
  319.  * count if we hit the buffer limit
  320.  * bytes copied if we hit a null byte
  321.  * (without the null byte)
  322.  */
  324. static inline long         
  325. __do_strncpy_from_user(char *dst, const char *src, long count)
  326. {
  327. long res;
  329. if (count == 0)
  330. return 0;
  332. /*
  333.  * Currently, in 2.4.0-test9, most ports use a simple byte-copy loop.
  334.  *  So do we.
  335.  *
  336.  *  This code is deduced from:
  337.  *
  338.  * char tmp2;
  339.  * long tmp1, tmp3
  340.  * tmp1 = count;
  341.  * while ((*dst++ = (tmp2 = *src++)) != 0
  342.  *        && --tmp1)
  343.  *   ;
  344.  *
  345.  * res = count - tmp1;
  346.  *
  347.  *  with tweaks.
  348.  */
  350. __asm__ __volatile__ (
  351. " move.d %3,%0n"
  352. " move.b [%2+],$r9n"
  353. "1: beq 2fn"
  354. " move.b $r9,[%1+]n"
  356. " subq 1,%0n"
  357. " bne 1bn"
  358. " move.b [%2+],$r9n"
  360. "2: sub.d %3,%0n"
  361. " neg.d %0,%0n"
  362. "3:n"
  363. " .section .fixup,"ax"n"
  364. "4: move.d %7,%0n"
  365. " jump 3bn"
  367. /* There's one address for a fault at the first move, and
  368.    two possible PC values for a fault at the second move,
  369.    being a delay-slot filler.  However, the branch-target
  370.    for the second move is the same as the first address.
  371.    Just so you don't get confused...  */
  372. " .previousn"
  373. " .section __ex_table,"a"n"
  374. " .dword 1b,4bn"
  375. " .dword 2b,4bn"
  376. " .previous"
  377. : "=r" (res), "=r" (dst), "=r" (src), "=r" (count)
  378. : "3" (count), "1" (dst), "2" (src), "g" (-EFAULT)
  379. : "r9");
  381. return res;
  382. }
  384. static inline unsigned long
  385. __generic_copy_to_user(void *to, const void *from, unsigned long n)
  386. {
  387. if (access_ok(VERIFY_WRITE, to, n))
  388. return __copy_user(to,from,n);
  389. return n;
  390. }
  392. static inline unsigned long
  393. __generic_copy_from_user(void *to, const void *from, unsigned long n)
  394. {
  395. if (access_ok(VERIFY_READ, from, n))
  396. return __copy_user_zeroing(to,from,n);
  397. return n;
  398. }
  400. static inline unsigned long
  401. __generic_clear_user(void *to, unsigned long n)
  402. {
  403. if (access_ok(VERIFY_WRITE, to, n))
  404. return __do_clear_user(to,n);
  405. return n;
  406. }
  408. static inline long
  409. __strncpy_from_user(char *dst, const char *src, long count)
  410. {
  411. return __do_strncpy_from_user(dst, src, count);
  412. }
  414. static inline long
  415. strncpy_from_user(char *dst, const char *src, long count)
  416. {
  417. long res = -EFAULT;
  418. if (access_ok(VERIFY_READ, src, 1))
  419. res = __do_strncpy_from_user(dst, src, count);
  420. return res;
  421. }
  423. /* A few copy asms to build up the more complex ones from.
  425.    Note again, a post-increment is performed regardless of whether a bus
  426.    fault occurred in that instruction, and PC for a faulted insn is the
  427.    address *after* the insn.  */
  429. #define __asm_copy_user_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  430. __asm__ __volatile__ (
  431. COPY
  432. "1:n"
  433. " .section .fixup,"ax"n"
  434. FIXUP
  435. " jump 1bn"
  436. " .previousn"
  437. " .section __ex_table,"a"n"
  438. TENTRY
  439. " .previousn"
  440. : "=r" (to), "=r" (from), "=r" (ret)
  441. : "0" (to), "1" (from), "2" (ret)
  442. : "r9", "memory")
  444. #define __asm_copy_from_user_1(to, from, ret) 
  445. __asm_copy_user_cont(to, from, ret,
  446. " move.b [%1+],$r9n"
  447. "2: move.b $r9,[%0+]n",
  448. "3: addq 1,%2n"
  449. " clear.b [%0+]n",
  450. " .dword 2b,3bn")
  452. #define __asm_copy_from_user_2x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  453. __asm_copy_user_cont(to, from, ret,
  454. " move.w [%1+],$r9n"
  455. "2: move.w $r9,[%0+]n" COPY,
  456. "3: addq 2,%2n"
  457. " clear.w [%0+]n" FIXUP,
  458. " .dword 2b,3bn" TENTRY)
  460. #define __asm_copy_from_user_2(to, from, ret) 
  461. __asm_copy_from_user_2x_cont(to, from, ret, "", "", "")
  463. #define __asm_copy_from_user_3(to, from, ret)
  464. __asm_copy_from_user_2x_cont(to, from, ret,
  465. " move.b [%1+],$r9n"
  466. "4: move.b $r9,[%0+]n",
  467. "5: addq 1,%2n"
  468. " clear.b [%0+]n",
  469. " .dword 4b,5bn")
  471. #define __asm_copy_from_user_4x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  472. __asm_copy_user_cont(to, from, ret,
  473. " move.d [%1+],$r9n"
  474. "2: move.d $r9,[%0+]n" COPY,
  475. "3: addq 4,%2n"
  476. " clear.d [%0+]n" FIXUP,
  477. " .dword 2b,3bn" TENTRY)
  479. #define __asm_copy_from_user_4(to, from, ret) 
  480. __asm_copy_from_user_4x_cont(to, from, ret, "", "", "")
  482. #define __asm_copy_from_user_5(to, from, ret) 
  483. __asm_copy_from_user_4x_cont(to, from, ret,
  484. " move.b [%1+],$r9n"
  485. "4: move.b $r9,[%0+]n",
  486. "5: addq 1,%2n"
  487. " clear.b [%0+]n",
  488. " .dword 4b,5bn")
  490. #define __asm_copy_from_user_6x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  491. __asm_copy_from_user_4x_cont(to, from, ret,
  492. " move.w [%1+],$r9n"
  493. "4: move.w $r9,[%0+]n" COPY,
  494. "5: addq 2,%2n"
  495. " clear.w [%0+]n" FIXUP,
  496. " .dword 4b,5bn" TENTRY)
  498. #define __asm_copy_from_user_6(to, from, ret) 
  499. __asm_copy_from_user_6x_cont(to, from, ret, "", "", "")
  501. #define __asm_copy_from_user_7(to, from, ret) 
  502. __asm_copy_from_user_6x_cont(to, from, ret,
  503. " move.b [%1+],$r9n"
  504. "6: move.b $r9,[%0+]n",
  505. "7: addq 1,%2n"
  506. " clear.b [%0+]n",
  507. " .dword 6b,7bn")
  509. #define __asm_copy_from_user_8x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  510. __asm_copy_from_user_4x_cont(to, from, ret,
  511. " move.d [%1+],$r9n"
  512. "4: move.d $r9,[%0+]n" COPY,
  513. "5: addq 4,%2n"
  514. " clear.d [%0+]n" FIXUP,
  515. " .dword 4b,5bn" TENTRY)
  517. #define __asm_copy_from_user_8(to, from, ret) 
  518. __asm_copy_from_user_8x_cont(to, from, ret, "", "", "")
  520. #define __asm_copy_from_user_9(to, from, ret) 
  521. __asm_copy_from_user_8x_cont(to, from, ret,
  522. " move.b [%1+],$r9n"
  523. "6: move.b $r9,[%0+]n",
  524. "7: addq 1,%2n"
  525. " clear.b [%0+]n",
  526. " .dword 6b,7bn")
  528. #define __asm_copy_from_user_10x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  529. __asm_copy_from_user_8x_cont(to, from, ret,
  530. " move.w [%1+],$r9n"
  531. "6: move.w $r9,[%0+]n" COPY,
  532. "7: addq 2,%2n"
  533. " clear.w [%0+]n" FIXUP,
  534. " .dword 6b,7bn" TENTRY)
  536. #define __asm_copy_from_user_10(to, from, ret) 
  537. __asm_copy_from_user_10x_cont(to, from, ret, "", "", "")
  539. #define __asm_copy_from_user_11(to, from, ret)
  540. __asm_copy_from_user_10x_cont(to, from, ret,
  541. " move.b [%1+],$r9n"
  542. "8: move.b $r9,[%0+]n",
  543. "9: addq 1,%2n"
  544. " clear.b [%0+]n",
  545. " .dword 8b,9bn")
  547. #define __asm_copy_from_user_12x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  548. __asm_copy_from_user_8x_cont(to, from, ret,
  549. " move.d [%1+],$r9n"
  550. "6: move.d $r9,[%0+]n" COPY,
  551. "7: addq 4,%2n"
  552. " clear.d [%0+]n" FIXUP,
  553. " .dword 6b,7bn" TENTRY)
  555. #define __asm_copy_from_user_12(to, from, ret) 
  556. __asm_copy_from_user_12x_cont(to, from, ret, "", "", "")
  558. #define __asm_copy_from_user_13(to, from, ret) 
  559. __asm_copy_from_user_12x_cont(to, from, ret,
  560. " move.b [%1+],$r9n"
  561. "8: move.b $r9,[%0+]n",
  562. "9: addq 1,%2n"
  563. " clear.b [%0+]n",
  564. " .dword 8b,9bn")
  566. #define __asm_copy_from_user_14x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  567. __asm_copy_from_user_12x_cont(to, from, ret,
  568. " move.w [%1+],$r9n"
  569. "8: move.w $r9,[%0+]n" COPY,
  570. "9: addq 2,%2n"
  571. " clear.w [%0+]n" FIXUP,
  572. " .dword 8b,9bn" TENTRY)
  574. #define __asm_copy_from_user_14(to, from, ret) 
  575. __asm_copy_from_user_14x_cont(to, from, ret, "", "", "")
  577. #define __asm_copy_from_user_15(to, from, ret) 
  578. __asm_copy_from_user_14x_cont(to, from, ret,
  579. " move.b [%1+],$r9n"
  580. "10: move.b $r9,[%0+]n",
  581. "11: addq 1,%2n"
  582. " clear.b [%0+]n",
  583. " .dword 10b,11bn")
  585. #define __asm_copy_from_user_16x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  586. __asm_copy_from_user_12x_cont(to, from, ret,
  587. " move.d [%1+],$r9n"
  588. "8: move.d $r9,[%0+]n" COPY,
  589. "9: addq 4,%2n"
  590. " clear.d [%0+]n" FIXUP,
  591. " .dword 8b,9bn" TENTRY)
  593. #define __asm_copy_from_user_16(to, from, ret) 
  594. __asm_copy_from_user_16x_cont(to, from, ret, "", "", "")
  596. #define __asm_copy_from_user_20x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  597. __asm_copy_from_user_16x_cont(to, from, ret,
  598. " move.d [%1+],$r9n"
  599. "10: move.d $r9,[%0+]n" COPY,
  600. "11: addq 4,%2n"
  601. " clear.d [%0+]n" FIXUP,
  602. " .dword 10b,11bn" TENTRY)
  604. #define __asm_copy_from_user_20(to, from, ret) 
  605. __asm_copy_from_user_20x_cont(to, from, ret, "", "", "")
  607. #define __asm_copy_from_user_24x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  608. __asm_copy_from_user_20x_cont(to, from, ret,
  609. " move.d [%1+],$r9n"
  610. "12: move.d $r9,[%0+]n" COPY,
  611. "13: addq 4,%2n"
  612. " clear.d [%0+]n" FIXUP,
  613. " .dword 12b,13bn" TENTRY)
  615. #define __asm_copy_from_user_24(to, from, ret) 
  616. __asm_copy_from_user_24x_cont(to, from, ret, "", "", "")
  618. /* And now, the to-user ones.  */
  620. #define __asm_copy_to_user_1(to, from, ret)
  621. __asm_copy_user_cont(to, from, ret,
  622. " move.b [%1+],$r9n"
  623. " move.b $r9,[%0+]n2:n",
  624. "3: addq 1,%2n",
  625. " .dword 2b,3bn")
  627. #define __asm_copy_to_user_2x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  628. __asm_copy_user_cont(to, from, ret,
  629. " move.w [%1+],$r9n"
  630. " move.w $r9,[%0+]n2:n" COPY,
  631. "3: addq 2,%2n" FIXUP,
  632. " .dword 2b,3bn" TENTRY)
  634. #define __asm_copy_to_user_2(to, from, ret) 
  635. __asm_copy_to_user_2x_cont(to, from, ret, "", "", "")
  637. #define __asm_copy_to_user_3(to, from, ret) 
  638. __asm_copy_to_user_2x_cont(to, from, ret,
  639. " move.b [%1+],$r9n"
  640. " move.b $r9,[%0+]n4:n",
  641. "5: addq 1,%2n",
  642. " .dword 4b,5bn")
  644. #define __asm_copy_to_user_4x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  645. __asm_copy_user_cont(to, from, ret,
  646. " move.d [%1+],$r9n"
  647. " move.d $r9,[%0+]n2:n" COPY,
  648. "3: addq 4,%2n" FIXUP,
  649. " .dword 2b,3bn" TENTRY)
  651. #define __asm_copy_to_user_4(to, from, ret) 
  652. __asm_copy_to_user_4x_cont(to, from, ret, "", "", "")
  654. #define __asm_copy_to_user_5(to, from, ret) 
  655. __asm_copy_to_user_4x_cont(to, from, ret,
  656. " move.b [%1+],$r9n"
  657. " move.b $r9,[%0+]n4:n",
  658. "5: addq 1,%2n",
  659. " .dword 4b,5bn")
  661. #define __asm_copy_to_user_6x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  662. __asm_copy_to_user_4x_cont(to, from, ret,
  663. " move.w [%1+],$r9n"
  664. " move.w $r9,[%0+]n4:n" COPY,
  665. "5: addq 2,%2n" FIXUP,
  666. " .dword 4b,5bn" TENTRY)
  668. #define __asm_copy_to_user_6(to, from, ret) 
  669. __asm_copy_to_user_6x_cont(to, from, ret, "", "", "")
  671. #define __asm_copy_to_user_7(to, from, ret) 
  672. __asm_copy_to_user_6x_cont(to, from, ret,
  673. " move.b [%1+],$r9n"
  674. " move.b $r9,[%0+]n6:n",
  675. "7: addq 1,%2n",
  676. " .dword 6b,7bn")
  678. #define __asm_copy_to_user_8x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  679. __asm_copy_to_user_4x_cont(to, from, ret,
  680. " move.d [%1+],$r9n"
  681. " move.d $r9,[%0+]n4:n" COPY,
  682. "5: addq 4,%2n"  FIXUP,
  683. " .dword 4b,5bn" TENTRY)
  685. #define __asm_copy_to_user_8(to, from, ret) 
  686. __asm_copy_to_user_8x_cont(to, from, ret, "", "", "")
  688. #define __asm_copy_to_user_9(to, from, ret) 
  689. __asm_copy_to_user_8x_cont(to, from, ret,
  690. " move.b [%1+],$r9n"
  691. " move.b $r9,[%0+]n6:n",
  692. "7: addq 1,%2n",
  693. " .dword 6b,7bn")
  695. #define __asm_copy_to_user_10x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  696. __asm_copy_to_user_8x_cont(to, from, ret,
  697. " move.w [%1+],$r9n"
  698. " move.w $r9,[%0+]n6:n" COPY,
  699. "7: addq 2,%2n" FIXUP,
  700. " .dword 6b,7bn" TENTRY)
  702. #define __asm_copy_to_user_10(to, from, ret) 
  703. __asm_copy_to_user_10x_cont(to, from, ret, "", "", "")
  705. #define __asm_copy_to_user_11(to, from, ret) 
  706. __asm_copy_to_user_10x_cont(to, from, ret,
  707. " move.b [%1+],$r9n"
  708. " move.b $r9,[%0+]n8:n",
  709. "9: addq 1,%2n",
  710. " .dword 8b,9bn")
  712. #define __asm_copy_to_user_12x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  713. __asm_copy_to_user_8x_cont(to, from, ret,
  714. " move.d [%1+],$r9n"
  715. " move.d $r9,[%0+]n6:n" COPY,
  716. "7: addq 4,%2n" FIXUP,
  717. " .dword 6b,7bn" TENTRY)
  719. #define __asm_copy_to_user_12(to, from, ret) 
  720. __asm_copy_to_user_12x_cont(to, from, ret, "", "", "")
  722. #define __asm_copy_to_user_13(to, from, ret) 
  723. __asm_copy_to_user_12x_cont(to, from, ret,
  724. " move.b [%1+],$r9n"
  725. " move.b $r9,[%0+]n8:n",
  726. "9: addq 1,%2n",
  727. " .dword 8b,9bn")
  729. #define __asm_copy_to_user_14x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  730. __asm_copy_to_user_12x_cont(to, from, ret,
  731. " move.w [%1+],$r9n"
  732. " move.w $r9,[%0+]n8:n" COPY,
  733. "9: addq 2,%2n" FIXUP,
  734. " .dword 8b,9bn" TENTRY)
  736. #define __asm_copy_to_user_14(to, from, ret)
  737. __asm_copy_to_user_14x_cont(to, from, ret, "", "", "")
  739. #define __asm_copy_to_user_15(to, from, ret) 
  740. __asm_copy_to_user_14x_cont(to, from, ret,
  741. " move.b [%1+],$r9n"
  742. " move.b $r9,[%0+]n10:n",
  743. "11: addq 1,%2n",
  744. " .dword 10b,11bn")
  746. #define __asm_copy_to_user_16x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  747. __asm_copy_to_user_12x_cont(to, from, ret,
  748. " move.d [%1+],$r9n"
  749. " move.d $r9,[%0+]n8:n" COPY,
  750. "9: addq 4,%2n" FIXUP,
  751. " .dword 8b,9bn" TENTRY)
  753. #define __asm_copy_to_user_16(to, from, ret) 
  754. __asm_copy_to_user_16x_cont(to, from, ret, "", "", "")
  756. #define __asm_copy_to_user_20x_cont(to, from, ret, COPY, FIXUP, TENTRY) 
  757. __asm_copy_to_user_16x_cont(to, from, ret,
  758. " move.d [%1+],$r9n"
  759. " move.d $r9,[%0+]n10:n" COPY,
  760. "11: addq 4,%2n" FIXUP,
  761. " .dword 10b,11bn" TENTRY)
  763. #define __asm_copy_to_user_20(to, from, ret) 
  764. __asm_copy_to_user_20x_cont(to, from, ret, "", "", "")
  766. #define __asm_copy_to_user_24x_cont(to, from, ret, COPY, FIXUP, TENTRY)
  767. __asm_copy_to_user_20x_cont(to, from, ret,
  768. " move.d [%1+],$r9n"
  769. " move.d $r9,[%0+]n12:n" COPY,
  770. "13: addq 4,%2n" FIXUP,
  771. " .dword 12b,13bn" TENTRY)
  773. #define __asm_copy_to_user_24(to, from, ret)
  774. __asm_copy_to_user_24x_cont(to, from, ret, "", "", "")
  776. /* Define a few clearing asms with exception handlers.  */
  778. /* This frame-asm is like the __asm_copy_user_cont one, but has one less
  779.    input.  */
  781. #define __asm_clear(to, ret, CLEAR, FIXUP, TENTRY) 
  782. __asm__ __volatile__ (
  783. CLEAR
  784. "1:n"
  785. " .section .fixup,"ax"n"
  786. FIXUP
  787. " jump 1bn"
  788. " .previousn"
  789. " .section __ex_table,"a"n"
  790. TENTRY
  791. " .previous"
  792. : "=r" (to), "=r" (ret)
  793. : "0" (to), "1" (ret)
  794. : "r9", "memory")
  796. #define __asm_clear_1(to, ret) 
  797. __asm_clear(to, ret,
  798. " clear.b [%0+]n2:n",
  799. "3: addq 1,%1n",
  800. " .dword 2b,3bn")
  802. #define __asm_clear_2(to, ret) 
  803. __asm_clear(to, ret,
  804. " clear.w [%0+]n2:n",
  805. "3: addq 2,%1n",
  806. " .dword 2b,3bn")
  808. #define __asm_clear_3(to, ret) 
  809.      __asm_clear(to, ret,
  810.  " clear.w [%0+]n"
  811.  "2: clear.b [%0+]n3:n",
  812.  "4: addq 2,%1n"
  813.  "5: addq 1,%1n",
  814.  " .dword 2b,4bn"
  815.  " .dword 3b,5bn")
  817. #define __asm_clear_4x_cont(to, ret, CLEAR, FIXUP, TENTRY) 
  818. __asm_clear(to, ret,
  819. " clear.d [%0+]n2:n" CLEAR,
  820. "3: addq 4,%1n" FIXUP,
  821. " .dword 2b,3bn" TENTRY)
  823. #define __asm_clear_4(to, ret) 
  824. __asm_clear_4x_cont(to, ret, "", "", "")
  826. #define __asm_clear_8x_cont(to, ret, CLEAR, FIXUP, TENTRY) 
  827. __asm_clear_4x_cont(to, ret,
  828. " clear.d [%0+]n4:n" CLEAR,
  829. "5: addq 4,%1n" FIXUP,
  830. " .dword 4b,5bn" TENTRY)
  832. #define __asm_clear_8(to, ret) 
  833. __asm_clear_8x_cont(to, ret, "", "", "")
  835. #define __asm_clear_12x_cont(to, ret, CLEAR, FIXUP, TENTRY) 
  836. __asm_clear_8x_cont(to, ret,
  837. " clear.d [%0+]n6:n" CLEAR,
  838. "7: addq 4,%1n" FIXUP,
  839. " .dword 6b,7bn" TENTRY)
  841. #define __asm_clear_12(to, ret) 
  842. __asm_clear_12x_cont(to, ret, "", "", "")
  844. #define __asm_clear_16x_cont(to, ret, CLEAR, FIXUP, TENTRY) 
  845. __asm_clear_12x_cont(to, ret,
  846. " clear.d [%0+]n8:n" CLEAR,
  847. "9: addq 4,%1n" FIXUP,
  848. " .dword 8b,9bn" TENTRY)
  850. #define __asm_clear_16(to, ret) 
  851. __asm_clear_16x_cont(to, ret, "", "", "")
  853. #define __asm_clear_20x_cont(to, ret, CLEAR, FIXUP, TENTRY) 
  854. __asm_clear_16x_cont(to, ret,
  855. " clear.d [%0+]n10:n" CLEAR,
  856. "11: addq 4,%1n" FIXUP,
  857. " .dword 10b,11bn" TENTRY)
  859. #define __asm_clear_20(to, ret) 
  860. __asm_clear_20x_cont(to, ret, "", "", "")
  862. #define __asm_clear_24x_cont(to, ret, CLEAR, FIXUP, TENTRY) 
  863. __asm_clear_20x_cont(to, ret,
  864. " clear.d [%0+]n12:n" CLEAR,
  865. "13: addq 4,%1n" FIXUP,
  866. " .dword 12b,13bn" TENTRY)
  868. #define __asm_clear_24(to, ret) 
  869. __asm_clear_24x_cont(to, ret, "", "", "")
  871. /* Note that if these expand awfully if made into switch constructs, so
  872.    don't do that.  */
  874. static inline unsigned long
  875. __constant_copy_from_user(void *to, const void *from, unsigned long n)
  876. {
  877. unsigned long ret = 0;
  878. if (n == 0)
  879. ;
  880. else if (n == 1)
  881. __asm_copy_from_user_1(to, from, ret);
  882. else if (n == 2)
  883. __asm_copy_from_user_2(to, from, ret);
  884. else if (n == 3)
  885. __asm_copy_from_user_3(to, from, ret);
  886. else if (n == 4)
  887. __asm_copy_from_user_4(to, from, ret);
  888. else if (n == 5)
  889. __asm_copy_from_user_5(to, from, ret);
  890. else if (n == 6)
  891. __asm_copy_from_user_6(to, from, ret);
  892. else if (n == 7)
  893. __asm_copy_from_user_7(to, from, ret);
  894. else if (n == 8)
  895. __asm_copy_from_user_8(to, from, ret);
  896. else if (n == 9)
  897. __asm_copy_from_user_9(to, from, ret);
  898. else if (n == 10)
  899. __asm_copy_from_user_10(to, from, ret);
  900. else if (n == 11)
  901. __asm_copy_from_user_11(to, from, ret);
  902. else if (n == 12)
  903. __asm_copy_from_user_12(to, from, ret);
  904. else if (n == 13)
  905. __asm_copy_from_user_13(to, from, ret);
  906. else if (n == 14)
  907. __asm_copy_from_user_14(to, from, ret);
  908. else if (n == 15)
  909. __asm_copy_from_user_15(to, from, ret);
  910. else if (n == 16)
  911. __asm_copy_from_user_16(to, from, ret);
  912. else if (n == 20)
  913. __asm_copy_from_user_20(to, from, ret);
  914. else if (n == 24)
  915. __asm_copy_from_user_24(to, from, ret);
  916. else
  917. ret = __generic_copy_from_user(to, from, n);
  919. return ret;
  920. }
  922. /* Ditto, don't make a switch out of this.  */
  924. static inline unsigned long
  925. __constant_copy_to_user(void *to, const void *from, unsigned long n)
  926. {
  927. unsigned long ret = 0;
  928. if (n == 0)
  929. ;
  930. else if (n == 1)
  931. __asm_copy_to_user_1(to, from, ret);
  932. else if (n == 2)
  933. __asm_copy_to_user_2(to, from, ret);
  934. else if (n == 3)
  935. __asm_copy_to_user_3(to, from, ret);
  936. else if (n == 4)
  937. __asm_copy_to_user_4(to, from, ret);
  938. else if (n == 5)
  939. __asm_copy_to_user_5(to, from, ret);
  940. else if (n == 6)
  941. __asm_copy_to_user_6(to, from, ret);
  942. else if (n == 7)
  943. __asm_copy_to_user_7(to, from, ret);
  944. else if (n == 8)
  945. __asm_copy_to_user_8(to, from, ret);
  946. else if (n == 9)
  947. __asm_copy_to_user_9(to, from, ret);
  948. else if (n == 10)
  949. __asm_copy_to_user_10(to, from, ret);
  950. else if (n == 11)
  951. __asm_copy_to_user_11(to, from, ret);
  952. else if (n == 12)
  953. __asm_copy_to_user_12(to, from, ret);
  954. else if (n == 13)
  955. __asm_copy_to_user_13(to, from, ret);
  956. else if (n == 14)
  957. __asm_copy_to_user_14(to, from, ret);
  958. else if (n == 15)
  959. __asm_copy_to_user_15(to, from, ret);
  960. else if (n == 16)
  961. __asm_copy_to_user_16(to, from, ret);
  962. else if (n == 20)
  963. __asm_copy_to_user_20(to, from, ret);
  964. else if (n == 24)
  965. __asm_copy_to_user_24(to, from, ret);
  966. else
  967. ret = __generic_copy_to_user(to, from, n);
  969. return ret;
  970. }
  972. /* No switch, please.  */
  974. static inline unsigned long
  975. __constant_clear_user(void *to, unsigned long n)
  976. {
  977. unsigned long ret = 0;
  978. if (n == 0)
  979. ;
  980. else if (n == 1)
  981. __asm_clear_1(to, ret);
  982. else if (n == 2)
  983. __asm_clear_2(to, ret);
  984. else if (n == 3)
  985. __asm_clear_3(to, ret);
  986. else if (n == 4)
  987. __asm_clear_4(to, ret);
  988. else if (n == 8)
  989. __asm_clear_8(to, ret);
  990. else if (n == 12)
  991. __asm_clear_12(to, ret);
  992. else if (n == 16)
  993. __asm_clear_16(to, ret);
  994. else if (n == 20)
  995. __asm_clear_20(to, ret);
  996. else if (n == 24)
  997. __asm_clear_24(to, ret);
  998. else
  999. ret = __generic_clear_user(to, n);
  1001. return ret;
  1002. }
  1005. #define clear_user(to, n)
  1006. (__builtin_constant_p(n) ?
  1007.  __constant_clear_user(to, n) :
  1008.  __generic_clear_user(to, n))
  1010. #define copy_from_user(to, from, n)
  1011. (__builtin_constant_p(n) ?
  1012.  __constant_copy_from_user(to, from, n) :
  1013.  __generic_copy_from_user(to, from, n))
  1015. #define copy_to_user(to, from, n)
  1016. (__builtin_constant_p(n) ?
  1017.  __constant_copy_to_user(to, from, n) :
  1018.  __generic_copy_to_user(to, from, n))
  1020. #define copy_to_user_ret(to,from,n,retval) 
  1021. do { if (copy_to_user(to,from,n)) return retval; } while (0)
  1022. #define copy_from_user_ret(to,from,n,retval) 
  1023. do { if (copy_from_user(to,from,n)) return retval; } while (0)
  1025. /* We let the __ versions of copy_from/to_user inline, because they're often
  1026.  * used in fast paths and have only a small space overhead.
  1027.  */
  1029. static inline unsigned long
  1030. __generic_copy_from_user_nocheck(void *to, const void *from, unsigned long n)
  1031. {
  1032. return __copy_user_zeroing(to,from,n);
  1033. }
  1035. static inline unsigned long
  1036. __generic_copy_to_user_nocheck(void *to, const void *from, unsigned long n)
  1037. {
  1038. return __copy_user(to,from,n);
  1039. }
  1041. static inline unsigned long
  1042. __generic_clear_user_nocheck(void *to, unsigned long n)
  1043. {
  1044. return __do_clear_user(to,n);
  1045. }
  1047. /* without checking */
  1049. #define __copy_to_user(to,from,n)   __generic_copy_to_user_nocheck((to),(from),(n))
  1050. #define __copy_from_user(to,from,n) __generic_copy_from_user_nocheck((to),(from),(n))
  1051. #define __clear_user(to,n) __generic_clear_user_nocheck((to),(n))
  1053. /*
  1054.  * Return the size of a string (including the ending 0)
  1055.  *
  1056.  * Return length of string in userspace including terminating 0
  1057.  * or 0 for error.  Return a value greater than N if too long.
  1058.  */
  1060. static inline long
  1061. strnlen_user(const char *s, long n)
  1062. {
  1063. long res, tmp1;
  1065. if (!access_ok(VERIFY_READ, s, 0))
  1066. return 0;
  1068. /*
  1069.  * This code is deduced from:
  1070.  *
  1071.  * tmp1 = n;
  1072.  * while (tmp1-- > 0 && *s++)
  1073.  *   ;
  1074.  *
  1075.  * res = n - tmp1;
  1076.  *
  1077.  *  (with tweaks).
  1078.  */
  1080. __asm__ __volatile__ (
  1081. " move.d %1,$r9n"
  1082. "0:n"
  1083. " ble 1fn"
  1084. " subq 1,$r9n"
  1086. " test.b [%0+]n"
  1087. " bne 0bn"
  1088. " test.d $r9n"
  1089. "1:n"
  1090. " move.d %1,%0n"
  1091. " sub.d $r9,%0n"
  1092. "2:n"
  1093. " .section .fixup,"ax"n"
  1095. "3: clear.d %0n"
  1096. " jump 2bn"
  1098. /* There's one address for a fault at the first move, and
  1099.    two possible PC values for a fault at the second move,
  1100.    being a delay-slot filler.  However, the branch-target
  1101.    for the second move is the same as the first address.
  1102.    Just so you don't get confused...  */
  1103. " .previousn"
  1104. " .section __ex_table,"a"n"
  1105. " .dword 0b,3bn"
  1106. " .dword 1b,3bn"
  1107. " .previousn"
  1108. : "=r" (res), "=r" (tmp1)
  1109. : "0" (s), "1" (n)
  1110. : "r9");
  1112. return res;
  1113. }
  1115. #define strlen_user(str) strnlen_user((str), 0x7ffffffe)
  1117. #endif  /* __ASSEMBLY__ */
  1119. #endif /* _CRIS_UACCESS_H */