[linux.git] / include / asm-frv / uaccess.h

/* uaccess.h: userspace accessor functions
 *
 * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells ([email protected])
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#ifndef _ASM_UACCESS_H
#define _ASM_UACCESS_H

/*
 * User space memory access functions
 */
#include <linux/sched.h>
#include <linux/mm.h>
#include <asm/segment.h>
#include <asm/sections.h>

#define HAVE_ARCH_UNMAPPED_AREA	/* we decide where to put mmaps */

#define __ptr(x) ((unsigned long __force *)(x))

#define VERIFY_READ	0
#define VERIFY_WRITE	1

#define __addr_ok(addr) ((unsigned long)(addr) < get_addr_limit())

/*
 * check that a range of addresses falls within the current address limit
 */
static inline int ___range_ok(unsigned long addr, unsigned long size)
{
#ifdef CONFIG_MMU
	int flag = -EFAULT, tmp;

	asm volatile (
		"	addcc	%3,%2,%1,icc0	\n"	/* set C-flag if addr+size>4GB */
		"	subcc.p	%1,%4,gr0,icc1	\n"	/* jump if addr+size>limit */
		"	bc	icc0,#0,0f	\n"
		"	bhi	icc1,#0,0f	\n"
		"	setlos	#0,%0		\n"	/* mark okay */
		"0:				\n"
		: "=r"(flag), "=&r"(tmp)
		: "r"(addr), "r"(size), "r"(get_addr_limit()), "0"(flag)
		);

	return flag;

#else

	if (addr < memory_start ||
	    addr > memory_end ||
	    size > memory_end - memory_start ||
	    addr + size > memory_end)
		return -EFAULT;

	return 0;
#endif
}

#define __range_ok(addr,size) ___range_ok((unsigned long) (addr), (unsigned long) (size))

#define access_ok(type,addr,size) (__range_ok((void __user *)(addr), (size)) == 0)
#define __access_ok(addr,size) (__range_ok((addr), (size)) == 0)

/*
 * 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;
};

/* Returns 0 if exception not found and fixup otherwise.  */
extern unsigned long search_exception_table(unsigned long);


/*
 * 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)						\
({									\
	int __pu_err = 0;						\
									\
	typeof(*(ptr)) __pu_val = (x);					\
	__chk_user_ptr(ptr);						\
									\
	switch (sizeof (*(ptr))) {					\
	case 1:								\
		__put_user_asm(__pu_err, __pu_val, ptr, "b", "r");	\
		break;							\
	case 2:								\
		__put_user_asm(__pu_err, __pu_val, ptr, "h", "r");	\
		break;							\
	case 4:								\
		__put_user_asm(__pu_err, __pu_val, ptr, "",  "r");	\
		break;							\
	case 8:								\
		__put_user_asm(__pu_err, __pu_val, ptr, "d", "e");	\
		break;							\
	default:							\
		__pu_err = __put_user_bad();				\
		break;							\
	}								\
	__pu_err;							\
})

#define put_user(x, ptr)			\
({						\
	typeof(*(ptr)) __user *_p = (ptr);	\
	int _e;					\
						\
	_e = __range_ok(_p, sizeof(*_p));	\
	if (_e == 0)				\
		_e = __put_user((x), _p);	\
	_e;					\
})

extern int __put_user_bad(void);

/*
 * Tell gcc we read from memory instead of writing: this is because
 * we do not write to any memory gcc knows about, so there are no
 * aliasing issues.
 */

#ifdef CONFIG_MMU

#define __put_user_asm(err,x,ptr,dsize,constraint)					\
do {											\
	asm volatile("1:	st"dsize"%I1	%2,%M1	\n"				\
		     "2:				\n"				\
		     ".subsection 2			\n"				\
		     "3:	setlos		%3,%0	\n"				\
		     "		bra		2b	\n"				\
		     ".previous				\n"				\
		     ".section __ex_table,\"a\"		\n"				\
		     "		.balign		8	\n"				\
		     "		.long		1b,3b	\n"				\
		     ".previous"							\
		     : "=r" (err)							\
		     : "m" (*__ptr(ptr)), constraint (x), "i"(-EFAULT), "0"(err)	\
		     : "memory");							\
} while (0)

#else

