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 179