Quelle  uaccess.h

/* SPDX-License-Identifier: GPL-2.0-only */
/*
 * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
 *
 * vineetg: June 2010
 *    -__clear_user( ) called multiple times during elf load was byte loop
 *    converted to do as much word clear as possible.
 *
 * vineetg: Dec 2009
 *    -Hand crafted constant propagation for "constant" copy sizes
 *    -stock kernel shrunk by 33K at -O3
 *
 * vineetg: Sept 2009
 *    -Added option to (UN)inline copy_(to|from)_user to reduce code sz
 *    -kernel shrunk by 200K even at -O3 (gcc 4.2.1)
 *    -Enabled when doing -Os
 *
 * Amit Bhor, Sameer Dhavale: Codito Technologies 2004
 */

#ifndef _ASM_ARC_UACCESS_H
#define _ASM_ARC_UACCESS_H

#include <linux/string.h> /* for generic string functions */

/*********** Single byte/hword/word copies ******************/

#define __get_user_fn(sz, u, k)     \
({        \
 long __ret = 0; /* success by default */ \
 switch (sz) {      \
 case 1: __arc_get_user_one(*(k), u, "ldb", __ret); break; \
 case 2: __arc_get_user_one(*(k), u, "ldw", __ret); break; \
 case 4: __arc_get_user_one(*(k), u, "ld", __ret);  break; \
 case 8: __arc_get_user_one_64(*(k), u, __ret);     break; \
 }       \
 __ret;       \
})

/*
 * Returns 0 on success, -EFAULT if not.
 * @ret already contains 0 - given that errors will be less likely
 * (hence +r asm constraint below).
 * In case of error, fixup code will make it -EFAULT
 */
#define __arc_get_user_one(dst, src, op, ret) \
 __asm__ __volatile__(                   \
 "1: "op"    %1,[%2]\n"  \
 "2: ;nop\n"    \
 " .section .fixup, \"ax\"\n" \
 " .align 4\n"   \
 "3: # return -EFAULT\n"  \
 " mov %0, %3\n"   \
 " # zero out dst ptr\n"  \
 " mov %1,  0\n"   \
 " j   2b\n"   \
 " .previous\n"   \
 " .section __ex_table, \"a\"\n" \
 " .align 4\n"   \
 " .word 1b,3b\n"   \
 " .previous\n"   \
      \
 : "+r" (ret), "=r" (dst)  \
 : "r" (src), "ir" (-EFAULT))

#define __arc_get_user_one_64(dst, src, ret) \
 __asm__ __volatile__(                   \
 "1: ld   %1,[%2]\n"   \
 "4: ld  %R1,[%2, 4]\n"  \
 "2: ;nop\n"    \
 " .section .fixup, \"ax\"\n" \
 " .align 4\n"   \
 "3: # return -EFAULT\n"  \
 " mov %0, %3\n"   \
 " # zero out dst ptr\n"  \
 " mov %1,  0\n"   \
 " mov %R1, 0\n"   \
 " j   2b\n"   \
 " .previous\n"   \
 " .section __ex_table, \"a\"\n" \
 " .align 4\n"   \
 " .word 1b,3b\n"   \
 " .word 4b,3b\n"   \
 " .previous\n"   \
      \
 : "+r" (ret), "=r" (dst)  \
 : "r" (src), "ir" (-EFAULT))

#define __put_user_fn(sz, u, k)     \
({        \
 long __ret = 0; /* success by default */ \
 switch (sz) {      \
 case 1: __arc_put_user_one(*(k), u, "stb", __ret); break; \
 case 2: __arc_put_user_one(*(k), u, "stw", __ret); break; \
 case 4: __arc_put_user_one(*(k), u, "st", __ret);  break; \
 case 8: __arc_put_user_one_64(*(k), u, __ret);     break; \
 }       \
 __ret;       \
})

