[mirror_ubuntu-artful-kernel.git] / arch / parisc / include / asm / uaccess.h

#ifndef __PARISC_UACCESS_H
#define __PARISC_UACCESS_H

/*
 * User space memory access functions
 */
#include <asm/page.h>
#include <asm/cache.h>
#include <asm/errno.h>
#include <asm-generic/uaccess-unaligned.h>

#include <linux/bug.h>
#include <linux/string.h>
#include <linux/thread_info.h>

#define VERIFY_READ 0
#define VERIFY_WRITE 1

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

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

#define get_ds()	(KERNEL_DS)
#define get_fs()	(current_thread_info()->addr_limit)
#define set_fs(x)	(current_thread_info()->addr_limit = (x))

/*
 * Note that since kernel addresses are in a separate address space on
 * parisc, we don't need to do anything for access_ok().
 * We just let the page fault handler do the right thing. This also means
 * that put_user is the same as __put_user, etc.
 */

#define access_ok(type, uaddr, size)	\
	( (uaddr) == (uaddr) )

#define put_user __put_user
#define get_user __get_user

#if !defined(CONFIG_64BIT)
#define LDD_USER(ptr)		__get_user_asm64(ptr)
#define STD_USER(x, ptr)	__put_user_asm64(x, ptr)
#else
#define LDD_USER(ptr)		__get_user_asm("ldd", ptr)
#define STD_USER(x, ptr)	__put_user_asm("std", x, ptr)
#endif

/*
 * The exception table contains two values: the first is the relative offset to
 * the address of the instruction that is allowed to fault, and the second is
 * the relative offset to the address of the fixup routine. Since relative
 * addresses are used, 32bit values are sufficient even on 64bit kernel.
 */

#define ARCH_HAS_RELATIVE_EXTABLE
struct exception_table_entry {
	int insn;	/* relative address of insn that is allowed to fault. */
	int fixup;	/* relative address of fixup routine */
};

#define ASM_EXCEPTIONTABLE_ENTRY( fault_addr, except_addr )\
	".section __ex_table,\"aw\"\n"			   \
	".word (" #fault_addr " - .), (" #except_addr " - .)\n\t" \
	".previous\n"

/*
 * ASM_EXCEPTIONTABLE_ENTRY_EFAULT() creates a special exception table entry
 * (with lowest bit set) for which the fault handler in fixup_exception() will
 * load -EFAULT into %r8 for a read or write fault, and zeroes the target
 * register in case of a read fault in get_user().
 */
#define ASM_EXCEPTIONTABLE_ENTRY_EFAULT( fault_addr, except_addr )\
	ASM_EXCEPTIONTABLE_ENTRY( fault_addr, except_addr + 1)

/*
 * The page fault handler stores, in a per-cpu area, the following information
 * if a fixup routine is available.
 */
struct exception_data {
	unsigned long fault_ip;
	unsigned long fault_gp;
	unsigned long fault_space;
	unsigned long fault_addr;
};

/*
 * load_sr2() preloads the space register %%sr2 - based on the value of
 * get_fs() - with either a value of 0 to access kernel space (KERNEL_DS which
 * is 0), or with the current value of %%sr3 to access user space (USER_DS)
 * memory. The following __get_user_asm() and __put_user_asm() functions have
 * %%sr2 hard-coded to access the requested memory.
 */
#define load_sr2() \
	__asm__(" or,=  %0,%%r0,%%r0\n\t"	\
		" mfsp %%sr3,%0\n\t"		\
		" mtsp %0,%%sr2\n\t"		\
		: : "r"(get_fs()) : )

#define __get_user(x, ptr)                               \
({                                                       \
	register long __gu_err __asm__ ("r8") = 0;       \
	register long __gu_val;				 \
							 \
	load_sr2();					 \
	switch (sizeof(*(ptr))) {			 \
	    case 1: __get_user_asm("ldb", ptr); break;   \
	    case 2: __get_user_asm("ldh", ptr); break;   \
	    case 4: __get_user_asm("ldw", ptr); break;   \
	    case 8: LDD_USER(ptr);  break;		 \
	    default: BUILD_BUG(); break;		 \
	}                                                \
							 \
	(x) = (__force __typeof__(*(ptr))) __gu_val;	 \
	__gu_err;                                        \
})

