sh: Initial consolidation of the _32/_64 uaccess split. (42fd3b14) · Commits · e / devices / android_kernel_oneplus_sm7250

include/asm-sh/uaccess.h

+222 −0

Original line number	Diff line number	Diff line
		#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)))

		/*
		* 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); \
		__chk_user_ptr(ptr); \
		__put_user_size((x), __pu_addr, (size), __pu_err); \
		__pu_err; \
		})

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

		#ifdef CONFIG_SUPERH32
		# include "uaccess_32.h"
		#else
		# include "uaccess_64.h"
		#endif

		/* 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; \
		})

		/**
		* strncpy_from_user: - Copy a NUL terminated string from userspace.
		* @dst: Destination address, in kernel space. This buffer must be at
		* least @count bytes long.
		* @src: Source address, in user space.
		* @count: Maximum number of bytes to copy, including the trailing NUL.
		*
		* Copies a NUL-terminated string from userspace to kernel space.
		*
		* On success, returns the length of the string (not including the trailing
		* NUL).
		*
		* If access to userspace fails, returns -EFAULT (some data may have been
		* copied).
		*
		* If @count is smaller than the length of the string, copies @count bytes
		* and returns @count.
		*/
		#define strncpy_from_user(dest,src,count) \
		({ \
		unsigned long __sfu_src = (unsigned long)(src); \
		int __sfu_count = (int)(count); \
		long __sfu_res = -EFAULT; \
		\
		if (__access_ok(__sfu_src, __sfu_count)) \
		__sfu_res = __strncpy_from_user((unsigned long)(dest), \
		__sfu_src, __sfu_count); \
		\
		__sfu_res; \
		})

		static inline unsigned long
		copy_from_user(void to, const void __user from, unsigned long n)
		{
		@@ -31,4 +190,67 @@ copy_to_user(void __user to, const void from, unsigned long n)
		return __copy_size;
		}

		/**
		* strnlen_user: - Get the size of a string in user space.
		* @s: The string to measure.
		* @n: The maximum valid length
		*
		* Context: User context only. This function may sleep.
		*
		* Get the size of a NUL-terminated string in user space.
		*
		* Returns the size of the string INCLUDING the terminating NUL.
		* On exception, returns 0.
		* If the string is too long, returns a value greater than @n.
		*/
		static inline long strnlen_user(const char __user *s, long n)
		{
		if (!__addr_ok(s))
		return 0;
		else
		return __strnlen_user(s, n);
		}

		/**
		* strlen_user: - Get the size of a string in user space.
		* @str: The string to measure.
		*
		* Context: User context only. This function may sleep.
		*
		* Get the size of a NUL-terminated string in user space.
		*
		* Returns the size of the string INCLUDING the terminating NUL.
		* On exception, returns 0.
		*
		* If there is a limit on the length of a valid string, you may wish to
		* consider using strnlen_user() instead.
		*/
		#define strlen_user(str) strnlen_user(str, ~0UL >> 1)

		/*
		* 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);


		#endif /* __ASM_SH_UACCESS_H */

include/asm-sh/uaccess_32.h

+48 −229

