[deliverable/linux.git] / arch / sparc / include / asm / uaccess_32.h

/*
 * uaccess.h: User space memore access functions.
 *
 * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
 * Copyright (C) 1996,1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
 */
#ifndef _ASM_UACCESS_H
#define _ASM_UACCESS_H

#ifdef __KERNEL__
#include <linux/compiler.h>
#include <linux/sched.h>
#include <linux/string.h>
#include <linux/errno.h>
#endif

#ifndef __ASSEMBLY__

#include <asm/processor.h>

#define ARCH_HAS_SORT_EXTABLE
#define ARCH_HAS_SEARCH_EXTABLE

/* Sparc is not segmented, however we need to be able to fool access_ok()
 * when doing system calls from kernel mode legitimately.
 *
 * "For historical reasons, these macros are grossly misnamed." -Linus
 */

#define KERNEL_DS   ((mm_segment_t) { 0 })
#define USER_DS     ((mm_segment_t) { -1 })

#define VERIFY_READ	0
#define VERIFY_WRITE	1

#define get_ds()	(KERNEL_DS)
#define get_fs()	(current->thread.current_ds)
#define set_fs(val)	((current->thread.current_ds) = (val))

#define segment_eq(a, b) ((a).seg == (b).seg)

/* We have there a nice not-mapped page at PAGE_OFFSET - PAGE_SIZE, so that this test
 * can be fairly lightweight.
 * No one can read/write anything from userland in the kernel space by setting
 * large size and address near to PAGE_OFFSET - a fault will break his intentions.
 */
#define __user_ok(addr, size) ({ (void)(size); (addr) < STACK_TOP; })
#define __kernel_ok (segment_eq(get_fs(), KERNEL_DS))
#define __access_ok(addr, size) (__user_ok((addr) & get_fs().seg, (size)))
#define access_ok(type, addr, size) \
	({ (void)(type); __access_ok((unsigned long)(addr), size); })

/*
 * 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.
 *
 * There is a special way how to put a range of potentially faulting
 * insns (like twenty ldd/std's with now intervening other instructions)
 * You specify address of first in insn and 0 in fixup and in the next
 * exception_table_entry you specify last potentially faulting insn + 1
 * and in fixup the routine which should handle the fault.
 * That fixup code will get
 * (faulting_insn_address - first_insn_in_the_range_address)/4
 * in %g2 (ie. index of the faulting instruction in the range).
 */

struct exception_table_entry
{
        unsigned long insn, fixup;
};

/* Returns 0 if exception not found and fixup otherwise.  */
unsigned long search_extables_range(unsigned long addr, unsigned long *g2);

void __ret_efault(void);

/* Uh, these should become the main single-value transfer routines..
 * They automatically use the right size if we just have the right
 * pointer type..
 *
 * This gets kind of ugly. We want to return _two_ values in "get_user()"
 * and yet we don't want to do any pointers, because that is too much
 * of a performance impact. Thus we have a few rather ugly macros here,
 * and hide all the ugliness from the user.
 */
#define put_user(x, ptr) ({ \
	unsigned long __pu_addr = (unsigned long)(ptr); \
	__chk_user_ptr(ptr); \
	__put_user_check((__typeof__(*(ptr)))(x), __pu_addr, sizeof(*(ptr))); \
})

#define get_user(x, ptr) ({ \
	unsigned long __gu_addr = (unsigned long)(ptr); \
	__chk_user_ptr(ptr); \
	__get_user_check((x), __gu_addr, sizeof(*(ptr)), __typeof__(*(ptr))); \
})

/*
 * The "__xxx" versions do not do address space checking, useful when
 * doing multiple accesses to the same area (the user has to do the
 * checks by hand with "access_ok()")
 */
#define __put_user(x, ptr) \
	__put_user_nocheck((__typeof__(*(ptr)))(x), (ptr), sizeof(*(ptr)))
#define __get_user(x, ptr) \
    __get_user_nocheck((x), (ptr), sizeof(*(ptr)), __typeof__(*(ptr)))

struct __large_struct { unsigned long buf[100]; };
#define __m(x) ((struct __large_struct __user *)(x))