#define __get_user_asm(ldx, ptr)                        \
	__asm__("1: " ldx " 0(%%sr2,%2),%0\n"		\
		"9:\n"					\
		ASM_EXCEPTIONTABLE_ENTRY_EFAULT(1b, 9b)	\
		: "=r"(__gu_val), "=r"(__gu_err)        \
		: "r"(ptr), "1"(__gu_err));

#if !defined(CONFIG_64BIT)

#define __get_user_asm64(ptr) 				\
	__asm__("   copy %%r0,%R0\n"			\
		"1: ldw 0(%%sr2,%2),%0\n"		\
		"2: ldw 4(%%sr2,%2),%R0\n"		\
		"9:\n"					\
		ASM_EXCEPTIONTABLE_ENTRY_EFAULT(1b, 9b)	\
		ASM_EXCEPTIONTABLE_ENTRY_EFAULT(2b, 9b)	\
		: "=r"(__gu_val), "=r"(__gu_err)	\
		: "r"(ptr), "1"(__gu_err));

#endif /* !defined(CONFIG_64BIT) */


#define __put_user(x, ptr)                                      \
({								\
	register long __pu_err __asm__ ("r8") = 0;      	\
        __typeof__(*(ptr)) __x = (__typeof__(*(ptr)))(x);	\
								\
	load_sr2();						\
	switch (sizeof(*(ptr))) {				\
	    case 1: __put_user_asm("stb", __x, ptr); break;     \
	    case 2: __put_user_asm("sth", __x, ptr); break;     \
	    case 4: __put_user_asm("stw", __x, ptr); break;     \
	    case 8: STD_USER(__x, ptr); break;			\
	    default: BUILD_BUG(); break;			\
	}                                                       \
								\
	__pu_err;						\
})

/*
 * The "__put_user/kernel_asm()" macros tell gcc they read from memory
 * instead of writing. This is because they do not write to any memory
 * gcc knows about, so there are no aliasing issues. These macros must
 * also be aware that fixups are executed in the context of the fault,
 * and any registers used there must be listed as clobbers.
 * r8 is already listed as err.
 */

#define __put_user_asm(stx, x, ptr)                         \
	__asm__ __volatile__ (                              \
		"1: " stx " %2,0(%%sr2,%1)\n"		    \
		"9:\n"					    \
		ASM_EXCEPTIONTABLE_ENTRY_EFAULT(1b, 9b)	    \
		: "=r"(__pu_err)                            \
		: "r"(ptr), "r"(x), "0"(__pu_err))


#if !defined(CONFIG_64BIT)

#define __put_user_asm64(__val, ptr) do {	    	    \
	__asm__ __volatile__ (				    \
		"1: stw %2,0(%%sr2,%1)\n"		    \
		"2: stw %R2,4(%%sr2,%1)\n"		    \
		"9:\n"					    \
		ASM_EXCEPTIONTABLE_ENTRY_EFAULT(1b, 9b)	    \
		ASM_EXCEPTIONTABLE_ENTRY_EFAULT(2b, 9b)	    \
		: "=r"(__pu_err)                            \
		: "r"(ptr), "r"(__val), "0"(__pu_err));	    \
} while (0)

#endif /* !defined(CONFIG_64BIT) */


/*
 * Complex access routines -- external declarations
 */

extern unsigned long lcopy_to_user(void __user *, const void *, unsigned long);
extern unsigned long lcopy_from_user(void *, const void __user *, unsigned long);
extern unsigned long lcopy_in_user(void __user *, const void __user *, unsigned long);
extern long strncpy_from_user(char *, const char __user *, long);
extern unsigned lclear_user(void __user *, unsigned long);
extern long lstrnlen_user(const char __user *, long);
/*
 * Complex access routines -- macros
 */
