arch/um/include/asm/uaccess.h

   1 /*
   2  * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
   3  * Licensed under the GPL
   4  */
   5
   6 #ifndef __UM_UACCESS_H
   7 #define __UM_UACCESS_H
   8
   9 /* thread_info has a mm_segment_t in it, so put the definition up here */
  10 typedef struct {
  11         unsigned long seg;
  12 } mm_segment_t;
  13
  14 #include <linux/thread_info.h>
  15 #include <linux/errno.h>
  16 #include <asm/processor.h>
  17 #include <asm/elf.h>
  18
  19 #define VERIFY_READ 0
  20 #define VERIFY_WRITE 1
  21
  22 /*
  23  * The fs value determines whether argument validity checking should be
  24  * performed or not.  If get_fs() == USER_DS, checking is performed, with
  25  * get_fs() == KERNEL_DS, checking is bypassed.
  26  *
  27  * For historical reasons, these macros are grossly misnamed.
  28  */
  29
  30 #define MAKE_MM_SEG(s)  ((mm_segment_t) { (s) })
  31
  32 #define KERNEL_DS       MAKE_MM_SEG(0xFFFFFFFF)
  33 #define USER_DS         MAKE_MM_SEG(TASK_SIZE)
  34
  35 #define get_ds()        (KERNEL_DS)
  36 #define get_fs()        (current_thread_info()->addr_limit)
  37 #define set_fs(x)       (current_thread_info()->addr_limit = (x))
  38
  39 #define segment_eq(a, b) ((a).seg == (b).seg)
  40
  41 #define __under_task_size(addr, size) \
  42         (((unsigned long) (addr) < TASK_SIZE) && \
  43          (((unsigned long) (addr) + (size)) < TASK_SIZE))
  44
  45 #define __access_ok_vsyscall(type, addr, size) \
  46          ((type == VERIFY_READ) && \
  47           ((unsigned long) (addr) >= FIXADDR_USER_START) && \
  48           ((unsigned long) (addr) + (size) <= FIXADDR_USER_END) && \
  49           ((unsigned long) (addr) + (size) >= (unsigned long)(addr)))
  50
  51 #define __addr_range_nowrap(addr, size) \
  52         ((unsigned long) (addr) <= ((unsigned long) (addr) + (size)))
  53
  54 #define access_ok(type, addr, size) \
  55         (__addr_range_nowrap(addr, size) && \
  56          (__under_task_size(addr, size) || \
  57           __access_ok_vsyscall(type, addr, size) || \
  58           segment_eq(get_fs(), KERNEL_DS)))
  59
  60 extern int copy_from_user(void *to, const void __user *from, int n);
  61 extern int copy_to_user(void __user *to, const void *from, int n);
  62
  63 /*
  64  * strncpy_from_user: - Copy a NUL terminated string from userspace.
  65  * @dst:   Destination address, in kernel space.  This buffer must be at
  66  *         least @count bytes long.
  67  * @src:   Source address, in user space.
  68  * @count: Maximum number of bytes to copy, including the trailing NUL.
  69  *
  70  * Copies a NUL-terminated string from userspace to kernel space.
  71  *
  72  * On success, returns the length of the string (not including the trailing
  73  * NUL).
  74  *
  75  * If access to userspace fails, returns -EFAULT (some data may have been
  76  * copied).
  77  *
  78  * If @count is smaller than the length of the string, copies @count bytes
  79  * and returns @count.
  80  */
  81
  82 extern int strncpy_from_user(char *dst, const char __user *src, int count);
  83
  84 /*
  85  * __clear_user: - Zero a block of memory in user space, with less checking.
  86  * @to:   Destination address, in user space.
  87  * @n:    Number of bytes to zero.
  88  *
  89  * Zero a block of memory in user space.  Caller must check
  90  * the specified block with access_ok() before calling this function.
  91  *
  92  * Returns number of bytes that could not be cleared.
  93  * On success, this will be zero.
  94  */
  95 extern int __clear_user(void __user *mem, int len);
  96
  97 /*
  98  * clear_user: - Zero a block of memory in user space.
  99  * @to:   Destination address, in user space.
 100  * @n:    Number of bytes to zero.
 101  *
 102  * Zero a block of memory in user space.
 103  *
 104  * Returns number of bytes that could not be cleared.
 105  * On success, this will be zero.
 106  */
 107 extern int clear_user(void __user *mem, int len);
 108
 109 /*
 110  * strlen_user: - Get the size of a string in user space.
 111  * @str: The string to measure.
 112  * @n:   The maximum valid length
 113  *
 114  * Get the size of a NUL-terminated string in user space.
 115  *
 116  * Returns the size of the string INCLUDING the terminating NUL.
 117  * On exception, returns 0.
 118  * If the string is too long, returns a value greater than @n.
 119  */
 120 extern int strnlen_user(const void __user *str, int len);
 121
 122 #define __copy_from_user(to, from, n) copy_from_user(to, from, n)
 123
 124 #define __copy_to_user(to, from, n) copy_to_user(to, from, n)
 125
 126 #define __copy_to_user_inatomic __copy_to_user
 127 #define __copy_from_user_inatomic __copy_from_user
 128
 129 #define __get_user(x, ptr) \
 130 ({ \
 131         const __typeof__(*(ptr)) __user *__private_ptr = (ptr); \
 132         __typeof__(x) __private_val;                    \
 133         int __private_ret = -EFAULT;                    \
 134         (x) = (__typeof__(*(__private_ptr)))0;                          \
 135         if (__copy_from_user((__force void *)&__private_val, (__private_ptr),\
 136                              sizeof(*(__private_ptr))) == 0) {          \
 137                 (x) = (__typeof__(*(__private_ptr))) __private_val;     \
 138                 __private_ret = 0;                                      \
 139         }                                                               \
 140         __private_ret;                                                  \
 141 })
 142
 143 #define get_user(x, ptr) \
 144 ({ \
 145         const __typeof__((*(ptr))) __user *private_ptr = (ptr); \
 146         (access_ok(VERIFY_READ, private_ptr, sizeof(*private_ptr)) ? \
 147          __get_user(x, private_ptr) : ((x) = (__typeof__(*ptr))0, -EFAULT)); \
 148 })
 149
 150 #define __put_user(x, ptr) \
 151 ({ \
 152         __typeof__(*(ptr)) __user *__private_ptr = ptr; \
 153         __typeof__(*(__private_ptr)) __private_val; \
 154         int __private_ret = -EFAULT; \
 155         __private_val = (__typeof__(*(__private_ptr))) (x); \
 156         if (__copy_to_user((__private_ptr), &__private_val, \
 157                            sizeof(*(__private_ptr))) == 0) { \
 158                 __private_ret = 0; \
 159         } \
 160         __private_ret; \
 161 })
 162
 163 #define put_user(x, ptr) \
 164 ({ \
 165         __typeof__(*(ptr)) __user *private_ptr = (ptr); \
 166         (access_ok(VERIFY_WRITE, private_ptr, sizeof(*private_ptr)) ? \
 167          __put_user(x, private_ptr) : -EFAULT); \
 168 })
 169
 170 #define strlen_user(str) strnlen_user(str, ~0U >> 1)
 171
 172 struct exception_table_entry
 173 {
 174         unsigned long insn;
 175         unsigned long fixup;
 176 };
 177
 178 #endif