[mirror_ubuntu-hirsute-kernel.git] / arch / avr32 / include / asm / uaccess.h

/*
 * Copyright (C) 2004-2006 Atmel Corporation
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#ifndef __ASM_AVR32_UACCESS_H
#define __ASM_AVR32_UACCESS_H

#include <linux/errno.h>
#include <linux/sched.h>

#define VERIFY_READ	0
#define VERIFY_WRITE	1

typedef struct {
	unsigned int is_user_space;
} mm_segment_t;

/*
 * The fs value determines whether argument validity checking should be
 * performed or not.  If get_fs() == USER_DS, checking is performed, with
 * get_fs() == KERNEL_DS, checking is bypassed.
 *
 * For historical reasons (Data Segment Register?), these macros are misnamed.
 */
#define MAKE_MM_SEG(s)	((mm_segment_t) { (s) })
#define segment_eq(a, b)	((a).is_user_space == (b).is_user_space)

#define USER_ADDR_LIMIT 0x80000000

#define KERNEL_DS	MAKE_MM_SEG(0)
#define USER_DS		MAKE_MM_SEG(1)

#define get_ds()	(KERNEL_DS)

static inline mm_segment_t get_fs(void)
{
	return MAKE_MM_SEG(test_thread_flag(TIF_USERSPACE));
}

static inline void set_fs(mm_segment_t s)
{
	if (s.is_user_space)
		set_thread_flag(TIF_USERSPACE);
	else
		clear_thread_flag(TIF_USERSPACE);
}

/*
 * Test whether a block of memory is a valid user space address.
 * Returns 0 if the range is valid, nonzero otherwise.
 *
 * We do the following checks:
 *   1. Is the access from kernel space?
 *   2. Does (addr + size) set the carry bit?
 *   3. Is (addr + size) a negative number (i.e. >= 0x80000000)?
 *
 * If yes on the first check, access is granted.
 * If no on any of the others, access is denied.
 */
#define __range_ok(addr, size)						\
	(test_thread_flag(TIF_USERSPACE)				\
	 && (((unsigned long)(addr) >= 0x80000000)			\
	     || ((unsigned long)(size) > 0x80000000)			\
	     || (((unsigned long)(addr) + (unsigned long)(size)) > 0x80000000)))

#define access_ok(type, addr, size) (likely(__range_ok(addr, size) == 0))

/* Generic arbitrary sized copy. Return the number of bytes NOT copied */
extern __kernel_size_t __copy_user(void *to, const void *from,
				   __kernel_size_t n);

extern __kernel_size_t copy_to_user(void __user *to, const void *from,
				    __kernel_size_t n);
extern __kernel_size_t ___copy_from_user(void *to, const void __user *from,
				      __kernel_size_t n);

static inline __kernel_size_t __copy_to_user(void __user *to, const void *from,
					     __kernel_size_t n)
{
	return __copy_user((void __force *)to, from, n);
}
static inline __kernel_size_t __copy_from_user(void *to,
					       const void __user *from,
					       __kernel_size_t n)
{
	return __copy_user(to, (const void __force *)from, n);
}
static inline __kernel_size_t copy_from_user(void *to,
					       const void __user *from,
					       __kernel_size_t n)
{
	size_t res = ___copy_from_user(to, from, n);
	if (unlikely(res))
		memset(to + (n - res), 0, res);
	return res;
}

#define __copy_to_user_inatomic __copy_to_user
#define __copy_from_user_inatomic __copy_from_user

/*
 * put_user: - Write a simple value into user space.
 * @x:   Value to copy to user space.
 * @ptr: Destination address, in user space.
 *
 * Context: User context only. This function may sleep if pagefaults are
 *          enabled.
 *
 * This macro copies a single simple value from kernel space to user
 * space.  It supports simple types like char and int, but not larger
 * data types like structures or arrays.
 *
 * @ptr must have pointer-to-simple-variable type, and @x must be assignable
 * to the result of dereferencing @ptr.
 *
 * Returns zero on success, or -EFAULT on error.
 */
#define put_user(x, ptr)	\
	__put_user_check((x), (ptr), sizeof(*(ptr)))