#define user_addr_max() (~0UL)

#define strnlen_user lstrnlen_user
#define strlen_user(str) lstrnlen_user(str, 0x7fffffffL)
#define clear_user lclear_user
#define __clear_user lclear_user

unsigned long __must_check __copy_to_user(void __user *dst, const void *src,
					  unsigned long len);
unsigned long __must_check __copy_from_user(void *dst, const void __user *src,
					  unsigned long len);
unsigned long copy_in_user(void __user *dst, const void __user *src,
			   unsigned long len);
#define __copy_in_user copy_in_user
#define __copy_to_user_inatomic __copy_to_user
#define __copy_from_user_inatomic __copy_from_user

extern void __compiletime_error("usercopy buffer size is too small")
__bad_copy_user(void);

static inline void copy_user_overflow(int size, unsigned long count)
{
	WARN(1, "Buffer overflow detected (%d < %lu)!\n", size, count);
}

static __always_inline unsigned long __must_check
copy_from_user(void *to, const void __user *from, unsigned long n)
{
	int sz = __compiletime_object_size(to);
	unsigned long ret = n;

	if (likely(sz < 0 || sz >= n)) {
		check_object_size(to, n, false);
		ret = __copy_from_user(to, from, n);
	} else if (!__builtin_constant_p(n))
		copy_user_overflow(sz, n);
	else
		__bad_copy_user();

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

	return ret;
}

static __always_inline unsigned long __must_check
copy_to_user(void __user *to, const void *from, unsigned long n)
{
	int sz = __compiletime_object_size(from);

	if (likely(sz < 0 || sz >= n)) {
		check_object_size(from, n, true);
		n = __copy_to_user(to, from, n);
	} else if (!__builtin_constant_p(n))
		copy_user_overflow(sz, n);
	else
		__bad_copy_user();

	return n;
}

struct pt_regs;
int fixup_exception(struct pt_regs *regs);

#endif /* __PARISC_UACCESS_H */
Commit	Line	Data
1da177e4 LT	1	#ifndef __PARISC_UACCESS_H
	2	#define __PARISC_UACCESS_H
	3
	4	/*
	5	* User space memory access functions
	6	*/
1da177e4	7	#include <asm/page.h>
1da177e4	8	#include <asm/cache.h>
888c31fc	9	#include <asm/errno.h>
5b17e1cd	10	#include <asm-generic/uaccess-unaligned.h>
1da177e4	11
8dd95c68	12	#include <linux/bug.h>
aace880f	13	#include <linux/string.h>
9e91db6b	14	#include <linux/thread_info.h>
8dd95c68	15
1da177e4 LT	16	#define VERIFY_READ 0
	17	#define VERIFY_WRITE 1
	18
	19	#define KERNEL_DS ((mm_segment_t){0})
	20	#define USER_DS ((mm_segment_t){1})
	21
b9762e7b	22	#define segment_eq(a, b) ((a).seg == (b).seg)
1da177e4 LT	23
	24	#define get_ds() (KERNEL_DS)
	25	#define get_fs() (current_thread_info()->addr_limit)
	26	#define set_fs(x) (current_thread_info()->addr_limit = (x))
	27
	28	/*
	29	* Note that since kernel addresses are in a separate address space on
e49332bd	30	* parisc, we don't need to do anything for access_ok().
1da177e4 LT	31	* We just let the page fault handler do the right thing. This also means
	32	* that put_user is the same as __put_user, etc.
	33	*/
	34
186ecf14 HD	35	#define access_ok(type, uaddr, size) \
186ecf14 HD	36	( (uaddr) == (uaddr) )
1da177e4	37
1da177e4 LT	38	#define put_user __put_user
	39	#define get_user __get_user
	40