#define __put_user_check(x, addr, size) ({ \
	register int __pu_ret; \
	if (__access_ok(addr, size)) { \
		switch (size) { \
		case 1: \
			__put_user_asm(x, b, addr, __pu_ret); \
			break; \
		case 2: \
			__put_user_asm(x, h, addr, __pu_ret); \
			break; \
		case 4: \
			__put_user_asm(x, , addr, __pu_ret); \
			break; \
		case 8: \
			__put_user_asm(x, d, addr, __pu_ret); \
			break; \
		default: \
			__pu_ret = __put_user_bad(); \
			break; \
		} \
	} else { \
		__pu_ret = -EFAULT; \
	} \
	__pu_ret; \
})

#define __put_user_nocheck(x, addr, size) ({			\
	register int __pu_ret;					\
	switch (size) {						\
	case 1: __put_user_asm(x, b, addr, __pu_ret); break;	\
	case 2: __put_user_asm(x, h, addr, __pu_ret); break;	\
	case 4: __put_user_asm(x, , addr, __pu_ret); break;	\
	case 8: __put_user_asm(x, d, addr, __pu_ret); break;	\
	default: __pu_ret = __put_user_bad(); break;		\
	} \
	__pu_ret; \
})

#define __put_user_asm(x, size, addr, ret)				\
__asm__ __volatile__(							\
		"/* Put user asm, inline. */\n"				\
	"1:\t"	"st"#size " %1, %2\n\t"					\
		"clr	%0\n"						\
	"2:\n\n\t"							\
		".section .fixup,#alloc,#execinstr\n\t"			\
		".align	4\n"						\
	"3:\n\t"							\
		"b	2b\n\t"						\
		" mov	%3, %0\n\t"					\
		".previous\n\n\t"					\
		".section __ex_table,#alloc\n\t"			\
		".align	4\n\t"						\
		".word	1b, 3b\n\t"					\
		".previous\n\n\t"					\
	       : "=&r" (ret) : "r" (x), "m" (*__m(addr)),		\
		 "i" (-EFAULT))

int __put_user_bad(void);

#define __get_user_check(x, addr, size, type) ({ \
	register int __gu_ret; \
	register unsigned long __gu_val; \
	if (__access_ok(addr, size)) { \
		switch (size) { \
		case 1: \
			 __get_user_asm(__gu_val, ub, addr, __gu_ret); \
			break; \
		case 2: \
			__get_user_asm(__gu_val, uh, addr, __gu_ret); \
			break; \
		case 4: \
			__get_user_asm(__gu_val, , addr, __gu_ret); \
			break; \
		case 8: \
			__get_user_asm(__gu_val, d, addr, __gu_ret); \
			break; \
		default: \
			__gu_val = 0; \
			__gu_ret = __get_user_bad(); \
			break; \
		} \
	 } else { \
		 __gu_val = 0; \
		 __gu_ret = -EFAULT; \
	} \
	x = (__force type) __gu_val; \
	__gu_ret; \
})

#define __get_user_nocheck(x, addr, size, type) ({			\
	register int __gu_ret;						\
	register unsigned long __gu_val;				\
	switch (size) {							\
	case 1: __get_user_asm(__gu_val, ub, addr, __gu_ret); break;	\
	case 2: __get_user_asm(__gu_val, uh, addr, __gu_ret); break;	\
	case 4: __get_user_asm(__gu_val, , addr, __gu_ret); break;	\
	case 8: __get_user_asm(__gu_val, d, addr, __gu_ret); break;	\
	default:							\
		__gu_val = 0;						\
		__gu_ret = __get_user_bad();				\
		break;							\
	}								\
	x = (__force type) __gu_val;					\
	__gu_ret;							\
})

