Quelle  uaccess.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __ASM_GENERIC_UACCESS_H
#define __ASM_GENERIC_UACCESS_H

/*
 * User space memory access functions, these should work
 * on any machine that has kernel and user data in the same
 * address space, e.g. all NOMMU machines.
 */
#include <linux/string.h>
#include <asm-generic/access_ok.h>

#ifdef CONFIG_UACCESS_MEMCPY
#include <linux/unaligned.h>

static __always_inline int
__get_user_fn(size_t size, const void __user *from, void *to)
{
 BUILD_BUG_ON(!__builtin_constant_p(size));

 switch (size) {
 case 1:
  *(u8 *)to = *((u8 __force *)from);
  return 0;
 case 2:
  *(u16 *)to = get_unaligned((u16 __force *)from);
  return 0;
 case 4:
  *(u32 *)to = get_unaligned((u32 __force *)from);
  return 0;
 case 8:
  *(u64 *)to = get_unaligned((u64 __force *)from);
  return 0;
 default:
  BUILD_BUG();
  return 0;
 }

}
#define __get_user_fn(sz, u, k) __get_user_fn(sz, u, k)

static __always_inline int
__put_user_fn(size_t size, void __user *to, void *from)
{
 BUILD_BUG_ON(!__builtin_constant_p(size));

 switch (size) {
 case 1:
  *(u8 __force *)to = *(u8 *)from;
  return 0;
 case 2:
  put_unaligned(*(u16 *)from, (u16 __force *)to);
  return 0;
 case 4:
  put_unaligned(*(u32 *)from, (u32 __force *)to);
  return 0;
 case 8:
  put_unaligned(*(u64 *)from, (u64 __force *)to);
  return 0;
 default:
  BUILD_BUG();
  return 0;
 }
}
#define __put_user_fn(sz, u, k) __put_user_fn(sz, u, k)

#define __get_kernel_nofault(dst, src, type, err_label)   \
do {         \
 *((type *)dst) = get_unaligned((type *)(src));   \
 if (0) /* make sure the label looks used to the compiler */ \
  goto err_label;      \
} while (0)

#define __put_kernel_nofault(dst, src, type, err_label)   \
do {         \
 put_unaligned(*((type *)src), (type *)(dst));   \
 if (0) /* make sure the label looks used to the compiler */ \
  goto err_label;      \
} while (0)

static inline __must_check unsigned long
raw_copy_from_user(void *to, const void __user * from, unsigned long n)
{
 memcpy(to, (const void __force *)from, n);
 return 0;
}

static inline __must_check unsigned long
raw_copy_to_user(void __user *to, const void *from, unsigned long n)
{
 memcpy((void __force *)to, from, n);
 return 0;
}
#define INLINE_COPY_FROM_USER
#define INLINE_COPY_TO_USER
#endif /* CONFIG_UACCESS_MEMCPY */

/*
 * These are the main single-value transfer routines.  They automatically
 * use the right size if we just have the right pointer type.
 * This version just falls back to copy_{from,to}_user, which should
 * provide a fast-path for small values.
 */
#define __put_user(x, ptr) \
({        \
 __typeof__(*(ptr)) __x = (x);    \
 int __pu_err = -EFAULT;     \
        __chk_user_ptr(ptr);                                    \
 switch (sizeof (*(ptr))) {    \
 case 1:       \
 case 2:       \
 case 4:       \
 case 8:       \
  __pu_err = __put_user_fn(sizeof (*(ptr)), \
      ptr, &__x);  \
  break;      \
 default:      \
  __put_user_bad();    \
  break;      \
  }       \
 __pu_err;      \
})

#define put_user(x, ptr)     \
({        \
 void __user *__p = (ptr);    \
 might_fault();      \
 access_ok(__p, sizeof(*ptr)) ?  \
  __put_user((x), ((__typeof__(*(ptr)) __user *)__p)) : \
  -EFAULT;     \
})

#ifndef __put_user_fn

static inline int __put_user_fn(size_t size, void __user *ptr, void *x)
{
 return unlikely(raw_copy_to_user(ptr, x, size)) ? -EFAULT : 0;
}

#define __put_user_fn(sz, u, k) __put_user_fn(sz, u, k)

#endif

extern int __put_user_bad(void) __attribute__((noreturn));

#define __get_user(x, ptr)     \
({        \
 int __gu_err = -EFAULT;     \
 __chk_user_ptr(ptr);     \
 switch (sizeof(*(ptr))) {    \
 case 1: {      \
  unsigned char __x = 0;    \
  __gu_err = __get_user_fn(sizeof (*(ptr)), \
      ptr, &__x);  \
  (x) = *(__force __typeof__(*(ptr)) *) &__x; \
  break;      \
 };       \
 case 2: {      \
  unsigned short __x = 0;    \
  __gu_err = __get_user_fn(sizeof (*(ptr)), \
      ptr, &__x);  \
  (x) = *(__force __typeof__(*(ptr)) *) &__x; \
  break;      \
 };       \
 case 4: {      \
  unsigned int __x = 0;    \
  __gu_err = __get_user_fn(sizeof (*(ptr)), \
      ptr, &__x);  \
  (x) = *(__force __typeof__(*(ptr)) *) &__x; \
  break;      \
 };       \
 case 8: {      \
  unsigned long long __x = 0;   \
  __gu_err = __get_user_fn(sizeof (*(ptr)), \
      ptr, &__x);  \
  (x) = *(__force __typeof__(*(ptr)) *) &__x; \
  break;      \
 };       \
 default:      \
  __get_user_bad();    \
  break;      \
 }       \
 __gu_err;      \
})

#define get_user(x, ptr)     \
({        \
 const void __user *__p = (ptr);    \
 might_fault();      \
 access_ok(__p, sizeof(*ptr)) ?  \
  __get_user((x), (__typeof__(*(ptr)) __user *)__p) :\
  ((x) = (__typeof__(*(ptr)))0,-EFAULT);  \
})

#ifndef __get_user_fn
static inline int __get_user_fn(size_t size, const void __user *ptr, void *x)
{
 return unlikely(raw_copy_from_user(x, ptr, size)) ? -EFAULT : 0;
}

#define __get_user_fn(sz, u, k) __get_user_fn(sz, u, k)

#endif

extern int __get_user_bad(void) __attribute__((noreturn));

/*
 * Zero Userspace
 */
#ifndef __clear_user
static inline __must_check unsigned long
__clear_user(void __user *to, unsigned long n)
{
 memset((void __force *)to, 0, n);
 return 0;
}
#endif

static inline __must_check unsigned long
clear_user(void __user *to, unsigned long n)
{
 might_fault();
 if (!access_ok(to, n))
  return n;

 return __clear_user(to, n);
}

#include <asm/extable.h>

__must_check long strncpy_from_user(char *dst, const char __user *src,
        long count);
__must_check long strnlen_user(const char __user *src, long n);

#endif /* __ASM_GENERIC_UACCESS_H */