1#ifndef __ASM_GENERIC_UACCESS_H 2#define __ASM_GENERIC_UACCESS_H 3 4/* 5 * User space memory access functions, these should work 6 * on any machine that has kernel and user data in the same 7 * address space, e.g. all NOMMU machines. 8 */ 9#include <linux/sched.h> 10#include <linux/string.h> 11 12#include <asm/segment.h> 13 14#define MAKE_MM_SEG(s) ((mm_segment_t) { (s) }) 15 16#ifndef KERNEL_DS 17#define KERNEL_DS MAKE_MM_SEG(~0UL) 18#endif 19 20#ifndef USER_DS 21#define USER_DS MAKE_MM_SEG(TASK_SIZE - 1) 22#endif 23 24#ifndef get_fs 25#define get_ds() (KERNEL_DS) 26#define get_fs() (current_thread_info()->addr_limit) 27 28static inline void set_fs(mm_segment_t fs) 29{ 30 current_thread_info()->addr_limit = fs; 31} 32#endif 33 34#ifndef segment_eq 35#define segment_eq(a, b) ((a).seg == (b).seg) 36#endif 37 38#define VERIFY_READ 0 39#define VERIFY_WRITE 1 40 41#define access_ok(type, addr, size) __access_ok((unsigned long)(addr),(size)) 42 43/* 44 * The architecture should really override this if possible, at least 45 * doing a check on the get_fs() 46 */ 47#ifndef __access_ok 48static inline int __access_ok(unsigned long addr, unsigned long size) 49{ 50 return 1; 51} 52#endif 53 54/* 55 * The exception table consists of pairs of addresses: the first is the 56 * address of an instruction that is allowed to fault, and the second is 57 * the address at which the program should continue. No registers are 58 * modified, so it is entirely up to the continuation code to figure out 59 * what to do. 60 * 61 * All the routines below use bits of fixup code that are out of line 62 * with the main instruction path. This means when everything is well, 63 * we don't even have to jump over them. Further, they do not intrude 64 * on our cache or tlb entries. 65 */ 66 67struct exception_table_entry 68{ 69 unsigned long insn, fixup; 70}; 71 72/* Returns 0 if exception not found and fixup otherwise. */ 73extern unsigned long search_exception_table(unsigned long); 74 75/* 76 * architectures with an MMU should override these two 77 */ 78#ifndef __copy_from_user 79static inline __must_check long __copy_from_user(void *to, 80 const void __user * from, unsigned long n) 81{ 82 if (__builtin_constant_p(n)) { 83 switch(n) { 84 case 1: 85 *(u8 *)to = *(u8 __force *)from; 86 return 0; 87 case 2: 88 *(u16 *)to = *(u16 __force *)from; 89 return 0; 90 case 4: 91 *(u32 *)to = *(u32 __force *)from; 92 return 0; 93#ifdef CONFIG_64BIT 94 case 8: 95 *(u64 *)to = *(u64 __force *)from; 96 return 0; 97#endif 98 default: 99 break; 100 } 101 } 102 103 memcpy(to, (const void __force *)from, n); 104 return 0; 105} 106#endif 107 108#ifndef __copy_to_user 109static inline __must_check long __copy_to_user(void __user *to, 110 const void *from, unsigned long n) 111{ 112 if (__builtin_constant_p(n)) { 113 switch(n) { 114 case 1: 115 *(u8 __force *)to = *(u8 *)from; 116 return 0; 117 case 2: 118 *(u16 __force *)to = *(u16 *)from; 119 return 0; 120 case 4: 121 *(u32 __force *)to = *(u32 *)from; 122 return 0; 123#ifdef CONFIG_64BIT 124 case 8: 125 *(u64 __force *)to = *(u64 *)from; 126 return 0; 127#endif 128 default: 129 break; 130 } 131 } 132 133 memcpy((void __force *)to, from, n); 134 return 0; 135} 136#endif 137 138/* 139 * These are the main single-value transfer routines. They automatically 140 * use the right size if we just have the right pointer type. 141 * This version just falls back to copy_{from,to}_user, which should 142 * provide a fast-path for small values. 143 */ 144#define __put_user(x, ptr) \ 145({ \ 146 __typeof__(*(ptr)) __x = (x); \ 147 int __pu_err = -EFAULT; \ 148 __chk_user_ptr(ptr); \ 149 switch (sizeof (*(ptr))) { \ 150 case 1: \ 151 case 2: \ 152 case 4: \ 153 case 8: \ 154 __pu_err = __put_user_fn(sizeof (*(ptr)), \ 155 ptr, &__x); \ 156 break; \ 157 default: \ 158 __put_user_bad(); \ 159 break; \ 160 } \ 161 __pu_err; \ 162}) 163 164#define put_user(x, ptr) \ 165({ \ 166 might_fault(); \ 167 access_ok(VERIFY_WRITE, ptr, sizeof(*ptr)) ? \ 168 __put_user(x, ptr) : \ 169 -EFAULT; \ 170}) 171 172#ifndef __put_user_fn 173 174static inline int __put_user_fn(size_t size, void __user *ptr, void *x) 175{ 176 size = __copy_to_user(ptr, x, size); 177 return size ? -EFAULT : size; 178} 179 180#define __put_user_fn(sz, u, k) __put_user_fn(sz, u, k) 181 182#endif 183 184extern int __put_user_bad(void) __attribute__((noreturn)); 185 186#define __get_user(x, ptr) \ 187({ \ 188 int __gu_err = -EFAULT; \ 189 __chk_user_ptr(ptr); \ 190 switch (sizeof(*(ptr))) { \ 191 case 1: { \ 192 unsigned char __x; \ 193 __gu_err = __get_user_fn(sizeof (*(ptr)), \ 194 ptr, &__x); \ 195 (x) = *(__force __typeof__(*(ptr)) *) &__x; \ 196 break; \ 197 }; \ 198 case 2: { \ 199 unsigned short __x; \ 200 __gu_err = __get_user_fn(sizeof (*(ptr)), \ 201 ptr, &__x); \ 202 (x) = *(__force __typeof__(*(ptr)) *) &__x; \ 203 break; \ 204 }; \ 205 case 4: { \ 206 unsigned int __x; \ 207 __gu_err = __get_user_fn(sizeof (*(ptr)), \ 208 ptr, &__x); \ 209 (x) = *(__force __typeof__(*(ptr)) *) &__x; \ 210 break; \ 211 }; \ 212 case 8: { \ 213 unsigned long long __x; \ 214 __gu_err = __get_user_fn(sizeof (*(ptr)), \ 215 ptr, &__x); \ 216 (x) = *(__force __typeof__(*(ptr)) *) &__x; \ 217 break; \ 218 }; \ 219 default: \ 220 __get_user_bad(); \ 221 break; \ 222 } \ 223 __gu_err; \ 224}) 225 226#define get_user(x, ptr) \ 227({ \ 228 might_fault(); \ 229 access_ok(VERIFY_READ, ptr, sizeof(*ptr)) ? \ 230 __get_user(x, ptr) : \ 231 -EFAULT; \ 232}) 233 234#ifndef __get_user_fn 235static inline int __get_user_fn(size_t size, const void __user *ptr, void *x) 236{ 237 size = __copy_from_user(x, ptr, size); 238 return size ? -EFAULT : size; 239} 240 241#define __get_user_fn(sz, u, k) __get_user_fn(sz, u, k) 242 243#endif 244 245extern int __get_user_bad(void) __attribute__((noreturn)); 246 247#ifndef __copy_from_user_inatomic 248#define __copy_from_user_inatomic __copy_from_user 249#endif 250 251#ifndef __copy_to_user_inatomic 252#define __copy_to_user_inatomic __copy_to_user 253#endif 254 255static inline long copy_from_user(void *to, 256 const void __user * from, unsigned long n) 257{ 258 might_fault(); 259 if (access_ok(VERIFY_READ, from, n)) 260 return __copy_from_user(to, from, n); 261 else 262 return n; 263} 264 265static inline long copy_to_user(void __user *to, 266 const void *from, unsigned long n) 267{ 268 might_fault(); 269 if (access_ok(VERIFY_WRITE, to, n)) 270 return __copy_to_user(to, from, n); 271 else 272 return n; 273} 274 275/* 276 * Copy a null terminated string from userspace. 277 */ 278#ifndef __strncpy_from_user 279static inline long 280__strncpy_from_user(char *dst, const char __user *src, long count) 281{ 282 char *tmp; 283 strncpy(dst, (const char __force *)src, count); 284 for (tmp = dst; *tmp && count > 0; tmp++, count--) 285 ; 286 return (tmp - dst); 287} 288#endif 289 290static inline long 291strncpy_from_user(char *dst, const char __user *src, long count) 292{ 293 if (!access_ok(VERIFY_READ, src, 1)) 294 return -EFAULT; 295 return __strncpy_from_user(dst, src, count); 296} 297 298/* 299 * Return the size of a string (including the ending 0) 300 * 301 * Return 0 on exception, a value greater than N if too long 302 */ 303#ifndef __strnlen_user 304#define __strnlen_user(s, n) (strnlen((s), (n)) + 1) 305#endif 306 307/* 308 * Unlike strnlen, strnlen_user includes the nul terminator in 309 * its returned count. Callers should check for a returned value 310 * greater than N as an indication the string is too long. 311 */ 312static inline long strnlen_user(const char __user *src, long n) 313{ 314 if (!access_ok(VERIFY_READ, src, 1)) 315 return 0; 316 return __strnlen_user(src, n); 317} 318 319static inline long strlen_user(const char __user *src) 320{ 321 return strnlen_user(src, 32767); 322} 323 324/* 325 * Zero Userspace 326 */ 327#ifndef __clear_user 328static inline __must_check unsigned long 329__clear_user(void __user *to, unsigned long n) 330{ 331 memset((void __force *)to, 0, n); 332 return 0; 333} 334#endif 335 336static inline __must_check unsigned long 337clear_user(void __user *to, unsigned long n) 338{ 339 might_fault(); 340 if (!access_ok(VERIFY_WRITE, to, n)) 341 return n; 342 343 return __clear_user(to, n); 344} 345 346#endif /* __ASM_GENERIC_UACCESS_H */ 347