#define __put_user_asm(err,x,ptr,bwl,con)	\
do {						\
	asm("	st"bwl"%I0	%1,%M0	\n"	\
	    "	membar			\n"	\
	    :					\
	    : "m" (*__ptr(ptr)), con (x)	\
	    : "memory");			\
} while (0)

#endif

/*****************************************************************************/
/*
 *
 */
#define __get_user(x, ptr)						\
({									\
	int __gu_err = 0;						\
	__chk_user_ptr(ptr);						\
									\
	switch (sizeof(*(ptr))) {					\
	case 1: {							\
		unsigned char __gu_val;					\
		__get_user_asm(__gu_err, __gu_val, ptr, "ub", "=r");	\
		(x) = *(__force __typeof__(*(ptr)) *) &__gu_val;	\
		break;							\
	}								\
	case 2: {							\
		unsigned short __gu_val;				\
		__get_user_asm(__gu_err, __gu_val, ptr, "uh", "=r");	\
		(x) = *(__force __typeof__(*(ptr)) *) &__gu_val;	\
		break;							\
	}								\
	case 4: {							\
		unsigned int __gu_val;					\
		__get_user_asm(__gu_err, __gu_val, ptr, "", "=r");	\
		(x) = *(__force __typeof__(*(ptr)) *) &__gu_val;	\
		break;							\
	}								\
	case 8: {							\
		unsigned long long __gu_val;				\
		__get_user_asm(__gu_err, __gu_val, ptr, "d", "=e");	\
		(x) = *(__force __typeof__(*(ptr)) *) &__gu_val;	\
		break;							\
	}								\
	default:							\
		__gu_err = __get_user_bad();				\
		break;							\
	}								\
	__gu_err;							\
})

#define get_user(x, ptr)			\
({						\
	const typeof(*(ptr)) __user *_p = (ptr);\
	int _e;					\
						\
	_e = __range_ok(_p, sizeof(*_p));	\
	if (likely(_e == 0))			\
		_e = __get_user((x), _p);	\
	else					\
		(x) = (typeof(x)) 0;		\
	_e;					\
})

extern int __get_user_bad(void);

#ifdef CONFIG_MMU

#define __get_user_asm(err,x,ptr,dtype,constraint)	\
do {							\
	asm("1:		ld"dtype"%I2	%M2,%1	\n"	\
	    "2:					\n"	\
	    ".subsection 2			\n"	\
	    "3:		setlos		%3,%0	\n"	\
	    "		setlos		#0,%1	\n"	\
	    "		bra		2b	\n"	\
	    ".previous				\n"	\
	    ".section __ex_table,\"a\"		\n"	\
	    "		.balign		8	\n"	\
	    "		.long		1b,3b	\n"	\
	    ".previous"					\
	    : "=r" (err), constraint (x)		\
	    : "m" (*__ptr(ptr)), "i"(-EFAULT), "0"(err)	\
	    );						\
} while(0)

#else

#define __get_user_asm(err,x,ptr,bwl,con)	\
	asm("	ld"bwl"%I1	%M1,%0	\n"	\
	    "	membar			\n"	\
	    : con(x)				\
	    : "m" (*__ptr(ptr)))

#endif

/*****************************************************************************/
/*
 *
 */
#define ____force(x) (__force void *)(void __user *)(x)
#ifdef CONFIG_MMU
extern long __memset_user(void *dst, unsigned long count);
extern long __memcpy_user(void *dst, const void *src, unsigned long count);

#define clear_user(dst,count)			__memset_user(____force(dst), (count))
#define __copy_from_user_inatomic(to, from, n)	__memcpy_user((to), ____force(from), (n))
#define __copy_to_user_inatomic(to, from, n)	__memcpy_user(____force(to), (from), (n))

#else

#define clear_user(dst,count)			(memset(____force(dst), 0, (count)), 0)
#define __copy_from_user_inatomic(to, from, n)	(memcpy((to), ____force(from), (n)), 0)
#define __copy_to_user_inatomic(to, from, n)	(memcpy(____force(to), (from), (n)), 0)

#endif

#define __clear_user clear_user

static inline unsigned long __must_check
__copy_to_user(void __user *to, const void *from, unsigned long n)
{
       might_sleep();
       return __copy_to_user_inatomic(to, from, n);
}

static inline unsigned long
__copy_from_user(void *to, const void __user *from, unsigned long n)
{
       might_sleep();
       return __copy_from_user_inatomic(to, from, n);
}