ca72a223	41	#if !defined(CONFIG_64BIT)
d2ad824f	42	#define LDD_USER(ptr) __get_user_asm64(ptr)
b9762e7b	43	#define STD_USER(x, ptr) __put_user_asm64(x, ptr)
1da177e4	44	#else
b9762e7b	45	#define LDD_USER(ptr) __get_user_asm("ldd", ptr)
b9762e7b	46	#define STD_USER(x, ptr) __put_user_asm("std", x, ptr)
1da177e4 LT	47	#endif
	48
	49	/*
cb910c17 HD	50	* The exception table contains two values: the first is the relative offset to
	51	* the address of the instruction that is allowed to fault, and the second is
	52	* the relative offset to the address of the fixup routine. Since relative
	53	* addresses are used, 32bit values are sufficient even on 64bit kernel.
1da177e4 LT	54	*/
1da177e4 LT	55
0de79858	56	#define ARCH_HAS_RELATIVE_EXTABLE
1da177e4	57	struct exception_table_entry {
0de79858 HD	58	int insn; /* relative address of insn that is allowed to fault. */
0de79858 HD	59	int fixup; /* relative address of fixup routine */
1da177e4 LT	60	};
1da177e4 LT	61
0b3d643f HD	62	#define ASM_EXCEPTIONTABLE_ENTRY( fault_addr, except_addr )\
0b3d643f HD	63	".section __ex_table,\"aw\"\n" \
0de79858	64	".word (" #fault_addr " - .), (" #except_addr " - .)\n\t" \
0b3d643f HD	65	".previous\n"
0b3d643f HD	66
d19f5e41 HD	67	/*
	68	* ASM_EXCEPTIONTABLE_ENTRY_EFAULT() creates a special exception table entry
	69	* (with lowest bit set) for which the fault handler in fixup_exception() will
	70	* load -EFAULT into %r8 for a read or write fault, and zeroes the target
	71	* register in case of a read fault in get_user().
	72	*/
	73	#define ASM_EXCEPTIONTABLE_ENTRY_EFAULT( fault_addr, except_addr )\
	74	ASM_EXCEPTIONTABLE_ENTRY( fault_addr, except_addr + 1)
	75
1da177e4 LT	76	/*
	77	* The page fault handler stores, in a per-cpu area, the following information
	78	* if a fixup routine is available.
	79	*/
	80	struct exception_data {
	81	unsigned long fault_ip;
2ef4dfd9	82	unsigned long fault_gp;
1da177e4 LT	83	unsigned long fault_space;
	84	unsigned long fault_addr;
	85	};
	86
06bff6b9 HD	87	/*
	88	* load_sr2() preloads the space register %%sr2 - based on the value of
	89	* get_fs() - with either a value of 0 to access kernel space (KERNEL_DS which
	90	* is 0), or with the current value of %%sr3 to access user space (USER_DS)
	91	* memory. The following __get_user_asm() and __put_user_asm() functions have
	92	* %%sr2 hard-coded to access the requested memory.
	93	*/
	94	#define load_sr2() \
	95	__asm__(" or,= %0,%%r0,%%r0\n\t" \
	96	" mfsp %%sr3,%0\n\t" \
	97	" mtsp %0,%%sr2\n\t" \
	98	: : "r"(get_fs()) : )
	99
