1/*
2 * Copyright (C) 2008-2009 Michal Simek <monstr@monstr.eu>
3 * Copyright (C) 2008-2009 PetaLogix
4 * Copyright (C) 2006 Atmark Techno, Inc.
5 *
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License. See the file "COPYING" in the main directory of this archive
8 * for more details.
9 */
10
11#ifndef _ASM_MICROBLAZE_UACCESS_H
12#define _ASM_MICROBLAZE_UACCESS_H
13
14#ifdef __KERNEL__
15#ifndef __ASSEMBLY__
16
17#include <linux/kernel.h>
18#include <linux/errno.h>
19#include <linux/sched.h> /* RLIMIT_FSIZE */
20#include <linux/mm.h>
21
22#include <asm/mmu.h>
23#include <asm/page.h>
24#include <asm/pgtable.h>
25#include <linux/string.h>
26
27#define VERIFY_READ	0
28#define VERIFY_WRITE	1
29
30/*
31 * On Microblaze the fs value is actually the top of the corresponding
32 * address space.
33 *
34 * The fs value determines whether argument validity checking should be
35 * performed or not. If get_fs() == USER_DS, checking is performed, with
36 * get_fs() == KERNEL_DS, checking is bypassed.
37 *
38 * For historical reasons, these macros are grossly misnamed.
39 *
40 * For non-MMU arch like Microblaze, KERNEL_DS and USER_DS is equal.
41 */
42# define MAKE_MM_SEG(s)       ((mm_segment_t) { (s) })
43
44#  ifndef CONFIG_MMU
45#  define KERNEL_DS	MAKE_MM_SEG(0)
46#  define USER_DS	KERNEL_DS
47#  else
48#  define KERNEL_DS	MAKE_MM_SEG(0xFFFFFFFF)
49#  define USER_DS	MAKE_MM_SEG(TASK_SIZE - 1)
50#  endif
51
52# define get_ds()	(KERNEL_DS)
53# define get_fs()	(current_thread_info()->addr_limit)
54# define set_fs(val)	(current_thread_info()->addr_limit = (val))
55
56# define segment_eq(a, b)	((a).seg == (b).seg)
57
58/*
59 * The exception table consists of pairs of addresses: the first is the
60 * address of an instruction that is allowed to fault, and the second is
61 * the address at which the program should continue. No registers are
62 * modified, so it is entirely up to the continuation code to figure out
63 * what to do.
64 *
65 * All the routines below use bits of fixup code that are out of line
66 * with the main instruction path. This means when everything is well,
67 * we don't even have to jump over them. Further, they do not intrude
68 * on our cache or tlb entries.
69 */
70struct exception_table_entry {
71	unsigned long insn, fixup;
72};
73
74/* Returns 0 if exception not found and fixup otherwise.  */
75extern unsigned long search_exception_table(unsigned long);
76
77#ifndef CONFIG_MMU
78
79/* Check against bounds of physical memory */
80static inline int ___range_ok(unsigned long addr, unsigned long size)
81{
82	return ((addr < memory_start) ||
83		((addr + size - 1) > (memory_start + memory_size - 1)));
84}
85
86#define __range_ok(addr, size) \
87		___range_ok((unsigned long)(addr), (unsigned long)(size))
88
89#define access_ok(type, addr, size) (__range_ok((addr), (size)) == 0)
90
91#else
92
93static inline int access_ok(int type, const void __user *addr,
94							unsigned long size)
95{
96	if (!size)
97		goto ok;
98
99	if ((get_fs().seg < ((unsigned long)addr)) ||
100			(get_fs().seg < ((unsigned long)addr + size - 1))) {
101		pr_devel("ACCESS fail: %s at 0x%08x (size 0x%x), seg 0x%08x\n",
102			type ? "WRITE" : "READ ", (__force u32)addr, (u32)size,
103			(u32)get_fs().seg);
104		return 0;
105	}
106ok:
107	pr_devel("ACCESS OK: %s at 0x%08x (size 0x%x), seg 0x%08x\n",
108			type ? "WRITE" : "READ ", (__force u32)addr, (u32)size,
109			(u32)get_fs().seg);
110	return 1;
111}
112#endif
113
114#ifdef CONFIG_MMU
115# define __FIXUP_SECTION	".section .fixup,\"ax\"\n"
116# define __EX_TABLE_SECTION	".section __ex_table,\"a\"\n"
117#else
118# define __FIXUP_SECTION	".section .discard,\"ax\"\n"
119# define __EX_TABLE_SECTION	".section .discard,\"ax\"\n"
120#endif
121
122extern unsigned long __copy_tofrom_user(void __user *to,
123		const void __user *from, unsigned long size);
124
125/* Return: number of not copied bytes, i.e. 0 if OK or non-zero if fail. */
126static inline unsigned long __must_check __clear_user(void __user *to,
127							unsigned long n)
128{
129	/* normal memset with two words to __ex_table */
130	__asm__ __volatile__ (				\
131			"1:	sb	r0, %1, r0;"	\
132			"	addik	%0, %0, -1;"	\
133			"	bneid	%0, 1b;"	\
134			"	addik	%1, %1, 1;"	\
135			"2:			"	\
136			__EX_TABLE_SECTION		\
137			".word	1b,2b;"			\
138			".previous;"			\
139		: "=r"(n), "=r"(to)			\
140		: "0"(n), "1"(to)
141	);
142	return n;
143}
144
145static inline unsigned long __must_check clear_user(void __user *to,
146							unsigned long n)
147{
148	might_fault();
149	if (unlikely(!access_ok(VERIFY_WRITE, to, n)))
150		return n;
151
152	return __clear_user(to, n);
153}
154
155/* put_user and get_user macros */
156extern long __user_bad(void);
157
158#define __get_user_asm(insn, __gu_ptr, __gu_val, __gu_err)	\
159({								\
160	__asm__ __volatile__ (					\
161			"1:"	insn	" %1, %2, r0;"		\
162			"	addk	%0, r0, r0;"		\
163			"2:			"		\
164			__FIXUP_SECTION				\
165			"3:	brid	2b;"			\
166			"	addik	%0, r0, %3;"		\
167			".previous;"				\
168			__EX_TABLE_SECTION			\
169			".word	1b,3b;"				\
170			".previous;"				\
171		: "=&r"(__gu_err), "=r"(__gu_val)		\
172		: "r"(__gu_ptr), "i"(-EFAULT)			\
173	);							\
174})
175
176/**
177 * get_user: - Get a simple variable from user space.
178 * @x:   Variable to store result.
179 * @ptr: Source address, in user space.
180 *
181 * Context: User context only.  This function may sleep.
182 *
183 * This macro copies a single simple variable from user space to kernel
184 * space.  It supports simple types like char and int, but not larger
185 * data types like structures or arrays.
186 *
187 * @ptr must have pointer-to-simple-variable type, and the result of
188 * dereferencing @ptr must be assignable to @x without a cast.
189 *
190 * Returns zero on success, or -EFAULT on error.
191 * On error, the variable @x is set to zero.
192 */
193#define get_user(x, ptr)						\
194	__get_user_check((x), (ptr), sizeof(*(ptr)))
195
196#define __get_user_check(x, ptr, size)					\
197({									\
198	unsigned long __gu_val = 0;					\
199	const typeof(*(ptr)) __user *__gu_addr = (ptr);			\
200	int __gu_err = 0;						\
201									\
202	if (access_ok(VERIFY_READ, __gu_addr, size)) {			\
203		switch (size) {						\
204		case 1:							\
205			__get_user_asm("lbu", __gu_addr, __gu_val,	\
206				       __gu_err);			\
207			break;						\
208		case 2:							\
209			__get_user_asm("lhu", __gu_addr, __gu_val,	\
210				       __gu_err);			\
211			break;						\
212		case 4:							\
213			__get_user_asm("lw", __gu_addr, __gu_val,	\
214				       __gu_err);			\
215			break;						\
216		default:						\
217			__gu_err = __user_bad();			\
218			break;						\
219		}							\
220	} else {							\
221		__gu_err = -EFAULT;					\
222	}								\
223	x = (__force typeof(*(ptr)))__gu_val;				\
224	__gu_err;							\
225})
226
227#define __get_user(x, ptr)						\
228({									\
229	unsigned long __gu_val;						\
230	/*unsigned long __gu_ptr = (unsigned long)(ptr);*/		\
231	long __gu_err;							\
232	switch (sizeof(*(ptr))) {					\
233	case 1:								\
234		__get_user_asm("lbu", (ptr), __gu_val, __gu_err);	\
235		break;							\
236	case 2:								\
237		__get_user_asm("lhu", (ptr), __gu_val, __gu_err);	\
238		break;							\
239	case 4:								\
240		__get_user_asm("lw", (ptr), __gu_val, __gu_err);	\
241		break;							\
242	default:							\
243		/* __gu_val = 0; __gu_err = -EINVAL;*/ __gu_err = __user_bad();\
244	}								\
245	x = (__force __typeof__(*(ptr))) __gu_val;			\
246	__gu_err;							\
247})
248
249
250#define __put_user_asm(insn, __gu_ptr, __gu_val, __gu_err)	\
251({								\
252	__asm__ __volatile__ (					\
253			"1:"	insn	" %1, %2, r0;"		\
254			"	addk	%0, r0, r0;"		\
255			"2:			"		\
256			__FIXUP_SECTION				\
257			"3:	brid	2b;"			\
258			"	addik	%0, r0, %3;"		\
259			".previous;"				\
260			__EX_TABLE_SECTION			\
261			".word	1b,3b;"				\
262			".previous;"				\
263		: "=&r"(__gu_err)				\
264		: "r"(__gu_val), "r"(__gu_ptr), "i"(-EFAULT)	\
265	);							\
266})
267
268#define __put_user_asm_8(__gu_ptr, __gu_val, __gu_err)		\
269({								\
270	__asm__ __volatile__ ("	lwi	%0, %1, 0;"		\
271			"1:	swi	%0, %2, 0;"		\
272			"	lwi	%0, %1, 4;"		\
273			"2:	swi	%0, %2, 4;"		\
274			"	addk	%0, r0, r0;"		\
275			"3:			"		\
276			__FIXUP_SECTION				\
277			"4:	brid	3b;"			\
278			"	addik	%0, r0, %3;"		\
279			".previous;"				\
280			__EX_TABLE_SECTION			\
281			".word	1b,4b,2b,4b;"			\
282			".previous;"				\
283		: "=&r"(__gu_err)				\
284		: "r"(&__gu_val), "r"(__gu_ptr), "i"(-EFAULT)	\
285		);						\
286})
287
288/**
289 * put_user: - Write a simple value into user space.
290 * @x:   Value to copy to user space.
291 * @ptr: Destination address, in user space.
292 *
293 * Context: User context only.  This function may sleep.
294 *
295 * This macro copies a single simple value from kernel space to user
296 * space.  It supports simple types like char and int, but not larger
297 * data types like structures or arrays.
298 *
299 * @ptr must have pointer-to-simple-variable type, and @x must be assignable
300 * to the result of dereferencing @ptr.
301 *
302 * Returns zero on success, or -EFAULT on error.
303 */
304#define put_user(x, ptr)						\
305	__put_user_check((x), (ptr), sizeof(*(ptr)))
306
307#define __put_user_check(x, ptr, size)					\
308({									\
309	typeof(*(ptr)) volatile __pu_val = x;				\
310	typeof(*(ptr)) __user *__pu_addr = (ptr);			\
311	int __pu_err = 0;						\
312									\
313	if (access_ok(VERIFY_WRITE, __pu_addr, size)) {			\
314		switch (size) {						\
315		case 1:							\
316			__put_user_asm("sb", __pu_addr, __pu_val,	\
317				       __pu_err);			\
318			break;						\
319		case 2:							\
320			__put_user_asm("sh", __pu_addr, __pu_val,	\
321				       __pu_err);			\
322			break;						\
323		case 4:							\
324			__put_user_asm("sw", __pu_addr, __pu_val,	\
325				       __pu_err);			\
326			break;						\
327		case 8:							\
328			__put_user_asm_8(__pu_addr, __pu_val, __pu_err);\
329			break;						\
330		default:						\
331			__pu_err = __user_bad();			\
332			break;						\
333		}							\
334	} else {							\
335		__pu_err = -EFAULT;					\
336	}								\
337	__pu_err;							\
338})
339
340#define __put_user(x, ptr)						\
341({									\
342	__typeof__(*(ptr)) volatile __gu_val = (x);			\
343	long __gu_err = 0;						\
344	switch (sizeof(__gu_val)) {					\
345	case 1:								\
346		__put_user_asm("sb", (ptr), __gu_val, __gu_err);	\
347		break;							\
348	case 2:								\
349		__put_user_asm("sh", (ptr), __gu_val, __gu_err);	\
350		break;							\
351	case 4:								\
352		__put_user_asm("sw", (ptr), __gu_val, __gu_err);	\
353		break;							\
354	case 8:								\
355		__put_user_asm_8((ptr), __gu_val, __gu_err);		\
356		break;							\
357	default:							\
358		/*__gu_err = -EINVAL;*/	__gu_err = __user_bad();	\
359	}								\
360	__gu_err;							\
361})
362
363
364/* copy_to_from_user */
365#define __copy_from_user(to, from, n)	\
366	__copy_tofrom_user((__force void __user *)(to), \
367				(void __user *)(from), (n))
368#define __copy_from_user_inatomic(to, from, n) \
369		__copy_from_user((to), (from), (n))
370
371static inline long copy_from_user(void *to,
372		const void __user *from, unsigned long n)
373{
374	might_fault();
375	if (access_ok(VERIFY_READ, from, n))
376		return __copy_from_user(to, from, n);
377	return n;
378}
379
380#define __copy_to_user(to, from, n)	\
381		__copy_tofrom_user((void __user *)(to), \
382			(__force const void __user *)(from), (n))
383#define __copy_to_user_inatomic(to, from, n) __copy_to_user((to), (from), (n))
384
385static inline long copy_to_user(void __user *to,
386		const void *from, unsigned long n)
387{
388	might_fault();
389	if (access_ok(VERIFY_WRITE, to, n))
390		return __copy_to_user(to, from, n);
391	return n;
392}
393
394/*
395 * Copy a null terminated string from userspace.
396 */
397extern int __strncpy_user(char *to, const char __user *from, int len);
398
399#define __strncpy_from_user	__strncpy_user
400
401static inline long
402strncpy_from_user(char *dst, const char __user *src, long count)
403{
404	if (!access_ok(VERIFY_READ, src, 1))
405		return -EFAULT;
406	return __strncpy_from_user(dst, src, count);
407}
408
409/*
410 * Return the size of a string (including the ending 0)
411 *
412 * Return 0 on exception, a value greater than N if too long
413 */
414extern int __strnlen_user(const char __user *sstr, int len);
415
416static inline long strnlen_user(const char __user *src, long n)
417{
418	if (!access_ok(VERIFY_READ, src, 1))
419		return 0;
420	return __strnlen_user(src, n);
421}
422
423#endif  /* __ASSEMBLY__ */
424#endif /* __KERNEL__ */
425
426#endif /* _ASM_MICROBLAZE_UACCESS_H */
427