static inline long copy_from_user(void *to, const void __user *from, unsigned long n)
{
	unsigned long ret = n;

	if (likely(__access_ok(from, n)))
		ret = __copy_from_user(to, from, n);

	if (unlikely(ret != 0))
		memset(to + (n - ret), 0, ret);

	return ret;
}

static inline long copy_to_user(void __user *to, const void *from, unsigned long n)
{
	return likely(__access_ok(to, n)) ? __copy_to_user(to, from, n) : n;
}

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

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

extern unsigned long search_exception_table(unsigned long addr);

#endif /* _ASM_UACCESS_H */
Commit	Line	Data
1da177e4 LT	1	/* uaccess.h: userspace accessor functions
	2	*
	3	* Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells ([email protected])
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*/
	11
	12	#ifndef _ASM_UACCESS_H
	13	#define _ASM_UACCESS_H
	14
	15	/*
	16	* User space memory access functions
	17	*/
	18	#include <linux/sched.h>
	19	#include <linux/mm.h>
	20	#include <asm/segment.h>
	21	#include <asm/sections.h>
	22
	23	#define HAVE_ARCH_UNMAPPED_AREA /* we decide where to put mmaps */
	24
a8a77573	25	#define __ptr(x) ((unsigned long __force *)(x))
1da177e4 LT	26
	27	#define VERIFY_READ 0
	28	#define VERIFY_WRITE 1
	29
	30	#define __addr_ok(addr) ((unsigned long)(addr) < get_addr_limit())
	31
	32	/*
	33	* check that a range of addresses falls within the current address limit
	34	*/
	35	static inline int ___range_ok(unsigned long addr, unsigned long size)
	36	{
	37	#ifdef CONFIG_MMU
	38	int flag = -EFAULT, tmp;
	39
	40	asm volatile (
	41	" addcc %3,%2,%1,icc0 \n" /* set C-flag if addr+size>4GB */
	42	" subcc.p %1,%4,gr0,icc1 \n" /* jump if addr+size>limit */
	43	" bc icc0,#0,0f \n"
	44	" bhi icc1,#0,0f \n"
	45	" setlos #0,%0 \n" /* mark okay */
	46	"0: \n"
	47	: "=r"(flag), "=&r"(tmp)
	48	: "r"(addr), "r"(size), "r"(get_addr_limit()), "0"(flag)
	49	);
	50
	51	return flag;
	52
	53	#else
	54
	55	if (addr < memory_start \|\|
	56	addr > memory_end \|\|
	57	size > memory_end - memory_start \|\|
	58	addr + size > memory_end)
	59	return -EFAULT;
	60
	61	return 0;
	62	#endif
	63	}
	64
	65	#define __range_ok(addr,size) ___range_ok((unsigned long) (addr), (unsigned long) (size))
	66