/*
 * get_user: - Get a simple variable from user space.
 * @x:   Variable to store result.
 * @ptr: Source address, in user space.
 *
 * Context: User context only. This function may sleep if pagefaults are
 *          enabled.
 *
 * This macro copies a single simple variable from user space to kernel
 * space.  It supports simple types like char and int, but not larger
 * data types like structures or arrays.
 *
 * @ptr must have pointer-to-simple-variable type, and the result of
 * dereferencing @ptr must be assignable to @x without a cast.
 *
 * Returns zero on success, or -EFAULT on error.
 * On error, the variable @x is set to zero.
 */
#define get_user(x, ptr) \
	__get_user_check((x), (ptr), sizeof(*(ptr)))

/*
 * __put_user: - Write a simple value into user space, with less checking.
 * @x:   Value to copy to user space.
 * @ptr: Destination address, in user space.
 *
 * Context: User context only. This function may sleep if pagefaults are
 *          enabled.
 *
 * This macro copies a single simple value from kernel space to user
 * space.  It supports simple types like char and int, but not larger
 * data types like structures or arrays.
 *
 * @ptr must have pointer-to-simple-variable type, and @x must be assignable
 * to the result of dereferencing @ptr.
 *
 * Caller must check the pointer with access_ok() before calling this
 * function.
 *
 * Returns zero on success, or -EFAULT on error.
 */
#define __put_user(x, ptr) \
	__put_user_nocheck((x), (ptr), sizeof(*(ptr)))

/*
 * __get_user: - Get a simple variable from user space, with less checking.
 * @x:   Variable to store result.
 * @ptr: Source address, in user space.
 *
 * Context: User context only. This function may sleep if pagefaults are
 *          enabled.
 *
 * This macro copies a single simple variable from user space to kernel
 * space.  It supports simple types like char and int, but not larger
 * data types like structures or arrays.
 *
 * @ptr must have pointer-to-simple-variable type, and the result of
 * dereferencing @ptr must be assignable to @x without a cast.
 *
 * Caller must check the pointer with access_ok() before calling this
 * function.
 *
 * Returns zero on success, or -EFAULT on error.
 * On error, the variable @x is set to zero.
 */
#define __get_user(x, ptr) \
	__get_user_nocheck((x), (ptr), sizeof(*(ptr)))

extern int __get_user_bad(void);
extern int __put_user_bad(void);

#define __get_user_nocheck(x, ptr, size)				\
({									\
	unsigned long __gu_val = 0;					\
	int __gu_err = 0;						\
									\
	switch (size) {							\
	case 1: __get_user_asm("ub", __gu_val, ptr, __gu_err); break;	\
	case 2: __get_user_asm("uh", __gu_val, ptr, __gu_err); break;	\
	case 4: __get_user_asm("w", __gu_val, ptr, __gu_err); break;	\
	default: __gu_err = __get_user_bad(); break;			\
	}								\
									\
	x = (__force typeof(*(ptr)))__gu_val;				\
	__gu_err;							\
})

#define __get_user_check(x, ptr, size)					\
({									\
	unsigned long __gu_val = 0;					\
	const typeof(*(ptr)) __user * __gu_addr = (ptr);		\
	int __gu_err = 0;						\
									\
	if (access_ok(VERIFY_READ, __gu_addr, size)) {			\
		switch (size) {						\
		case 1:							\
			__get_user_asm("ub", __gu_val, __gu_addr,	\
				       __gu_err);			\
			break;						\
		case 2:							\
			__get_user_asm("uh", __gu_val, __gu_addr,	\
				       __gu_err);			\
			break;						\
		case 4:							\
			__get_user_asm("w", __gu_val, __gu_addr,	\
				       __gu_err);			\
			break;						\
		default:						\
			__gu_err = __get_user_bad();			\
			break;						\
		}							\
	} else {							\
		__gu_err = -EFAULT;					\
	}								\
	x = (__force typeof(*(ptr)))__gu_val;				\
	__gu_err;							\
})

#define __get_user_asm(suffix, __gu_val, ptr, __gu_err)			\
	asm volatile(							\
		"1:	ld." suffix "	%1, %3			\n"	\
		"2:						\n"	\
		"	.subsection 1				\n"	\
		"3:	mov	%0, %4				\n"	\
		"	rjmp	2b				\n"	\
		"	.subsection 0				\n"	\
		"	.section __ex_table, \"a\"		\n"	\
		"	.long	1b, 3b				\n"	\
		"	.previous				\n"	\
		: "=r"(__gu_err), "=r"(__gu_val)			\
		: "0"(__gu_err), "m"(*(ptr)), "i"(-EFAULT))

