Import of Linux/MIPS 2.1.36

1 files changed, 282 insertions, 148 deletions

diff --git a/include/asm-sparc/uaccess.h b/include/asm-sparc/uaccess.h
index 53eb75cae..4ffc23657 100644
--- a/include/asm-sparc/uaccess.h
+++ b/include/asm-sparc/uaccess.h
@@ -1,15 +1,17 @@
-/* $Id: uaccess.h,v 1.2 1996/10/31 00:59:56 davem Exp $ */
+/* $Id: uaccess.h,v 1.13 1997/04/11 00:42:22 davem Exp $
+ * uaccess.h: User space memore access functions.
+ *
+ * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
+ * Copyright (C) 1996,1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
+ */
 #ifndef _ASM_UACCESS_H
 #define _ASM_UACCESS_H
 
-/*
- * User space memory access functions
- */
-
 #ifdef __KERNEL__
 #include <linux/sched.h>
 #include <linux/string.h>
 #include <asm/vac-ops.h>
+#include <asm/a.out.h>
 #endif
 
 #ifndef __ASSEMBLY__
@@ -20,7 +22,7 @@
  * "For historical reasons, these macros are grossly misnamed." -Linus
  */
 #define KERNEL_DS   0
-#define USER_DS     1
+#define USER_DS     -1
 
 #define VERIFY_READ	0
 #define VERIFY_WRITE	1
@@ -29,9 +31,14 @@
 #define get_ds() (KERNEL_DS)
 #define set_fs(val) ((current->tss.current_ds) = (val))
 
-#define __user_ok(addr,size) (((size) <= page_offset)&&((addr) <= page_offset-(size)))
+/* We have there a nice not-mapped page at page_offset - PAGE_SIZE, so that this test
+ * can be fairly lightweight.
+ * No one can read/write anything from userland in the kernel space by setting
+ * large size and address near to page_offset - a fault will break his intentions.
+ */
+#define __user_ok(addr,size) ((addr) < stack_top)
 #define __kernel_ok (get_fs() == KERNEL_DS)
-#define __access_ok(addr,size) (__kernel_ok || __user_ok((addr),(size)))
+#define __access_ok(addr,size) (__user_ok((addr) & get_fs(),(size)))
 #define access_ok(type,addr,size) __access_ok((unsigned long)(addr),(size))
 
 extern inline int verify_area(int type, const void * addr, unsigned long size)
@@ -39,6 +46,38 @@ extern inline int verify_area(int type, const void * addr, unsigned long size)
 	return access_ok(type,addr,size)?0:-EFAULT;
 }
 