#define __get_user_asm(x, size, addr, ret)				\
__asm__ __volatile__(							\
		"/* Get user asm, inline. */\n"				\
	"1:\t"	"ld"#size " %2, %1\n\t"					\
		"clr	%0\n"						\
	"2:\n\n\t"							\
		".section .fixup,#alloc,#execinstr\n\t"			\
		".align	4\n"						\
	"3:\n\t"							\
		"clr	%1\n\t"						\
		"b	2b\n\t"						\
		" mov	%3, %0\n\n\t"					\
		".previous\n\t"						\
		".section __ex_table,#alloc\n\t"			\
		".align	4\n\t"						\
		".word	1b, 3b\n\n\t"					\
		".previous\n\t"						\
	       : "=&r" (ret), "=&r" (x) : "m" (*__m(addr)),		\
		 "i" (-EFAULT))

int __get_user_bad(void);

unsigned long __copy_user(void __user *to, const void __user *from, unsigned long size);

static inline unsigned long copy_to_user(void __user *to, const void *from, unsigned long n)
{
	if (n && __access_ok((unsigned long) to, n)) {
		check_object_size(from, n, true);
		return __copy_user(to, (__force void __user *) from, n);
	} else
		return n;
}

static inline unsigned long __copy_to_user(void __user *to, const void *from, unsigned long n)
{
	check_object_size(from, n, true);
	return __copy_user(to, (__force void __user *) from, n);
}

static inline unsigned long copy_from_user(void *to, const void __user *from, unsigned long n)
{
	if (n && __access_ok((unsigned long) from, n)) {
		check_object_size(to, n, false);
		return __copy_user((__force void __user *) to, from, n);
	} else
		return n;
}

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

#define __copy_to_user_inatomic __copy_to_user
#define __copy_from_user_inatomic __copy_from_user

static inline unsigned long __clear_user(void __user *addr, unsigned long size)
{
	unsigned long ret;

	__asm__ __volatile__ (
		".section __ex_table,#alloc\n\t"
		".align 4\n\t"
		".word 1f,3\n\t"
		".previous\n\t"
		"mov %2, %%o1\n"
		"1:\n\t"
		"call __bzero\n\t"
		" mov %1, %%o0\n\t"
		"mov %%o0, %0\n"
		: "=r" (ret) : "r" (addr), "r" (size) :
		"o0", "o1", "o2", "o3", "o4", "o5", "o7",
		"g1", "g2", "g3", "g4", "g5", "g7", "cc");

	return ret;
}

static inline unsigned long clear_user(void __user *addr, unsigned long n)
{
	if (n && __access_ok((unsigned long) addr, n))
		return __clear_user(addr, n);
	else
		return n;
}

__must_check long strlen_user(const char __user *str);
__must_check long strnlen_user(const char __user *str, long n);

#endif  /* __ASSEMBLY__ */

#endif /* _ASM_UACCESS_H */
Commit	Line	Data
f5e706ad SR	1	/*
	2	* uaccess.h: User space memore access functions.
	3	*
	4	* Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
	5	* Copyright (C) 1996,1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
	6	*/
	7	#ifndef _ASM_UACCESS_H
	8	#define _ASM_UACCESS_H
	9
	10	#ifdef __KERNEL__
	11	#include <linux/compiler.h>
	12	#include <linux/sched.h>
	13	#include <linux/string.h>
	14	#include <linux/errno.h>
f5e706ad SR	15	#endif
	16
	17	#ifndef __ASSEMBLY__
	18
2c66f623 DM	19	#include <asm/processor.h>
2c66f623 DM	20
ad6561df RR	21	#define ARCH_HAS_SORT_EXTABLE
	22	#define ARCH_HAS_SEARCH_EXTABLE
	23
f5e706ad SR	24	/* Sparc is not segmented, however we need to be able to fool access_ok()
	25	* when doing system calls from kernel mode legitimately.
	26	*
	27	* "For historical reasons, these macros are grossly misnamed." -Linus
	28	*/
	29
	30	#define KERNEL_DS ((mm_segment_t) { 0 })
	31	#define USER_DS ((mm_segment_t) { -1 })
	32
	33	#define VERIFY_READ 0
	34	#define VERIFY_WRITE 1
	35
	36	#define get_ds() (KERNEL_DS)
	37	#define get_fs() (current->thread.current_ds)
	38	#define set_fs(val) ((current->thread.current_ds) = (val))
	39