b9762e7b MT	100	#define __get_user(x, ptr) \
	101	({ \
	102	register long __gu_err __asm__ ("r8") = 0; \
d19f5e41	103	register long __gu_val; \
b9762e7b	104	\
06bff6b9 HD	105	load_sr2(); \
06bff6b9 HD	106	switch (sizeof(*(ptr))) { \
b9762e7b MT	107	case 1: __get_user_asm("ldb", ptr); break; \
	108	case 2: __get_user_asm("ldh", ptr); break; \
	109	case 4: __get_user_asm("ldw", ptr); break; \
	110	case 8: LDD_USER(ptr); break; \
	111	default: BUILD_BUG(); break; \
b9762e7b MT	112	} \
	113	\
	114	(x) = (__force __typeof__(*(ptr))) __gu_val; \
	115	__gu_err; \
1da177e4 LT	116	})
1da177e4 LT	117
b9762e7b	118	#define __get_user_asm(ldx, ptr) \
d19f5e41 HD	119	__asm__("1: " ldx " 0(%%sr2,%2),%0\n" \
	120	"9:\n" \
	121	ASM_EXCEPTIONTABLE_ENTRY_EFAULT(1b, 9b) \
1da177e4	122	: "=r"(__gu_val), "=r"(__gu_err) \
d19f5e41	123	: "r"(ptr), "1"(__gu_err));
1da177e4	124
d2ad824f HD	125	#if !defined(CONFIG_64BIT)
	126
	127	#define __get_user_asm64(ptr) \
d19f5e41 HD	128	__asm__(" copy %%r0,%R0\n" \
	129	"1: ldw 0(%%sr2,%2),%0\n" \
	130	"2: ldw 4(%%sr2,%2),%R0\n" \
	131	"9:\n" \
	132	ASM_EXCEPTIONTABLE_ENTRY_EFAULT(1b, 9b) \
	133	ASM_EXCEPTIONTABLE_ENTRY_EFAULT(2b, 9b) \
d2ad824f	134	: "=r"(__gu_val), "=r"(__gu_err) \
d19f5e41	135	: "r"(ptr), "1"(__gu_err));
d2ad824f HD	136
	137	#endif /* !defined(CONFIG_64BIT) */
	138
	139
b9762e7b	140	#define __put_user(x, ptr) \
1da177e4 LT	141	({ \
	142	register long __pu_err __asm__ ("r8") = 0; \
	143	__typeof__((ptr)) __x = (__typeof__((ptr)))(x); \
	144	\
06bff6b9 HD	145	load_sr2(); \
06bff6b9 HD	146	switch (sizeof(*(ptr))) { \
b9762e7b MT	147	case 1: __put_user_asm("stb", __x, ptr); break; \
	148	case 2: __put_user_asm("sth", __x, ptr); break; \
	149	case 4: __put_user_asm("stw", __x, ptr); break; \
	150	case 8: STD_USER(__x, ptr); break; \
8dd95c68	151	default: BUILD_BUG(); break; \
1da177e4 LT	152	} \
	153	\
	154	__pu_err; \
	155	})
	156
	157	/*
	158	* The "__put_user/kernel_asm()" macros tell gcc they read from memory
	159	* instead of writing. This is because they do not write to any memory
3fd3a74f	160	* gcc knows about, so there are no aliasing issues. These macros must
d19f5e41 HD	161	* also be aware that fixups are executed in the context of the fault,
	162	* and any registers used there must be listed as clobbers.
	163	* r8 is already listed as err.
1da177e4 LT	164	*/
1da177e4 LT	165
b9762e7b	166	#define __put_user_asm(stx, x, ptr) \
1da177e4	167	__asm__ __volatile__ ( \
d19f5e41 HD	168	"1: " stx " %2,0(%%sr2,%1)\n" \
	169	"9:\n" \
	170	ASM_EXCEPTIONTABLE_ENTRY_EFAULT(1b, 9b) \
1da177e4	171	: "=r"(__pu_err) \
d19f5e41	172	: "r"(ptr), "r"(x), "0"(__pu_err))
1da177e4	173
1da177e4	174
ca72a223	175	#if !defined(CONFIG_64BIT)
94a1981d	176
b9762e7b	177	#define __put_user_asm64(__val, ptr) do { \
1da177e4	178	__asm__ __volatile__ ( \
d19f5e41 HD	179	"1: stw %2,0(%%sr2,%1)\n" \
	180	"2: stw %R2,4(%%sr2,%1)\n" \
	181	"9:\n" \
	182	ASM_EXCEPTIONTABLE_ENTRY_EFAULT(1b, 9b) \
	183	ASM_EXCEPTIONTABLE_ENTRY_EFAULT(2b, 9b) \
1da177e4	184	: "=r"(__pu_err) \
d19f5e41	185	: "r"(ptr), "r"(__val), "0"(__pu_err)); \
1da177e4 LT	186	} while (0)
1da177e4 LT	187
ca72a223	188	#endif /* !defined(CONFIG_64BIT) */
1da177e4 LT	189
	190
	191	/*
	192	* Complex access routines -- external declarations
	193	*/
	194
	195	extern unsigned long lcopy_to_user(void __user , const void , unsigned long);
	196	extern unsigned long lcopy_from_user(void , const void __user , unsigned long);
	197	extern unsigned long lcopy_in_user(void __user , const void __user , unsigned long);