+/*
+ * 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.
+ *
+ * There is a special way how to put a range of potentially faulting
+ * insns (like twenty ldd/std's with now intervening other instructions)
+ * You specify address of first in insn and 0 in fixup and in the next
+ * exception_table_entry you specify last potentially faulting insn + 1
+ * and in fixup the routine which should handle the fault.
+ * That fixup code will get
+ * (faulting_insn_address - first_insn_in_the_range_address)/4
+ * in %g2 (ie. index of the faulting instruction in the range).
+ */
+
+struct exception_table_entry
+{
+        unsigned long insn, fixup;
+};
+
+/* Returns 0 if exception not found and fixup otherwise.  */
+extern unsigned long search_exception_table(unsigned long, unsigned long *);
+
+extern void __ret_efault(void);
+
 /* Uh, these should become the main single-value transfer routines..
  * They automatically use the right size if we just have the right
  * pointer type..
@@ -52,200 +91,285 @@ extern inline int verify_area(int type, const void * addr, unsigned long size)
 unsigned long __pu_addr = (unsigned long)(ptr); \
 __put_user_check((__typeof__(*(ptr)))(x),__pu_addr,sizeof(*(ptr))); })
 
+#define put_user_ret(x,ptr,retval) ({ \
+unsigned long __pu_addr = (unsigned long)(ptr); \
+__put_user_check_ret((__typeof__(*(ptr)))(x),__pu_addr,sizeof(*(ptr)),retval); })
+
 #define get_user(x,ptr) ({ \
 unsigned long __gu_addr = (unsigned long)(ptr); \
 __get_user_check((x),__gu_addr,sizeof(*(ptr)),__typeof__(*(ptr))); })
 
+#define get_user_ret(x,ptr,retval) ({ \
+unsigned long __gu_addr = (unsigned long)(ptr); \
+__get_user_check_ret((x),__gu_addr,sizeof(*(ptr)),__typeof__(*(ptr)),retval); })
+
 /*
  * 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 __put_user_ret(x,ptr,retval) __put_user_nocheck_ret((x),(ptr),sizeof(*(ptr)),retval)
 #define __get_user(x,ptr) __get_user_nocheck((x),(ptr),sizeof(*(ptr)),__typeof__(*(ptr)))
+#define __get_user_ret(x,ptr,retval) __get_user_nocheck_ret((x),(ptr),sizeof(*(ptr)),__typeof__(*(ptr)),retval)
 
 struct __large_struct { unsigned long buf[100]; };
 #define __m(x) ((struct __large_struct *)(x))
 
 #define __put_user_check(x,addr,size) ({ \
-register int __pu_ret asm("g1"); \
-__pu_ret = -EFAULT; \
+register int __pu_ret; \
 if (__access_ok(addr,size)) { \
 switch (size) { \
-case 1: __put_user_8(x,addr,__pu_ret); break; \
-case 2: __put_user_16(x,addr,__pu_ret); break; \
-case 4: __put_user_32(x,addr,__pu_ret); break; \
+case 1: __put_user_asm(x,b,addr,__pu_ret); break; \
+case 2: __put_user_asm(x,h,addr,__pu_ret); break; \
+case 4: __put_user_asm(x,,addr,__pu_ret); break; \
 default: __pu_ret = __put_user_bad(); break; \
-} } __pu_ret; })
+} } else { __pu_ret = -EFAULT; } __pu_ret; })
+
+#define __put_user_check_ret(x,addr,size,retval) ({ \
+register int __foo __asm__ ("l1"); \
+if (__access_ok(addr,size)) { \
+switch (size) { \
+case 1: __put_user_asm_ret(x,b,addr,retval,__foo); break; \
+case 2: __put_user_asm_ret(x,h,addr,retval,__foo); break; \
+case 4: __put_user_asm_ret(x,,addr,retval,__foo); break; \
+default: if (__put_user_bad()) return retval; break; \
+} } else return retval; })
 
 #define __put_user_nocheck(x,addr,size) ({ \
-register int __pu_ret asm("g1"); \
-__pu_ret = -EFAULT; \
+register int __pu_ret; \
 switch (size) { \
-case 1: __put_user_8(x,addr,__pu_ret); break; \
-case 2: __put_user_16(x,addr,__pu_ret); break; \
-case 4: __put_user_32(x,addr,__pu_ret); break; \
+case 1: __put_user_asm(x,b,addr,__pu_ret); break; \
+case 2: __put_user_asm(x,h,addr,__pu_ret); break; \
+case 4: __put_user_asm(x,,addr,__pu_ret); break; \
 default: __pu_ret = __put_user_bad(); break; \
 } __pu_ret; })
 
-#define __put_user_8(x,addr,ret)						\
-__asm__ __volatile(								\
-	"/* Put user 8, inline. */\n\t"						\
-	"ld	[%%g6 + %3], %%g2\n\t"						\
-	"set	1f, %0\n\t"							\
-	"add	%%g2, 1, %%g3\n\t"						\
-	"st	%0, [%%g6 + %4]\n\t"						\
-	"st	%%g3, [%%g6 + %3]\n\t"						\
-	"stb	%1, [%2]\n\t"							\
-	"mov	0, %0\n\t"							\
-	"st	%%g2, [%%g6 + %3]\n"						\
-"1:\n" : "=&r" (ret) : "r" (x), "r" (__m(addr)),				\
-	 "i" ((const unsigned long)(&((struct task_struct *)0)->tss.ex.count)),	\
-	 "i" ((const unsigned long)(&((struct task_struct *)0)->tss.ex.expc))	\
-       : "g2", "g3")
-
-#define __put_user_16(x,addr,ret)						\
-__asm__ __volatile(								\
-	"/* Put user 16, inline. */\n\t"					\
-	"ld	[%%g6 + %3], %%g2\n\t"						\
-	"set	1f, %0\n\t"							\
-	"add	%%g2, 1, %%g3\n\t"						\
-	"st	%0, [%%g6 + %4]\n\t"						\
-	"st	%%g3, [%%g6 + %3]\n\t"						\
-	"sth	%1, [%2]\n\t"							\
-	"mov	0, %0\n\t"							\
-	"st	%%g2, [%%g6 + %3]\n"						\
-"1:\n" : "=&r" (ret) : "r" (x), "r" (__m(addr)),				\
-	 "i" ((const unsigned long)(&((struct task_struct *)0)->tss.ex.count)),	\
-	 "i" ((const unsigned long)(&((struct task_struct *)0)->tss.ex.expc))	\
-       : "g2", "g3")
-
-#define __put_user_32(x,addr,ret)						\
-__asm__ __volatile(								\
-	"/* Put user 32, inline. */\n\t"					\
-	"ld	[%%g6 + %3], %%g2\n\t"						\
-	"set	1f, %0\n\t"							\
-	"add	%%g2, 1, %%g3\n\t"						\
-	"st	%0, [%%g6 + %4]\n\t"						\
-	"st	%%g3, [%%g6 + %3]\n\t"						\
-	"st	%1, [%2]\n\t"							\
-	"mov	0, %0\n\t"							\
-	"st	%%g2, [%%g6 + %3]\n"						\
-"1:\n" : "=&r" (ret) : "r" (x), "r" (__m(addr)),				\
-	 "i" ((const unsigned long)(&((struct task_struct *)0)->tss.ex.count)),	\
-	 "i" ((const unsigned long)(&((struct task_struct *)0)->tss.ex.expc))	\
-       : "g2", "g3")
+#define __put_user_nocheck_ret(x,addr,size,retval) ({ \
+register int __foo __asm__ ("l1"); \
+switch (size) { \
+case 1: __put_user_asm_ret(x,b,addr,retval,__foo); break; \
+case 2: __put_user_asm_ret(x,h,addr,retval,__foo); break; \
+case 4: __put_user_asm_ret(x,,addr,retval,__foo); break; \
+default: if (__put_user_bad()) return retval; break; \
+} })
+
+#define __put_user_asm(x,size,addr,ret)					\
+__asm__ __volatile__(							\
+	"/* Put user asm, inline. */\n"					\
+"1:\t"	"st"#size " %1, %2\n\t"						\
+	"clr	%0\n"							\
+"2:\n\n\t"								\
+	".section .fixup,#alloc,#execinstr\n\t"				\
+	".align	4\n"							\
+"3:\n\t"								\
+	"b	2b\n\t"							\
+	" mov	%3, %0\n\t"						\
+        ".previous\n\n\t"						\
+	".section __ex_table,#alloc\n\t"				\
+	".align	4\n\t"							\
+	".word	1b, 3b\n\t"						\
+	".previous\n\n\t"						\
+       : "=&r" (ret) : "r" (x), "m" (*__m(addr)),			\
+	 "i" (-EFAULT))
+
+#define __put_user_asm_ret(x,size,addr,ret,foo)				\
+if (__builtin_constant_p(ret) && ret == -EFAULT)			\
+__asm__ __volatile__(							\
+	"/* Put user asm ret, inline. */\n"				\
+"1:\t"	"st"#size " %1, %2\n\n\t"					\
+	".section __ex_table,#alloc\n\t"				\
+	".align	4\n\t"							\
+	".word	1b, __ret_efault\n\n\t"					\
+	".previous\n\n\t"						\
+       : "=r" (foo) : "r" (x), "m" (*__m(addr)));			\
+else									\
+__asm__ __volatile(							\
+	"/* Put user asm ret, inline. */\n"				\
+"1:\t"	"st"#size " %1, %2\n\n\t"					\
+	".section .fixup,#alloc,#execinstr\n\t"				\
+	".align	4\n"							\
+"3:\n\t"								\
+	"ret\n\t"							\
+	" restore %%g0, %3, %%o0\n\t"					\
+	".previous\n\n\t"						\
+	".section __ex_table,#alloc\n\t"				\
+	".align	4\n\t"							\
+	".word	1b, 3b\n\n\t"						\
+	".previous\n\n\t"						\
+       : "=r" (foo) : "r" (x), "m" (*__m(addr)), "i" (ret))
 
 extern int __put_user_bad(void);
 
 #define __get_user_check(x,addr,size,type) ({ \
