Logo Search packages:      
Sourcecode: linux version File versions

uaccess.h

#ifndef __ASM_SH_UACCESS_H
#define __ASM_SH_UACCESS_H

#include <linux/errno.h>
#include <linux/sched.h>
#include <asm/segment.h>

#define VERIFY_READ    0
#define VERIFY_WRITE   1

#define __addr_ok(addr) \
      ((unsigned long __force)(addr) < current_thread_info()->addr_limit.seg)

/*
 * __access_ok: Check if address with size is OK or not.
 *
 * Uhhuh, this needs 33-bit arithmetic. We have a carry..
 *
 * sum := addr + size;  carry? --> flag = true;
 * if (sum >= addr_limit) flag = true;
 */
#define __access_ok(addr, size)           \
      (__addr_ok((addr) + (size)))
#define access_ok(type, addr, size) \
      (__chk_user_ptr(addr),        \
       __access_ok((unsigned long __force)(addr), (size)))

/*
 * Uh, these should become the main single-value transfer routines ...
 * They automatically use the right size if we just have the right
 * pointer type ...
 *
 * As SuperH uses the same address space for kernel and user data, we
 * can just do these as direct assignments.
 *
 * Careful to not
 * (a) re-use the arguments for side effects (sizeof is ok)
 * (b) require any knowledge of processes at this stage
 */
#define put_user(x,ptr)       __put_user_check((x), (ptr), sizeof(*(ptr)))
#define get_user(x,ptr)       __get_user_check((x), (ptr), sizeof(*(ptr)))

/*
 * The "__xxx" versions do not do address space checking, useful when
 * doing multiple accesses to the same area (the user has to do the
 * checks by hand with "access_ok()")
 */
#define __put_user(x,ptr)     __put_user_nocheck((x), (ptr), sizeof(*(ptr)))
#define __get_user(x,ptr)     __get_user_nocheck((x), (ptr), sizeof(*(ptr)))

struct __large_struct { unsigned long buf[100]; };
#define __m(x) (*(struct __large_struct __user *)(x))

#define __get_user_nocheck(x,ptr,size)                      \
({                                              \
      long __gu_err;                                  \
      unsigned long __gu_val;                         \
      const __typeof__(*(ptr)) __user *__gu_addr = (ptr);   \
      __chk_user_ptr(ptr);                            \
      __get_user_size(__gu_val, __gu_addr, (size), __gu_err);     \
      (x) = (__typeof__(*(ptr)))__gu_val;             \
      __gu_err;                                 \
})

#define __get_user_check(x,ptr,size)                              \
({                                                    \
      long __gu_err = -EFAULT;                              \
      unsigned long __gu_val = 0;                           \
      const __typeof__(*(ptr)) *__gu_addr = (ptr);                \
      if (likely(access_ok(VERIFY_READ, __gu_addr, (size))))            \
            __get_user_size(__gu_val, __gu_addr, (size), __gu_err);     \
      (x) = (__typeof__(*(ptr)))__gu_val;                   \
      __gu_err;                                       \
})

#define __put_user_nocheck(x,ptr,size)                      \
({                                              \
      long __pu_err;                                  \
      __typeof__(*(ptr)) __user *__pu_addr = (ptr);         \
      __typeof__(*(ptr)) __pu_val = x;                \
      __chk_user_ptr(ptr);                            \
      __put_user_size(__pu_val, __pu_addr, (size), __pu_err);     \
      __pu_err;                                 \
})

#define __put_user_check(x,ptr,size)                        \
({                                              \
      long __pu_err = -EFAULT;                        \
      __typeof__(*(ptr)) __user *__pu_addr = (ptr);         \
      __typeof__(*(ptr)) __pu_val = x;                \
      if (likely(access_ok(VERIFY_WRITE, __pu_addr, size))) \
            __put_user_size(__pu_val, __pu_addr, (size),    \
                        __pu_err);              \
      __pu_err;                                 \
})

#ifdef CONFIG_SUPERH32
# include "uaccess_32.h"
#else
# include "uaccess_64.h"
#endif

/* Generic arbitrary sized copy.  */
/* Return the number of bytes NOT copied */
__kernel_size_t __copy_user(void *to, const void *from, __kernel_size_t n);

static __always_inline unsigned long
__copy_from_user(void *to, const void __user *from, unsigned long n)
{
      return __copy_user(to, (__force void *)from, n);
}

static __always_inline unsigned long __must_check
__copy_to_user(void __user *to, const void *from, unsigned long n)
{
      return __copy_user((__force void *)to, from, n);
}