#define __put_user_nocheck(x, ptr, size)				\
({									\
	typeof(*(ptr)) __pu_val;					\
	int __pu_err = 0;						\
									\
	__pu_val = (x);							\
	switch (size) {							\
	case 1: __put_user_asm("b", ptr, __pu_val, __pu_err); break;	\
	case 2: __put_user_asm("h", ptr, __pu_val, __pu_err); break;	\
	case 4: __put_user_asm("w", ptr, __pu_val, __pu_err); break;	\
	case 8: __put_user_asm("d", ptr, __pu_val, __pu_err); break;	\
	default: __pu_err = __put_user_bad(); break;			\
	}								\
	__pu_err;							\
})

#define __put_user_check(x, ptr, size)					\
({									\
	typeof(*(ptr)) __pu_val;					\
	typeof(*(ptr)) __user *__pu_addr = (ptr);			\
	int __pu_err = 0;						\
									\
	__pu_val = (x);							\
	if (access_ok(VERIFY_WRITE, __pu_addr, size)) {			\
		switch (size) {						\
		case 1:							\
			__put_user_asm("b", __pu_addr, __pu_val,	\
				       __pu_err);			\
			break;						\
		case 2:							\
			__put_user_asm("h", __pu_addr, __pu_val,	\
				       __pu_err);			\
			break;						\
		case 4:							\
			__put_user_asm("w", __pu_addr, __pu_val,	\
				       __pu_err);			\
			break;						\
		case 8:							\
			__put_user_asm("d", __pu_addr, __pu_val,	\
				       __pu_err);			\
			break;						\
		default:						\
			__pu_err = __put_user_bad();			\
			break;						\
		}							\
	} else {							\
		__pu_err = -EFAULT;					\
	}								\
	__pu_err;							\
})

#define __put_user_asm(suffix, ptr, __pu_val, __gu_err)			\
	asm volatile(							\
		"1:	st." suffix "	%1, %3			\n"	\
		"2:						\n"	\
		"	.subsection 1				\n"	\
		"3:	mov	%0, %4				\n"	\
		"	rjmp	2b				\n"	\
		"	.subsection 0				\n"	\
		"	.section __ex_table, \"a\"		\n"	\
		"	.long	1b, 3b				\n"	\
		"	.previous				\n"	\
		: "=r"(__gu_err), "=m"(*(ptr))				\
		: "0"(__gu_err), "r"(__pu_val), "i"(-EFAULT))

extern __kernel_size_t clear_user(void __user *addr, __kernel_size_t size);
extern __kernel_size_t __clear_user(void __user *addr, __kernel_size_t size);

extern long strncpy_from_user(char *dst, const char __user *src, long count);
extern long __strncpy_from_user(char *dst, const char __user *src, long count);

extern long strnlen_user(const char __user *__s, long __n);
extern long __strnlen_user(const char __user *__s, long __n);

#define strlen_user(s) strnlen_user(s, ~0UL >> 1)

struct exception_table_entry
{
	unsigned long insn, fixup;
};

#endif /* __ASM_AVR32_UACCESS_H */
Commit	Line	Data
5f97f7f9 HS	1	/*
	2	* Copyright (C) 2004-2006 Atmel Corporation
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License version 2 as
	6	* published by the Free Software Foundation.
	7	*/
	8	#ifndef __ASM_AVR32_UACCESS_H
	9	#define __ASM_AVR32_UACCESS_H
	10
	11	#include <linux/errno.h>
	12	#include <linux/sched.h>
	13
	14	#define VERIFY_READ 0
	15	#define VERIFY_WRITE 1
	16
	17	typedef struct {
	18	unsigned int is_user_space;
	19	} mm_segment_t;
	20
	21	/*
	22	* The fs value determines whether argument validity checking should be
	23	* performed or not. If get_fs() == USER_DS, checking is performed, with
	24	* get_fs() == KERNEL_DS, checking is bypassed.
	25	*
	26	* For historical reasons (Data Segment Register?), these macros are misnamed.
	27	*/
	28	#define MAKE_MM_SEG(s) ((mm_segment_t) { (s) })
