[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / sh / include / asm / uaccess.h

#ifndef __ASM_SH_UACCESS_H
#define __ASM_SH_UACCESS_H

#include <linux/errno.h>
#include <linux/sched.h>
#include <asm/segment.h>

#define VERIFY_READ    0
#define VERIFY_WRITE   1

#define __addr_ok(addr) \
	((unsigned long __force)(addr) < current_thread_info()->addr_limit.seg)

/*
 * __access_ok: Check if address with size is OK or not.
 *
 * Uhhuh, this needs 33-bit arithmetic. We have a carry..
 *
 * sum := addr + size;  carry? --> flag = true;
 * if (sum >= addr_limit) flag = true;
 */
#define __access_ok(addr, size)		\
	(__addr_ok((addr) + (size)))
#define access_ok(type, addr, size)	\
	(__chk_user_ptr(addr),		\
	 __access_ok((unsigned long __force)(addr), (size)))

#define user_addr_max()	(current_thread_info()->addr_limit.seg)

/*
 * Uh, these should become the main single-value transfer routines ...
 * They automatically use the right size if we just have the right
 * pointer type ...
 *
 * As SuperH uses the same address space for kernel and user data, we
 * can just do these as direct assignments.
 *
 * Careful to not
 * (a) re-use the arguments for side effects (sizeof is ok)
 * (b) require any knowledge of processes at this stage
 */
#define put_user(x,ptr)		__put_user_check((x), (ptr), sizeof(*(ptr)))
#define get_user(x,ptr)		__get_user_check((x), (ptr), sizeof(*(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((x), (ptr), sizeof(*(ptr)))
#define __get_user(x,ptr)	__get_user_nocheck((x), (ptr), sizeof(*(ptr)))

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

#define __get_user_nocheck(x,ptr,size)				\
({								\
	long __gu_err;						\
	unsigned long __gu_val;					\
	const __typeof__(*(ptr)) __user *__gu_addr = (ptr);	\
	__chk_user_ptr(ptr);					\
	__get_user_size(__gu_val, __gu_addr, (size), __gu_err);	\
	(x) = (__typeof__(*(ptr)))__gu_val;			\
	__gu_err;						\
})

#define __get_user_check(x,ptr,size)					\
({									\
	long __gu_err = -EFAULT;					\
	unsigned long __gu_val = 0;					\
	const __typeof__(*(ptr)) *__gu_addr = (ptr);			\
	if (likely(access_ok(VERIFY_READ, __gu_addr, (size))))		\
		__get_user_size(__gu_val, __gu_addr, (size), __gu_err);	\
	(x) = (__typeof__(*(ptr)))__gu_val;				\
	__gu_err;							\
})

#define __put_user_nocheck(x,ptr,size)				\
({								\
	long __pu_err;						\
	__typeof__(*(ptr)) __user *__pu_addr = (ptr);		\
	__typeof__(*(ptr)) __pu_val = x;			\
	__chk_user_ptr(ptr);					\
	__put_user_size(__pu_val, __pu_addr, (size), __pu_err);	\
	__pu_err;						\
})

#define __put_user_check(x,ptr,size)				\
({								\
	long __pu_err = -EFAULT;				\
	__typeof__(*(ptr)) __user *__pu_addr = (ptr);		\
	__typeof__(*(ptr)) __pu_val = x;			\
	if (likely(access_ok(VERIFY_WRITE, __pu_addr, size)))	\
		__put_user_size(__pu_val, __pu_addr, (size),	\
				__pu_err);			\
	__pu_err;						\
})

#ifdef CONFIG_SUPERH32
# include <asm/uaccess_32.h>
#else
# include <asm/uaccess_64.h>
#endif

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

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

/* Generic arbitrary sized copy.  */
/* Return the number of bytes NOT copied */
__kernel_size_t __copy_user(void *to, const void *from, __kernel_size_t n);

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

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

#define __copy_to_user_inatomic __copy_to_user
#define __copy_from_user_inatomic __copy_from_user

/*
 * Clear the area and return remaining number of bytes
 * (on failure.  Usually it's 0.)
 */
__kernel_size_t __clear_user(void *addr, __kernel_size_t size);

#define clear_user(addr,n)						\
({									\
	void __user * __cl_addr = (addr);				\
	unsigned long __cl_size = (n);					\
									\
	if (__cl_size && access_ok(VERIFY_WRITE,			\
		((unsigned long)(__cl_addr)), __cl_size))		\
		__cl_size = __clear_user(__cl_addr, __cl_size);		\
									\
	__cl_size;							\
})

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

	if (__copy_size && __access_ok(__copy_from, __copy_size))
		__copy_size = __copy_user(to, from, __copy_size);

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

	return __copy_size;
}