-register int __gu_ret asm("g1"); \
-register unsigned long __gu_val = 0; \
-__gu_ret = -EFAULT; \
+register int __gu_ret; \
+register unsigned long __gu_val; \
+if (__access_ok(addr,size)) { \
+switch (size) { \
+case 1: __get_user_asm(__gu_val,ub,addr,__gu_ret); break; \
+case 2: __get_user_asm(__gu_val,uh,addr,__gu_ret); break; \
+case 4: __get_user_asm(__gu_val,,addr,__gu_ret); break; \
+default: __gu_val = 0; __gu_ret = __get_user_bad(); break; \
+} } else { __gu_val = 0; __gu_ret = -EFAULT; } x = (type) __gu_val; __gu_ret; })
+
+#define __get_user_check_ret(x,addr,size,type,retval) ({ \
+register unsigned long __gu_val __asm__ ("l1"); \
 if (__access_ok(addr,size)) { \
 switch (size) { \
-case 1: __get_user_8(__gu_val,addr,__gu_ret); break; \
-case 2: __get_user_16(__gu_val,addr,__gu_ret); break; \
-case 4: __get_user_32(__gu_val,addr,__gu_ret); break; \
-default: __gu_ret = __get_user_bad(); break; \
-} } x = (type) __gu_val; __gu_ret; })
+case 1: __get_user_asm_ret(__gu_val,ub,addr,retval); break; \
+case 2: __get_user_asm_ret(__gu_val,uh,addr,retval); break; \
+case 4: __get_user_asm_ret(__gu_val,,addr,retval); break; \
+default: if (__get_user_bad()) return retval; \
+} x = (type) __gu_val; } else return retval; })
 
 #define __get_user_nocheck(x,addr,size,type) ({ \
