kcsan: Report observed value changes

When a thread detects that a memory location was modified without its
watchpoint being hit, the report notes that a change was detected, but
does not provide concrete values for the change. Knowing the concrete
values can be very helpful in tracking down any racy writers (e.g. as
specific values may only be written in some portions of code, or under
certain conditions).

When we detect a modification, let's report the concrete old/new values,
along with the access's mask of relevant bits (and which relevant bits
were modified). This can make it easier to identify potential racy
writers. As the snapshots are at most 8 bytes, we can only report values
for acceses up to this size, but this appears to cater for the common
case.

When we detect a race via a watchpoint, we may or may not have concrete
values for the modification. To be helpful, let's attempt to log them
when we do as they can be ignored where irrelevant.

The resulting reports appears as follows, with values zero-padded to the
access width:

| ==================================================================
| BUG: KCSAN: data-race in el0_svc_common+0x34/0x25c arch/arm64/kernel/syscall.c:96
|
| race at unknown origin, with read to 0xffff00007ae6aa00 of 8 bytes by task 223 on cpu 1:
|  el0_svc_common+0x34/0x25c arch/arm64/kernel/syscall.c:96
|  do_el0_svc+0x48/0xec arch/arm64/kernel/syscall.c:178
|  el0_svc arch/arm64/kernel/entry-common.c:226 [inline]
|  el0_sync_handler+0x1a4/0x390 arch/arm64/kernel/entry-common.c:236
|  el0_sync+0x140/0x180 arch/arm64/kernel/entry.S:674
|
| value changed: 0x0000000000000000 -> 0x0000000000000002
|
| Reported by Kernel Concurrency Sanitizer on:
| CPU: 1 PID: 223 Comm: syz-executor.1 Not tainted 5.8.0-rc3-00094-ga73f923ecc8e-dirty #3
| Hardware name: linux,dummy-virt (DT)
| ==================================================================

If an access mask is set, it is shown underneath the "value changed"
line as "bits changed: 0x<bits changed> with mask 0x<non-zero mask>".

Signed-off-by: Mark Rutland <mark.rutland@arm.com>
[ elver@google.com: align "value changed" and "bits changed" lines,
  which required massaging the message; do not print bits+mask if no
  mask set. ]
Signed-off-by: Marco Elver <elver@google.com>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>

diff --git a/kernel/kcsan/core.c b/kernel/kcsan/core.c
index 6fe1513e1e6aa0bee9cd8cb7daf98265a57f1b7c..26709ea65c7151c6cd8ef00602baf61ce776fea6 100644 (file)
--- a/kernel/kcsan/core.c
+++ b/kernel/kcsan/core.c
@@ -557,7 +557,8 @@ kcsan_setup_watchpoint(const volatile void *ptr, size_t size, int type)
                        atomic_long_inc(&kcsan_counters[KCSAN_COUNTER_ASSERT_FAILURES]);
 
                kcsan_report_known_origin(ptr, size, type, value_change,
-                                         watchpoint - watchpoints);
+                                         watchpoint - watchpoints,
+                                         old, new, access_mask);
        } else if (value_change == KCSAN_VALUE_CHANGE_TRUE) {
                /* Inferring a race, since the value should not have changed. */
 
@@ -566,7 +567,7 @@ kcsan_setup_watchpoint(const volatile void *ptr, size_t size, int type)
                        atomic_long_inc(&kcsan_counters[KCSAN_COUNTER_ASSERT_FAILURES]);
 
                if (IS_ENABLED(CONFIG_KCSAN_REPORT_RACE_UNKNOWN_ORIGIN) || is_assert)
-                       kcsan_report_unknown_origin(ptr, size, type);
+                       kcsan_report_unknown_origin(ptr, size, type, old, new, access_mask);
        }
 
        /*

diff --git a/kernel/kcsan/kcsan.h b/kernel/kcsan/kcsan.h
index 572f119a19eb659d31566059e3b8fc6e6fd2ef57..f36e25c497ed80850eee338a16402037f6be2ed6 100644 (file)
--- a/kernel/kcsan/kcsan.h
+++ b/kernel/kcsan/kcsan.h
@@ -129,12 +129,14 @@ void kcsan_report_set_info(const volatile void *ptr, size_t size, int access_typ
  * thread.
  */
 void kcsan_report_known_origin(const volatile void *ptr, size_t size, int access_type,
-                              enum kcsan_value_change value_change, int watchpoint_idx);
+                              enum kcsan_value_change value_change, int watchpoint_idx,
+                              u64 old, u64 new, u64 mask);
 
 /*
  * No other thread was observed to race with the access, but the data value
  * before and after the stall differs. Reports a race of "unknown origin".
  */
