Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
uaccess.h
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2002 Jeff Dike ([email protected])
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 
173 {
174  unsigned long insn;
175  unsigned long fixup;
176 };
177 
178 #endif