8ccf7b25	40	#define segment_eq(a, b) ((a).seg == (b).seg)
f5e706ad SR	41
	42	/* We have there a nice not-mapped page at PAGE_OFFSET - PAGE_SIZE, so that this test
	43	* can be fairly lightweight.
	44	* No one can read/write anything from userland in the kernel space by setting
	45	* large size and address near to PAGE_OFFSET - a fault will break his intentions.
	46	*/
	47	#define __user_ok(addr, size) ({ (void)(size); (addr) < STACK_TOP; })
	48	#define __kernel_ok (segment_eq(get_fs(), KERNEL_DS))
8ccf7b25 MT	49	#define __access_ok(addr, size) (__user_ok((addr) & get_fs().seg, (size)))
8ccf7b25 MT	50	#define access_ok(type, addr, size) \
f5e706ad SR	51	({ (void)(type); __access_ok((unsigned long)(addr), size); })
	52
	53	/*
	54	* The exception table consists of pairs of addresses: the first is the
	55	* address of an instruction that is allowed to fault, and the second is
	56	* the address at which the program should continue. No registers are
	57	* modified, so it is entirely up to the continuation code to figure out
	58	* what to do.
	59	*
	60	* All the routines below use bits of fixup code that are out of line
	61	* with the main instruction path. This means when everything is well,
	62	* we don't even have to jump over them. Further, they do not intrude
	63	* on our cache or tlb entries.
	64	*
	65	* There is a special way how to put a range of potentially faulting
	66	* insns (like twenty ldd/std's with now intervening other instructions)
	67	* You specify address of first in insn and 0 in fixup and in the next
	68	* exception_table_entry you specify last potentially faulting insn + 1
	69	* and in fixup the routine which should handle the fault.
	70	* That fixup code will get
	71	* (faulting_insn_address - first_insn_in_the_range_address)/4
	72	* in %g2 (ie. index of the faulting instruction in the range).
	73	*/
	74
	75	struct exception_table_entry
	76	{
	77	unsigned long insn, fixup;
	78	};
	79
	80	/* Returns 0 if exception not found and fixup otherwise. */
f05a6865	81	unsigned long search_extables_range(unsigned long addr, unsigned long *g2);
f5e706ad	82
f05a6865	83	void __ret_efault(void);
f5e706ad SR	84
	85	/* Uh, these should become the main single-value transfer routines..
	86	* They automatically use the right size if we just have the right
	87	* pointer type..
	88	*
	89	* This gets kind of ugly. We want to return _two_ values in "get_user()"
	90	* and yet we don't want to do any pointers, because that is too much
	91	* of a performance impact. Thus we have a few rather ugly macros here,
	92	* and hide all the ugliness from the user.
	93	*/
8ccf7b25 MT	94	#define put_user(x, ptr) ({ \
	95	unsigned long __pu_addr = (unsigned long)(ptr); \
	96	__chk_user_ptr(ptr); \
	97	__put_user_check((__typeof__((ptr)))(x), __pu_addr, sizeof((ptr))); \
	98	})
	99
	100	#define get_user(x, ptr) ({ \
	101	unsigned long __gu_addr = (unsigned long)(ptr); \
	102	__chk_user_ptr(ptr); \
	103	__get_user_check((x), __gu_addr, sizeof((ptr)), __typeof__((ptr))); \
	104	})
f5e706ad SR	105
	106	/*
	107	* The "__xxx" versions do not do address space checking, useful when
	108	* doing multiple accesses to the same area (the user has to do the
	109	* checks by hand with "access_ok()")
	110	*/
8ccf7b25 MT	111	#define __put_user(x, ptr) \
	112	__put_user_nocheck((__typeof__((ptr)))(x), (ptr), sizeof((ptr)))
	113	#define __get_user(x, ptr) \
	114	__get_user_nocheck((x), (ptr), sizeof((ptr)), __typeof__((ptr)))
f5e706ad SR	115
	116	struct __large_struct { unsigned long buf[100]; };
	117	#define __m(x) ((struct __large_struct __user *)(x))
	118