d13beabe	29	#define segment_eq(a, b) ((a).is_user_space == (b).is_user_space)
5f97f7f9 HS	30
	31	#define USER_ADDR_LIMIT 0x80000000
	32
	33	#define KERNEL_DS MAKE_MM_SEG(0)
	34	#define USER_DS MAKE_MM_SEG(1)
	35
	36	#define get_ds() (KERNEL_DS)
	37
	38	static inline mm_segment_t get_fs(void)
	39	{
	40	return MAKE_MM_SEG(test_thread_flag(TIF_USERSPACE));
	41	}
	42
	43	static inline void set_fs(mm_segment_t s)
	44	{
	45	if (s.is_user_space)
	46	set_thread_flag(TIF_USERSPACE);
	47	else
	48	clear_thread_flag(TIF_USERSPACE);
	49	}
	50
	51	/*
	52	* Test whether a block of memory is a valid user space address.
	53	* Returns 0 if the range is valid, nonzero otherwise.
	54	*
	55	* We do the following checks:
	56	* 1. Is the access from kernel space?
	57	* 2. Does (addr + size) set the carry bit?
	58	* 3. Is (addr + size) a negative number (i.e. >= 0x80000000)?
	59	*
	60	* If yes on the first check, access is granted.
	61	* If no on any of the others, access is denied.
	62	*/
	63	#define __range_ok(addr, size) \
	64	(test_thread_flag(TIF_USERSPACE) \
	65	&& (((unsigned long)(addr) >= 0x80000000) \
	66	\|\| ((unsigned long)(size) > 0x80000000) \
	67	\|\| (((unsigned long)(addr) + (unsigned long)(size)) > 0x80000000)))
	68
	69	#define access_ok(type, addr, size) (likely(__range_ok(addr, size) == 0))
	70
5f97f7f9 HS	71	/* Generic arbitrary sized copy. Return the number of bytes NOT copied */
	72	extern __kernel_size_t __copy_user(void to, const void from,
	73	__kernel_size_t n);
	74
	75	extern __kernel_size_t copy_to_user(void __user to, const void from,
	76	__kernel_size_t n);
8630c322	77	extern __kernel_size_t ___copy_from_user(void to, const void __user from,
5f97f7f9 HS	78	__kernel_size_t n);
	79
	80	static inline __kernel_size_t __copy_to_user(void __user to, const void from,
	81	__kernel_size_t n)
	82	{
	83	return __copy_user((void __force *)to, from, n);
	84	}
	85	static inline __kernel_size_t __copy_from_user(void *to,
	86	const void __user *from,
	87	__kernel_size_t n)
	88	{
	89	return __copy_user(to, (const void __force *)from, n);
	90	}
8630c322 AV	91	static inline __kernel_size_t copy_from_user(void *to,
	92	const void __user *from,
	93	__kernel_size_t n)
	94	{
	95	size_t res = ___copy_from_user(to, from, n);
	96	if (unlikely(res))
	97	memset(to + (n - res), 0, res);
	98	return res;
	99	}
5f97f7f9 HS	100
	101	#define __copy_to_user_inatomic __copy_to_user
	102	#define __copy_from_user_inatomic __copy_from_user
	103
	104	/*
	105	* put_user: - Write a simple value into user space.
	106	* @x: Value to copy to user space.
	107	* @ptr: Destination address, in user space.
	108	*
b3c395ef DH	109	* Context: User context only. This function may sleep if pagefaults are
b3c395ef DH	110	* enabled.
5f97f7f9 HS	111	*
	112	* This macro copies a single simple value from kernel space to user
	113	* space. It supports simple types like char and int, but not larger
	114	* data types like structures or arrays.
	115	*
	116	* @ptr must have pointer-to-simple-variable type, and @x must be assignable
	117	* to the result of dereferencing @ptr.
	118	*
	119	* Returns zero on success, or -EFAULT on error.
	120	*/
d13beabe MT	121	#define put_user(x, ptr) \
d13beabe MT	122	__put_user_check((x), (ptr), sizeof(*(ptr)))
5f97f7f9 HS	123
	124	/*
	125	* get_user: - Get a simple variable from user space.
	126	* @x: Variable to store result.
	127	* @ptr: Source address, in user space.
	128	*
b3c395ef DH	129	* Context: User context only. This function may sleep if pagefaults are
b3c395ef DH	130	* enabled.
5f97f7f9 HS	131	*
	132	* This macro copies a single simple variable from user space to kernel
	133	* space. It supports simple types like char and int, but not larger
	134	* data types like structures or arrays.
	135	*
	136	* @ptr must have pointer-to-simple-variable type, and the result of
	137	* dereferencing @ptr must be assignable to @x without a cast.
	138	*
	139	* Returns zero on success, or -EFAULT on error.
	140	* On error, the variable @x is set to zero.
	141	*/