#define __arc_put_user_one(src, dst, op, ret) \
 __asm__ __volatile__(                   \
 "1: "op"    %1,[%2]\n"  \
 "2: ;nop\n"    \
 " .section .fixup, \"ax\"\n" \
 " .align 4\n"   \
 "3: mov %0, %3\n"   \
 " j   2b\n"   \
 " .previous\n"   \
 " .section __ex_table, \"a\"\n" \
 " .align 4\n"   \
 " .word 1b,3b\n"   \
 " .previous\n"   \
      \
 : "+r" (ret)    \
 : "r" (src), "r" (dst), "ir" (-EFAULT))

#define __arc_put_user_one_64(src, dst, ret) \
 __asm__ __volatile__(                   \
 "1: st   %1,[%2]\n"   \
 "4: st  %R1,[%2, 4]\n"  \
 "2: ;nop\n"    \
 " .section .fixup, \"ax\"\n" \
 " .align 4\n"   \
 "3: mov %0, %3\n"   \
 " j   2b\n"   \
 " .previous\n"   \
 " .section __ex_table, \"a\"\n" \
 " .align 4\n"   \
 " .word 1b,3b\n"   \
 " .word 4b,3b\n"   \
 " .previous\n"   \
      \
 : "+r" (ret)    \
 : "r" (src), "r" (dst), "ir" (-EFAULT))