-register int __gu_ret asm("g1"); \
-register unsigned long __gu_val = 0; \
-__gu_ret = -EFAULT; \
+register int __gu_ret; \
+register unsigned long __gu_val; \
 switch (size) { \
-case 1: __get_user_8(__gu_val,addr,__gu_ret); break; \
-case 2: __get_user_16(__gu_val,addr,__gu_ret); break; \
-case 4: __get_user_32(__gu_val,addr,__gu_ret); break; \
-default: __gu_ret = __get_user_bad(); break; \
+case 1: __get_user_asm(__gu_val,ub,addr,__gu_ret); break; \
+case 2: __get_user_asm(__gu_val,uh,addr,__gu_ret); break; \
+case 4: __get_user_asm(__gu_val,,addr,__gu_ret); break; \
+default: __gu_val = 0; __gu_ret = __get_user_bad(); break; \
 } x = (type) __gu_val; __gu_ret; })
 
-#define __get_user_8(x,addr,ret)						\
-__asm__ __volatile__(								\
-	"/* Get user 8, inline. */\n\t"						\
-	"ld	[%%g6 + %3], %%g2\n\t"						\
-	"set	1f, %0\n\t"							\
-	"add	%%g2, 1, %%g3\n\t"						\
-	"st	%0, [%%g6 + %4]\n\t"						\
-	"st	%%g3, [%%g6 + %3]\n\t"						\
-	"ldub	[%2], %1\n\t"							\
-	"mov	0, %0\n\t"							\
-	"st	%%g2, [%%g6 + %3]\n"						\
-"1:\n" : "=&r" (ret), "=&r" (x) : "r" (__m(addr)),				\
-	 "i" ((const unsigned long)(&((struct task_struct *)0)->tss.ex.count)),	\
-	 "i" ((const unsigned long)(&((struct task_struct *)0)->tss.ex.expc))	\
-       : "g2", "g3")
-
-#define __get_user_16(x,addr,ret)						\
-__asm__ __volatile__(								\
-	"/* Get user 16, inline. */\n\t"					\
-	"ld	[%%g6 + %3], %%g2\n\t"						\
-	"set	1f, %0\n\t"							\
-	"add	%%g2, 1, %%g3\n\t"						\
-	"st	%0, [%%g6 + %4]\n\t"						\
-	"st	%%g3, [%%g6 + %3]\n\t"						\
-	"lduh	[%2], %1\n\t"							\
-	"mov	0, %0\n\t"							\
-	"st	%%g2, [%%g6 + %3]\n"						\
-"1:\n" : "=&r" (ret), "=&r" (x) : "r" (__m(addr)),				\
-	 "i" ((const unsigned long)(&((struct task_struct *)0)->tss.ex.count)),	\
-	 "i" ((const unsigned long)(&((struct task_struct *)0)->tss.ex.expc))	\
-       : "g2", "g3")
-
-#define __get_user_32(x,addr,ret)						\
-__asm__ __volatile__(								\
-	"/* Get user 32, inline. */\n\t"					\
-	"ld	[%%g6 + %3], %%g2\n\t"						\
-	"set	1f, %0\n\t"							\
-	"add	%%g2, 1, %%g3\n\t"						\
-	"st	%0, [%%g6 + %4]\n\t"						\
-	"st	%%g3, [%%g6 + %3]\n\t"						\
-	"ld	[%2], %1\n\t"							\
-	"mov	0, %0\n\t"							\
-	"st	%%g2, [%%g6 + %3]\n"						\
-"1:\n" : "=&r" (ret), "=&r" (x) : "r" (__m(addr)),				\
-	 "i" ((const unsigned long)(&((struct task_struct *)0)->tss.ex.count)),	\
-	 "i" ((const unsigned long)(&((struct task_struct *)0)->tss.ex.expc))	\
-       : "g2", "g3")
+#define __get_user_nocheck_ret(x,addr,size,type,retval) ({ \
+register unsigned long __gu_val __asm__ ("l1"); \
+switch (size) { \
+case 1: __get_user_asm_ret(__gu_val,ub,addr,retval); break; \
+case 2: __get_user_asm_ret(__gu_val,uh,addr,retval); break; \
+case 4: __get_user_asm_ret(__gu_val,,addr,retval); break; \
+default: if (__get_user_bad()) return retval; \
+} x = (type) __gu_val; })
+
+#define __get_user_asm(x,size,addr,ret)					\
+__asm__ __volatile__(							\
+	"/* Get user asm, inline. */\n"					\
+"1:\t"	"ld"#size " %2, %1\n\t"						\
+	"clr	%0\n"							\
+"2:\n\n\t"								\
+	".section .fixup,#alloc,#execinstr\n\t"				\
+	".align	4\n"							\
+"3:\n\t"								\
+	"clr	%1\n\t"							\
+	"b	2b\n\t"							\
+	" mov	%3, %0\n\n\t"						\
+	".previous\n\t"							\
+	".section __ex_table,#alloc\n\t"				\
+	".align	4\n\t"							\
+	".word	1b, 3b\n\n\t"						\
+	".previous\n\t"							\
+       : "=&r" (ret), "=&r" (x) : "m" (*__m(addr)),			\
+	 "i" (-EFAULT))
+
+#define __get_user_asm_ret(x,size,addr,retval)				\
+if (__builtin_constant_p(retval) && retval == -EFAULT)			\
+__asm__ __volatile__(							\
+	"/* Get user asm ret, inline. */\n"				\
+"1:\t"	"ld"#size " %1, %0\n\n\t"					\
+	".section __ex_table,#alloc\n\t"				\
+	".align	4\n\t"							\
+	".word	1b,__ret_efault\n\n\t"					\
+	".previous\n\t"							\
+       : "=&r" (x) : "m" (*__m(addr)));					\
+else									\
+__asm__ __volatile__(							\
+	"/* Get user asm ret, inline. */\n"				\
+"1:\t"	"ld"#size " %1, %0\n\n\t"					\
+	".section .fixup,#alloc,#execinstr\n\t"				\
+	".align	4\n"							\
+"3:\n\t"								\
+	"ret\n\t"							\
+	" restore %%g0, %2, %%o0\n\n\t"					\
+	".previous\n\t"							\
+	".section __ex_table,#alloc\n\t"				\
+	".align	4\n\t"							\
+	".word	1b, 3b\n\n\t"						\
+	".previous\n\t"							\
+       : "=&r" (x) : "m" (*__m(addr)), "i" (retval))
 
 extern int __get_user_bad(void);
 