8ccf7b25 MT	119	#define __put_user_check(x, addr, size) ({ \
	120	register int __pu_ret; \
	121	if (__access_ok(addr, size)) { \
	122	switch (size) { \
	123	case 1: \
	124	__put_user_asm(x, b, addr, __pu_ret); \
	125	break; \
	126	case 2: \
	127	__put_user_asm(x, h, addr, __pu_ret); \
	128	break; \
	129	case 4: \
	130	__put_user_asm(x, , addr, __pu_ret); \
	131	break; \
	132	case 8: \
	133	__put_user_asm(x, d, addr, __pu_ret); \
	134	break; \
	135	default: \
	136	__pu_ret = __put_user_bad(); \
	137	break; \
	138	} \
	139	} else { \
	140	__pu_ret = -EFAULT; \
	141	} \
	142	__pu_ret; \
	143	})
	144
0795cb1b MT	145	#define __put_user_nocheck(x, addr, size) ({ \
	146	register int __pu_ret; \
	147	switch (size) { \
	148	case 1: __put_user_asm(x, b, addr, __pu_ret); break; \
	149	case 2: __put_user_asm(x, h, addr, __pu_ret); break; \
	150	case 4: __put_user_asm(x, , addr, __pu_ret); break; \
	151	case 8: __put_user_asm(x, d, addr, __pu_ret); break; \
	152	default: __pu_ret = __put_user_bad(); break; \
8ccf7b25 MT	153	} \
	154	__pu_ret; \
	155	})
	156
	157	#define __put_user_asm(x, size, addr, ret) \
f5e706ad	158	__asm__ __volatile__( \
8ccf7b25 MT	159	"/* Put user asm, inline. */\n" \
	160	"1:\t" "st"#size " %1, %2\n\t" \
	161	"clr %0\n" \
	162	"2:\n\n\t" \
	163	".section .fixup,#alloc,#execinstr\n\t" \
	164	".align 4\n" \
	165	"3:\n\t" \
	166	"b 2b\n\t" \
	167	" mov %3, %0\n\t" \
	168	".previous\n\n\t" \
	169	".section __ex_table,#alloc\n\t" \
	170	".align 4\n\t" \
	171	".word 1b, 3b\n\t" \
	172	".previous\n\n\t" \
	173	: "=&r" (ret) : "r" (x), "m" (*__m(addr)), \
	174	"i" (-EFAULT))
f5e706ad	175
f05a6865	176	int __put_user_bad(void);
f5e706ad	177
8ccf7b25 MT	178	#define __get_user_check(x, addr, size, type) ({ \
	179	register int __gu_ret; \
	180	register unsigned long __gu_val; \
	181	if (__access_ok(addr, size)) { \
	182	switch (size) { \
	183	case 1: \
	184	__get_user_asm(__gu_val, ub, addr, __gu_ret); \
	185	break; \
	186	case 2: \
	187	__get_user_asm(__gu_val, uh, addr, __gu_ret); \
	188	break; \
	189	case 4: \
	190	__get_user_asm(__gu_val, , addr, __gu_ret); \
	191	break; \
	192	case 8: \
	193	__get_user_asm(__gu_val, d, addr, __gu_ret); \
	194	break; \
	195	default: \
	196	__gu_val = 0; \
	197	__gu_ret = __get_user_bad(); \
	198	break; \
	199	} \
	200	} else { \
	201	__gu_val = 0; \
	202	__gu_ret = -EFAULT; \
	203	} \
	204	x = (__force type) __gu_val; \
	205	__gu_ret; \
	206	})
	207
0795cb1b MT	208	#define __get_user_nocheck(x, addr, size, type) ({ \
	209	register int __gu_ret; \
	210	register unsigned long __gu_val; \
	211	switch (size) { \
	212	case 1: __get_user_asm(__gu_val, ub, addr, __gu_ret); break; \
	213	case 2: __get_user_asm(__gu_val, uh, addr, __gu_ret); break; \
	214	case 4: __get_user_asm(__gu_val, , addr, __gu_ret); break; \
	215	case 8: __get_user_asm(__gu_val, d, addr, __gu_ret); break; \
	216	default: \
	217	__gu_val = 0; \
	218	__gu_ret = __get_user_bad(); \
	219	break; \
	220	} \
	221	x = (__force type) __gu_val; \
	222	__gu_ret; \