d13beabe MT	142	#define get_user(x, ptr) \
d13beabe MT	143	__get_user_check((x), (ptr), sizeof(*(ptr)))
5f97f7f9 HS	144
	145	/*
	146	* __put_user: - Write a simple value into user space, with less checking.
	147	* @x: Value to copy to user space.
	148	* @ptr: Destination address, in user space.
	149	*
b3c395ef DH	150	* Context: User context only. This function may sleep if pagefaults are
b3c395ef DH	151	* enabled.
5f97f7f9 HS	152	*
	153	* This macro copies a single simple value from kernel space to user
	154	* space. It supports simple types like char and int, but not larger
	155	* data types like structures or arrays.
	156	*
	157	* @ptr must have pointer-to-simple-variable type, and @x must be assignable
	158	* to the result of dereferencing @ptr.
	159	*
	160	* Caller must check the pointer with access_ok() before calling this
	161	* function.
	162	*
	163	* Returns zero on success, or -EFAULT on error.
	164	*/
d13beabe MT	165	#define __put_user(x, ptr) \
d13beabe MT	166	__put_user_nocheck((x), (ptr), sizeof(*(ptr)))
5f97f7f9 HS	167
	168	/*
	169	* __get_user: - Get a simple variable from user space, with less checking.
	170	* @x: Variable to store result.
	171	* @ptr: Source address, in user space.
	172	*
b3c395ef DH	173	* Context: User context only. This function may sleep if pagefaults are
b3c395ef DH	174	* enabled.
5f97f7f9 HS	175	*
	176	* This macro copies a single simple variable from user space to kernel
	177	* space. It supports simple types like char and int, but not larger
	178	* data types like structures or arrays.
	179	*
	180	* @ptr must have pointer-to-simple-variable type, and the result of
	181	* dereferencing @ptr must be assignable to @x without a cast.
	182	*
	183	* Caller must check the pointer with access_ok() before calling this
	184	* function.
	185	*
	186	* Returns zero on success, or -EFAULT on error.
	187	* On error, the variable @x is set to zero.
	188	*/
