path: root/include/asm-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 */