static inline unsigned long
raw_copy_from_user(void *to, const void __user *from, unsigned long n)
{
 long res = 0;
 char val;
 unsigned long tmp1, tmp2, tmp3, tmp4;
 unsigned long orig_n = n;

 if (n == 0)
  return 0;

 /* fallback for unaligned access when hardware doesn't support */
 if (!IS_ENABLED(CONFIG_ARC_USE_UNALIGNED_MEM_ACCESS) &&
      (((unsigned long)to & 0x3) || ((unsigned long)from & 0x3))) {

  unsigned char tmp;

  __asm__ __volatile__ (
  " mov.f   lp_count, %0  \n"
  " lpnz 2f    \n"
  "1: ldb.ab  %1, [%3, 1]  \n"
  " stb.ab  %1, [%2, 1]  \n"
  " sub     %0,%0,1   \n"
  "2: ;nop    \n"
  " .section .fixup, \"ax\"  \n"
  " .align 4   \n"
  "3: j   2b    \n"
  " .previous   \n"
  " .section __ex_table, \"a\" \n"
  " .align 4   \n"
  " .word   1b, 3b   \n"
  " .previous   \n"

  : "+r" (n),
  /*
 * Note as an '&' earlyclobber operand to make sure the
 * temporary register inside the loop is not the same as
 *  FROM or TO.
*/
    "=&r" (tmp), "+r" (to), "+r" (from)
  :
  : "lp_count", "memory");

  return n;
 }

 /*
 * Hand-crafted constant propagation to reduce code sz of the
 * laddered copy 16x,8,4,2,1
 */
 if (__builtin_constant_p(orig_n)) {
  res = orig_n;

  if (orig_n / 16) {
   orig_n = orig_n % 16;

   __asm__ __volatile__(
   " lsr   lp_count, %7,4  \n"
   " lp    3f   \n"
   "1: ld.ab   %3, [%2, 4]  \n"
   "11: ld.ab   %4, [%2, 4]  \n"
   "12: ld.ab   %5, [%2, 4]  \n"
   "13: ld.ab   %6, [%2, 4]  \n"
   " st.ab   %3, [%1, 4]  \n"
   " st.ab   %4, [%1, 4]  \n"
   " st.ab   %5, [%1, 4]  \n"
   " st.ab   %6, [%1, 4]  \n"
   " sub     %0,%0,16  \n"
   "3: ;nop    \n"
   " .section .fixup, \"ax\"  \n"
   " .align 4   \n"
   "4: j   3b    \n"
   " .previous   \n"
   " .section __ex_table, \"a\" \n"
   " .align 4   \n"
   " .word   1b, 4b   \n"
   " .word   11b,4b   \n"
   " .word   12b,4b   \n"
   " .word   13b,4b   \n"
   " .previous   \n"
   : "+r" (res), "+r"(to), "+r"(from),
     "=r"(tmp1), "=r"(tmp2), "=r"(tmp3), "=r"(tmp4)
   : "ir"(n)
   : "lp_count", "memory");
  }
  if (orig_n / 8) {
   orig_n = orig_n % 8;

   __asm__ __volatile__(
   "14: ld.ab   %3, [%2,4]  \n"
   "15: ld.ab   %4, [%2,4]  \n"
   " st.ab   %3, [%1,4]  \n"
   " st.ab   %4, [%1,4]  \n"
   " sub     %0,%0,8   \n"
   "31: ;nop    \n"
   " .section .fixup, \"ax\"  \n"
   " .align 4   \n"
   "4: j   31b    \n"
   " .previous   \n"
   " .section __ex_table, \"a\" \n"
   " .align 4   \n"
   " .word   14b,4b   \n"
   " .word   15b,4b   \n"
   " .previous   \n"
   : "+r" (res), "+r"(to), "+r"(from),
     "=r"(tmp1), "=r"(tmp2)
   :
   : "memory");
  }
  if (orig_n / 4) {
   orig_n = orig_n % 4;

   __asm__ __volatile__(
   "16: ld.ab   %3, [%2,4]  \n"
   " st.ab   %3, [%1,4]  \n"
   " sub     %0,%0,4   \n"
   "32: ;nop    \n"
   " .section .fixup, \"ax\"  \n"
   " .align 4   \n"
   "4: j   32b    \n"
   " .previous   \n"
   " .section __ex_table, \"a\" \n"
   " .align 4   \n"
   " .word   16b,4b   \n"
   " .previous   \n"
   : "+r" (res), "+r"(to), "+r"(from), "=r"(tmp1)
   :
   : "memory");
  }
  if (orig_n / 2) {
   orig_n = orig_n % 2;

   __asm__ __volatile__(
   "17: ldw.ab   %3, [%2,2]  \n"
   " stw.ab   %3, [%1,2]  \n"
   " sub      %0,%0,2  \n"
   "33: ;nop    \n"
   " .section .fixup, \"ax\"  \n"
   " .align 4   \n"
   "4: j   33b    \n"
   " .previous   \n"
   " .section __ex_table, \"a\" \n"
   " .align 4   \n"
   " .word   17b,4b   \n"
   " .previous   \n"
   : "+r" (res), "+r"(to), "+r"(from), "=r"(tmp1)
   :
   : "memory");
  }
  if (orig_n & 1) {
   __asm__ __volatile__(
   "18: ldb.ab   %3, [%2,2]  \n"
   " stb.ab   %3, [%1,2]  \n"
   " sub      %0,%0,1  \n"
   "34: ; nop    \n"
   " .section .fixup, \"ax\"  \n"
   " .align 4   \n"
   "4: j   34b    \n"
   " .previous   \n"
   " .section __ex_table, \"a\" \n"
   " .align 4   \n"
   " .word   18b,4b   \n"
   " .previous   \n"
   : "+r" (res), "+r"(to), "+r"(from), "=r"(tmp1)
   :
   : "memory");
  }
 } else {  /* n is NOT constant, so laddered copy of 16x,8,4,2,1  */

  __asm__ __volatile__(
  " mov %0,%3   \n"
  " lsr.f   lp_count, %3,4  \n"  /* 16x bytes */
  " lpnz    3f   \n"
  "1: ld.ab   %5, [%2, 4]  \n"
  "11: ld.ab   %6, [%2, 4]  \n"
  "12: ld.ab   %7, [%2, 4]  \n"
  "13: ld.ab   %8, [%2, 4]  \n"
  " st.ab   %5, [%1, 4]  \n"
  " st.ab   %6, [%1, 4]  \n"
  " st.ab   %7, [%1, 4]  \n"
  " st.ab   %8, [%1, 4]  \n"
  " sub     %0,%0,16  \n"
  "3: and.f   %3,%3,0xf  \n"  /* stragglers */
  " bz      34f   \n"
  " bbit0   %3,3,31f  \n"  /* 8 bytes left */
  "14: ld.ab   %5, [%2,4]  \n"
  "15: ld.ab   %6, [%2,4]  \n"
  " st.ab   %5, [%1,4]  \n"
  " st.ab   %6, [%1,4]  \n"
  " sub.f   %0,%0,8   \n"
  "31: bbit0   %3,2,32f  \n"  /* 4 bytes left */
  "16: ld.ab   %5, [%2,4]  \n"
  " st.ab   %5, [%1,4]  \n"
  " sub.f   %0,%0,4   \n"
  "32: bbit0   %3,1,33f  \n"  /* 2 bytes left */
  "17: ldw.ab  %5, [%2,2]  \n"
  " stw.ab  %5, [%1,2]  \n"
  " sub.f   %0,%0,2   \n"
  "33: bbit0   %3,0,34f  \n"
  "18: ldb.ab  %5, [%2,1]  \n"  /* 1 byte left */
  " stb.ab  %5, [%1,1]  \n"
  " sub.f   %0,%0,1   \n"
  "34: ;nop    \n"
  " .section .fixup, \"ax\"  \n"
  " .align 4   \n"
  "4: j   34b    \n"
  " .previous   \n"
  " .section __ex_table, \"a\" \n"
  " .align 4   \n"
  " .word   1b, 4b   \n"
  " .word   11b,4b   \n"
  " .word   12b,4b   \n"
  " .word   13b,4b   \n"
  " .word   14b,4b   \n"
  " .word   15b,4b   \n"
  " .word   16b,4b   \n"
  " .word   17b,4b   \n"
  " .word   18b,4b   \n"
  " .previous   \n"
  : "=r" (res), "+r"(to), "+r"(from), "+r"(n), "=r"(val),
    "=r"(tmp1), "=r"(tmp2), "=r"(tmp3), "=r"(tmp4)
  :
  : "lp_count", "memory");
 }

 return res;
}