b1195c0e	198	extern long strncpy_from_user(char , const char __user , long);
b9762e7b MT	199	extern unsigned lclear_user(void __user *, unsigned long);
b9762e7b MT	200	extern long lstrnlen_user(const char __user *, long);
1da177e4 LT	201	/*
	202	* Complex access routines -- macros
	203	*/
a0ffa8f0	204	#define user_addr_max() (~0UL)
1da177e4	205
1da177e4 LT	206	#define strnlen_user lstrnlen_user
	207	#define strlen_user(str) lstrnlen_user(str, 0x7fffffffL)
	208	#define clear_user lclear_user
	209	#define __clear_user lclear_user
	210
9e91db6b HD	211	unsigned long __must_check __copy_to_user(void __user dst, const void src,
	212	unsigned long len);
	213	unsigned long __must_check __copy_from_user(void dst, const void __user src,
	214	unsigned long len);
	215	unsigned long copy_in_user(void __user dst, const void __user src,
	216	unsigned long len);
1da177e4 LT	217	#define __copy_in_user copy_in_user
	218	#define __copy_to_user_inatomic __copy_to_user
	219	#define __copy_from_user_inatomic __copy_from_user
	220
0d025d27 JP	221	extern void __compiletime_error("usercopy buffer size is too small")
	222	__bad_copy_user(void);
	223
	224	static inline void copy_user_overflow(int size, unsigned long count)
	225	{
	226	WARN(1, "Buffer overflow detected (%d < %lu)!\n", size, count);
	227	}
888c31fc	228
9e91db6b HD	229	static __always_inline unsigned long __must_check
9e91db6b HD	230	copy_from_user(void to, const void __user from, unsigned long n)
888c31fc	231	{
9e91db6b HD	232	int sz = __compiletime_object_size(to);
9e91db6b HD	233	unsigned long ret = n;
888c31fc	234
9e91db6b HD	235	if (likely(sz < 0 \|\| sz >= n)) {
	236	check_object_size(to, n, false);
	237	ret = __copy_from_user(to, from, n);
	238	} else if (!__builtin_constant_p(n))
0d025d27 JP	239	copy_user_overflow(sz, n);
0d025d27 JP	240	else
9e91db6b	241	__bad_copy_user();
888c31fc	242
aace880f AV	243	if (unlikely(ret))
aace880f AV	244	memset(to + (n - ret), 0, ret);
9e91db6b HD	245
	246	return ret;
	247	}
	248
	249	static __always_inline unsigned long __must_check
	250	copy_to_user(void __user to, const void from, unsigned long n)
	251	{
	252	int sz = __compiletime_object_size(from);
	253
	254	if (likely(sz < 0 \|\| sz >= n)) {
	255	check_object_size(from, n, true);
	256	n = __copy_to_user(to, from, n);
	257	} else if (!__builtin_constant_p(n))
	258	copy_user_overflow(sz, n);
	259	else
	260	__bad_copy_user();
	261
	262	return n;
888c31fc HD	263	}
888c31fc HD	264
e448372c	265	struct pt_regs;
c61c25eb KM	266	int fixup_exception(struct pt_regs *regs);
c61c25eb KM	267
1da177e4	268	#endif /* __PARISC_UACCESS_H */