Original line number	Diff line number	Diff line
		@@ -12,56 +12,6 @@
		#ifndef __ASM_SH_UACCESS_32_H
		#define __ASM_SH_UACCESS_32_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)))

		/*
		* 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_size(x,ptr,size,retval) \
		do { \
		retval = 0; \
		@@ -81,28 +31,7 @@ do { \
		} \
		} while (0)

		#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; \
		})

		#ifdef CONFIG_MMU
		#define __get_user_asm(x, addr, err, insn) \
		({ \
		__asm__ __volatile__( \
		@@ -123,6 +52,16 @@ __asm__ __volatile__( \
		".previous" \
		:"=&r" (err), "=&r" (x) \
		:"m" (__m(addr)), "i" (-EFAULT), "0" (err)); })
		#else
		#define __get_user_asm(x, addr, err, insn) \
		do { \
		__asm__ __volatile__ ( \
		"mov." insn " %1, %0\n\t" \
		: "=&r" (x) \
		: "m" (__m(addr)) \
		); \
		} while (0)
		#endif /* CONFIG_MMU */

		extern void __get_user_unknown(void);

		@@ -147,27 +86,9 @@ do { \
		} \
		} while (0)

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

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

		#ifdef CONFIG_MMU
		#define __put_user_asm(x, addr, err, insn) \
		({ \
		do { \
		__asm__ __volatile__ ( \
		"1:\n\t" \
		"mov." insn " %1, %2\n\t" \
		@@ -184,8 +105,22 @@ __asm__ __volatile__( \
		".long 1b, 3b\n\t" \
		".previous" \
		: "=&r" (err) \
		:"r" (x), "m" (__m(addr)), "i" (-EFAULT), "0" (err) \
		:"memory"); })
		: "r" (x), "m" (__m(addr)), "i" (-EFAULT), \
		"0" (err) \
		: "memory" \
		); \
		} while (0)
		#else
		#define __put_user_asm(x, addr, err, insn) \
		do { \
		__asm__ __volatile__ ( \
		"mov." insn " %0, %1\n\t" \
		: /* no outputs */ \
		: "r" (x), "m" (__m(addr)) \
		: "memory" \
		); \
		} while (0)
		#endif /* CONFIG_MMU */

		#if defined(CONFIG_CPU_LITTLE_ENDIAN)
		#define __put_user_u64(val,addr,retval) \
		@@ -235,40 +170,7 @@ __asm__ __volatile__( \

		extern void __put_user_unknown(void);

		/* 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.)
		*/
		extern __kernel_size_t __clear_user(void *addr, __kernel_size_t size);

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

		static __inline__ int
		static inline int
		__strncpy_from_user(unsigned long __dest, unsigned long __user __src, int __count)
		{
		__kernel_size_t res;
		@@ -307,37 +209,11 @@ __strncpy_from_user(unsigned long __dest, unsigned long __user __src, int __coun
		return res;
		}

		/**
		* strncpy_from_user: - Copy a NUL terminated string from userspace.
		* @dst: Destination address, in kernel space. This buffer must be at
		* least @count bytes long.
		* @src: Source address, in user space.
		* @count: Maximum number of bytes to copy, including the trailing NUL.
		*
		* Copies a NUL-terminated string from userspace to kernel space.
		*
		* On success, returns the length of the string (not including the trailing
		* NUL).
		*
		* If access to userspace fails, returns -EFAULT (some data may have been
		* copied).
		*
		* If @count is smaller than the length of the string, copies @count bytes
		* and returns @count.
		*/
		#define strncpy_from_user(dest,src,count) ({ \
		unsigned long __sfu_src = (unsigned long) (src); \
		int __sfu_count = (int) (count); \
		long __sfu_res = -EFAULT; \
		if(__access_ok(__sfu_src, __sfu_count)) { \
		__sfu_res = __strncpy_from_user((unsigned long) (dest), __sfu_src, __sfu_count); \
		} __sfu_res; })

		/*
		* Return the size of a string (including the ending 0 even when we have
		* exceeded the maximum string length).
		*/
		static __inline__ long __strnlen_user(const char __user *__s, long __n)
		static inline long __strnlen_user(const char __user *__s, long __n)
		{
		unsigned long res;
		unsigned long __dummy;
		@@ -369,61 +245,4 @@ static __inline__ long __strnlen_user(const char __user *__s, long __n)
		return res;
		}

		/**
		* strnlen_user: - Get the size of a string in user space.
		* @s: The string to measure.
		* @n: The maximum valid length
		*
		* Context: User context only. This function may sleep.
		*
		* Get the size of a NUL-terminated string in user space.
		*
		* Returns the size of the string INCLUDING the terminating NUL.
		* On exception, returns 0.
		* If the string is too long, returns a value greater than @n.
		*/
		static __inline__ long strnlen_user(const char __user *s, long n)
		{
		if (!__addr_ok(s))
		return 0;
		else
		return __strnlen_user(s, n);
		}

		/**
		* strlen_user: - Get the size of a string in user space.
		* @str: The string to measure.
		*
		* Context: User context only. This function may sleep.
		*
		* Get the size of a NUL-terminated string in user space.
		*
		* Returns the size of the string INCLUDING the terminating NUL.
		* On exception, returns 0.
		*
		* If there is a limit on the length of a valid string, you may wish to
		* consider using strnlen_user() instead.
		*/
		#define strlen_user(str) strnlen_user(str, ~0UL >> 1)

		/*
		* 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;
		};

		extern int fixup_exception(struct pt_regs *regs);

		#endif /* __ASM_SH_UACCESS_32_H */

include/asm-sh/uaccess_64.h

+0 −187

