include/asm-m68k/uaccess.h - kernel/msm - Gitiles

 #ifndef __M68K_UACCESS_H
 #define __M68K_UACCESS_H

 /*
  * User space memory access functions
  */
 #include <linux/compiler.h>
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <asm/segment.h>

 #define VERIFY_READ	0
 #define VERIFY_WRITE	1

 /* We let the MMU do all checking */
 #define access_ok(type,addr,size) 1

 /*
  * The exception table consists of pairs of addresses: the first is the
  * address of an instruction that is allowed to fault, and the second is
  * the address at which the program should continue.  No registers are
  * modified, so it is entirely up to the continuation code to figure out
  * what to do.
  *
  * All the routines below use bits of fixup code that are out of line
  * with the main instruction path.  This means when everything is well,
  * we don't even have to jump over them.  Further, they do not intrude
  * on our cache or tlb entries.
  */

 struct exception_table_entry
 {
 	unsigned long insn, fixup;
 };

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

 #define __put_user_asm(res, x, ptr, bwl, reg, err)	\
 asm volatile ("\n"					\
 	"1:	moves."#bwl"	%2,%1\n"		\
 	"2:\n"						\
 	"	.section .fixup,\"ax\"\n"		\
 	"	.even\n"				\
 	"10:	moveq.l	%3,%0\n"			\
 	"	jra 2b\n"				\
 	"	.previous\n"				\
 	"\n"						\
 	"	.section __ex_table,\"a\"\n"		\
 	"	.align	4\n"				\
 	"	.long	1b,10b\n"			\
 	"	.long	2b,10b\n"			\
 	"	.previous"				\
 	: "+d" (res), "=m" (*(ptr))			\
 	: #reg (x), "i" (err))

 /*
  * These are the main single-value transfer routines.  They automatically
  * use the right size if we just have the right pointer type.
  */

 #define __put_user(x, ptr)						\
 ({									\
 	typeof(*(ptr)) __pu_val = (x);					\
 	int __pu_err = 0;						\
 	__chk_user_ptr(ptr);						\
 	switch (sizeof (*(ptr))) {					\
 	case 1:								\
 		__put_user_asm(__pu_err, __pu_val, ptr, b, d, -EFAULT);	\
 		break;							\
 	case 2:								\
 		__put_user_asm(__pu_err, __pu_val, ptr, w, d, -EFAULT);	\
 		break;							\
 	case 4:								\
 		__put_user_asm(__pu_err, __pu_val, ptr, l, r, -EFAULT);	\
 		break;							\
 	case 8:								\
  	    {								\
  		const void *__pu_ptr = (ptr);				\
 		asm volatile ("\n"					\
 			"1:	moves.l	%2,(%1)+\n"			\
 			"2:	moves.l	%R2,(%1)\n"			\
 			"3:\n"						\
 			"	.section .fixup,\"ax\"\n"		\
 			"	.even\n"				\
 			"10:	movel %3,%0\n"				\
 			"	jra 3b\n"				\
 			"	.previous\n"				\
 			"\n"						\
 			"	.section __ex_table,\"a\"\n"		\
 			"	.align 4\n"				\
 			"	.long 1b,10b\n"				\
 			"	.long 2b,10b\n"				\
 			"	.long 3b,10b\n"				\
 			"	.previous"				\
 			: "+d" (__pu_err), "+a" (__pu_ptr)		\
 			: "r" (__pu_val), "i" (-EFAULT)			\
 			: "memory");					\
 		break;							\
 	    }								\
 	default:							\
 		__pu_err = __put_user_bad();				\
 		break;							\
 	}								\
 	__pu_err;							\
 })
 #define put_user(x, ptr)	__put_user(x, ptr)


 #define __get_user_asm(res, x, ptr, type, bwl, reg, err) ({	\
 	type __gu_val;						\
 	asm volatile ("\n"					\
 		"1:	moves."#bwl"	%2,%1\n"		\
 		"2:\n"						\
 		"	.section .fixup,\"ax\"\n"		\
 		"	.even\n"				\
 		"10:	move.l	%3,%0\n"			\
 		"	sub."#bwl"	%1,%1\n"		\
 		"	jra	2b\n"				\
 		"	.previous\n"				\
 		"\n"						\
 		"	.section __ex_table,\"a\"\n"		\
 		"	.align	4\n"				\
 		"	.long	1b,10b\n"			\
 		"	.previous"				\
 		: "+d" (res), "=&" #reg (__gu_val)		\
 		: "m" (*(ptr)), "i" (err));			\
 	(x) = (typeof(*(ptr)))(long)__gu_val;			\
 })

 #define __get_user(x, ptr)						\
 ({									\
 	int __gu_err = 0;						\
 	__chk_user_ptr(ptr);						\
 	switch (sizeof(*(ptr))) {					\
 	case 1:								\
 		__get_user_asm(__gu_err, x, ptr, u8, b, d, -EFAULT);	\
 		break;							\
 	case 2:								\
 		__get_user_asm(__gu_err, x, ptr, u16, w, d, -EFAULT);	\
 		break;							\
 	case 4:								\
 		__get_user_asm(__gu_err, x, ptr, u32, l, r, -EFAULT);	\
 		break;							\
 /*	case 8:	disabled because gcc-4.1 has a broken typeof		\
  	    {								\
  		const void *__gu_ptr = (ptr);				\
  		u64 __gu_val;						\
 		asm volatile ("\n"					\
 			"1:	moves.l	(%2)+,%1\n"			\
 			"2:	moves.l	(%2),%R1\n"			\
 			"3:\n"						\
 			"	.section .fixup,\"ax\"\n"		\
 			"	.even\n"				\
 			"10:	move.l	%3,%0\n"			\
 			"	sub.l	%1,%1\n"			\
 			"	sub.l	%R1,%R1\n"			\
 			"	jra	3b\n"				\
 			"	.previous\n"				\
 			"\n"						\
 			"	.section __ex_table,\"a\"\n"		\
 			"	.align	4\n"				\
 			"	.long	1b,10b\n"			\
 			"	.long	2b,10b\n"			\
 			"	.previous"				\
 			: "+d" (__gu_err), "=&r" (__gu_val),		\
 			  "+a" (__gu_ptr)				\
 			: "i" (-EFAULT)					\
 			: "memory");					\
 		(x) = (typeof(*(ptr)))__gu_val;				\
 		break;							\
 	    }	*/							\
 	default:							\
 		__gu_err = __get_user_bad();				\
 		break;							\
 	}								\
 	__gu_err;							\
 })
 #define get_user(x, ptr) __get_user(x, ptr)

 unsigned long __generic_copy_from_user(void *to, const void __user *from, unsigned long n);
 unsigned long __generic_copy_to_user(void __user *to, const void *from, unsigned long n);

 static __always_inline unsigned long
 __constant_copy_from_user(void *to, const void __user *from, unsigned long n)
 {
 	unsigned long res = 0, tmp;

 	/* limit the inlined version to 3 moves */
 	if (n == 11 || n > 12)
 		return __generic_copy_from_user(to, from, n);

 	switch (n) {
 	case 1:
 		__get_user_asm(res, *(u8 *)to, (u8 *)from, u8, b, d, 1);
 		return res;
 	case 2:
 		__get_user_asm(res, *(u16 *)to, (u16 *)from, u16, w, d, 2);
 		return res;
 	case 4:
 		__get_user_asm(res, *(u32 *)to, (u32 *)from, u32, l, r, 4);
 		return res;
 	}

 	asm volatile ("\n"
 		"	.ifndef	.Lfrom_user\n"
 		"	.set	.Lfrom_user,1\n"
 		"	.macro	copy_from_user to,from,tmp\n"
 		"	.if	.Lcnt >= 4\n"
 		"1:	moves.l	(\\from)+,\\tmp\n"
 		"	move.l	\\tmp,(\\to)+\n"
 		"	.set	.Lcnt,.Lcnt-4\n"
 		"	.elseif	.Lcnt & 2\n"
 		"1:	moves.w	(\\from)+,\\tmp\n"
 		"	move.w	\\tmp,(\\to)+\n"
 		"	.set	.Lcnt,.Lcnt-2\n"
 		"	.elseif	.Lcnt & 1\n"
 		"1:	moves.b	(\\from)+,\\tmp\n"
 		"	move.b	\\tmp,(\\to)+\n"
 		"	.set	.Lcnt,.Lcnt-1\n"
 		"	.else\n"
 		"	.exitm\n"
 		"	.endif\n"
 		"\n"
 		"	.section __ex_table,\"a\"\n"
 		"	.align	4\n"
 		"	.long	1b,3f\n"
 		"	.previous\n"
 		"	.endm\n"
 		"	.endif\n"
 		"\n"
 		"	.set	.Lcnt,%c4\n"
 		"	copy_from_user %1,%2,%3\n"
 		"	copy_from_user %1,%2,%3\n"
 		"	copy_from_user %1,%2,%3\n"
 		"2:\n"
 		"	.section .fixup,\"ax\"\n"
 		"	.even\n"
 		"3:	moveq.l	%4,%0\n"
 		"	move.l	%5,%1\n"
 		"	.rept	%c4 / 4\n"
 		"	clr.l	(%1)+\n"
 		"	.endr\n"
 		"	.if	%c4 & 2\n"
 		"	clr.w	(%1)+\n"
 		"	.endif\n"
 		"	.if	%c4 & 1\n"
 		"	clr.b	(%1)+\n"
 		"	.endif\n"
 		"	jra	2b\n"
 		"	.previous\n"
 		: "+r" (res), "+a" (to), "+a" (from), "=&d" (tmp)
 		: "i" (n), "g" (to)
 		: "memory");

 	return res;
 }

 static __always_inline unsigned long
 __constant_copy_to_user(void __user *to, const void *from, unsigned long n)
 {
 	unsigned long res = 0, tmp;

 	/* limit the inlined version to 3 moves */
 	if (n == 11 || n > 12)
 		return __generic_copy_to_user(to, from, n);

 	switch (n) {
 	case 1:
 		__put_user_asm(res, *(u8 *)from, (u8 *)to, b, d, 1);
 		return res;
 	case 2:
 		__put_user_asm(res, *(u16 *)from, (u16 *)to, w, d, 2);
 		return res;
 	case 4:
 		__put_user_asm(res, *(u32 *)from, (u32 *)to, l, r, 4);
 		return res;
 	}

 	asm volatile ("\n"
 		"	.ifndef	.Lto_user\n"
 		"	.set	.Lto_user,1\n"
 		"	.macro	copy_to_user to,from,tmp\n"
 		"	.if	.Lcnt >= 4\n"
 		"	move.l	(\\from)+,\\tmp\n"
 		"11:	moves.l	\\tmp,(\\to)+\n"
 		"12:	.set	.Lcnt,.Lcnt-4\n"
 		"	.elseif	.Lcnt & 2\n"
 		"	move.w	(\\from)+,\\tmp\n"
 		"11:	moves.w	\\tmp,(\\to)+\n"
 		"12:	.set	.Lcnt,.Lcnt-2\n"
 		"	.elseif	.Lcnt & 1\n"
 		"	move.b	(\\from)+,\\tmp\n"
 		"11:	moves.b	\\tmp,(\\to)+\n"
 		"12:	.set	.Lcnt,.Lcnt-1\n"
 		"	.else\n"
 		"	.exitm\n"
 		"	.endif\n"
 		"\n"
 		"	.section __ex_table,\"a\"\n"
 		"	.align	4\n"
 		"	.long	11b,3f\n"
 		"	.long	12b,3f\n"
 		"	.previous\n"
 		"	.endm\n"
 		"	.endif\n"
 		"\n"
 		"	.set	.Lcnt,%c4\n"
 		"	copy_to_user %1,%2,%3\n"
 		"	copy_to_user %1,%2,%3\n"
 		"	copy_to_user %1,%2,%3\n"
 		"2:\n"
 		"	.section .fixup,\"ax\"\n"
 		"	.even\n"
 		"3:	moveq.l	%4,%0\n"
 		"	jra	2b\n"
 		"	.previous\n"
 		: "+r" (res), "+a" (to), "+a" (from), "=&d" (tmp)
 		: "i" (n)
 		: "memory");

 	return res;
 }

 #define __copy_from_user(to, from, n)		\
 (__builtin_constant_p(n) ?			\
  __constant_copy_from_user(to, from, n) :	\
  __generic_copy_from_user(to, from, n))

 #define __copy_to_user(to, from, n)		\
 (__builtin_constant_p(n) ?			\
  __constant_copy_to_user(to, from, n) :		\
  __generic_copy_to_user(to, from, n))

 #define __copy_to_user_inatomic		__copy_to_user
 #define __copy_from_user_inatomic	__copy_from_user

 #define copy_from_user(to, from, n)	__copy_from_user(to, from, n)
 #define copy_to_user(to, from, n)	__copy_to_user(to, from, n)

 long strncpy_from_user(char *dst, const char __user *src, long count);
 long strnlen_user(const char __user *src, long n);
 unsigned long clear_user(void __user *to, unsigned long n);

 #define strlen_user(str) strnlen_user(str, 32767)

 #endif /* _M68K_UACCESS_H */
	#ifndef __M68K_UACCESS_H
	#define __M68K_UACCESS_H

	/*
	* User space memory access functions
	*/
	#include <linux/compiler.h>
	#include <linux/errno.h>
	#include <linux/types.h>
	#include <asm/segment.h>

	#define VERIFY_READ 0
	#define VERIFY_WRITE 1

	/* We let the MMU do all checking */
	#define access_ok(type,addr,size) 1

	/*
	* The exception table consists of pairs of addresses: the first is the
	* address of an instruction that is allowed to fault, and the second is
	* the address at which the program should continue. No registers are
	* modified, so it is entirely up to the continuation code to figure out
	* what to do.
	*
	* All the routines below use bits of fixup code that are out of line
	* with the main instruction path. This means when everything is well,
	* we don't even have to jump over them. Further, they do not intrude
	* on our cache or tlb entries.
	*/

	struct exception_table_entry
	{
	unsigned long insn, fixup;
	};

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

	#define __put_user_asm(res, x, ptr, bwl, reg, err) \
	asm volatile ("\n" \
	"1: moves."#bwl" %2,%1\n" \
	"2:\n" \
	" .section .fixup,\"ax\"\n" \
	" .even\n" \
	"10: moveq.l %3,%0\n" \
	" jra 2b\n" \
	" .previous\n" \
	"\n" \
	" .section __ex_table,\"a\"\n" \
	" .align 4\n" \
	" .long 1b,10b\n" \
	" .long 2b,10b\n" \
	" .previous" \
	: "+d" (res), "=m" (*(ptr)) \
	: #reg (x), "i" (err))

	/*
	* These are the main single-value transfer routines. They automatically
	* use the right size if we just have the right pointer type.
	*/

	#define __put_user(x, ptr) \
	({ \
	typeof(*(ptr)) __pu_val = (x); \
	int __pu_err = 0; \
	__chk_user_ptr(ptr); \
	switch (sizeof (*(ptr))) { \
	case 1: \
	__put_user_asm(__pu_err, __pu_val, ptr, b, d, -EFAULT); \
	break; \
	case 2: \
	__put_user_asm(__pu_err, __pu_val, ptr, w, d, -EFAULT); \
	break; \
	case 4: \
	__put_user_asm(__pu_err, __pu_val, ptr, l, r, -EFAULT); \
	break; \
	case 8: \
	{ \
	const void *__pu_ptr = (ptr); \
	asm volatile ("\n" \
	"1: moves.l %2,(%1)+\n" \
	"2: moves.l %R2,(%1)\n" \
	"3:\n" \
	" .section .fixup,\"ax\"\n" \
	" .even\n" \
	"10: movel %3,%0\n" \
	" jra 3b\n" \
	" .previous\n" \
	"\n" \
	" .section __ex_table,\"a\"\n" \
	" .align 4\n" \
	" .long 1b,10b\n" \
	" .long 2b,10b\n" \
	" .long 3b,10b\n" \
	" .previous" \
	: "+d" (__pu_err), "+a" (__pu_ptr) \
	: "r" (__pu_val), "i" (-EFAULT) \
	: "memory"); \
	break; \
	} \
	default: \
	__pu_err = __put_user_bad(); \
	break; \
	} \
	__pu_err; \
	})
	#define put_user(x, ptr) __put_user(x, ptr)


	#define __get_user_asm(res, x, ptr, type, bwl, reg, err) ({ \
	type __gu_val; \
	asm volatile ("\n" \
	"1: moves."#bwl" %2,%1\n" \
	"2:\n" \
	" .section .fixup,\"ax\"\n" \
	" .even\n" \
	"10: move.l %3,%0\n" \
	" sub."#bwl" %1,%1\n" \
	" jra 2b\n" \
	" .previous\n" \
	"\n" \
	" .section __ex_table,\"a\"\n" \
	" .align 4\n" \
	" .long 1b,10b\n" \
	" .previous" \
	: "+d" (res), "=&" #reg (__gu_val) \
	: "m" (*(ptr)), "i" (err)); \
	(x) = (typeof(*(ptr)))(long)__gu_val; \
	})

	#define __get_user(x, ptr) \
	({ \
	int __gu_err = 0; \
	__chk_user_ptr(ptr); \
	switch (sizeof(*(ptr))) { \
	case 1: \
	__get_user_asm(__gu_err, x, ptr, u8, b, d, -EFAULT); \
	break; \
	case 2: \
	__get_user_asm(__gu_err, x, ptr, u16, w, d, -EFAULT); \
	break; \
	case 4: \
	__get_user_asm(__gu_err, x, ptr, u32, l, r, -EFAULT); \
	break; \
	/* case 8: disabled because gcc-4.1 has a broken typeof \
	{ \
	const void *__gu_ptr = (ptr); \
	u64 __gu_val; \
	asm volatile ("\n" \
	"1: moves.l (%2)+,%1\n" \
	"2: moves.l (%2),%R1\n" \
	"3:\n" \
	" .section .fixup,\"ax\"\n" \
	" .even\n" \
	"10: move.l %3,%0\n" \
	" sub.l %1,%1\n" \
	" sub.l %R1,%R1\n" \
	" jra 3b\n" \
	" .previous\n" \
	"\n" \
	" .section __ex_table,\"a\"\n" \
	" .align 4\n" \
	" .long 1b,10b\n" \
	" .long 2b,10b\n" \
	" .previous" \
	: "+d" (__gu_err), "=&r" (__gu_val), \
	"+a" (__gu_ptr) \
	: "i" (-EFAULT) \
	: "memory"); \
	(x) = (typeof(*(ptr)))__gu_val; \
	break; \
	} */ \
	default: \
	__gu_err = __get_user_bad(); \
	break; \
	} \
	__gu_err; \
	})
	#define get_user(x, ptr) __get_user(x, ptr)

	unsigned long __generic_copy_from_user(void to, const void __user from, unsigned long n);
	unsigned long __generic_copy_to_user(void __user to, const void from, unsigned long n);

	static __always_inline unsigned long
	__constant_copy_from_user(void to, const void __user from, unsigned long n)
	{
	unsigned long res = 0, tmp;

	/* limit the inlined version to 3 moves */
	if (n == 11 \|\| n > 12)
	return __generic_copy_from_user(to, from, n);

	switch (n) {
	case 1:
	__get_user_asm(res, (u8 )to, (u8 *)from, u8, b, d, 1);
	return res;
	case 2:
	__get_user_asm(res, (u16 )to, (u16 *)from, u16, w, d, 2);
	return res;
	case 4:
	__get_user_asm(res, (u32 )to, (u32 *)from, u32, l, r, 4);
	return res;
	}

	asm volatile ("\n"
	" .ifndef .Lfrom_user\n"
	" .set .Lfrom_user,1\n"
	" .macro copy_from_user to,from,tmp\n"
	" .if .Lcnt >= 4\n"
	"1: moves.l (\\from)+,\\tmp\n"
	" move.l \\tmp,(\\to)+\n"
	" .set .Lcnt,.Lcnt-4\n"
	" .elseif .Lcnt & 2\n"
	"1: moves.w (\\from)+,\\tmp\n"
	" move.w \\tmp,(\\to)+\n"
	" .set .Lcnt,.Lcnt-2\n"
	" .elseif .Lcnt & 1\n"
	"1: moves.b (\\from)+,\\tmp\n"
	" move.b \\tmp,(\\to)+\n"
	" .set .Lcnt,.Lcnt-1\n"
	" .else\n"
	" .exitm\n"
	" .endif\n"
	"\n"
	" .section __ex_table,\"a\"\n"
	" .align 4\n"
	" .long 1b,3f\n"
	" .previous\n"
	" .endm\n"
	" .endif\n"
	"\n"
	" .set .Lcnt,%c4\n"
	" copy_from_user %1,%2,%3\n"
	" copy_from_user %1,%2,%3\n"
	" copy_from_user %1,%2,%3\n"
	"2:\n"
	" .section .fixup,\"ax\"\n"
	" .even\n"
	"3: moveq.l %4,%0\n"
	" move.l %5,%1\n"
	" .rept %c4 / 4\n"
	" clr.l (%1)+\n"
	" .endr\n"
	" .if %c4 & 2\n"
	" clr.w (%1)+\n"
	" .endif\n"
	" .if %c4 & 1\n"
	" clr.b (%1)+\n"
	" .endif\n"
	" jra 2b\n"
	" .previous\n"
	: "+r" (res), "+a" (to), "+a" (from), "=&d" (tmp)
	: "i" (n), "g" (to)
	: "memory");

	return res;
	}

	static __always_inline unsigned long
	__constant_copy_to_user(void __user to, const void from, unsigned long n)
	{
	unsigned long res = 0, tmp;

	/* limit the inlined version to 3 moves */
	if (n == 11 \|\| n > 12)
	return __generic_copy_to_user(to, from, n);

	switch (n) {
	case 1:
	__put_user_asm(res, (u8 )from, (u8 *)to, b, d, 1);
	return res;
	case 2:
	__put_user_asm(res, (u16 )from, (u16 *)to, w, d, 2);
	return res;
	case 4:
	__put_user_asm(res, (u32 )from, (u32 *)to, l, r, 4);
	return res;
	}

	asm volatile ("\n"
	" .ifndef .Lto_user\n"
	" .set .Lto_user,1\n"
	" .macro copy_to_user to,from,tmp\n"
	" .if .Lcnt >= 4\n"
	" move.l (\\from)+,\\tmp\n"
	"11: moves.l \\tmp,(\\to)+\n"
	"12: .set .Lcnt,.Lcnt-4\n"
	" .elseif .Lcnt & 2\n"
	" move.w (\\from)+,\\tmp\n"
	"11: moves.w \\tmp,(\\to)+\n"
	"12: .set .Lcnt,.Lcnt-2\n"
	" .elseif .Lcnt & 1\n"
	" move.b (\\from)+,\\tmp\n"
	"11: moves.b \\tmp,(\\to)+\n"
	"12: .set .Lcnt,.Lcnt-1\n"
	" .else\n"
	" .exitm\n"
	" .endif\n"
	"\n"
	" .section __ex_table,\"a\"\n"
	" .align 4\n"
	" .long 11b,3f\n"
	" .long 12b,3f\n"
	" .previous\n"
	" .endm\n"
	" .endif\n"
	"\n"
	" .set .Lcnt,%c4\n"
	" copy_to_user %1,%2,%3\n"
	" copy_to_user %1,%2,%3\n"
	" copy_to_user %1,%2,%3\n"
	"2:\n"
	" .section .fixup,\"ax\"\n"
	" .even\n"
	"3: moveq.l %4,%0\n"
	" jra 2b\n"
	" .previous\n"
	: "+r" (res), "+a" (to), "+a" (from), "=&d" (tmp)
	: "i" (n)
	: "memory");

	return res;
	}

	#define __copy_from_user(to, from, n) \
	(__builtin_constant_p(n) ? \
	__constant_copy_from_user(to, from, n) : \
	__generic_copy_from_user(to, from, n))

	#define __copy_to_user(to, from, n) \
	(__builtin_constant_p(n) ? \
	__constant_copy_to_user(to, from, n) : \
	__generic_copy_to_user(to, from, n))

	#define __copy_to_user_inatomic __copy_to_user
	#define __copy_from_user_inatomic __copy_from_user

	#define copy_from_user(to, from, n) __copy_from_user(to, from, n)
	#define copy_to_user(to, from, n) __copy_to_user(to, from, n)

	long strncpy_from_user(char dst, const char __user src, long count);
	long strnlen_user(const char __user *src, long n);
	unsigned long clear_user(void __user *to, unsigned long n);

	#define strlen_user(str) strnlen_user(str, 32767)

	#endif /* _M68K_UACCESS_H */