powerpc: merge uaccess.h (2df5e8bc) · Commits · e / devices / android_kernel_teracube_2e

include/asm-ppc/uaccess.h→include/asm-powerpc/uaccess.h

+504 −0

Original line number	Diff line number	Diff line
		#ifdef __KERNEL__
		#ifndef _PPC_UACCESS_H
		#define _PPC_UACCESS_H
		#ifndef _ARCH_POWERPC_UACCESS_H
		#define _ARCH_POWERPC_UACCESS_H

		#ifdef __KERNEL__
		#ifndef __ASSEMBLY__

		#include <linux/sched.h>
		#include <linux/errno.h>
		#include <asm/processor.h>
		@@ -21,8 +22,15 @@
		* This simplifies the checking in the routines below.
		*/

		#define KERNEL_DS ((mm_segment_t) { ~0UL })
		#define USER_DS ((mm_segment_t) { TASK_SIZE - 1 })
		#define MAKE_MM_SEG(s) ((mm_segment_t) { (s) })

		#ifdef __powerpc64__
		#define KERNEL_DS MAKE_MM_SEG(0UL)
		#define USER_DS MAKE_MM_SEG(0xf000000000000000UL)
		#else
		#define KERNEL_DS MAKE_MM_SEG(~0UL)
		#define USER_DS MAKE_MM_SEG(TASK_SIZE - 1)
		#endif

		#define get_ds() (KERNEL_DS)
		#define get_fs() (current->thread.fs)
		@@ -30,12 +38,36 @@

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

		#define __access_ok(addr,size) \
		((addr) <= current->thread.fs.seg \
		&& ((size) == 0 \|\| (size) - 1 <= current->thread.fs.seg - (addr)))
		#ifdef __powerpc64__
		/*
		* Use the alpha trick for checking ranges:
		*
		* Is a address valid? This does a straightforward calculation rather
		* than tests.
		*
		* Address valid if:
		* - "addr" doesn't have any high-bits set
		* - AND "size" doesn't have any high-bits set
		* - OR we are in kernel mode.
		*
		* We dont have to check for high bits in (addr+size) because the first
		* two checks force the maximum result to be below the start of the
		* kernel region.
		*/
		#define __access_ok(addr, size, segment) \
		(((segment).seg & (addr \| size )) == 0)

		#else

		#define __access_ok(addr, size, segment) \
		(((addr) <= (segment).seg) && \
		(((size) == 0) \|\| (((size) - 1) <= ((segment).seg - (addr)))))

		#endif

		#define access_ok(type, addr, size) \
		(__chk_user_ptr(addr),__access_ok((unsigned long)(addr),(size)))
		(__chk_user_ptr(addr), \
		__access_ok((__force unsigned long)(addr), (size), get_fs()))

		/*
		* The exception table consists of pairs of addresses: the first is the
		@@ -50,9 +82,9 @@
		* on our cache or tlb entries.
		*/

		struct exception_table_entry
		{
		unsigned long insn, fixup;
		struct exception_table_entry {
		unsigned long insn;
		unsigned long fixup;
		};

		/*
		@@ -81,59 +113,33 @@ struct exception_table_entry
		*/
		#define get_user(x, ptr) \
		__get_user_check((x), (ptr), sizeof(*(ptr)))
		#define get_user64(x,ptr) \
		__get_user64_check((x),(ptr),sizeof(*(ptr)))
		#define put_user(x, ptr) \
		__put_user_check((__typeof__((ptr)))(x), (ptr), sizeof((ptr)))
		#define put_user64(x,ptr) put_user(x,ptr)

		#define __get_user(x, ptr) \
		__get_user_nocheck((x), (ptr), sizeof(*(ptr)))
		#define __get_user64(x,ptr) \
		__get_user64_nocheck((x),(ptr),sizeof(*(ptr)))
		#define __put_user(x, ptr) \
		__put_user_nocheck((__typeof__((ptr)))(x), (ptr), sizeof((ptr)))
		#ifndef __powerpc64__
		#define __get_user64(x, ptr) \
		__get_user64_nocheck((x), (ptr), sizeof(*(ptr)))
		#define __put_user64(x, ptr) __put_user(x, ptr)
		#endif

		extern long __put_user_bad(void);
		#ifdef __powerpc64__
		#define __get_user_unaligned __get_user
		#define __put_user_unaligned __put_user
		#endif

		#define __put_user_nocheck(x,ptr,size) \
		({ \
		long __pu_err; \
		__chk_user_ptr(ptr); \
		__put_user_size((x),(ptr),(size),__pu_err); \
		__pu_err; \
		})
		extern long __put_user_bad(void);

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

		#define __put_user_size(x,ptr,size,retval) \
		do { \
		retval = 0; \
		switch (size) { \
		case 1: \
		__put_user_asm(x, ptr, retval, "stb"); \
		break; \
		case 2: \
		__put_user_asm(x, ptr, retval, "sth"); \
		break; \
		case 4: \
		__put_user_asm(x, ptr, retval, "stw"); \
		break; \
		case 8: \
		__put_user_asm2(x, ptr, retval); \
		break; \
		default: \
		__put_user_bad(); \
		} \
		} while (0)
		#ifdef __powerpc64__
		#define __EX_TABLE_ALIGN "3"
		#define __EX_TABLE_TYPE "llong"
		#else
		#define __EX_TABLE_ALIGN "2"
		#define __EX_TABLE_TYPE "long"
		#endif

		/*
		* We don't tell gcc that we are accessing memory, but this is OK
		@@ -142,19 +148,20 @@ do { \
		*/
		#define __put_user_asm(x, addr, err, op) \
		__asm__ __volatile__( \
		"1: "op" %1,0(%2)\n" \
		"1: " op " %1,0(%2) # put_user\n" \
		"2:\n" \
		".section .fixup,\"ax\"\n" \
		"3: li %0,%3\n" \
		" b 2b\n" \
		".previous\n" \
		".section __ex_table,\"a\"\n" \
		" .align 2\n" \
		" .long 1b,3b\n" \
		" .align " __EX_TABLE_ALIGN "\n" \
		" ."__EX_TABLE_TYPE" 1b,3b\n" \
		".previous" \
		: "=r" (err) \
		: "r" (x), "b" (addr), "i" (-EFAULT), "0" (err))

		#ifndef __powerpc64__
		#define __put_user_asm2(x, addr, err) \
		__asm__ __volatile__( \
		"1: stw %1,0(%2)\n" \
		@@ -165,99 +172,53 @@ do { \
		" b 3b\n" \
		".previous\n" \
		".section __ex_table,\"a\"\n" \
		" .align 2\n" \
		" .long 1b,4b\n" \
		" .long 2b,4b\n" \
		" .align " __EX_TABLE_ALIGN "\n" \
		" ." __EX_TABLE_TYPE " 1b,4b\n" \
		" ." __EX_TABLE_TYPE " 2b,4b\n" \
		".previous" \
		: "=r" (err) \
		: "r" (x), "b" (addr), "i" (-EFAULT), "0" (err))
		#else /* __powerpc64__ */
		#define __put_user_asm2(x, ptr, retval) \
		__put_user_asm(x, ptr, retval, "std")
		#endif /* __powerpc64__ */

		#define __get_user_nocheck(x, ptr, size) \
		({ \
		long __gu_err; \
		unsigned long __gu_val; \
		__chk_user_ptr(ptr); \
		__get_user_size(__gu_val, (ptr), (size), __gu_err); \
		(x) = (__typeof__(*(ptr)))__gu_val; \
		__gu_err; \
		})
		#define __put_user_size(x, ptr, size, retval) \
		do { \
		retval = 0; \
		switch (size) { \
		case 1: __put_user_asm(x, ptr, retval, "stb"); break; \
		case 2: __put_user_asm(x, ptr, retval, "sth"); break; \
		case 4: __put_user_asm(x, ptr, retval, "stw"); break; \
		case 8: __put_user_asm2(x, ptr, retval); break; \
		default: __put_user_bad(); \
		} \
		} while (0)

		#define __get_user64_nocheck(x, ptr, size) \
		#define __put_user_nocheck(x, ptr, size) \
		({ \
		long __gu_err; \
		long long __gu_val; \
		long __pu_err; \
		might_sleep(); \
		__chk_user_ptr(ptr); \
		__get_user_size64(__gu_val, (ptr), (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)) __user __gu_addr = (ptr); \
		if (access_ok(VERIFY_READ, __gu_addr, (size))) \
		__get_user_size(__gu_val, __gu_addr, (size), __gu_err); \
		(x) = (__typeof__(*(ptr)))__gu_val; \
		__gu_err; \
		__put_user_size((x), (ptr), (size), __pu_err); \
		__pu_err; \
		})

		#define __get_user64_check(x, ptr, size) \
		#define __put_user_check(x, ptr, size) \
		({ \
		long __gu_err = -EFAULT; \
		long long __gu_val = 0; \
		const __typeof__((ptr)) __user __gu_addr = (ptr); \
		if (access_ok(VERIFY_READ, __gu_addr, (size))) \
		__get_user_size64(__gu_val, __gu_addr, (size), __gu_err); \
		(x) = (__typeof__(*(ptr)))__gu_val; \
		__gu_err; \
		long __pu_err = -EFAULT; \
		__typeof__((ptr)) __user __pu_addr = (ptr); \
		might_sleep(); \
		if (access_ok(VERIFY_WRITE, __pu_addr, size)) \
		__put_user_size((x), __pu_addr, (size), __pu_err); \
		__pu_err; \
		})

		extern long __get_user_bad(void);

		#define __get_user_size(x, ptr, size, retval) \
		do { \
		retval = 0; \
		switch (size) { \
		case 1: \
		__get_user_asm(x, ptr, retval, "lbz"); \
		break; \
		case 2: \
		__get_user_asm(x, ptr, retval, "lhz"); \
		break; \
		case 4: \
		__get_user_asm(x, ptr, retval, "lwz"); \
		break; \
		default: \
		x = __get_user_bad(); \
		} \
		} while (0)

		#define __get_user_size64(x, ptr, size, retval) \
		do { \
		retval = 0; \
		switch (size) { \
		case 1: \
		__get_user_asm(x, ptr, retval, "lbz"); \
		break; \
		case 2: \
		__get_user_asm(x, ptr, retval, "lhz"); \
		break; \
		case 4: \
		__get_user_asm(x, ptr, retval, "lwz"); \
		break; \
		case 8: \
		__get_user_asm2(x, ptr, retval); \
		break; \
		default: \
		x = __get_user_bad(); \
		} \
		} while (0)

		#define __get_user_asm(x, addr, err, op) \
		__asm__ __volatile__( \
		"1: "op" %1,0(%2)\n" \
		"1: "op" %1,0(%2) # get_user\n" \
		"2:\n" \
		".section .fixup,\"ax\"\n" \
		"3: li %0,%3\n" \
		@@ -265,12 +226,13 @@ do { \
		" b 2b\n" \
		".previous\n" \
		".section __ex_table,\"a\"\n" \
		" .align 2\n" \
		" .long 1b,3b\n" \
		" .align "__EX_TABLE_ALIGN "\n" \
		" ." __EX_TABLE_TYPE " 1b,3b\n" \
		".previous" \
		: "=r" (err), "=r" (x) \
		: "b" (addr), "i" (-EFAULT), "0" (err))

		#ifndef __powerpc64__
		#define __get_user_asm2(x, addr, err) \
		__asm__ __volatile__( \
		"1: lwz %1,0(%2)\n" \
		@@ -283,18 +245,74 @@ do { \
		" b 3b\n" \
		".previous\n" \
		".section __ex_table,\"a\"\n" \
		" .align 2\n" \
		" .long 1b,4b\n" \
		" .long 2b,4b\n" \
		" .align " __EX_TABLE_ALIGN "\n" \
		" ." __EX_TABLE_TYPE " 1b,4b\n" \
		" ." __EX_TABLE_TYPE " 2b,4b\n" \
		".previous" \
		: "=r" (err), "=&r" (x) \
		: "b" (addr), "i" (-EFAULT), "0" (err))
		#else
		#define __get_user_asm2(x, addr, err) \
		__get_user_asm(x, addr, err, "ld")
		#endif /* __powerpc64__ */

		#define __get_user_size(x, ptr, size, retval) \
		do { \
		retval = 0; \
		__chk_user_ptr(ptr); \
		if (size > sizeof(x)) \
		(x) = __get_user_bad(); \
		switch (size) { \
		case 1: __get_user_asm(x, ptr, retval, "lbz"); break; \
		case 2: __get_user_asm(x, ptr, retval, "lhz"); break; \
		case 4: __get_user_asm(x, ptr, retval, "lwz"); break; \
		case 8: __get_user_asm2(x, ptr, retval); break; \
		default: (x) = __get_user_bad(); \
		} \
		} while (0)

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

		#ifndef __powerpc64__
		#define __get_user64_nocheck(x, ptr, size) \
		({ \
		long __gu_err; \
		long long __gu_val; \
		__chk_user_ptr(ptr); \
		might_sleep(); \
		__get_user_size(__gu_val, (ptr), (size), __gu_err); \
		(x) = (__typeof__(*(ptr)))__gu_val; \
		__gu_err; \
		})
		#endif /* __powerpc64__ */

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

		/* more complex routines */

		extern int __copy_tofrom_user(void __user to, const void __user from,
		unsigned long size);
		extern unsigned long __copy_tofrom_user(void __user *to,
		const void __user *from, unsigned long size);

		#ifndef __powerpc64__
		extern inline unsigned long
		copy_from_user(void to, const void __user from, unsigned long n)
		{
		@@ -304,7 +322,8 @@ copy_from_user(void to, const void __user from, unsigned long n)
		return __copy_tofrom_user((__force void __user *)to, from, n);
		if ((unsigned long)from < TASK_SIZE) {
		over = (unsigned long)from + n - TASK_SIZE;
		return __copy_tofrom_user((__force void __user *)to, from, n - over) + over;
		return __copy_tofrom_user((__force void __user *)to, from,
		n - over) + over;
		}
		return n;
		}
		@@ -318,44 +337,126 @@ copy_to_user(void __user to, const void from, unsigned long n)
		return __copy_tofrom_user(to, (__force void __user *)from, n);
		if ((unsigned long)to < TASK_SIZE) {
		over = (unsigned long)to + n - TASK_SIZE;
		return __copy_tofrom_user(to, (__force void __user *) from, n - over) + over;
		return __copy_tofrom_user(to, (__force void __user *)from,
		n - over) + over;
		}
		return n;
		}

		static inline unsigned long __copy_from_user(void to, const void __user from, unsigned long size)
		#else /* __powerpc64__ */

		static inline unsigned long
		__copy_from_user_inatomic(void to, const void __user from, unsigned long n)
		{
		if (__builtin_constant_p(n) && (n <= 8)) {
		unsigned long ret;

		switch (n) {
		case 1:
		__get_user_size((u8 )to, from, 1, ret);
		break;
		case 2:
		__get_user_size((u16 )to, from, 2, ret);
		break;
		case 4:
		__get_user_size((u32 )to, from, 4, ret);
		break;
		case 8:
		__get_user_size((u64 )to, from, 8, ret);
		break;
		}
		return (ret == -EFAULT) ? n : 0;
		}
		return __copy_tofrom_user((__force void __user *) to, from, n);
		}

		static inline unsigned long
		__copy_to_user_inatomic(void __user to, const void from, unsigned long n)
		{
		if (__builtin_constant_p(n) && (n <= 8)) {
		unsigned long ret;

		switch (n) {
		case 1:
		__put_user_size((u8 )from, (u8 __user *)to, 1, ret);
		break;
		case 2:
		__put_user_size((u16 )from, (u16 __user *)to, 2, ret);
		break;
		case 4:
		__put_user_size((u32 )from, (u32 __user *)to, 4, ret);
		break;
		case 8:
		__put_user_size((u64 )from, (u64 __user *)to, 8, ret);
		break;
		}
		return (ret == -EFAULT) ? n : 0;
		}
		return __copy_tofrom_user(to, (__force const void __user *) from, n);
		}

		#endif /* __powerpc64__ */

		static inline unsigned long
		__copy_from_user(void to, const void __user from, unsigned long size)
		{
		might_sleep();
		#ifndef __powerpc64__
		return __copy_tofrom_user((__force void __user *)to, from, size);
		#else /* __powerpc64__ */
		return __copy_from_user_inatomic(to, from, size);
		#endif /* __powerpc64__ */
		}

		static inline unsigned long __copy_to_user(void __user to, const void from, unsigned long size)
		static inline unsigned long
		__copy_to_user(void __user to, const void from, unsigned long size)
		{
		might_sleep();
		#ifndef __powerpc64__
		return __copy_tofrom_user(to, (__force void __user *)from, size);
		#else /* __powerpc64__ */
		return __copy_to_user_inatomic(to, from, size);
		#endif /* __powerpc64__ */
		}

		#ifndef __powerpc64__
		#define __copy_to_user_inatomic __copy_to_user
		#define __copy_from_user_inatomic __copy_from_user
		#else /* __powerpc64__ */
		#define __copy_in_user(to, from, size) \
		__copy_tofrom_user((to), (from), (size))

		extern unsigned long copy_from_user(void to, const void __user from,
		unsigned long n);
		extern unsigned long copy_to_user(void __user to, const void from,
		unsigned long n);
		extern unsigned long copy_in_user(void __user to, const void __user from,
		unsigned long n);
		#endif /* __powerpc64__ */

		extern unsigned long __clear_user(void __user *addr, unsigned long size);

		extern inline unsigned long
		clear_user(void __user *addr, unsigned long size)
		static inline unsigned long clear_user(void __user *addr, unsigned long size)
		{
		if (access_ok(VERIFY_WRITE, addr, size))
		might_sleep();
		if (likely(access_ok(VERIFY_WRITE, addr, size)))
		return __clear_user(addr, size);
		#ifndef __powerpc64__
		if ((unsigned long)addr < TASK_SIZE) {
		unsigned long over = (unsigned long)addr + size - TASK_SIZE;
		return __clear_user(addr, size - over) + over;
		}
		#endif /* __powerpc64__ */
		return size;
		}

		extern int __strncpy_from_user(char dst, const char __user src, long count);

		extern inline long
		strncpy_from_user(char dst, const char __user src, long count)
		static inline long strncpy_from_user(char dst, const char __user src,
		long count)
		{
		if (access_ok(VERIFY_READ, src, 1))
		might_sleep();
		if (likely(access_ok(VERIFY_READ, src, 1)))
		return __strncpy_from_user(dst, src, count);
		return -EFAULT;
		}
		@@ -365,8 +466,11 @@ strncpy_from_user(char dst, const char __user src, long count)
		*
		* Return 0 for error
		*/

		#ifndef __powerpc64__
		extern int __strnlen_user(const char __user *str, long len, unsigned long top);
		#else /* __powerpc64__ */
		extern int __strnlen_user(const char __user *str, long len);
		#endif /* __powerpc64__ */

		/*
		* Returns the length of the string at str (including the null byte),
		@@ -376,18 +480,25 @@ extern int __strnlen_user(const char __user *str, long len, unsigned long top);
		* The `top' parameter to __strnlen_user is to make sure that
		* we can never overflow from the user area into kernel space.
		*/
		extern __inline__ int strnlen_user(const char __user *str, long len)
		static inline int strnlen_user(const char __user *str, long len)
		{
		#ifndef __powerpc64__
		unsigned long top = current->thread.fs.seg;

		if ((unsigned long)str > top)
		return 0;
		return __strnlen_user(str, len, top);
		#else /* __powerpc64__ */
		might_sleep();
		if (likely(access_ok(VERIFY_READ, str, 1)))
		return __strnlen_user(str, len);
		return 0;
		#endif /* __powerpc64__ */
		}

		#define strlen_user(str) strnlen_user((str), 0x7ffffffe)

		#endif /* __ASSEMBLY__ */

		#endif /* _PPC_UACCESS_H */
		#endif /* __KERNEL__ */

		#endif /* _ARCH_POWERPC_UACCESS_H */

include/asm-ppc64/uaccess.h

deleted100644 → 0

+0 −341

File deleted.

Preview size limit exceeded, changes collapsed.