-extern int __copy_to_user(unsigned long to, unsigned long from, int size);
-extern int __copy_from_user(unsigned long to, unsigned long from, int size);
+extern __kernel_size_t __copy_user(void *to, void *from, __kernel_size_t size);
 
 #define copy_to_user(to,from,n) ({ \
-unsigned long __copy_to = (unsigned long) (to); \
-unsigned long __copy_size = (unsigned long) (n); \
-unsigned long __copy_res; \
-if(__copy_size && __access_ok(__copy_to, __copy_size)) { \
-__copy_res = __copy_to_user(__copy_to, (unsigned long) (from), __copy_size); \
-if(__copy_res) __copy_res = __copy_size - __copy_res; \
+void *__copy_to = (void *) (to); \
+__kernel_size_t __copy_size = (__kernel_size_t) (n); \
+__kernel_size_t __copy_res; \
+if(__copy_size && __access_ok((unsigned long)__copy_to, __copy_size)) { \
+__copy_res = __copy_user(__copy_to, (void *) (from), __copy_size); \
 } else __copy_res = __copy_size; \
 __copy_res; })
 
+#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(to,from,n) ({ \
-unsigned long __copy_from = (unsigned long) (from); \
-unsigned long __copy_size = (unsigned long) (n); \
-unsigned long __copy_res; \
-if(__copy_size && __access_ok(__copy_from, __copy_size)) { \
-__copy_res = __copy_from_user((unsigned long) (to), __copy_from, __copy_size); \
-if(__copy_res) __copy_res = __copy_size - __copy_res; \
+void *__copy_from = (void *) (from); \
+__kernel_size_t __copy_size = (__kernel_size_t) (n); \
+__kernel_size_t __copy_res; \
+if(__copy_size && __access_ok((unsigned long)__copy_from, __copy_size)) { \
+__copy_res = __copy_user((void *) (to), __copy_from, __copy_size); \
 } else __copy_res = __copy_size; \
 __copy_res; })
 