-void kcsan_report_unknown_origin(const volatile void *ptr, size_t size, int access_type);
+void kcsan_report_unknown_origin(const volatile void *ptr, size_t size, int access_type,
+                                u64 old, u64 new, u64 mask);
 
 #endif /* _KERNEL_KCSAN_KCSAN_H */

diff --git a/kernel/kcsan/report.c b/kernel/kcsan/report.c
index 50cee2357885647b00a68e95d547c1e2491092b9..e37e4386f86dced29d937983e8aa838482f5a835 100644 (file)
--- a/kernel/kcsan/report.c
+++ b/kernel/kcsan/report.c
@@ -327,7 +327,8 @@ static void print_verbose_info(struct task_struct *task)
 
 static void print_report(enum kcsan_value_change value_change,
                         const struct access_info *ai,
-                        const struct other_info *other_info)
+                        const struct other_info *other_info,
+                        u64 old, u64 new, u64 mask)
 {
        unsigned long stack_entries[NUM_STACK_ENTRIES] = { 0 };
        int num_stack_entries = stack_trace_save(stack_entries, NUM_STACK_ENTRIES, 1);
@@ -407,6 +408,24 @@ static void print_report(enum kcsan_value_change value_change,
        if (IS_ENABLED(CONFIG_KCSAN_VERBOSE))
                print_verbose_info(current);
 
+       /* Print observed value change. */
+       if (ai->size <= 8) {
+               int hex_len = ai->size * 2;
+               u64 diff = old ^ new;
+
+               if (mask)
+                       diff &= mask;
+               if (diff) {
+                       pr_err("\n");
+                       pr_err("value changed: 0x%0*llx -> 0x%0*llx\n",
+                              hex_len, old, hex_len, new);
+                       if (mask) {
+                               pr_err(" bits changed: 0x%0*llx with mask 0x%0*llx\n",
+                                      hex_len, diff, hex_len, mask);
+                       }
+               }
+       }
+
        /* Print report footer. */
        pr_err("\n");
        pr_err("Reported by Kernel Concurrency Sanitizer on:\n");
@@ -584,7 +603,8 @@ void kcsan_report_set_info(const volatile void *ptr, size_t size, int access_typ
 }
 
 void kcsan_report_known_origin(const volatile void *ptr, size_t size, int access_type,
-                              enum kcsan_value_change value_change, int watchpoint_idx)
+                              enum kcsan_value_change value_change, int watchpoint_idx,
+                              u64 old, u64 new, u64 mask)
 {
        const struct access_info ai = prepare_access_info(ptr, size, access_type);
        struct other_info *other_info = &other_infos[watchpoint_idx];
@@ -608,7 +628,7 @@ void kcsan_report_known_origin(const volatile void *ptr, size_t size, int access
         * be done once we know the full stack trace in print_report().
         */
        if (value_change != KCSAN_VALUE_CHANGE_FALSE)
-               print_report(value_change, &ai, other_info);
+               print_report(value_change, &ai, other_info, old, new, mask);
 
        release_report(&flags, other_info);
 out:
@@ -616,7 +636,8 @@ out:
        kcsan_enable_current();
 }
 
-void kcsan_report_unknown_origin(const volatile void *ptr, size_t size, int access_type)
+void kcsan_report_unknown_origin(const volatile void *ptr, size_t size, int access_type,
+                                u64 old, u64 new, u64 mask)
 {
        const struct access_info ai = prepare_access_info(ptr, size, access_type);
        unsigned long flags;
@@ -625,7 +646,7 @@ void kcsan_report_unknown_origin(const volatile void *ptr, size_t size, int acce
        lockdep_off(); /* See kcsan_report_known_origin(). */
 
        raw_spin_lock_irqsave(&report_lock, flags);
-       print_report(KCSAN_VALUE_CHANGE_TRUE, &ai, NULL);
+       print_report(KCSAN_VALUE_CHANGE_TRUE, &ai, NULL, old, new, mask);
        raw_spin_unlock_irqrestore(&report_lock, flags);
 
        lockdep_on();