#define __copy_to_user_inatomic __copy_to_user
#define __copy_from_user_inatomic __copy_from_user

/*
 * Clear the area and return remaining number of bytes
 * (on failure.  Usually it's 0.)
 */
__kernel_size_t __clear_user(void *addr, __kernel_size_t size);

#define clear_user(addr,n)                                  \
({                                                    \
      void __user * __cl_addr = (addr);                     \
      unsigned long __cl_size = (n);                              \
                                                      \
      if (__cl_size && access_ok(VERIFY_WRITE,              \
            ((unsigned long)(__cl_addr)), __cl_size))       \
            __cl_size = __clear_user(__cl_addr, __cl_size);       \
                                                      \
      __cl_size;                                      \
})

/**
 * strncpy_from_user: - Copy a NUL terminated string from userspace.
 * @dst:   Destination address, in kernel space.  This buffer must be at
 *         least @count bytes long.
 * @src:   Source address, in user space.
 * @count: Maximum number of bytes to copy, including the trailing NUL.
 *
 * Copies a NUL-terminated string from userspace to kernel space.
 *
 * On success, returns the length of the string (not including the trailing
 * NUL).
 *
 * If access to userspace fails, returns -EFAULT (some data may have been
 * copied).
 *
 * If @count is smaller than the length of the string, copies @count bytes
 * and returns @count.
 */
#define strncpy_from_user(dest,src,count)                   \
({                                                    \
      unsigned long __sfu_src = (unsigned long)(src);             \
      int __sfu_count = (int)(count);                             \
      long __sfu_res = -EFAULT;                             \
                                                      \
      if (__access_ok(__sfu_src, __sfu_count))              \
            __sfu_res = __strncpy_from_user((unsigned long)(dest),      \
                        __sfu_src, __sfu_count);            \
                                                      \
      __sfu_res;                                      \
})

static inline unsigned long
copy_from_user(void *to, const void __user *from, unsigned long n)
{
      unsigned long __copy_from = (unsigned long) from;
      __kernel_size_t __copy_size = (__kernel_size_t) n;

      if (__copy_size && __access_ok(__copy_from, __copy_size))
            return __copy_user(to, from, __copy_size);

      return __copy_size;
}

static inline unsigned long
copy_to_user(void __user *to, const void *from, unsigned long n)
{
      unsigned long __copy_to = (unsigned long) to;
      __kernel_size_t __copy_size = (__kernel_size_t) n;

      if (__copy_size && __access_ok(__copy_to, __copy_size))
            return __copy_user(to, from, __copy_size);

      return __copy_size;
}

/**
 * strnlen_user: - Get the size of a string in user space.
 * @s: The string to measure.
 * @n: The maximum valid length
 *
 * Context: User context only.  This function may sleep.
 *
 * Get the size of a NUL-terminated string in user space.
 *
 * Returns the size of the string INCLUDING the terminating NUL.
 * On exception, returns 0.
 * If the string is too long, returns a value greater than @n.
 */
static inline long strnlen_user(const char __user *s, long n)
{
      if (!__addr_ok(s))
            return 0;
      else
            return __strnlen_user(s, n);
}

/**
 * strlen_user: - Get the size of a string in user space.
 * @str: The string to measure.
 *
 * Context: User context only.  This function may sleep.
 *
 * Get the size of a NUL-terminated string in user space.
 *
 * Returns the size of the string INCLUDING the terminating NUL.
 * On exception, returns 0.
 *
 * If there is a limit on the length of a valid string, you may wish to
 * consider using strnlen_user() instead.
 */
#define strlen_user(str)      strnlen_user(str, ~0UL >> 1)

/*
 * The exception table consists of pairs of addresses: the first is the
 * address of an instruction that is allowed to fault, and the second is
 * the address at which the program should continue.  No registers are
 * modified, so it is entirely up to the continuation code to figure out
 * what to do.
 *
 * All the routines below use bits of fixup code that are out of line
 * with the main instruction path.  This means when everything is well,
 * we don't even have to jump over them.  Further, they do not intrude
 * on our cache or tlb entries.
 */
struct exception_table_entry {
      unsigned long insn, fixup;
};

#if defined(CONFIG_SUPERH64) && defined(CONFIG_MMU)
#define ARCH_HAS_SEARCH_EXTABLE
#endif

int fixup_exception(struct pt_regs *regs);
/* Returns 0 if exception not found and fixup.unit otherwise.  */
unsigned long search_exception_table(unsigned long addr);
const struct exception_table_entry *search_exception_tables(unsigned long addr);


#endif /* __ASM_SH_UACCESS_H */

Generated by  Doxygen 1.6.0   Back to index