a8a77573	67	#define access_ok(type,addr,size) (__range_ok((void __user *)(addr), (size)) == 0)
1da177e4 LT	68	#define __access_ok(addr,size) (__range_ok((addr), (size)) == 0)
1da177e4 LT	69
1da177e4 LT	70	/*
	71	* The exception table consists of pairs of addresses: the first is the
	72	* address of an instruction that is allowed to fault, and the second is
	73	* the address at which the program should continue. No registers are
	74	* modified, so it is entirely up to the continuation code to figure out
	75	* what to do.
	76	*
	77	* All the routines below use bits of fixup code that are out of line
	78	* with the main instruction path. This means when everything is well,
	79	* we don't even have to jump over them. Further, they do not intrude
	80	* on our cache or tlb entries.
	81	*/
	82	struct exception_table_entry
	83	{
	84	unsigned long insn, fixup;
	85	};
	86
	87	/* Returns 0 if exception not found and fixup otherwise. */
	88	extern unsigned long search_exception_table(unsigned long);
	89
	90
	91	/*
	92	* These are the main single-value transfer routines. They automatically
	93	* use the right size if we just have the right pointer type.
	94	*/
	95	#define __put_user(x, ptr) \
	96	({ \
	97	int __pu_err = 0; \
	98	\
	99	typeof(*(ptr)) __pu_val = (x); \
a8a77573	100	__chk_user_ptr(ptr); \
1da177e4 LT	101	\
	102	switch (sizeof (*(ptr))) { \
	103	case 1: \
	104	__put_user_asm(__pu_err, __pu_val, ptr, "b", "r"); \
	105	break; \
	106	case 2: \
	107	__put_user_asm(__pu_err, __pu_val, ptr, "h", "r"); \
	108	break; \
	109	case 4: \
	110	__put_user_asm(__pu_err, __pu_val, ptr, "", "r"); \
	111	break; \
	112	case 8: \
	113	__put_user_asm(__pu_err, __pu_val, ptr, "d", "e"); \
	114	break; \
	115	default: \
	116	__pu_err = __put_user_bad(); \
	117	break; \
	118	} \
	119	__pu_err; \
	120	})
	121
	122	#define put_user(x, ptr) \
	123	({ \
a8a77573	124	typeof((ptr)) __user _p = (ptr); \
1da177e4 LT	125	int _e; \
	126	\
	127	_e = __range_ok(_p, sizeof(*_p)); \
	128	if (_e == 0) \
	129	_e = __put_user((x), _p); \
	130	_e; \
	131	})
	132
	133	extern int __put_user_bad(void);
	134
	135	/*
	136	* Tell gcc we read from memory instead of writing: this is because
	137	* we do not write to any memory gcc knows about, so there are no
	138	* aliasing issues.
	139	*/
	140
	141	#ifdef CONFIG_MMU
	142
	143	#define __put_user_asm(err,x,ptr,dsize,constraint) \
	144	do { \
	145	asm volatile("1: st"dsize"%I1 %2,%M1 \n" \
	146	"2: \n" \
	147	".subsection 2 \n" \
	148	"3: setlos %3,%0 \n" \
	149	" bra 2b \n" \
	150	".previous \n" \
	151	".section __ex_table,\"a\" \n" \
	152	" .balign 8 \n" \
	153	" .long 1b,3b \n" \
	154	".previous" \
	155	: "=r" (err) \
	156	: "m" (*__ptr(ptr)), constraint (x), "i"(-EFAULT), "0"(err) \
	157	: "memory"); \
	158	} while (0)
	159
	160	#else
	161
	162	#define __put_user_asm(err,x,ptr,bwl,con) \
	163	do { \
	164	asm(" st"bwl"%I0 %1,%M0 \n" \
	165	" membar \n" \
	166	: \
	167	: "m" (*__ptr(ptr)), con (x) \
	168	: "memory"); \
	169	} while (0)
	170
	171	#endif
	172
	173	/*****************************************************************************/
	174	/*
	175	*
	176	*/
	177	#define __get_user(x, ptr) \
	178	({ \
1da177e4	179	int __gu_err = 0; \
a8a77573	180	__chk_user_ptr(ptr); \
1da177e4 LT	181	\
1da177e4 LT	182	switch (sizeof(*(ptr))) { \
a8a77573 AV	183	case 1: { \
	184	unsigned char __gu_val; \
	185	__get_user_asm(__gu_err, __gu_val, ptr, "ub", "=r"); \
	186	(x) = (__force __typeof__((ptr)) *) &__gu_val; \
1da177e4	187	break; \
a8a77573 AV	188	} \
	189	case 2: { \
	190	unsigned short __gu_val; \
	191	__get_user_asm(__gu_err, __gu_val, ptr, "uh", "=r"); \
	192	(x) = (__force __typeof__((ptr)) *) &__gu_val; \
1da177e4	193	break; \
a8a77573 AV	194	} \
	195	case 4: { \
	196	unsigned int __gu_val; \
	197	__get_user_asm(__gu_err, __gu_val, ptr, "", "=r"); \
	198	(x) = (__force __typeof__((ptr)) *) &__gu_val; \
1da177e4	199	break; \
a8a77573 AV	200	} \
	201	case 8: { \
	202	unsigned long long __gu_val; \
	203	__get_user_asm(__gu_err, __gu_val, ptr, "d", "=e"); \
	204	(x) = (__force __typeof__((ptr)) *) &__gu_val; \
1da177e4	205	break; \
a8a77573	206	} \
1da177e4 LT	207	default: \
	208	__gu_err = __get_user_bad(); \
	209	break; \
	210	} \
1da177e4 LT	211	__gu_err; \
	212	})
	213
	214	#define get_user(x, ptr) \
	215	({ \
a8a77573	216	const typeof((ptr)) __user _p = (ptr);\
1da177e4 LT	217	int _e; \
	218	\
	219	_e = __range_ok(_p, sizeof(*_p)); \
	220	if (likely(_e == 0)) \
	221	_e = __get_user((x), _p); \
	222	else \
	223	(x) = (typeof(x)) 0; \
	224	_e; \
	225	})
	226
	227	extern int __get_user_bad(void);
	228
	229	#ifdef CONFIG_MMU
	230
	231	#define __get_user_asm(err,x,ptr,dtype,constraint) \
	232	do { \
	233	asm("1: ld"dtype"%I2 %M2,%1 \n" \
	234	"2: \n" \
	235	".subsection 2 \n" \
	236	"3: setlos %3,%0 \n" \
	237	" setlos #0,%1 \n" \
	238	" bra 2b \n" \
	239	".previous \n" \
	240	".section __ex_table,\"a\" \n" \
	241	" .balign 8 \n" \
	242	" .long 1b,3b \n" \
	243	".previous" \
	244	: "=r" (err), constraint (x) \
	245	: "m" (*__ptr(ptr)), "i"(-EFAULT), "0"(err) \
	246	); \
	247	} while(0)
	248
	249	#else
	250
	251	#define __get_user_asm(err,x,ptr,bwl,con) \
	252	asm(" ld"bwl"%I1 %M1,%0 \n" \
	253	" membar \n" \
	254	: con(x) \
	255	: "m" (*__ptr(ptr)))
	256
	257	#endif
	258
	259	/*****************************************************************************/
	260	/*
	261	*
	262	*/
