Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6] / include / asm-x86 / uaccess_32.h
1 #ifndef __i386_UACCESS_H
2 #define __i386_UACCESS_H
3
4 /*
5  * User space memory access functions
6  */
7 #include <linux/errno.h>
8 #include <linux/thread_info.h>
9 #include <linux/prefetch.h>
10 #include <linux/string.h>
11 #include <asm/asm.h>
12 #include <asm/page.h>
13
14 unsigned long __must_check __copy_to_user_ll
15                 (void __user *to, const void *from, unsigned long n);
16 unsigned long __must_check __copy_from_user_ll
17                 (void *to, const void __user *from, unsigned long n);
18 unsigned long __must_check __copy_from_user_ll_nozero
19                 (void *to, const void __user *from, unsigned long n);
20 unsigned long __must_check __copy_from_user_ll_nocache
21                 (void *to, const void __user *from, unsigned long n);
22 unsigned long __must_check __copy_from_user_ll_nocache_nozero
23                 (void *to, const void __user *from, unsigned long n);
24
25 /**
26  * __copy_to_user_inatomic: - Copy a block of data into user space, with less checking.
27  * @to:   Destination address, in user space.
28  * @from: Source address, in kernel space.
29  * @n:    Number of bytes to copy.
30  *
31  * Context: User context only.
32  *
33  * Copy data from kernel space to user space.  Caller must check
34  * the specified block with access_ok() before calling this function.
35  * The caller should also make sure he pins the user space address
36  * so that the we don't result in page fault and sleep.
37  *
38  * Here we special-case 1, 2 and 4-byte copy_*_user invocations.  On a fault
39  * we return the initial request size (1, 2 or 4), as copy_*_user should do.
40  * If a store crosses a page boundary and gets a fault, the x86 will not write
41  * anything, so this is accurate.
42  */
43
44 static __always_inline unsigned long __must_check
45 __copy_to_user_inatomic(void __user *to, const void *from, unsigned long n)
46 {
47         if (__builtin_constant_p(n)) {
48                 unsigned long ret;
49
50                 switch (n) {
51                 case 1:
52                         __put_user_size(*(u8 *)from, (u8 __user *)to,
53                                         1, ret, 1);
54                         return ret;
55                 case 2:
56                         __put_user_size(*(u16 *)from, (u16 __user *)to,
57                                         2, ret, 2);
58                         return ret;
59                 case 4:
60                         __put_user_size(*(u32 *)from, (u32 __user *)to,
61                                         4, ret, 4);
62                         return ret;
63                 }
64         }
65         return __copy_to_user_ll(to, from, n);
66 }
67
68 /**
69  * __copy_to_user: - Copy a block of data into user space, with less checking.
70  * @to:   Destination address, in user space.
71  * @from: Source address, in kernel space.
72  * @n:    Number of bytes to copy.
73  *
74  * Context: User context only.  This function may sleep.
75  *
76  * Copy data from kernel space to user space.  Caller must check
77  * the specified block with access_ok() before calling this function.
78  *
79  * Returns number of bytes that could not be copied.
80  * On success, this will be zero.
81  */
82 static __always_inline unsigned long __must_check
83 __copy_to_user(void __user *to, const void *from, unsigned long n)
84 {
85        might_sleep();
86        return __copy_to_user_inatomic(to, from, n);
87 }
88
89 static __always_inline unsigned long
90 __copy_from_user_inatomic(void *to, const void __user *from, unsigned long n)
91 {
92         /* Avoid zeroing the tail if the copy fails..
93          * If 'n' is constant and 1, 2, or 4, we do still zero on a failure,
94          * but as the zeroing behaviour is only significant when n is not
95          * constant, that shouldn't be a problem.
96          */
97         if (__builtin_constant_p(n)) {
98                 unsigned long ret;
99
100                 switch (n) {
101                 case 1:
102                         __get_user_size(*(u8 *)to, from, 1, ret, 1);
103                         return ret;
104                 case 2:
105                         __get_user_size(*(u16 *)to, from, 2, ret, 2);
106                         return ret;
107                 case 4:
108                         __get_user_size(*(u32 *)to, from, 4, ret, 4);
109                         return ret;
110                 }
111         }
112         return __copy_from_user_ll_nozero(to, from, n);
113 }
114
115 /**
116  * __copy_from_user: - Copy a block of data from user space, with less checking.
117  * @to:   Destination address, in kernel space.
118  * @from: Source address, in user space.
119  * @n:    Number of bytes to copy.
120  *
121  * Context: User context only.  This function may sleep.
122  *
123  * Copy data from user space to kernel space.  Caller must check
124  * the specified block with access_ok() before calling this function.
125  *
126  * Returns number of bytes that could not be copied.
127  * On success, this will be zero.
128  *
129  * If some data could not be copied, this function will pad the copied
130  * data to the requested size using zero bytes.
131  *
132  * An alternate version - __copy_from_user_inatomic() - may be called from
133  * atomic context and will fail rather than sleep.  In this case the
134  * uncopied bytes will *NOT* be padded with zeros.  See fs/filemap.h
135  * for explanation of why this is needed.
136  */
137 static __always_inline unsigned long
138 __copy_from_user(void *to, const void __user *from, unsigned long n)
139 {
140         might_sleep();
141         if (__builtin_constant_p(n)) {
142                 unsigned long ret;
143
144                 switch (n) {
145                 case 1:
146                         __get_user_size(*(u8 *)to, from, 1, ret, 1);
147                         return ret;
148                 case 2:
149                         __get_user_size(*(u16 *)to, from, 2, ret, 2);
150                         return ret;
151                 case 4:
152                         __get_user_size(*(u32 *)to, from, 4, ret, 4);
153                         return ret;
154                 }
155         }
156         return __copy_from_user_ll(to, from, n);
157 }
158
159 static __always_inline unsigned long __copy_from_user_nocache(void *to,
160                                 const void __user *from, unsigned long n)
161 {
162         might_sleep();
163         if (__builtin_constant_p(n)) {
164                 unsigned long ret;
165
166                 switch (n) {
167                 case 1:
168                         __get_user_size(*(u8 *)to, from, 1, ret, 1);
169                         return ret;
170                 case 2:
171                         __get_user_size(*(u16 *)to, from, 2, ret, 2);
172                         return ret;
173                 case 4:
174                         __get_user_size(*(u32 *)to, from, 4, ret, 4);
175                         return ret;
176                 }
177         }
178         return __copy_from_user_ll_nocache(to, from, n);
179 }
180
181 static __always_inline unsigned long
182 __copy_from_user_inatomic_nocache(void *to, const void __user *from,
183                                   unsigned long n)
184 {
185        return __copy_from_user_ll_nocache_nozero(to, from, n);
186 }
187
188 unsigned long __must_check copy_to_user(void __user *to,
189                                         const void *from, unsigned long n);
190 unsigned long __must_check copy_from_user(void *to,
191                                           const void __user *from,
192                                           unsigned long n);
193 long __must_check strncpy_from_user(char *dst, const char __user *src,
194                                     long count);
195 long __must_check __strncpy_from_user(char *dst,
196                                       const char __user *src, long count);
197
198 /**
199  * strlen_user: - Get the size of a string in user space.
200  * @str: The string to measure.
201  *
202  * Context: User context only.  This function may sleep.
203  *
204  * Get the size of a NUL-terminated string in user space.
205  *
206  * Returns the size of the string INCLUDING the terminating NUL.
207  * On exception, returns 0.
208  *
209  * If there is a limit on the length of a valid string, you may wish to
210  * consider using strnlen_user() instead.
211  */
212 #define strlen_user(str) strnlen_user(str, LONG_MAX)
213
214 long strnlen_user(const char __user *str, long n);
215 unsigned long __must_check clear_user(void __user *mem, unsigned long len);
216 unsigned long __must_check __clear_user(void __user *mem, unsigned long len);
217
218 #endif /* __i386_UACCESS_H */