static inline unsigned long
raw_copy_to_user(void __user *to, const void *from, unsigned long n)
{
 long res = 0;
 char val;
 unsigned long tmp1, tmp2, tmp3, tmp4;
 unsigned long orig_n = n;

 if (n == 0)
  return 0;

 /* fallback for unaligned access when hardware doesn't support */
 if (!IS_ENABLED(CONFIG_ARC_USE_UNALIGNED_MEM_ACCESS) &&
      (((unsigned long)to & 0x3) || ((unsigned long)from & 0x3))) {

  unsigned char tmp;

  __asm__ __volatile__(
  " mov.f   lp_count, %0  \n"
  " lpnz 3f    \n"
  " ldb.ab  %1, [%3, 1]  \n"
  "1: stb.ab  %1, [%2, 1]  \n"
  " sub     %0, %0, 1  \n"
  "3: ;nop    \n"
  " .section .fixup, \"ax\"  \n"
  " .align 4   \n"
  "4: j   3b    \n"
  " .previous   \n"
  " .section __ex_table, \"a\" \n"
  " .align 4   \n"
  " .word   1b, 4b   \n"
  " .previous   \n"

  : "+r" (n),
  /* Note as an '&' earlyclobber operand to make sure the
 * temporary register inside the loop is not the same as
 * FROM or TO.
 */
    "=&r" (tmp), "+r" (to), "+r" (from)
  :
  : "lp_count", "memory");

  return n;
 }

 if (__builtin_constant_p(orig_n)) {
  res = orig_n;

  if (orig_n / 16) {
   orig_n = orig_n % 16;

   __asm__ __volatile__(
   " lsr lp_count, %7,4  \n"
   " lp  3f    \n"
   " ld.ab %3, [%2, 4]  \n"
   " ld.ab %4, [%2, 4]  \n"
   " ld.ab %5, [%2, 4]  \n"
   " ld.ab %6, [%2, 4]  \n"
   "1: st.ab %3, [%1, 4]  \n"
   "11: st.ab %4, [%1, 4]  \n"
   "12: st.ab %5, [%1, 4]  \n"
   "13: st.ab %6, [%1, 4]  \n"
   " sub   %0, %0, 16  \n"
   "3:;nop     \n"
   " .section .fixup, \"ax\"  \n"
   " .align 4   \n"
   "4: j   3b    \n"
   " .previous   \n"
   " .section __ex_table, \"a\" \n"
   " .align 4   \n"
   " .word   1b, 4b   \n"
   " .word   11b,4b   \n"
   " .word   12b,4b   \n"
   " .word   13b,4b   \n"
   " .previous   \n"
   : "+r" (res), "+r"(to), "+r"(from),
     "=r"(tmp1), "=r"(tmp2), "=r"(tmp3), "=r"(tmp4)
   : "ir"(n)
   : "lp_count", "memory");
  }
  if (orig_n / 8) {
   orig_n = orig_n % 8;

   __asm__ __volatile__(
   " ld.ab   %3, [%2,4]  \n"
   " ld.ab   %4, [%2,4]  \n"
   "14: st.ab   %3, [%1,4]  \n"
   "15: st.ab   %4, [%1,4]  \n"
   " sub     %0, %0, 8  \n"
   "31:;nop    \n"
   " .section .fixup, \"ax\"  \n"
   " .align 4   \n"
   "4: j   31b    \n"
   " .previous   \n"
   " .section __ex_table, \"a\" \n"
   " .align 4   \n"
   " .word   14b,4b   \n"
   " .word   15b,4b   \n"
   " .previous   \n"
   : "+r" (res), "+r"(to), "+r"(from),
     "=r"(tmp1), "=r"(tmp2)
   :
   : "memory");
  }
  if (orig_n / 4) {
   orig_n = orig_n % 4;

   __asm__ __volatile__(
   " ld.ab   %3, [%2,4]  \n"
   "16: st.ab   %3, [%1,4]  \n"
   " sub     %0, %0, 4  \n"
   "32:;nop    \n"
   " .section .fixup, \"ax\"  \n"
   " .align 4   \n"
   "4: j   32b    \n"
   " .previous   \n"
   " .section __ex_table, \"a\" \n"
   " .align 4   \n"
   " .word   16b,4b   \n"
   " .previous   \n"
   : "+r" (res), "+r"(to), "+r"(from), "=r"(tmp1)
   :
   : "memory");
  }
  if (orig_n / 2) {
   orig_n = orig_n % 2;

   __asm__ __volatile__(
   " ldw.ab    %3, [%2,2]  \n"
   "17: stw.ab    %3, [%1,2]  \n"
   " sub       %0, %0, 2  \n"
   "33:;nop    \n"
   " .section .fixup, \"ax\"  \n"
   " .align 4   \n"
   "4: j   33b    \n"
   " .previous   \n"
   " .section __ex_table, \"a\" \n"
   " .align 4   \n"
   " .word   17b,4b   \n"
   " .previous   \n"
   : "+r" (res), "+r"(to), "+r"(from), "=r"(tmp1)
   :
   : "memory");
  }
  if (orig_n & 1) {
   __asm__ __volatile__(
   " ldb.ab  %3, [%2,1]  \n"
   "18: stb.ab  %3, [%1,1]  \n"
   " sub     %0, %0, 1  \n"
   "34: ;nop    \n"
   " .section .fixup, \"ax\"  \n"
   " .align 4   \n"
   "4: j   34b    \n"
   " .previous   \n"
   " .section __ex_table, \"a\" \n"
   " .align 4   \n"
   " .word   18b,4b   \n"
   " .previous   \n"
   : "+r" (res), "+r"(to), "+r"(from), "=r"(tmp1)
   :
   : "memory");
  }
 } else {  /* n is NOT constant, so laddered copy of 16x,8,4,2,1  */

  __asm__ __volatile__(
  " mov   %0,%3   \n"
  " lsr.f lp_count, %3,4  \n"  /* 16x bytes */
  " lpnz  3f   \n"
  " ld.ab %5, [%2, 4]  \n"
  " ld.ab %6, [%2, 4]  \n"
  " ld.ab %7, [%2, 4]  \n"
  " ld.ab %8, [%2, 4]  \n"
  "1: st.ab %5, [%1, 4]  \n"
  "11: st.ab %6, [%1, 4]  \n"
  "12: st.ab %7, [%1, 4]  \n"
  "13: st.ab %8, [%1, 4]  \n"
  " sub   %0, %0, 16  \n"
  "3: and.f %3,%3,0xf   \n" /* stragglers */
  " bz 34f    \n"
  " bbit0   %3,3,31f  \n" /* 8 bytes left */
  " ld.ab   %5, [%2,4]  \n"
  " ld.ab   %6, [%2,4]  \n"
  "14: st.ab   %5, [%1,4]  \n"
  "15: st.ab   %6, [%1,4]  \n"
  " sub.f   %0, %0, 8  \n"
  "31: bbit0   %3,2,32f  \n"  /* 4 bytes left */
  " ld.ab   %5, [%2,4]  \n"
  "16: st.ab   %5, [%1,4]  \n"
  " sub.f   %0, %0, 4  \n"
  "32: bbit0 %3,1,33f   \n"  /* 2 bytes left */
  " ldw.ab    %5, [%2,2]  \n"
  "17: stw.ab    %5, [%1,2]  \n"
  " sub.f %0, %0, 2   \n"
  "33: bbit0 %3,0,34f   \n"
  " ldb.ab    %5, [%2,1]  \n"  /* 1 byte left */
  "18: stb.ab  %5, [%1,1]  \n"
  " sub.f %0, %0, 1   \n"
  "34: ;nop    \n"
  " .section .fixup, \"ax\"  \n"
  " .align 4   \n"
  "4: j   34b    \n"
  " .previous   \n"
  " .section __ex_table, \"a\" \n"
  " .align 4   \n"
  " .word   1b, 4b   \n"
  " .word   11b,4b   \n"
  " .word   12b,4b   \n"
  " .word   13b,4b   \n"
  " .word   14b,4b   \n"
  " .word   15b,4b   \n"
  " .word   16b,4b   \n"
  " .word   17b,4b   \n"
  " .word   18b,4b   \n"
  " .previous   \n"
  : "=r" (res), "+r"(to), "+r"(from), "+r"(n), "=r"(val),
    "=r"(tmp1), "=r"(tmp2), "=r"(tmp3), "=r"(tmp4)
  :
  : "lp_count", "memory");
 }

 return res;
}