d13beabe MT	189	#define __get_user(x, ptr) \
d13beabe MT	190	__get_user_nocheck((x), (ptr), sizeof(*(ptr)))
5f97f7f9 HS	191
	192	extern int __get_user_bad(void);
	193	extern int __put_user_bad(void);
	194
	195	#define __get_user_nocheck(x, ptr, size) \
	196	({ \
8224ca19	197	unsigned long __gu_val = 0; \
5f97f7f9 HS	198	int __gu_err = 0; \
	199	\
	200	switch (size) { \
	201	case 1: __get_user_asm("ub", __gu_val, ptr, __gu_err); break; \
	202	case 2: __get_user_asm("uh", __gu_val, ptr, __gu_err); break; \
	203	case 4: __get_user_asm("w", __gu_val, ptr, __gu_err); break; \
5f97f7f9 HS	204	default: __gu_err = __get_user_bad(); break; \
	205	} \
	206	\
7f0db2be	207	x = (__force typeof(*(ptr)))__gu_val; \
5f97f7f9 HS	208	__gu_err; \
	209	})
	210
	211	#define __get_user_check(x, ptr, size) \
	212	({ \
8224ca19	213	unsigned long __gu_val = 0; \
5f97f7f9 HS	214	const typeof((ptr)) __user __gu_addr = (ptr); \
	215	int __gu_err = 0; \
	216	\
	217	if (access_ok(VERIFY_READ, __gu_addr, size)) { \
	218	switch (size) { \
	219	case 1: \
	220	__get_user_asm("ub", __gu_val, __gu_addr, \
	221	__gu_err); \
	222	break; \
	223	case 2: \
	224	__get_user_asm("uh", __gu_val, __gu_addr, \
	225	__gu_err); \
	226	break; \
	227	case 4: \
	228	__get_user_asm("w", __gu_val, __gu_addr, \
	229	__gu_err); \
	230	break; \
5f97f7f9 HS	231	default: \
	232	__gu_err = __get_user_bad(); \
	233	break; \
	234	} \
	235	} else { \
	236	__gu_err = -EFAULT; \
	237	} \
7f0db2be	238	x = (__force typeof(*(ptr)))__gu_val; \
5f97f7f9 HS	239	__gu_err; \
	240	})
	241
	242	#define __get_user_asm(suffix, __gu_val, ptr, __gu_err) \
	243	asm volatile( \
	244	"1: ld." suffix " %1, %3 \n" \
	245	"2: \n" \
61f3632f	246	" .subsection 1 \n" \
5f97f7f9 HS	247	"3: mov %0, %4 \n" \
5f97f7f9 HS	248	" rjmp 2b \n" \
61f3632f	249	" .subsection 0 \n" \
5f97f7f9 HS	250	" .section __ex_table, \"a\" \n" \
	251	" .long 1b, 3b \n" \
	252	" .previous \n" \
	253	: "=r"(__gu_err), "=r"(__gu_val) \
	254	: "0"(__gu_err), "m"(*(ptr)), "i"(-EFAULT))
	255
	256	#define __put_user_nocheck(x, ptr, size) \
	257	({ \
	258	typeof(*(ptr)) __pu_val; \
	259	int __pu_err = 0; \
	260	\
	261	__pu_val = (x); \
	262	switch (size) { \
	263	case 1: __put_user_asm("b", ptr, __pu_val, __pu_err); break; \
	264	case 2: __put_user_asm("h", ptr, __pu_val, __pu_err); break; \
	265	case 4: __put_user_asm("w", ptr, __pu_val, __pu_err); break; \
	266	case 8: __put_user_asm("d", ptr, __pu_val, __pu_err); break; \
	267	default: __pu_err = __put_user_bad(); break; \
	268	} \
	269	__pu_err; \
	270	})
	271
	272	#define __put_user_check(x, ptr, size) \
	273	({ \
	274	typeof(*(ptr)) __pu_val; \
	275	typeof((ptr)) __user __pu_addr = (ptr); \
	276	int __pu_err = 0; \
	277	\
	278	__pu_val = (x); \
	279	if (access_ok(VERIFY_WRITE, __pu_addr, size)) { \
	280	switch (size) { \
	281	case 1: \
	282	__put_user_asm("b", __pu_addr, __pu_val, \
	283	__pu_err); \
	284	break; \
	285	case 2: \
	286	__put_user_asm("h", __pu_addr, __pu_val, \
	287	__pu_err); \
	288	break; \
	289	case 4: \
	290	__put_user_asm("w", __pu_addr, __pu_val, \
	291	__pu_err); \
	292	break; \
	293	case 8: \
99408c84	294	__put_user_asm("d", __pu_addr, __pu_val, \
5f97f7f9 HS	295	__pu_err); \
	296	break; \
	297	default: \
	298	__pu_err = __put_user_bad(); \
	299	break; \
	300	} \
	301	} else { \
	302	__pu_err = -EFAULT; \
	303	} \
	304	__pu_err; \
	305	})
	306
	307	#define __put_user_asm(suffix, ptr, __pu_val, __gu_err) \
	308	asm volatile( \
	309	"1: st." suffix " %1, %3 \n" \
	310	"2: \n" \
61f3632f	311	" .subsection 1 \n" \
5f97f7f9 HS	312	"3: mov %0, %4 \n" \
5f97f7f9 HS	313	" rjmp 2b \n" \
61f3632f	314	" .subsection 0 \n" \
5f97f7f9 HS	315	" .section __ex_table, \"a\" \n" \
	316	" .long 1b, 3b \n" \
	317	" .previous \n" \
	318	: "=r"(__gu_err), "=m"(*(ptr)) \
	319	: "0"(__gu_err), "r"(__pu_val), "i"(-EFAULT))
	320
	321	extern __kernel_size_t clear_user(void __user *addr, __kernel_size_t size);
	322	extern __kernel_size_t __clear_user(void __user *addr, __kernel_size_t size);
	323
	324	extern long strncpy_from_user(char dst, const char __user src, long count);
	325	extern long __strncpy_from_user(char dst, const char __user src, long count);
	326
	327	extern long strnlen_user(const char __user *__s, long __n);
	328	extern long __strnlen_user(const char __user *__s, long __n);
	329
	330	#define strlen_user(s) strnlen_user(s, ~0UL >> 1)
	331
	332	struct exception_table_entry
	333	{
	334	unsigned long insn, fixup;
	335	};
	336
	337	#endif /* __ASM_AVR32_UACCESS_H */