Original line number	Diff line number	Diff line
		@@ -20,68 +20,6 @@
		* License. See the file "COPYING" in the main directory of this archive
		* for more details.
		*/
		#include <linux/errno.h>
		#include <linux/sched.h>

		#define VERIFY_READ 0
		#define VERIFY_WRITE 1

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

		/*
		* Uhhuh, this needs 33-bit arithmetic. We have a carry..
		*
		* sum := addr + size; carry? --> flag = true;
		* if (sum >= addr_limit) flag = true;
		*/
		#define __range_ok(addr,size) (((unsigned long) (addr) + (size) < (current_thread_info()->addr_limit.seg)) ? 0 : 1)

		#define access_ok(type,addr,size) (__range_ok(addr,size) == 0)
		#define __access_ok(addr,size) (__range_ok(addr,size) == 0)

		/*
		* 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 MIPS 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)))

		/*
		* The "xxx_ret" versions return constant specified in third argument, if
		* something bad happens. These macros can be optimized for the
		* case of just returning from the function xxx_ret is used.
		*/

		#define put_user_ret(x,ptr,ret) ({ \
		if (put_user(x,ptr)) return ret; })

		#define get_user_ret(x,ptr,ret) ({ \
		if (get_user(x,ptr)) return ret; })

		#define __put_user_ret(x,ptr,ret) ({ \
		if (__put_user(x,ptr)) return ret; })

		#define __get_user_ret(x,ptr,ret) ({ \
		if (__get_user(x,ptr)) return ret; })

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

		#define __get_user_size(x,ptr,size,retval) \
		do { \
		@@ -105,26 +43,6 @@ do { \
		} \
		} while (0)

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

		#define __get_user_check(x,ptr,size) \
		({ \
		long __gu_addr = (long)(ptr); \
		long __gu_err = -EFAULT, __gu_val; \
		if (__access_ok(__gu_addr, (size))) \
		__get_user_size((void *)&__gu_val, __gu_addr, \
		(size), __gu_err); \
		(x) = (__typeof__(*(ptr))) __gu_val; \
		__gu_err; \
		})

		extern long __get_user_asm_b(void *, long);
		extern long __get_user_asm_w(void *, long);
		extern long __get_user_asm_l(void *, long);
		@@ -152,115 +70,10 @@ do { \
		} \
		} while (0)

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

		#define __put_user_check(x,ptr,size) \
		({ \
		long __pu_err = -EFAULT; \
		long __pu_addr = (long)(ptr); \
		__typeof__(*(ptr)) __pu_val = (x); \
		\
		if (__access_ok(__pu_addr, (size))) \
		__put_user_size((void *)&__pu_val, __pu_addr, (size), __pu_err);\
		__pu_err; \
		})

		extern long __put_user_asm_b(void *, long);
		extern long __put_user_asm_w(void *, long);
		extern long __put_user_asm_l(void *, long);
		extern long __put_user_asm_q(void *, long);
		extern void __put_user_unknown(void);


		/* Generic arbitrary sized copy. */
		/* Return the number of bytes NOT copied */
		/* XXX: should be such that: 4byte and the rest. */
		extern __kernel_size_t __copy_user(void __to, const void __from, __kernel_size_t __n);

		#define copy_to_user_ret(to,from,n,retval) ({ \
		if (copy_to_user(to,from,n)) \
		return retval; \
		})

		#define __copy_to_user(to,from,n) \
		__copy_user((void *)(to), \
		(void *)(from), n)

		#define __copy_to_user_ret(to,from,n,retval) ({ \
		if (__copy_to_user(to,from,n)) \
		return retval; \
		})

		#define copy_from_user_ret(to,from,n,retval) ({ \
		if (copy_from_user(to,from,n)) \
		return retval; \
		})

		#define __copy_from_user(to,from,n) \
		__copy_user((void *)(to), \
		(void *)(from), n)

		#define __copy_from_user_ret(to,from,n,retval) ({ \
		if (__copy_from_user(to,from,n)) \
		return retval; \
		})

		#define __copy_to_user_inatomic __copy_to_user
		#define __copy_from_user_inatomic __copy_from_user

		/* XXX: Not sure it works well..
		should be such that: 4byte clear and the rest. */
		extern __kernel_size_t __clear_user(void *addr, __kernel_size_t size);

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

		extern int __strncpy_from_user(unsigned long __dest, unsigned long __src, int __count);

		#define strncpy_from_user(dest,src,count) ({ \
		unsigned long __sfu_src = (unsigned long) (src); \
		int __sfu_count = (int) (count); \
		long __sfu_res = -EFAULT; \
		if(__access_ok(__sfu_src, __sfu_count)) { \
		__sfu_res = __strncpy_from_user((unsigned long) (dest), __sfu_src, __sfu_count); \
		} __sfu_res; })

		#define strlen_user(str) strnlen_user(str, ~0UL >> 1)

		/*
		* Return the size of a string (including the ending 0!)
		*/
		extern long __strnlen_user(const char *__s, long __n);

		static inline long strnlen_user(const char *s, long n)
		{
		if (!__addr_ok(s))
		return 0;
		else
		return __strnlen_user(s, n);
		}

		struct exception_table_entry
		{
		unsigned long insn, fixup;
		};

		#ifdef CONFIG_MMU
		#define ARCH_HAS_SEARCH_EXTABLE
		#endif

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

		#endif /* __ASM_SH_UACCESS_64_H */