static inline unsigned long __clear_user(void __user *to, unsigned long n)
{
 long res = n;
 unsigned char *d_char = to;

 __asm__ __volatile__(
 " bbit0   %0, 0, 1f  \n"
 "75: stb.ab  %2, [%0,1]  \n"
 " sub %1, %1, 1   \n"
 "1: bbit0   %0, 1, 2f  \n"
 "76: stw.ab  %2, [%0,2]  \n"
 " sub %1, %1, 2   \n"
 "2: asr.f   lp_count, %1, 2  \n"
 " lpnz    3f   \n"
 "77: st.ab   %2, [%0,4]  \n"
 " sub %1, %1, 4   \n"
 "3: bbit0   %1, 1, 4f  \n"
 "78: stw.ab  %2, [%0,2]  \n"
 " sub %1, %1, 2   \n"
 "4: bbit0   %1, 0, 5f  \n"
 "79: stb.ab  %2, [%0,1]  \n"
 " sub %1, %1, 1   \n"
 "5:     \n"
 " .section .fixup, \"ax\"  \n"
 " .align 4   \n"
 "3: j   5b    \n"
 " .previous   \n"
 " .section __ex_table, \"a\" \n"
 " .align 4   \n"
 " .word   75b, 3b   \n"
 " .word   76b, 3b   \n"
 " .word   77b, 3b   \n"
 " .word   78b, 3b   \n"
 " .word   79b, 3b   \n"
 " .previous   \n"
 : "+r"(d_char), "+r"(res)
 : "i"(0)
 : "lp_count", "memory");

 return res;
}

#define INLINE_COPY_TO_USER
#define INLINE_COPY_FROM_USER

#define __clear_user   __clear_user

#include <asm-generic/uaccess.h>

#endif