1
2
3
4
5
6
7
8
9#ifndef __S390_UACCESS_H
10#define __S390_UACCESS_H
11
12
13
14
15#include <linux/sched.h>
16#include <linux/errno.h>
17#include <asm/ctl_reg.h>
18
19#define VERIFY_READ 0
20#define VERIFY_WRITE 1
21
22
23
24
25
26
27
28
29
30
31#define MAKE_MM_SEG(a) ((mm_segment_t) { (a) })
32
33
34#define KERNEL_DS MAKE_MM_SEG(0)
35#define USER_DS MAKE_MM_SEG(1)
36
37#define get_ds() (KERNEL_DS)
38#define get_fs() (current->thread.mm_segment)
39
40#define set_fs(x) \
41({ \
42 unsigned long __pto; \
43 current->thread.mm_segment = (x); \
44 __pto = current->thread.mm_segment.ar4 ? \
45 S390_lowcore.user_asce : S390_lowcore.kernel_asce; \
46 __ctl_load(__pto, 7, 7); \
47})
48
49#define segment_eq(a,b) ((a).ar4 == (b).ar4)
50
51static inline int __range_ok(unsigned long addr, unsigned long size)
52{
53 return 1;
54}
55
56#define __access_ok(addr, size) \
57({ \
58 __chk_user_ptr(addr); \
59 __range_ok((unsigned long)(addr), (size)); \
60})
61
62#define access_ok(type, addr, size) __access_ok(addr, size)
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77struct exception_table_entry
78{
79 int insn, fixup;
80};
81
82static inline unsigned long extable_insn(const struct exception_table_entry *x)
83{
84 return (unsigned long)&x->insn + x->insn;
85}
86
87static inline unsigned long extable_fixup(const struct exception_table_entry *x)
88{
89 return (unsigned long)&x->fixup + x->fixup;
90}
91
92#define ARCH_HAS_SORT_EXTABLE
93#define ARCH_HAS_SEARCH_EXTABLE
94
95struct uaccess_ops {
96 size_t (*copy_from_user)(size_t, const void __user *, void *);
97 size_t (*copy_from_user_small)(size_t, const void __user *, void *);
98 size_t (*copy_to_user)(size_t, void __user *, const void *);
99 size_t (*copy_to_user_small)(size_t, void __user *, const void *);
100 size_t (*copy_in_user)(size_t, void __user *, const void __user *);
101 size_t (*clear_user)(size_t, void __user *);
102 size_t (*strnlen_user)(size_t, const char __user *);
103 size_t (*strncpy_from_user)(size_t, const char __user *, char *);
104 int (*futex_atomic_op)(int op, u32 __user *, int oparg, int *old);
105 int (*futex_atomic_cmpxchg)(u32 *, u32 __user *, u32 old, u32 new);
106};
107
108extern struct uaccess_ops uaccess;
109extern struct uaccess_ops uaccess_std;
110extern struct uaccess_ops uaccess_mvcos;
111extern struct uaccess_ops uaccess_mvcos_switch;
112extern struct uaccess_ops uaccess_pt;
113
114extern int __handle_fault(unsigned long, unsigned long, int);
115
116static inline int __put_user_fn(size_t size, void __user *ptr, void *x)
117{
118 size = uaccess.copy_to_user_small(size, ptr, x);
119 return size ? -EFAULT : size;
120}
121
122static inline int __get_user_fn(size_t size, const void __user *ptr, void *x)
123{
124 size = uaccess.copy_from_user_small(size, ptr, x);
125 return size ? -EFAULT : size;
126}
127
128
129
130
131
132#define __put_user(x, ptr) \
133({ \
134 __typeof__(*(ptr)) __x = (x); \
135 int __pu_err = -EFAULT; \
136 __chk_user_ptr(ptr); \
137 switch (sizeof (*(ptr))) { \
138 case 1: \
139 case 2: \
140 case 4: \
141 case 8: \
142 __pu_err = __put_user_fn(sizeof (*(ptr)), \
143 ptr, &__x); \
144 break; \
145 default: \
146 __put_user_bad(); \
147 break; \
148 } \
149 __pu_err; \
150})
151
152#define put_user(x, ptr) \
153({ \
154 might_fault(); \
155 __put_user(x, ptr); \
156})
157
158
159extern int __put_user_bad(void) __attribute__((noreturn));
160
161#define __get_user(x, ptr) \
162({ \
163 int __gu_err = -EFAULT; \
164 __chk_user_ptr(ptr); \
165 switch (sizeof(*(ptr))) { \
166 case 1: { \
167 unsigned char __x; \
168 __gu_err = __get_user_fn(sizeof (*(ptr)), \
169 ptr, &__x); \
170 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
171 break; \
172 }; \
173 case 2: { \
174 unsigned short __x; \
175 __gu_err = __get_user_fn(sizeof (*(ptr)), \
176 ptr, &__x); \
177 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
178 break; \
179 }; \
180 case 4: { \
181 unsigned int __x; \
182 __gu_err = __get_user_fn(sizeof (*(ptr)), \
183 ptr, &__x); \
184 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
185 break; \
186 }; \
187 case 8: { \
188 unsigned long long __x; \
189 __gu_err = __get_user_fn(sizeof (*(ptr)), \
190 ptr, &__x); \
191 (x) = *(__force __typeof__(*(ptr)) *) &__x; \
192 break; \
193 }; \
194 default: \
195 __get_user_bad(); \
196 break; \
197 } \
198 __gu_err; \
199})
200
201#define get_user(x, ptr) \
202({ \
203 might_fault(); \
204 __get_user(x, ptr); \
205})
206
207extern int __get_user_bad(void) __attribute__((noreturn));
208
209#define __put_user_unaligned __put_user
210#define __get_user_unaligned __get_user
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226static inline unsigned long __must_check
227__copy_to_user(void __user *to, const void *from, unsigned long n)
228{
229 if (__builtin_constant_p(n) && (n <= 256))
230 return uaccess.copy_to_user_small(n, to, from);
231 else
232 return uaccess.copy_to_user(n, to, from);
233}
234
235#define __copy_to_user_inatomic __copy_to_user
236#define __copy_from_user_inatomic __copy_from_user
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251static inline unsigned long __must_check
252copy_to_user(void __user *to, const void *from, unsigned long n)
253{
254 might_fault();
255 return __copy_to_user(to, from, n);
256}
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275static inline unsigned long __must_check
276__copy_from_user(void *to, const void __user *from, unsigned long n)
277{
278 if (__builtin_constant_p(n) && (n <= 256))
279 return uaccess.copy_from_user_small(n, from, to);
280 else
281 return uaccess.copy_from_user(n, from, to);
282}
283
284extern void copy_from_user_overflow(void)
285#ifdef CONFIG_DEBUG_STRICT_USER_COPY_CHECKS
286__compiletime_warning("copy_from_user() buffer size is not provably correct")
287#endif
288;
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306static inline unsigned long __must_check
307copy_from_user(void *to, const void __user *from, unsigned long n)
308{
309 unsigned int sz = __compiletime_object_size(to);
310
311 might_fault();
312 if (unlikely(sz != -1 && sz < n)) {
313 copy_from_user_overflow();
314 return n;
315 }
316 return __copy_from_user(to, from, n);
317}
318
319static inline unsigned long __must_check
320__copy_in_user(void __user *to, const void __user *from, unsigned long n)
321{
322 return uaccess.copy_in_user(n, to, from);
323}
324
325static inline unsigned long __must_check
326copy_in_user(void __user *to, const void __user *from, unsigned long n)
327{
328 might_fault();
329 return __copy_in_user(to, from, n);
330}
331
332
333
334
335static inline long __must_check
336strncpy_from_user(char *dst, const char __user *src, long count)
337{
338 might_fault();
339 return uaccess.strncpy_from_user(count, src, dst);
340}
341
342static inline unsigned long
343strnlen_user(const char __user * src, unsigned long n)
344{
345 might_fault();
346 return uaccess.strnlen_user(n, src);
347}
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363#define strlen_user(str) strnlen_user(str, ~0UL)
364
365
366
367
368
369static inline unsigned long __must_check
370__clear_user(void __user *to, unsigned long n)
371{
372 return uaccess.clear_user(n, to);
373}
374
375static inline unsigned long __must_check
376clear_user(void __user *to, unsigned long n)
377{
378 might_fault();
379 return uaccess.clear_user(n, to);
380}
381
382extern int copy_to_user_real(void __user *dest, void *src, size_t count);
383extern int copy_from_user_real(void *dest, void __user *src, size_t count);
384
385#endif
386