-extern int __clear_user(unsigned long addr, int size);
+#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; \
+})
+
+extern __inline__ __kernel_size_t __clear_user(void *addr, __kernel_size_t size)
+{
+  __kernel_size_t ret;
+  __asm__ __volatile__ ("
+	.section __ex_table,#alloc
+	.align 4
+	.word 1f,3
+	.previous
+1:
+	mov %2, %%o1
+	call __bzero
+	 mov %1, %%o0
+	mov %%o0, %0 
+	" : "=r" (ret) : "r" (addr), "r" (size) :
+	"o0", "o1", "o2", "o3", "o4", "o5", "o7",
+	"g1", "g2", "g3", "g4", "g5", "g7", "cc");
+  return ret;
+}
 
 #define clear_user(addr,n) ({ \
-unsigned long __clear_addr = (unsigned long) (addr); \
-int __clear_size = (int) (n); \
-int __clear_res; \
-if(__clear_size && __access_ok(__clear_addr, __clear_size)) { \
+void *__clear_addr = (void *) (addr); \
+__kernel_size_t __clear_size = (__kernel_size_t) (n); \
+__kernel_size_t __clear_res; \
+if(__clear_size && __access_ok((unsigned long)__clear_addr, __clear_size)) { \
 __clear_res = __clear_user(__clear_addr, __clear_size); \
-if(__clear_res) __clear_res = __clear_size - __clear_res; \
 } else __clear_res = __clear_size; \
 __clear_res; })
 
+#define clear_user_ret(addr,size,retval) ({ \
+if (clear_user(addr,size)) \
+	return retval; \
+})
+
 extern int __strncpy_from_user(unsigned long dest, unsigned long src, int count);
 
 #define strncpy_from_user(dest,src,count) ({ \
@@ -256,6 +380,16 @@ if(__access_ok(__sfu_src, __sfu_count)) { \
 __sfu_res = __strncpy_from_user((unsigned long) (dest), __sfu_src, __sfu_count); \
 } __sfu_res; })
 
+extern int __strlen_user(const char *);
+
+extern __inline__ int strlen_user(const char *str)
+{
+	if(!access_ok(VERIFY_READ, str, 0))
+		return 0;
+	else
+		return __strlen_user(str);
+}
+
 #endif  /* __ASSEMBLY__ */
 
 #endif /* _ASM_UACCESS_H */