diff options
Diffstat (limited to 'include/asm-sparc64/uaccess.h')
-rw-r--r-- | include/asm-sparc64/uaccess.h | 335 |
1 files changed, 335 insertions, 0 deletions
diff --git a/include/asm-sparc64/uaccess.h b/include/asm-sparc64/uaccess.h new file mode 100644 index 000000000000..5690142f82de --- /dev/null +++ b/include/asm-sparc64/uaccess.h | |||
@@ -0,0 +1,335 @@ | |||
1 | /* $Id: uaccess.h,v 1.35 2002/02/09 19:49:31 davem Exp $ */ | ||
2 | #ifndef _ASM_UACCESS_H | ||
3 | #define _ASM_UACCESS_H | ||
4 | |||
5 | /* | ||
6 | * User space memory access functions | ||
7 | */ | ||
8 | |||
9 | #ifdef __KERNEL__ | ||
10 | #include <linux/compiler.h> | ||
11 | #include <linux/sched.h> | ||
12 | #include <linux/string.h> | ||
13 | #include <asm/a.out.h> | ||
14 | #include <asm/asi.h> | ||
15 | #include <asm/system.h> | ||
16 | #include <asm/spitfire.h> | ||
17 | #include <asm-generic/uaccess.h> | ||
18 | #endif | ||
19 | |||
20 | #ifndef __ASSEMBLY__ | ||
21 | |||
22 | /* | ||
23 | * Sparc64 is segmented, though more like the M68K than the I386. | ||
24 | * We use the secondary ASI to address user memory, which references a | ||
25 | * completely different VM map, thus there is zero chance of the user | ||
26 | * doing something queer and tricking us into poking kernel memory. | ||
27 | * | ||
28 | * What is left here is basically what is needed for the other parts of | ||
29 | * the kernel that expect to be able to manipulate, erum, "segments". | ||
30 | * Or perhaps more properly, permissions. | ||
31 | * | ||
32 | * "For historical reasons, these macros are grossly misnamed." -Linus | ||
33 | */ | ||
34 | |||
35 | #define KERNEL_DS ((mm_segment_t) { ASI_P }) | ||
36 | #define USER_DS ((mm_segment_t) { ASI_AIUS }) /* har har har */ | ||
37 | |||
38 | #define VERIFY_READ 0 | ||
39 | #define VERIFY_WRITE 1 | ||
40 | |||
41 | #define get_fs() ((mm_segment_t) { get_thread_current_ds() }) | ||
42 | #define get_ds() (KERNEL_DS) | ||
43 | |||
44 | #define segment_eq(a,b) ((a).seg == (b).seg) | ||
45 | |||
46 | #define set_fs(val) \ | ||
47 | do { \ | ||
48 | set_thread_current_ds((val).seg); \ | ||
49 | __asm__ __volatile__ ("wr %%g0, %0, %%asi" : : "r" ((val).seg)); \ | ||
50 | } while(0) | ||
51 | |||
52 | static inline int __access_ok(const void __user * addr, unsigned long size) | ||
53 | { | ||
54 | return 1; | ||
55 | } | ||
56 | |||
57 | static inline int access_ok(int type, const void __user * addr, unsigned long size) | ||
58 | { | ||
59 | return 1; | ||
60 | } | ||
61 | |||
62 | /* this function will go away soon - use access_ok() instead */ | ||
63 | static inline int __deprecated verify_area(int type, const void __user * addr, unsigned long size) | ||
64 | { | ||
65 | return 0; | ||
66 | } | ||
67 | |||
68 | /* | ||
69 | * The exception table consists of pairs of addresses: the first is the | ||
70 | * address of an instruction that is allowed to fault, and the second is | ||
71 | * the address at which the program should continue. No registers are | ||
72 | * modified, so it is entirely up to the continuation code to figure out | ||
73 | * what to do. | ||
74 | * | ||
75 | * All the routines below use bits of fixup code that are out of line | ||
76 | * with the main instruction path. This means when everything is well, | ||
77 | * we don't even have to jump over them. Further, they do not intrude | ||
78 | * on our cache or tlb entries. | ||
79 | * | ||
80 | * There is a special way how to put a range of potentially faulting | ||
81 | * insns (like twenty ldd/std's with now intervening other instructions) | ||
82 | * You specify address of first in insn and 0 in fixup and in the next | ||
83 | * exception_table_entry you specify last potentially faulting insn + 1 | ||
84 | * and in fixup the routine which should handle the fault. | ||
85 | * That fixup code will get | ||
86 | * (faulting_insn_address - first_insn_in_the_range_address)/4 | ||
87 | * in %g2 (ie. index of the faulting instruction in the range). | ||
88 | */ | ||
89 | |||
90 | struct exception_table_entry | ||
91 | { | ||
92 | unsigned insn, fixup; | ||
93 | }; | ||
94 | |||
95 | /* Special exable search, which handles ranges. Returns fixup */ | ||
96 | unsigned long search_extables_range(unsigned long addr, unsigned long *g2); | ||
97 | |||
98 | extern void __ret_efault(void); | ||
99 | |||
100 | /* Uh, these should become the main single-value transfer routines.. | ||
101 | * They automatically use the right size if we just have the right | ||
102 | * pointer type.. | ||
103 | * | ||
104 | * This gets kind of ugly. We want to return _two_ values in "get_user()" | ||
105 | * and yet we don't want to do any pointers, because that is too much | ||
106 | * of a performance impact. Thus we have a few rather ugly macros here, | ||
107 | * and hide all the ugliness from the user. | ||
108 | */ | ||
109 | #define put_user(x,ptr) ({ \ | ||
110 | unsigned long __pu_addr = (unsigned long)(ptr); \ | ||
111 | __chk_user_ptr(ptr); \ | ||
112 | __put_user_nocheck((__typeof__(*(ptr)))(x),__pu_addr,sizeof(*(ptr))); }) | ||
113 | |||
114 | #define get_user(x,ptr) ({ \ | ||
115 | unsigned long __gu_addr = (unsigned long)(ptr); \ | ||
116 | __chk_user_ptr(ptr); \ | ||
117 | __get_user_nocheck((x),__gu_addr,sizeof(*(ptr)),__typeof__(*(ptr))); }) | ||
118 | |||
119 | #define __put_user(x,ptr) put_user(x,ptr) | ||
120 | #define __get_user(x,ptr) get_user(x,ptr) | ||
121 | |||
122 | struct __large_struct { unsigned long buf[100]; }; | ||
123 | #define __m(x) ((struct __large_struct *)(x)) | ||
124 | |||
125 | #define __put_user_nocheck(data,addr,size) ({ \ | ||
126 | register int __pu_ret; \ | ||
127 | switch (size) { \ | ||
128 | case 1: __put_user_asm(data,b,addr,__pu_ret); break; \ | ||
129 | case 2: __put_user_asm(data,h,addr,__pu_ret); break; \ | ||
130 | case 4: __put_user_asm(data,w,addr,__pu_ret); break; \ | ||
131 | case 8: __put_user_asm(data,x,addr,__pu_ret); break; \ | ||
132 | default: __pu_ret = __put_user_bad(); break; \ | ||
133 | } __pu_ret; }) | ||
134 | |||
135 | #define __put_user_nocheck_ret(data,addr,size,retval) ({ \ | ||
136 | register int __foo __asm__ ("l1"); \ | ||
137 | switch (size) { \ | ||
138 | case 1: __put_user_asm_ret(data,b,addr,retval,__foo); break; \ | ||
139 | case 2: __put_user_asm_ret(data,h,addr,retval,__foo); break; \ | ||
140 | case 4: __put_user_asm_ret(data,w,addr,retval,__foo); break; \ | ||
141 | case 8: __put_user_asm_ret(data,x,addr,retval,__foo); break; \ | ||
142 | default: if (__put_user_bad()) return retval; break; \ | ||
143 | } }) | ||
144 | |||
145 | #define __put_user_asm(x,size,addr,ret) \ | ||
146 | __asm__ __volatile__( \ | ||
147 | "/* Put user asm, inline. */\n" \ | ||
148 | "1:\t" "st"#size "a %1, [%2] %%asi\n\t" \ | ||
149 | "clr %0\n" \ | ||
150 | "2:\n\n\t" \ | ||
151 | ".section .fixup,#alloc,#execinstr\n\t" \ | ||
152 | ".align 4\n" \ | ||
153 | "3:\n\t" \ | ||
154 | "b 2b\n\t" \ | ||
155 | " mov %3, %0\n\n\t" \ | ||
156 | ".previous\n\t" \ | ||
157 | ".section __ex_table,#alloc\n\t" \ | ||
158 | ".align 4\n\t" \ | ||
159 | ".word 1b, 3b\n\t" \ | ||
160 | ".previous\n\n\t" \ | ||
161 | : "=r" (ret) : "r" (x), "r" (__m(addr)), \ | ||
162 | "i" (-EFAULT)) | ||
163 | |||
164 | #define __put_user_asm_ret(x,size,addr,ret,foo) \ | ||
165 | if (__builtin_constant_p(ret) && ret == -EFAULT) \ | ||
166 | __asm__ __volatile__( \ | ||
167 | "/* Put user asm ret, inline. */\n" \ | ||
168 | "1:\t" "st"#size "a %1, [%2] %%asi\n\n\t" \ | ||
169 | ".section __ex_table,#alloc\n\t" \ | ||
170 | ".align 4\n\t" \ | ||
171 | ".word 1b, __ret_efault\n\n\t" \ | ||
172 | ".previous\n\n\t" \ | ||
173 | : "=r" (foo) : "r" (x), "r" (__m(addr))); \ | ||
174 | else \ | ||
175 | __asm__ __volatile__( \ | ||
176 | "/* Put user asm ret, inline. */\n" \ | ||
177 | "1:\t" "st"#size "a %1, [%2] %%asi\n\n\t" \ | ||
178 | ".section .fixup,#alloc,#execinstr\n\t" \ | ||
179 | ".align 4\n" \ | ||
180 | "3:\n\t" \ | ||
181 | "ret\n\t" \ | ||
182 | " restore %%g0, %3, %%o0\n\n\t" \ | ||
183 | ".previous\n\t" \ | ||
184 | ".section __ex_table,#alloc\n\t" \ | ||
185 | ".align 4\n\t" \ | ||
186 | ".word 1b, 3b\n\n\t" \ | ||
187 | ".previous\n\n\t" \ | ||
188 | : "=r" (foo) : "r" (x), "r" (__m(addr)), \ | ||
189 | "i" (ret)) | ||
190 | |||
191 | extern int __put_user_bad(void); | ||
192 | |||
193 | #define __get_user_nocheck(data,addr,size,type) ({ \ | ||
194 | register int __gu_ret; \ | ||
195 | register unsigned long __gu_val; \ | ||
196 | switch (size) { \ | ||
197 | case 1: __get_user_asm(__gu_val,ub,addr,__gu_ret); break; \ | ||
198 | case 2: __get_user_asm(__gu_val,uh,addr,__gu_ret); break; \ | ||
199 | case 4: __get_user_asm(__gu_val,uw,addr,__gu_ret); break; \ | ||
200 | case 8: __get_user_asm(__gu_val,x,addr,__gu_ret); break; \ | ||
201 | default: __gu_val = 0; __gu_ret = __get_user_bad(); break; \ | ||
202 | } data = (type) __gu_val; __gu_ret; }) | ||
203 | |||
204 | #define __get_user_nocheck_ret(data,addr,size,type,retval) ({ \ | ||
205 | register unsigned long __gu_val __asm__ ("l1"); \ | ||
206 | switch (size) { \ | ||
207 | case 1: __get_user_asm_ret(__gu_val,ub,addr,retval); break; \ | ||
208 | case 2: __get_user_asm_ret(__gu_val,uh,addr,retval); break; \ | ||
209 | case 4: __get_user_asm_ret(__gu_val,uw,addr,retval); break; \ | ||
210 | case 8: __get_user_asm_ret(__gu_val,x,addr,retval); break; \ | ||
211 | default: if (__get_user_bad()) return retval; \ | ||
212 | } data = (type) __gu_val; }) | ||
213 | |||
214 | #define __get_user_asm(x,size,addr,ret) \ | ||
215 | __asm__ __volatile__( \ | ||
216 | "/* Get user asm, inline. */\n" \ | ||
217 | "1:\t" "ld"#size "a [%2] %%asi, %1\n\t" \ | ||
218 | "clr %0\n" \ | ||
219 | "2:\n\n\t" \ | ||
220 | ".section .fixup,#alloc,#execinstr\n\t" \ | ||
221 | ".align 4\n" \ | ||
222 | "3:\n\t" \ | ||
223 | "clr %1\n\t" \ | ||
224 | "b 2b\n\t" \ | ||
225 | " mov %3, %0\n\n\t" \ | ||
226 | ".previous\n\t" \ | ||
227 | ".section __ex_table,#alloc\n\t" \ | ||
228 | ".align 4\n\t" \ | ||
229 | ".word 1b, 3b\n\n\t" \ | ||
230 | ".previous\n\t" \ | ||
231 | : "=r" (ret), "=r" (x) : "r" (__m(addr)), \ | ||
232 | "i" (-EFAULT)) | ||
233 | |||
234 | #define __get_user_asm_ret(x,size,addr,retval) \ | ||
235 | if (__builtin_constant_p(retval) && retval == -EFAULT) \ | ||
236 | __asm__ __volatile__( \ | ||
237 | "/* Get user asm ret, inline. */\n" \ | ||
238 | "1:\t" "ld"#size "a [%1] %%asi, %0\n\n\t" \ | ||
239 | ".section __ex_table,#alloc\n\t" \ | ||
240 | ".align 4\n\t" \ | ||
241 | ".word 1b,__ret_efault\n\n\t" \ | ||
242 | ".previous\n\t" \ | ||
243 | : "=r" (x) : "r" (__m(addr))); \ | ||
244 | else \ | ||
245 | __asm__ __volatile__( \ | ||
246 | "/* Get user asm ret, inline. */\n" \ | ||
247 | "1:\t" "ld"#size "a [%1] %%asi, %0\n\n\t" \ | ||
248 | ".section .fixup,#alloc,#execinstr\n\t" \ | ||
249 | ".align 4\n" \ | ||
250 | "3:\n\t" \ | ||
251 | "ret\n\t" \ | ||
252 | " restore %%g0, %2, %%o0\n\n\t" \ | ||
253 | ".previous\n\t" \ | ||
254 | ".section __ex_table,#alloc\n\t" \ | ||
255 | ".align 4\n\t" \ | ||
256 | ".word 1b, 3b\n\n\t" \ | ||
257 | ".previous\n\t" \ | ||
258 | : "=r" (x) : "r" (__m(addr)), "i" (retval)) | ||
259 | |||
260 | extern int __get_user_bad(void); | ||
261 | |||
262 | extern unsigned long __must_check ___copy_from_user(void *to, | ||
263 | const void __user *from, | ||
264 | unsigned long size); | ||
265 | extern unsigned long copy_from_user_fixup(void *to, const void __user *from, | ||
266 | unsigned long size); | ||
267 | static inline unsigned long __must_check | ||
268 | copy_from_user(void *to, const void __user *from, unsigned long size) | ||
269 | { | ||
270 | unsigned long ret = ___copy_from_user(to, from, size); | ||
271 | |||
272 | if (ret) | ||
273 | ret = copy_from_user_fixup(to, from, size); | ||
274 | return ret; | ||
275 | } | ||
276 | #define __copy_from_user copy_from_user | ||
277 | |||
278 | extern unsigned long __must_check ___copy_to_user(void __user *to, | ||
279 | const void *from, | ||
280 | unsigned long size); | ||
281 | extern unsigned long copy_to_user_fixup(void __user *to, const void *from, | ||
282 | unsigned long size); | ||
283 | static inline unsigned long __must_check | ||
284 | copy_to_user(void __user *to, const void *from, unsigned long size) | ||
285 | { | ||
286 | unsigned long ret = ___copy_to_user(to, from, size); | ||
287 | |||
288 | if (ret) | ||
289 | ret = copy_to_user_fixup(to, from, size); | ||
290 | return ret; | ||
291 | } | ||
292 | #define __copy_to_user copy_to_user | ||
293 | |||
294 | extern unsigned long __must_check ___copy_in_user(void __user *to, | ||
295 | const void __user *from, | ||
296 | unsigned long size); | ||
297 | extern unsigned long copy_in_user_fixup(void __user *to, void __user *from, | ||
298 | unsigned long size); | ||
299 | static inline unsigned long __must_check | ||
300 | copy_in_user(void __user *to, void __user *from, unsigned long size) | ||
301 | { | ||
302 | unsigned long ret = ___copy_in_user(to, from, size); | ||
303 | |||
304 | if (ret) | ||
305 | ret = copy_in_user_fixup(to, from, size); | ||
306 | return ret; | ||
307 | } | ||
308 | #define __copy_in_user copy_in_user | ||
309 | |||
310 | extern unsigned long __must_check __bzero_noasi(void __user *, unsigned long); | ||
311 | |||
312 | static inline unsigned long __must_check | ||
313 | __clear_user(void __user *addr, unsigned long size) | ||
314 | { | ||
315 | |||
316 | return __bzero_noasi(addr, size); | ||
317 | } | ||
318 | |||
319 | #define clear_user __clear_user | ||
320 | |||
321 | extern long __must_check __strncpy_from_user(char *dest, const char __user *src, long count); | ||
322 | |||
323 | #define strncpy_from_user __strncpy_from_user | ||
324 | |||
325 | extern long __strlen_user(const char __user *); | ||
326 | extern long __strnlen_user(const char __user *, long len); | ||
327 | |||
328 | #define strlen_user __strlen_user | ||
329 | #define strnlen_user __strnlen_user | ||
330 | #define __copy_to_user_inatomic __copy_to_user | ||
331 | #define __copy_from_user_inatomic __copy_from_user | ||
332 | |||
333 | #endif /* __ASSEMBLY__ */ | ||
334 | |||
335 | #endif /* _ASM_UACCESS_H */ | ||