8ccf7b25 MT	223	})
8ccf7b25 MT	224
8ccf7b25	225	#define __get_user_asm(x, size, addr, ret) \
f5e706ad	226	__asm__ __volatile__( \
8ccf7b25 MT	227	"/* Get user asm, inline. */\n" \
	228	"1:\t" "ld"#size " %2, %1\n\t" \
	229	"clr %0\n" \
	230	"2:\n\n\t" \
	231	".section .fixup,#alloc,#execinstr\n\t" \
	232	".align 4\n" \
	233	"3:\n\t" \
	234	"clr %1\n\t" \
	235	"b 2b\n\t" \
	236	" mov %3, %0\n\n\t" \
	237	".previous\n\t" \
	238	".section __ex_table,#alloc\n\t" \
	239	".align 4\n\t" \
	240	".word 1b, 3b\n\n\t" \
	241	".previous\n\t" \
	242	: "=&r" (ret), "=&r" (x) : "m" (*__m(addr)), \
	243	"i" (-EFAULT))
	244
f05a6865	245	int __get_user_bad(void);
f5e706ad	246
f05a6865	247	unsigned long __copy_user(void __user to, const void __user from, unsigned long size);
f5e706ad SR	248
	249	static inline unsigned long copy_to_user(void __user to, const void from, unsigned long n)
	250	{
9d9208a1	251	if (n && __access_ok((unsigned long) to, n)) {
81409e9e	252	check_object_size(from, n, true);
f5e706ad	253	return __copy_user(to, (__force void __user *) from, n);
9d9208a1	254	} else
f5e706ad SR	255	return n;
	256	}
	257
	258	static inline unsigned long __copy_to_user(void __user to, const void from, unsigned long n)
	259	{
81409e9e	260	check_object_size(from, n, true);
f5e706ad SR	261	return __copy_user(to, (__force void __user *) from, n);
	262	}
	263
	264	static inline unsigned long copy_from_user(void to, const void __user from, unsigned long n)
	265	{
9d9208a1	266	if (n && __access_ok((unsigned long) from, n)) {
81409e9e	267	check_object_size(to, n, false);
f5e706ad	268	return __copy_user((__force void __user *) to, from, n);
9d9208a1	269	} else
f5e706ad SR	270	return n;
	271	}
	272
	273	static inline unsigned long __copy_from_user(void to, const void __user from, unsigned long n)
	274	{
	275	return __copy_user((__force void __user *) to, from, n);
	276	}
	277
	278	#define __copy_to_user_inatomic __copy_to_user
	279	#define __copy_from_user_inatomic __copy_from_user
	280
	281	static inline unsigned long __clear_user(void __user *addr, unsigned long size)
	282	{
	283	unsigned long ret;
	284
	285	__asm__ __volatile__ (
	286	".section __ex_table,#alloc\n\t"
	287	".align 4\n\t"
	288	".word 1f,3\n\t"
	289	".previous\n\t"
	290	"mov %2, %%o1\n"
	291	"1:\n\t"
	292	"call __bzero\n\t"
	293	" mov %1, %%o0\n\t"
	294	"mov %%o0, %0\n"
	295	: "=r" (ret) : "r" (addr), "r" (size) :
	296	"o0", "o1", "o2", "o3", "o4", "o5", "o7",
	297	"g1", "g2", "g3", "g4", "g5", "g7", "cc");
	298
	299	return ret;
	300	}
	301
	302	static inline unsigned long clear_user(void __user *addr, unsigned long n)
	303	{
	304	if (n && __access_ok((unsigned long) addr, n))
	305	return __clear_user(addr, n);
	306	else
	307	return n;
	308	}
	309
f05a6865 SR	310	__must_check long strlen_user(const char __user *str);
f05a6865 SR	311	__must_check long strnlen_user(const char __user *str, long n);
f5e706ad SR	312
	313	#endif /* __ASSEMBLY__ */
	314
	315	#endif /* _ASM_UACCESS_H */