[deliverable/linux.git] / include / linux / uaccess.h

#ifndef __LINUX_UACCESS_H__
#define __LINUX_UACCESS_H__

#include <linux/preempt.h>
#include <asm/uaccess.h>

/*
 * These routines enable/disable the pagefault handler in that
 * it will not take any locks and go straight to the fixup table.
 *
 * They have great resemblance to the preempt_disable/enable calls
 * and in fact they are identical; this is because currently there is
 * no other way to make the pagefault handlers do this. So we do
 * disable preemption but we don't necessarily care about that.
 */
static inline void pagefault_disable(void)
{
	inc_preempt_count();
	/*
	 * make sure to have issued the store before a pagefault
	 * can hit.
	 */
	barrier();
}

static inline void pagefault_enable(void)
{
	/*
	 * make sure to issue those last loads/stores before enabling
	 * the pagefault handler again.
	 */
	barrier();
	dec_preempt_count();
	/*
	 * make sure we do..
	 */
	barrier();
	preempt_check_resched();
}

#ifndef ARCH_HAS_NOCACHE_UACCESS

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

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

#endif		/* ARCH_HAS_NOCACHE_UACCESS */

/**
 * probe_kernel_address(): safely attempt to read from a location
 * @addr: address to read from - its type is type typeof(retval)*
 * @retval: read into this variable
 *
 * Safely read from address @addr into variable @revtal.  If a kernel fault
 * happens, handle that and return -EFAULT.
 * We ensure that the __get_user() is executed in atomic context so that
 * do_page_fault() doesn't attempt to take mmap_sem.  This makes
 * probe_kernel_address() suitable for use within regions where the caller
 * already holds mmap_sem, or other locks which nest inside mmap_sem.
 */
#define probe_kernel_address(addr, retval)		\
	({						\
		long ret;				\
							\
		pagefault_disable();			\
		ret = __get_user(retval, addr);		\
		pagefault_enable();			\
		ret;					\
	})

#endif		/* __LINUX_UACCESS_H__ */
Commit	Line	Data
c22ce143 HY	1	#ifndef __LINUX_UACCESS_H__
	2	#define __LINUX_UACCESS_H__
	3
a866374a	4	#include <linux/preempt.h>
c22ce143 HY	5	#include <asm/uaccess.h>
c22ce143 HY	6
a866374a PZ	7	/*
	8	* These routines enable/disable the pagefault handler in that
	9	* it will not take any locks and go straight to the fixup table.
	10	*
	11	* They have great resemblance to the preempt_disable/enable calls
	12	* and in fact they are identical; this is because currently there is
	13	* no other way to make the pagefault handlers do this. So we do
	14	* disable preemption but we don't necessarily care about that.
	15	*/
	16	static inline void pagefault_disable(void)
	17	{
	18	inc_preempt_count();
	19	/*
	20	* make sure to have issued the store before a pagefault
	21	* can hit.
	22	*/
	23	barrier();
	24	}
	25
	26	static inline void pagefault_enable(void)
	27	{
	28	/*
	29	* make sure to issue those last loads/stores before enabling
	30	* the pagefault handler again.
	31	*/
	32	barrier();
	33	dec_preempt_count();
	34	/*
	35	* make sure we do..
	36	*/
	37	barrier();
	38	preempt_check_resched();
	39	}
	40
c22ce143 HY	41	#ifndef ARCH_HAS_NOCACHE_UACCESS
	42
	43	static inline unsigned long __copy_from_user_inatomic_nocache(void *to,
	44	const void __user *from, unsigned long n)
	45	{
	46	return __copy_from_user_inatomic(to, from, n);
	47	}
	48
	49	static inline unsigned long __copy_from_user_nocache(void *to,
	50	const void __user *from, unsigned long n)
	51	{
	52	return __copy_from_user(to, from, n);
	53	}
	54
	55	#endif /* ARCH_HAS_NOCACHE_UACCESS */
	56
1b79e551 AM	57	/**
	58	* probe_kernel_address(): safely attempt to read from a location
	59	* @addr: address to read from - its type is type typeof(retval)*
	60	* @retval: read into this variable
	61	*
	62	* Safely read from address @addr into variable @revtal. If a kernel fault
	63	* happens, handle that and return -EFAULT.
	64	* We ensure that the __get_user() is executed in atomic context so that
	65	* do_page_fault() doesn't attempt to take mmap_sem. This makes
	66	* probe_kernel_address() suitable for use within regions where the caller
	67	* already holds mmap_sem, or other locks which nest inside mmap_sem.
	68	*/
	69	#define probe_kernel_address(addr, retval) \
	70	({ \
	71	long ret; \
	72	\
a866374a	73	pagefault_disable(); \
1b79e551	74	ret = __get_user(retval, addr); \
a866374a	75	pagefault_enable(); \
1b79e551 AM	76	ret; \
	77	})
	78
c22ce143	79	#endif /* __LINUX_UACCESS_H__ */