static inline unsigned long
copy_to_user(void __user *to, const void *from, unsigned long n)
{
	unsigned long __copy_to = (unsigned long) to;
	__kernel_size_t __copy_size = (__kernel_size_t) n;

	if (__copy_size && __access_ok(__copy_to, __copy_size))
		return __copy_user(to, from, __copy_size);

	return __copy_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.
 */
struct exception_table_entry {
	unsigned long insn, fixup;
};

#if defined(CONFIG_SUPERH64) && defined(CONFIG_MMU)
#define ARCH_HAS_SEARCH_EXTABLE
#endif

int fixup_exception(struct pt_regs *regs);
/* Returns 0 if exception not found and fixup.unit otherwise.  */
unsigned long search_exception_table(unsigned long addr);
const struct exception_table_entry *search_exception_tables(unsigned long addr);

extern void *set_exception_table_vec(unsigned int vec, void *handler);

static inline void *set_exception_table_evt(unsigned int evt, void *handler)
{
	return set_exception_table_vec(evt >> 5, handler);
}

struct mem_access {
	unsigned long (*from)(void *dst, const void __user *src, unsigned long cnt);
	unsigned long (*to)(void __user *dst, const void *src, unsigned long cnt);
};

int handle_unaligned_access(insn_size_t instruction, struct pt_regs *regs,
			    struct mem_access *ma, int, unsigned long address);

#endif /* __ASM_SH_UACCESS_H */
Commit	Line	Data
1e6760c5 MD	1	#ifndef __ASM_SH_UACCESS_H
	2	#define __ASM_SH_UACCESS_H
	3
42fd3b14 PM	4	#include <linux/errno.h>
	5	#include <linux/sched.h>
	6	#include <asm/segment.h>
	7
	8	#define VERIFY_READ 0
	9	#define VERIFY_WRITE 1
	10
	11	#define __addr_ok(addr) \
	12	((unsigned long __force)(addr) < current_thread_info()->addr_limit.seg)
	13
	14	/*
	15	* __access_ok: Check if address with size is OK or not.
	16	*
	17	* Uhhuh, this needs 33-bit arithmetic. We have a carry..
	18	*
	19	* sum := addr + size; carry? --> flag = true;
	20	* if (sum >= addr_limit) flag = true;
	21	*/
	22	#define __access_ok(addr, size) \
	23	(__addr_ok((addr) + (size)))
	24	#define access_ok(type, addr, size) \
	25	(__chk_user_ptr(addr), \
	26	__access_ok((unsigned long __force)(addr), (size)))
	27
0e100e11 PM	28	#define user_addr_max() (current_thread_info()->addr_limit.seg)
0e100e11 PM	29
42fd3b14 PM	30	/*
	31	* Uh, these should become the main single-value transfer routines ...
	32	* They automatically use the right size if we just have the right
	33	* pointer type ...
	34	*
	35	* As SuperH uses the same address space for kernel and user data, we
	36	* can just do these as direct assignments.
	37	*
	38	* Careful to not
	39	* (a) re-use the arguments for side effects (sizeof is ok)
	40	* (b) require any knowledge of processes at this stage
	41	*/
	42	#define put_user(x,ptr) __put_user_check((x), (ptr), sizeof(*(ptr)))
	43	#define get_user(x,ptr) __get_user_check((x), (ptr), sizeof(*(ptr)))
	44
	45	/*
	46	* The "__xxx" versions do not do address space checking, useful when
	47	* doing multiple accesses to the same area (the user has to do the
	48	* checks by hand with "access_ok()")
	49	*/
	50	#define __put_user(x,ptr) __put_user_nocheck((x), (ptr), sizeof(*(ptr)))
	51	#define __get_user(x,ptr) __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
	52
	53	struct __large_struct { unsigned long buf[100]; };
	54	#define __m(x) ((struct __large_struct __user )(x))
	55
	56	#define __get_user_nocheck(x,ptr,size) \
	57	({ \
	58	long __gu_err; \
	59	unsigned long __gu_val; \
	60	const __typeof__((ptr)) __user __gu_addr = (ptr); \
	61	__chk_user_ptr(ptr); \
	62	__get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
	63	(x) = (__typeof__(*(ptr)))__gu_val; \
	64	__gu_err; \
	65	})
	66
	67	#define __get_user_check(x,ptr,size) \
	68	({ \
	69	long __gu_err = -EFAULT; \
	70	unsigned long __gu_val = 0; \
	71	const __typeof__((ptr)) __gu_addr = (ptr); \
	72	if (likely(access_ok(VERIFY_READ, __gu_addr, (size)))) \
	73	__get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
	74	(x) = (__typeof__(*(ptr)))__gu_val; \
	75	__gu_err; \
	76	})
	77
	78	#define __put_user_nocheck(x,ptr,size) \
	79	({ \
	80	long __pu_err; \
	81	__typeof__((ptr)) __user __pu_addr = (ptr); \
6de9c648	82	__typeof__(*(ptr)) __pu_val = x; \
42fd3b14	83	__chk_user_ptr(ptr); \
6de9c648	84	__put_user_size(__pu_val, __pu_addr, (size), __pu_err); \
42fd3b14 PM	85	__pu_err; \
	86	})
	87
	88	#define __put_user_check(x,ptr,size) \
	89	({ \
	90	long __pu_err = -EFAULT; \
	91	__typeof__((ptr)) __user __pu_addr = (ptr); \
6de9c648	92	__typeof__(*(ptr)) __pu_val = x; \
42fd3b14	93	if (likely(access_ok(VERIFY_WRITE, __pu_addr, size))) \
6de9c648	94	__put_user_size(__pu_val, __pu_addr, (size), \
42fd3b14 PM	95	__pu_err); \
	96	__pu_err; \
	97	})
	98
9b01bd9e	99	#ifdef CONFIG_SUPERH32
a1ce3928	100	# include <asm/uaccess_32.h>
1da177e4	101	#else
a1ce3928	102	# include <asm/uaccess_64.h>
1da177e4	103	#endif
1e6760c5	104
0e100e11 PM	105	extern long strncpy_from_user(char dest, const char __user src, long count);
0e100e11 PM	106
cba8df4b PM	107	extern __must_check long strlen_user(const char __user *str);
	108	extern __must_check long strnlen_user(const char __user *str, long n);
	109
42fd3b14 PM	110	/* Generic arbitrary sized copy. */
	111	/* Return the number of bytes NOT copied */
	112	__kernel_size_t __copy_user(void to, const void from, __kernel_size_t n);
	113
	114	static __always_inline unsigned long
	115	__copy_from_user(void to, const void __user from, unsigned long n)
	116	{
	117	return __copy_user(to, (__force void *)from, n);
	118	}
	119
	120	static __always_inline unsigned long __must_check
	121	__copy_to_user(void __user to, const void from, unsigned long n)
	122	{
	123	return __copy_user((__force void *)to, from, n);
	124	}
	125
	126	#define __copy_to_user_inatomic __copy_to_user
	127	#define __copy_from_user_inatomic __copy_from_user
	128
	129	/*
	130	* Clear the area and return remaining number of bytes
	131	* (on failure. Usually it's 0.)
	132	*/
	133	__kernel_size_t __clear_user(void *addr, __kernel_size_t size);
	134
	135	#define clear_user(addr,n) \
	136	({ \
	137	void __user * __cl_addr = (addr); \
	138	unsigned long __cl_size = (n); \
	139	\
	140	if (__cl_size && access_ok(VERIFY_WRITE, \
	141	((unsigned long)(__cl_addr)), __cl_size)) \
	142	__cl_size = __clear_user(__cl_addr, __cl_size); \
	143	\
	144	__cl_size; \
	145	})
	146
1e6760c5 MD	147	static inline unsigned long
	148	copy_from_user(void to, const void __user from, unsigned long n)
	149	{
	150	unsigned long __copy_from = (unsigned long) from;
	151	__kernel_size_t __copy_size = (__kernel_size_t) n;
	152
	153	if (__copy_size && __access_ok(__copy_from, __copy_size))
a6c16ec5 AV	154	__copy_size = __copy_user(to, from, __copy_size);
	155
	156	if (unlikely(__copy_size))
	157	memset(to + (n - __copy_size), 0, __copy_size);
1e6760c5 MD	158
	159	return __copy_size;
	160	}
	161
	162	static inline unsigned long
	163	copy_to_user(void __user to, const void from, unsigned long n)
	164	{
	165	unsigned long __copy_to = (unsigned long) to;
	166	__kernel_size_t __copy_size = (__kernel_size_t) n;
	167
	168	if (__copy_size && __access_ok(__copy_to, __copy_size))
	169	return __copy_user(to, from, __copy_size);
	170
	171	return __copy_size;
	172	}
	173
42fd3b14 PM	174	/*
	175	* The exception table consists of pairs of addresses: the first is the
	176	* address of an instruction that is allowed to fault, and the second is
	177	* the address at which the program should continue. No registers are
	178	* modified, so it is entirely up to the continuation code to figure out
	179	* what to do.
	180	*
	181	* All the routines below use bits of fixup code that are out of line
	182	* with the main instruction path. This means when everything is well,
	183	* we don't even have to jump over them. Further, they do not intrude
	184	* on our cache or tlb entries.
	185	*/
	186	struct exception_table_entry {
	187	unsigned long insn, fixup;
	188	};
	189
	190	#if defined(CONFIG_SUPERH64) && defined(CONFIG_MMU)
	191	#define ARCH_HAS_SEARCH_EXTABLE
	192	#endif
	193
	194	int fixup_exception(struct pt_regs *regs);
	195	/* Returns 0 if exception not found and fixup.unit otherwise. */
	196	unsigned long search_exception_table(unsigned long addr);
	197	const struct exception_table_entry *search_exception_tables(unsigned long addr);
	198
e839ca52 DH	199	extern void set_exception_table_vec(unsigned int vec, void handler);
	200
	201	static inline void set_exception_table_evt(unsigned int evt, void handler)
	202	{
	203	return set_exception_table_vec(evt >> 5, handler);
	204	}
	205
	206	struct mem_access {
	207	unsigned long (from)(void dst, const void __user *src, unsigned long cnt);
	208	unsigned long (to)(void __user dst, const void *src, unsigned long cnt);
	209	};
	210
	211	int handle_unaligned_access(insn_size_t instruction, struct pt_regs *regs,
	212	struct mem_access *ma, int, unsigned long address);
42fd3b14	213
1e6760c5	214	#endif /* __ASM_SH_UACCESS_H */