add fault injection to user memory access
Subsystems (6)
v3 cover add fault injection to user memory access
From: Albert van der Linde <[email protected]>
The goal of this series is to improve testing of fault-tolerance in usages of user memory access functions, by adding support for fault injection.
The first patch adds failure injection capability for usercopy functions. The second changes usercopy functions to use this new failure capability (copy_from_user, ...). The third patch adds get/put/clear_user failures to x86.
Changes in v2:
- simplified overall failure capability by either failing or not, without having functions fail partially by copying/clearing only some bytes
Changes in v3:
- adressed comments from Peter Zijlstra: fixed inconsistent ordering with might_fault()
Albert van der Linde (3):
lib, include/linux: add usercopy failure capability lib, uaccess: add failure injection to usercopy functions
x86: add failure injection to get/put/clear_user
.../admin-guide/kernel-parameters.txt | 1 + .../fault-injection/fault-injection.rst | 7 +- arch/x86/include/asm/uaccess.h | 68 +++++++++++-------- arch/x86/lib/usercopy_64.c | 3 + include/linux/fault-inject-usercopy.h | 22 ++++++ include/linux/uaccess.h | 11 ++- lib/Kconfig.debug | 7 ++ lib/Makefile | 1 + lib/fault-inject-usercopy.c | 39 +++++++++++ lib/iov_iter.c | 5 ++ lib/strncpy_from_user.c | 3 + lib/usercopy.c | 5 +- 12 files changed, 140 insertions(+), 32 deletions(-) create mode 100644 include/linux/fault-inject-usercopy.h create mode 100644 lib/fault-inject-usercopy.c
Signature · 1 line
2.28.0.402.g5ffc5be6b7-goog
PATCH v3 1/3 lib, include/linux: add usercopy failure capability
From: Albert van der Linde <[email protected]>
Add a failure injection capability to improve testing of fault-tolerance in usages of user memory access functions.
Add CONFIG_FAULT_INJECTION_USERCOPY to enable faults in usercopy functions. The should_fail_usercopy function is to be called by these functions (copy_from_user, get_user, ...) in order to fail or not.
---
v2:
- adressed comments from Dmitry Vyukov
- removed failsize
- changed should_fail function to return bool
v3:
- no changes
--- .../admin-guide/kernel-parameters.txt | 1 + .../fault-injection/fault-injection.rst | 7 +++- include/linux/fault-inject-usercopy.h | 22 +++++++++++ lib/Kconfig.debug | 7 ++++ lib/Makefile | 1 + lib/fault-inject-usercopy.c | 39 +++++++++++++++++++ 6 files changed, 76 insertions(+), 1 deletion(-) create mode 100644 include/linux/fault-inject-usercopy.h create mode 100644 lib/fault-inject-usercopy.c
Documentation/admin-guide/kernel-parameters.txt +1 -0
@@ -1332,6 +1332,7 @@ current integrity status. failslab= + fail_usercopy= fail_page_alloc= fail_make_request=[KNL] General fault injection mechanism.
Documentation/fault-injection/fault-injection.rst +6 -1
@@ -16,6 +16,10 @@ Available fault injection capabilities injects page allocation failures. (alloc_pages(), get_free_pages(), ...) +- fail_usercopy + + injects failures in user memory access functions. (copy_from_user(), get_user(), ...) + - fail_futex injects futex deadlock and uaddr fault errors.
@@ -177,6 +181,7 @@ use the boot option:: failslab= fail_page_alloc= + fail_usercopy= fail_make_request= fail_futex= mmc_core.fail_request=<interval>,<probability>,<space>,<times>
@@ -222,7 +227,7 @@ How to add new fault injection capability - debugfs entries - failslab, fail_page_alloc, and fail_make_request use this way. + failslab, fail_page_alloc, fail_usercopy, and fail_make_request use this way. Helper functions: fault_create_debugfs_attr(name, parent, attr);
include/linux/fault-inject-usercopy.h new file +22 -0
@@ -0,0 +1,22 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __LINUX_FAULT_INJECT_USERCOPY_H__ +#define __LINUX_FAULT_INJECT_USERCOPY_H__ + +/* +* This header provides a wrapper for injecting failures to user space memory +* access functions. +*/ + +#include <linux/types.h> + +#ifdef CONFIG_FAULT_INJECTION_USERCOPY + +bool should_fail_usercopy (void ); + +#else + +static inline bool should_fail_usercopy (void ) {return false; } + +#endif /* CONFIG_FAULT_INJECTION_USERCOPY */ + +#endif /* __LINUX_FAULT_INJECT_USERCOPY_H__ */
lib/Kconfig.debug +7 -0
@@ -1770,6 +1770,13 @@ config FAIL_PAGE_ALLOC help Provide fault-injection capability for alloc_pages(). +config FAULT_INJECTION_USERCOPY + bool "Fault injection capability for usercopy functions" + depends on FAULT_INJECTION + help + Provides fault-injection capability to inject failures + in usercopy functions (copy_from_user(), get_user(), ...). + config FAIL_MAKE_REQUEST bool "Fault-injection capability for disk IO" depends on FAULT_INJECTION && BLOCK
lib/Makefile +1 -0
@@ -207,6 +207,7 @@ obj-$(CONFIG_AUDIT_COMPAT_GENERIC) += compat_audit.o obj-$(CONFIG_IOMMU_HELPER) += iommu-helper.o obj-$(CONFIG_FAULT_INJECTION) += fault-inject.o +obj-$(CONFIG_FAULT_INJECTION_USERCOPY) += fault-inject-usercopy.o obj-$(CONFIG_NOTIFIER_ERROR_INJECTION) += notifier-error-inject.o obj-$(CONFIG_PM_NOTIFIER_ERROR_INJECT) += pm-notifier-error-inject.o obj-$(CONFIG_NETDEV_NOTIFIER_ERROR_INJECT) += netdev-notifier-error-inject.o
lib/fault-inject-usercopy.c new file +39 -0
@@ -0,0 +1,39 @@ +// SPDX-License-Identifier: GPL-2.0-only +#include <linux/fault-inject.h> +#include <linux/fault-inject-usercopy.h> + +static struct { +struct fault_attr attr; +} fail_usercopy = { + .attr =FAULT_ATTR_INITIALIZER , +}; + +static int __init setup_fail_usercopy (char *str) +{ +return setup_fault_attr (&fail_usercopy.attr, str); +} +__setup ("fail_usercopy=" , setup_fail_usercopy); + +#ifdef CONFIG_FAULT_INJECTION_DEBUG_FS + +static int __init fail_usercopy_debugfs (void ) +{ +struct dentry *dir; + + dir =fault_create_debugfs_attr ("fail_usercopy" ,NULL , + &fail_usercopy.attr); +if (IS_ERR (dir)) +return PTR_ERR (dir); + +return 0 ; +} + +late_initcall (fail_usercopy_debugfs); + +#endif /* CONFIG_FAULT_INJECTION_DEBUG_FS */ + +bool should_fail_usercopy (void ) +{ +return should_fail (&fail_usercopy.attr,1 ); +} +EXPORT_SYMBOL_GPL (should_fail_usercopy);
Signature · 1 line
2.28.0.402.g5ffc5be6b7-goog
PATCH v3 2/3 lib, uaccess: add failure injection to usercopy functions
In reply to [email protected]From: Albert van der Linde <[email protected]>
To test fault-tolerance of user memory access functions, introduce fault injection to usercopy functions.
If a failure is expected return either -EFAULT or the total amount of bytes that were not copied.
---
v2:
- removed partial failures
v3:
- adressed comments from Peter Zijlstra (fixed ordering with might_fault())
--- include/linux/uaccess.h | 11 ++++++++++- lib/iov_iter.c | 5 +++++ lib/strncpy_from_user.c | 3 +++ lib/usercopy.c | 5 ++++- 4 files changed, 22 insertions(+), 2 deletions(-)
include/linux/uaccess.h +10 -1
@@ -2,6 +2,7 @@#ifndef __LINUX_UACCESS_H__#define __LINUX_UACCESS_H__ +#include <linux/fault-inject-usercopy.h> #include <linux/instrumented.h> #include <linux/sched.h> #include <linux/thread_info.h>
@@ -83,6 +84,8 @@ static __always_inline __must_check unsigned long __copy_from_user(void *to, const void __user *from, unsigned long n) {might_fault (); +if (should_fail_usercopy ()) +return n;instrument_copy_from_user (to, from, n);check_object_size (to, n, false);return raw_copy_from_user (to, from, n);
@@ -104,6 +107,8 @@ __copy_from_user(void *to, const void __user *from, unsigned long n)static __always_inline __must_check unsigned long __copy_to_user_inatomic (void __user *to,const void *from,unsigned long n) { +if (should_fail_usercopy ()) +return n;instrument_copy_to_user (to, from, n);check_object_size (from, n, true);return raw_copy_to_user (to, from, n);
@@ -113,6 +118,8 @@ static __always_inline __must_check unsigned long __copy_to_user(void __user *to, const void *from, unsigned long n) {might_fault (); +if (should_fail_usercopy ()) +return n;instrument_copy_to_user (to, from, n);check_object_size (from, n, true);return raw_copy_to_user (to, from, n);
@@ -124,7 +131,7 @@ _copy_from_user(void *to, const void __user *from, unsigned long n) {unsigned long res = n;might_fault (); -if (likely (access_ok (from, n))) { +if (!should_fail_usercopy () &&likely (access_ok (from, n))) {instrument_copy_from_user (to, from, n); res =raw_copy_from_user (to, from, n); }
@@ -142,6 +149,8 @@ static inline __must_check unsigned long _copy_to_user(void __user *to, const void *from, unsigned long n) {might_fault (); +if (should_fail_usercopy ()) +return n;if (access_ok (to, n)) {instrument_copy_to_user (to, from, n); n =raw_copy_to_user (to, from, n);
lib/iov_iter.c +5 -0
@@ -2,6 +2,7 @@#include <crypto/hash.h> #include <linux/export.h> #include <linux/bvec.h> +#include <linux/fault-inject-usercopy.h> #include <linux/uio.h> #include <linux/pagemap.h> #include <linux/slab.h>
@@ -139,6 +140,8 @@static int copyout (void __user *to,const void *from,size_t n) { +if (should_fail_usercopy ()) +return n;if (access_ok (to, n)) {instrument_copy_to_user (to, from, n); n =raw_copy_to_user (to, from, n);
@@ -148,6 +151,8 @@ static int copyout(void __user *to, const void *from, size_t n)static int copyin (void *to,const void __user *from,size_t n) { +if (should_fail_usercopy ()) +return n;if (access_ok (from, n)) {instrument_copy_from_user (to, from, n); n =raw_copy_from_user (to, from, n);
lib/strncpy_from_user.c +3 -0
@@ -1,6 +1,7 @@// SPDX-License-Identifier: GPL-2.0 #include <linux/compiler.h> #include <linux/export.h> +#include <linux/fault-inject-usercopy.h> #include <linux/kasan-checks.h> #include <linux/thread_info.h> #include <linux/uaccess.h>
@@ -99,6 +100,8 @@ long strncpy_from_user(char *dst, const char __user *src, long count)unsigned long max_addr, src_addr;might_fault (); +if (should_fail_usercopy ()) +return -EFAULT ;if (unlikely (count <=0 ))return 0 ;
lib/usercopy.c +4 -1
@@ -1,5 +1,6 @@// SPDX-License-Identifier: GPL-2.0 #include <linux/bitops.h> +#include <linux/fault-inject-usercopy.h> #include <linux/instrumented.h> #include <linux/uaccess.h>
@@ -10,7 +11,7 @@ unsigned long _copy_from_user(void *to, const void __user *from, unsigned long n {unsigned long res = n;might_fault (); -if (likely (access_ok (from, n))) { +if (!should_fail_usercopy () &&likely (access_ok (from, n))) {instrument_copy_from_user (to, from, n); res =raw_copy_from_user (to, from, n); }
@@ -25,6 +26,8 @@ EXPORT_SYMBOL(_copy_from_user);unsigned long _copy_to_user (void __user *to,const void *from,unsigned long n) {might_fault (); +if (should_fail_usercopy ()) +return n;if (likely (access_ok (to, n))) {instrument_copy_to_user (to, from, n); n =raw_copy_to_user (to, from, n);
Signature · 1 line
2.28.0.402.g5ffc5be6b7-goog
PATCH v3 3/3 x86: add failure injection to get/put/clear_user
In reply to [email protected]From: Albert van der Linde <[email protected]>
To test fault-tolerance of user memory acceses in x86, add support for fault injection.
Make both put_user() and get_user() fail with -EFAULT, and clear_user() fail by not clearing any bytes.
---
v2:
- no significant changes
v3:
- no changes
--- arch/x86/include/asm/uaccess.h | 68 +++++++++++++++++++--------------- arch/x86/lib/usercopy_64.c | 3 ++ 2 files changed, 42 insertions(+), 29 deletions(-)
arch/x86/include/asm/uaccess.h +39 -29
@@ -5,6 +5,7 @@* User space memory access functions */ #include <linux/compiler.h> +#include <linux/fault-inject-usercopy.h> #include <linux/kasan-checks.h> #include <linux/string.h> #include <asm/asm.h>
@@ -175,11 +176,16 @@ extern int __get_user_bad(void); register __inttype(*(ptr)) __val_gu asm("%"_ASM_DX); \__chk_user_ptr (ptr); \might_fault (); \ - asmvolatile ("call __get_user_%P4" \ - : "=a" (__ret_gu), "=r" (__val_gu), \ +if (should_fail_usercopy ()) { \ + (x) =0 ; \ + __ret_gu = -EFAULT ; \ + }else { \ + asmvolatile ("call __get_user_%P4" \ + : "=a" (__ret_gu), "=r" (__val_gu), \ ASM_CALL_CONSTRAINT \ - :"0" (ptr),"i" (sizeof (*(ptr)))); \ - (x) = (__force __typeof__(*(ptr))) __val_gu; \ + :"0" (ptr),"i" (sizeof (*(ptr)))); \ + (x) = (__force __typeof__(*(ptr))) __val_gu; \ + } \__builtin_expect (__ret_gu,0 ); \ })
@@ -236,31 +242,35 @@ extern void __put_user_8(void);* * Return: zero on success, or -EFAULT on error. */ -#define put_user (x, ptr) \ -({ \ - int __ret_pu; \ - __typeof__(*(ptr)) __pu_val; \ - __chk_user_ptr(ptr); \ - might_fault(); \ - __pu_val = x; \ - switch (sizeof(*(ptr))) { \ - case 1: \ - __put_user_x(1, __pu_val, ptr, __ret_pu); \ - break; \ - case 2: \ - __put_user_x(2, __pu_val, ptr, __ret_pu); \ - break; \ - case 4: \ - __put_user_x(4, __pu_val, ptr, __ret_pu); \ - break; \ - case 8: \ - __put_user_x8(__pu_val, ptr, __ret_pu); \ - break; \ - default: \ - __put_user_x(X, __pu_val, ptr, __ret_pu); \ - break; \ - } \ - __builtin_expect(__ret_pu, 0); \ +#define put_user (x, ptr) \ +({ \ + int __ret_pu; \ + __typeof__(*(ptr)) __pu_val; \ + __chk_user_ptr(ptr); \ + might_fault(); \ + __pu_val = x; \ + if (should_fail_usercopy()) { \ + __ret_pu = -EFAULT; \ + } else { \ + switch (sizeof(*(ptr))) { \ + case 1: \ + __put_user_x(1, __pu_val, ptr, __ret_pu); \ + break; \ + case 2: \ + __put_user_x(2, __pu_val, ptr, __ret_pu); \ + break; \ + case 4: \ + __put_user_x(4, __pu_val, ptr, __ret_pu); \ + break; \ + case 8: \ + __put_user_x8(__pu_val, ptr, __ret_pu); \ + break; \ + default: \ + __put_user_x(X, __pu_val, ptr, __ret_pu); \ + break; \ + } \ + } \ + __builtin_expect(__ret_pu, 0); \ })#define __put_user_size (x, ptr, size, label) \
arch/x86/lib/usercopy_64.c +3 -0
@@ -7,6 +7,7 @@* Copyright 2002 Andi Kleen <[email protected]> */ #include <linux/export.h> +#include <linux/fault-inject-usercopy.h> #include <linux/uaccess.h> #include <linux/highmem.h>
@@ -50,6 +51,8 @@ EXPORT_SYMBOL(__clear_user);unsigned long clear_user (void __user *to,unsigned long n) { +if (should_fail_usercopy ()) +return n;if (access_ok (to, n))return __clear_user (to, n);return n;
Signature · 1 line
2.28.0.402.g5ffc5be6b7-goog
Andrew Morton
maintainerQuoted 3 lines · On Mon, 31 Aug 2020 17:17:30 +0000 [email protected] wrote:
The goal of this series is to improve testing of fault-tolerance in usages of user memory access functions, by adding support for fault injection.
Does anyone actually plan to use this feature, on an ongoing basis? It's the sort of thing which the various test robots could exploit, but I'm not sure that they are using fault injection?
Quoted 10 lines · Andrew Morton
Quoted 3 lines · On Mon, 31 Aug 2020 17:17:30 +0000 [email protected] wrote:
The goal of this series is to improve testing of fault-tolerance in usages of user memory access functions, by adding support for fault injection.
Does anyone actually plan to use this feature, on an ongoing basis? It's the sort of thing which the various test robots could exploit, but I'm not sure that they are using fault injection?
Hi Andrew,
syzkaller/syzbot is using the existing fault injection modes and will use this particular feature too.
Thanks!