a8a77573	263	#define ____force(x) (__force void )(void __user )(x)
1da177e4 LT	264	#ifdef CONFIG_MMU
	265	extern long __memset_user(void *dst, unsigned long count);
	266	extern long __memcpy_user(void dst, const void src, unsigned long count);
	267
a8a77573 AV	268	#define clear_user(dst,count) __memset_user(____force(dst), (count))
	269	#define __copy_from_user_inatomic(to, from, n) __memcpy_user((to), ____force(from), (n))
	270	#define __copy_to_user_inatomic(to, from, n) __memcpy_user(____force(to), (from), (n))
1da177e4 LT	271
	272	#else
	273
a8a77573 AV	274	#define clear_user(dst,count) (memset(____force(dst), 0, (count)), 0)
	275	#define __copy_from_user_inatomic(to, from, n) (memcpy((to), ____force(from), (n)), 0)
	276	#define __copy_to_user_inatomic(to, from, n) (memcpy(____force(to), (from), (n)), 0)
1da177e4 LT	277
	278	#endif
	279
b4a06918 AV	280	#define __clear_user clear_user
b4a06918 AV	281
1da177e4 LT	282	static inline unsigned long __must_check
	283	__copy_to_user(void __user to, const void from, unsigned long n)
	284	{
	285	might_sleep();
	286	return __copy_to_user_inatomic(to, from, n);
	287	}
	288
	289	static inline unsigned long
	290	__copy_from_user(void to, const void __user from, unsigned long n)
	291	{
	292	might_sleep();
	293	return __copy_from_user_inatomic(to, from, n);
	294	}
	295
a8a77573	296	static inline long copy_from_user(void to, const void __user from, unsigned long n)
1da177e4 LT	297	{
	298	unsigned long ret = n;
	299
	300	if (likely(__access_ok(from, n)))
	301	ret = __copy_from_user(to, from, n);
	302
	303	if (unlikely(ret != 0))
	304	memset(to + (n - ret), 0, ret);
	305
	306	return ret;
	307	}
	308
a8a77573	309	static inline long copy_to_user(void __user to, const void from, unsigned long n)
1da177e4 LT	310	{
	311	return likely(__access_ok(to, n)) ? __copy_to_user(to, from, n) : n;
	312	}
	313
a8a77573 AV	314	extern long strncpy_from_user(char dst, const char __user src, long count);
a8a77573 AV	315	extern long strnlen_user(const char __user *src, long count);
1da177e4 LT	316
	317	#define strlen_user(str) strnlen_user(str, 32767)
	318
	319	extern unsigned long search_exception_table(unsigned long addr);
	320
1da177e4	321	#endif /* _ASM_UACCESS_H */