x86/asm changes for v3.13
Linus,
Please pull the latest x86-asm-for-linus git tree from:
git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git x86-asm-for-linus
# HEAD: 7a3d9b0f3abbea957b829cdfff8169872c575642 x86: Unify copy_to_user() and add size checking to it
This tree contains two copy_[from/to]_user() build time checking changes/enhancements from Jan Beulich.
The desired outcome is to get better compiler warnings with CONFIG_DEBUG_STRICT_USER_COPY_CHECKS=y, to keep people from introducing bugs such as overflows and information leaks.
Thanks,
Ingo
------------------>
Jan Beulich (2):
x86: Unify copy_from_user() size checking
x86: Unify copy_to_user() and add size checking to it
arch/x86/include/asm/uaccess.h | 98 +++++++++++++++++++++++++++++++++++++++ arch/x86/include/asm/uaccess_32.h | 29 ------------ arch/x86/include/asm/uaccess_64.h | 28 ----------- arch/x86/lib/usercopy_32.c | 8 ++-- 4 files changed, 101 insertions(+), 62 deletions(-)
arch/x86/include/asm/uaccess.h +98 -0
@@ -542,5 +542,103 @@ extern struct movsl_mask {# include <asm/uaccess_64.h> #endif +unsigned long __must_check _copy_from_user (void *to,const void __user *from, +unsigned n); +unsigned long __must_check _copy_to_user (void __user *to,const void *from, +unsigned n); + +#ifdef CONFIG_DEBUG_STRICT_USER_COPY_CHECKS +# define copy_user_diag __compiletime_error +#else +# define copy_user_diag __compiletime_warning +#endif + +extern void copy_user_diag("copy_from_user() buffer size is too small") +copy_from_user_overflow (void); +extern void copy_user_diag("copy_to_user() buffer size is too small") +copy_to_user_overflow (void) __asm__("copy_from_user_overflow" ); + +#undef copy_user_diag + +#ifdef CONFIG_DEBUG_STRICT_USER_COPY_CHECKS + +extern void +__compiletime_warning("copy_from_user() buffer size is not provably correct") +__copy_from_user_overflow (void) __asm__("copy_from_user_overflow" ); +#define __copy_from_user_overflow (size, count) __copy_from_user_overflow() + +extern void +__compiletime_warning("copy_to_user() buffer size is not provably correct") +__copy_to_user_overflow (void) __asm__("copy_from_user_overflow" ); +#define __copy_to_user_overflow (size, count) __copy_to_user_overflow() + +#else + +static inline void +__copy_from_user_overflow (int size,unsigned long count) +{ +WARN (1 ,"Buffer overflow detected (%d < %lu)!\n" , size, count); +} + +#define __copy_to_user_overflow __copy_from_user_overflow + +#endif + +static inline unsigned long __must_check +copy_from_user (void *to,const void __user *from,unsigned long n) +{ +int sz =__compiletime_object_size (to); + +might_fault (); + +/* +* While we would like to have the compiler do the checking for us +* even in the non-constant size case, any false positives there are +* a problem (especially when DEBUG_STRICT_USER_COPY_CHECKS, but even +* without - the [hopefully] dangerous looking nature of the warning +* would make people go look at the respecitive call sites over and +* over again just to find that there's no problem). +* +* And there are cases where it's just not realistic for the compiler +* to prove the count to be in range. For example when multiple call +* sites of a helper function - perhaps in different source files - +* all doing proper range checking, yet the helper function not doing +* so again. +* +* Therefore limit the compile time checking to the constant size +* case, and do only runtime checking for non-constant sizes. +*/ + +if (likely (sz <0 || sz >= n)) + n =_copy_from_user (to, from, n); +else if (__builtin_constant_p (n)) +copy_from_user_overflow (); +else +__copy_from_user_overflow (sz, n); + +return n; +} + +static inline unsigned long __must_check +copy_to_user (void __user *to,const void *from,unsigned long n) +{ +int sz =__compiletime_object_size (from); + +might_fault (); + +/* See the comment in copy_from_user() above. */ +if (likely (sz <0 || sz >= n)) + n =_copy_to_user (to, from, n); +else if (__builtin_constant_p (n)) +copy_to_user_overflow (); +else +__copy_to_user_overflow (sz, n); + +return n; +} + +#undef __copy_from_user_overflow +#undef __copy_to_user_overflow +#endif /* _ASM_X86_UACCESS_H */
arch/x86/include/asm/uaccess_32.h +0 -29
@@ -184,33 +184,4 @@ __copy_from_user_inatomic_nocache(void *to, const void __user *from, return __copy_from_user_ll_nocache_nozero(to, from, n); } -unsigned long __must_check copy_to_user (void __user *to, -const void *from,unsigned long n); -unsigned long __must_check _copy_from_user (void *to, -const void __user *from, -unsigned long n); - - -extern void copy_from_user_overflow(void) -#ifdef CONFIG_DEBUG_STRICT_USER_COPY_CHECKS - __compiletime_error("copy_from_user() buffer size is not provably correct") -#else - __compiletime_warning("copy_from_user() buffer size is not provably correct") -#endif -; - -static inline unsigned long __must_check copy_from_user (void *to, -const void __user *from, -unsigned long n) -{ -int sz =__compiletime_object_size (to); - -if (likely (sz ==-1 || sz >= n)) - n =_copy_from_user (to, from, n); -else -copy_from_user_overflow (); - -return n; -} -#endif /* _ASM_X86_UACCESS_32_H */
arch/x86/include/asm/uaccess_64.h +0 -28
@@ -46,36 +46,8 @@ copy_user_generic(void *to, const void *from, unsigned len) }__must_check unsigned long -_copy_to_user (void __user *to,const void *from,unsigned len); -__must_check unsigned long -_copy_from_user (void *to,const void __user *from,unsigned len); -__must_check unsigned long copy_in_user (void __user *to,const void __user *from,unsigned len); -static inline unsigned long __must_check copy_from_user (void *to, -const void __user *from, -unsigned long n) -{ -int sz =__compiletime_object_size (to); - -might_fault (); -if (likely (sz ==-1 || sz >= n)) - n =_copy_from_user (to, from, n); -#ifdef CONFIG_DEBUG_VM - else - WARN(1, "Buffer overflow detected!\n"); -#endif -return n; -} - -static __always_inline __must_check -int copy_to_user(void __user *dst, const void *src, unsigned size) -{ -might_fault (); - -return _copy_to_user (dst, src, size); -} -static __always_inline __must_check int __copy_from_user(void *dst, const void __user *src, unsigned size) {
arch/x86/lib/usercopy_32.c +3 -5
@@ -654,14 +654,13 @@ EXPORT_SYMBOL(__copy_from_user_ll_nocache_nozero);* Returns number of bytes that could not be copied. * On success, this will be zero. */ -unsigned long -copy_to_user (void __user *to,const void *from,unsigned long n) +unsigned long _copy_to_user (void __user *to,const void *from,unsigned n) {if (access_ok (VERIFY_WRITE , to, n)) n =__copy_to_user (to, from, n);return n; } -EXPORT_SYMBOL (copy_to_user); +EXPORT_SYMBOL (_copy_to_user);/** * copy_from_user: - Copy a block of data from user space.
@@ -679,8 +678,7 @@ EXPORT_SYMBOL(copy_to_user);* If some data could not be copied, this function will pad the copied * data to the requested size using zero bytes. */ -unsigned long -_copy_from_user (void *to,const void __user *from,unsigned long n) +unsigned long _copy_from_user (void *to,const void __user *from,unsigned n) {if (access_ok (VERIFY_READ , from, n)) n =__copy_from_user (to, from, n);