kcsan: Add ability to pass instruction pointer of access to reporting

Add the ability to pass an explicitly set instruction pointer of access
from check_access() all the way through to reporting.

In preparation of using it in reporting.

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 76e67d1e02d48bb0fc267e66d0e92603124229bf..bffd1d95addbb66652f2f9e684cb62c9472d42c9 100644 (file)
--- a/kernel/kcsan/core.c
+++ b/kernel/kcsan/core.c
@@ -350,6 +350,7 @@ void kcsan_restore_irqtrace(struct task_struct *task)
 static noinline void kcsan_found_watchpoint(const volatile void *ptr,
                                            size_t size,
                                            int type,
+                                           unsigned long ip,
                                            atomic_long_t *watchpoint,
                                            long encoded_watchpoint)
 {
@@ -396,7 +397,7 @@ static noinline void kcsan_found_watchpoint(const volatile void *ptr,
 
        if (consumed) {
                kcsan_save_irqtrace(current);
-               kcsan_report_set_info(ptr, size, type, watchpoint - watchpoints);
+               kcsan_report_set_info(ptr, size, type, ip, watchpoint - watchpoints);
                kcsan_restore_irqtrace(current);
        } else {
                /*
@@ -416,7 +417,7 @@ static noinline void kcsan_found_watchpoint(const volatile void *ptr,
 }
 
 static noinline void
-kcsan_setup_watchpoint(const volatile void *ptr, size_t size, int type)
+kcsan_setup_watchpoint(const volatile void *ptr, size_t size, int type, unsigned long ip)
 {
        const bool is_write = (type & KCSAN_ACCESS_WRITE) != 0;
        const bool is_assert = (type & KCSAN_ACCESS_ASSERT) != 0;
@@ -568,8 +569,8 @@ kcsan_setup_watchpoint(const volatile void *ptr, size_t size, int type)
                if (is_assert && value_change == KCSAN_VALUE_CHANGE_TRUE)
                        atomic_long_inc(&kcsan_counters[KCSAN_COUNTER_ASSERT_FAILURES]);
 
-               kcsan_report_known_origin(ptr, size, type, value_change,
-                                         watchpoint - watchpoints,
+               kcsan_report_known_origin(ptr, size, type, ip,
+                                         value_change, watchpoint - watchpoints,
                                          old, new, access_mask);
        } else if (value_change == KCSAN_VALUE_CHANGE_TRUE) {
                /* Inferring a race, since the value should not have changed. */
@@ -578,8 +579,10 @@ kcsan_setup_watchpoint(const volatile void *ptr, size_t size, int type)
                if (is_assert)
                        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, old, new, access_mask);
+               if (IS_ENABLED(CONFIG_KCSAN_REPORT_RACE_UNKNOWN_ORIGIN) || is_assert) {
+                       kcsan_report_unknown_origin(ptr, size, type, ip,
+                                                   old, new, access_mask);
+               }
        }
 
        /*
@@ -596,8 +599,8 @@ out:
        user_access_restore(ua_flags);
 }
 
-static __always_inline void check_access(const volatile void *ptr, size_t size,
-                                        int type)
+static __always_inline void
+check_access(const volatile void *ptr, size_t size, int type, unsigned long ip)
 {
        const bool is_write = (type & KCSAN_ACCESS_WRITE) != 0;
        atomic_long_t *watchpoint;
@@ -625,13 +628,12 @@ static __always_inline void check_access(const volatile void *ptr, size_t size,
         */
 
        if (unlikely(watchpoint != NULL))
-               kcsan_found_watchpoint(ptr, size, type, watchpoint,
-                                      encoded_watchpoint);
+               kcsan_found_watchpoint(ptr, size, type, ip, watchpoint, encoded_watchpoint);
        else {
                struct kcsan_ctx *ctx = get_ctx(); /* Call only once in fast-path. */
 
                if (unlikely(should_watch(ptr, size, type, ctx)))
-                       kcsan_setup_watchpoint(ptr, size, type);
+                       kcsan_setup_watchpoint(ptr, size, type, ip);
                else if (unlikely(ctx->scoped_accesses.prev))
                        kcsan_check_scoped_accesses();
        }
@@ -757,7 +759,7 @@ kcsan_begin_scoped_access(const volatile void *ptr, size_t size, int type,
 {
        struct kcsan_ctx *ctx = get_ctx();
 
-       __kcsan_check_access(ptr, size, type);
+       check_access(ptr, size, type, _RET_IP_);
 
        ctx->disable_count++; /* Disable KCSAN, in case list debugging is on. */
 
@@ -802,7 +804,7 @@ EXPORT_SYMBOL(kcsan_end_scoped_access);
 
 void __kcsan_check_access(const volatile void *ptr, size_t size, int type)
 {
-       check_access(ptr, size, type);
+       check_access(ptr, size, type, _RET_IP_);
 }
 EXPORT_SYMBOL(__kcsan_check_access);
 
@@ -823,7 +825,7 @@ EXPORT_SYMBOL(__kcsan_check_access);
        void __tsan_read##size(void *ptr);                                     \
        void __tsan_read##size(void *ptr)                                      \
        {                                                                      \
-               check_access(ptr, size, 0);                                    \
+               check_access(ptr, size, 0, _RET_IP_);                          \
        }                                                                      \
        EXPORT_SYMBOL(__tsan_read##size);                                      \
        void __tsan_unaligned_read##size(void *ptr)                            \
@@ -832,7 +834,7 @@ EXPORT_SYMBOL(__kcsan_check_access);
        void __tsan_write##size(void *ptr);                                    \
        void __tsan_write##size(void *ptr)                                     \
        {                                                                      \
-               check_access(ptr, size, KCSAN_ACCESS_WRITE);                   \
+               check_access(ptr, size, KCSAN_ACCESS_WRITE, _RET_IP_);         \
        }                                                                      \
        EXPORT_SYMBOL(__tsan_write##size);                                     \
        void __tsan_unaligned_write##size(void *ptr)                           \
@@ -842,7 +844,8 @@ EXPORT_SYMBOL(__kcsan_check_access);
        void __tsan_read_write##size(void *ptr)                                \
        {                                                                      \
                check_access(ptr, size,                                        \
-                            KCSAN_ACCESS_COMPOUND | KCSAN_ACCESS_WRITE);      \
+                            KCSAN_ACCESS_COMPOUND | KCSAN_ACCESS_WRITE,       \
+                            _RET_IP_);                                        \
        }                                                                      \
        EXPORT_SYMBOL(__tsan_read_write##size);                                \
        void __tsan_unaligned_read_write##size(void *ptr)                      \
@@ -858,14 +861,14 @@ DEFINE_TSAN_READ_WRITE(16);
 void __tsan_read_range(void *ptr, size_t size);
 void __tsan_read_range(void *ptr, size_t size)
 {
-       check_access(ptr, size, 0);
+       check_access(ptr, size, 0, _RET_IP_);
 }
 EXPORT_SYMBOL(__tsan_read_range);
 
 void __tsan_write_range(void *ptr, size_t size);
 void __tsan_write_range(void *ptr, size_t size)
 {
-       check_access(ptr, size, KCSAN_ACCESS_WRITE);
+       check_access(ptr, size, KCSAN_ACCESS_WRITE, _RET_IP_);
 }
 EXPORT_SYMBOL(__tsan_write_range);
 
@@ -886,7 +889,8 @@ EXPORT_SYMBOL(__tsan_write_range);
                                       IS_ALIGNED((unsigned long)ptr, size);   \
                if (IS_ENABLED(CONFIG_KCSAN_IGNORE_ATOMICS) && is_atomic)      \
                        return;                                                \
-               check_access(ptr, size, is_atomic ? KCSAN_ACCESS_ATOMIC : 0);  \
+               check_access(ptr, size, is_atomic ? KCSAN_ACCESS_ATOMIC : 0,   \
+                            _RET_IP_);                                        \
        }                                                                      \
        EXPORT_SYMBOL(__tsan_volatile_read##size);                             \
        void __tsan_unaligned_volatile_read##size(void *ptr)                   \
@@ -901,7 +905,8 @@ EXPORT_SYMBOL(__tsan_write_range);
                        return;                                                \
                check_access(ptr, size,                                        \
                             KCSAN_ACCESS_WRITE |                              \
-                                    (is_atomic ? KCSAN_ACCESS_ATOMIC : 0));   \
+                                    (is_atomic ? KCSAN_ACCESS_ATOMIC : 0),    \
+                            _RET_IP_);                                        \
        }                                                                      \
        EXPORT_SYMBOL(__tsan_volatile_write##size);                            \
        void __tsan_unaligned_volatile_write##size(void *ptr)                  \
@@ -955,7 +960,7 @@ EXPORT_SYMBOL(__tsan_init);
        u##bits __tsan_atomic##bits##_load(const u##bits *ptr, int memorder)                       \
        {                                                                                          \
                if (!IS_ENABLED(CONFIG_KCSAN_IGNORE_ATOMICS)) {                                    \
-                       check_access(ptr, bits / BITS_PER_BYTE, KCSAN_ACCESS_ATOMIC);              \
+                       check_access(ptr, bits / BITS_PER_BYTE, KCSAN_ACCESS_ATOMIC, _RET_IP_);    \
                }                                                                                  \
                return __atomic_load_n(ptr, memorder);                                             \
        }                                                                                          \
@@ -965,7 +970,7 @@ EXPORT_SYMBOL(__tsan_init);
        {                                                                                          \
                if (!IS_ENABLED(CONFIG_KCSAN_IGNORE_ATOMICS)) {                                    \
                        check_access(ptr, bits / BITS_PER_BYTE,                                    \
-                                    KCSAN_ACCESS_WRITE | KCSAN_ACCESS_ATOMIC);                    \
+                                    KCSAN_ACCESS_WRITE | KCSAN_ACCESS_ATOMIC, _RET_IP_);          \
                }                                                                                  \
                __atomic_store_n(ptr, v, memorder);                                                \
        }                                                                                          \
@@ -978,7 +983,7 @@ EXPORT_SYMBOL(__tsan_init);
                if (!IS_ENABLED(CONFIG_KCSAN_IGNORE_ATOMICS)) {                                    \
                        check_access(ptr, bits / BITS_PER_BYTE,                                    \
                                     KCSAN_ACCESS_COMPOUND | KCSAN_ACCESS_WRITE |                  \
-                                            KCSAN_ACCESS_ATOMIC);                                 \
+                                            KCSAN_ACCESS_ATOMIC, _RET_IP_);                       \
                }                                                                                  \
                return __atomic_##op##suffix(ptr, v, memorder);                                    \
        }                                                                                          \
@@ -1010,7 +1015,7 @@ EXPORT_SYMBOL(__tsan_init);
                if (!IS_ENABLED(CONFIG_KCSAN_IGNORE_ATOMICS)) {                                    \
                        check_access(ptr, bits / BITS_PER_BYTE,                                    \
                                     KCSAN_ACCESS_COMPOUND | KCSAN_ACCESS_WRITE |                  \
-                                            KCSAN_ACCESS_ATOMIC);                                 \
+                                            KCSAN_ACCESS_ATOMIC, _RET_IP_);                       \
                }                                                                                  \
                return __atomic_compare_exchange_n(ptr, exp, val, weak, mo, fail_mo);              \
        }                                                                                          \
@@ -1025,7 +1030,7 @@ EXPORT_SYMBOL(__tsan_init);
                if (!IS_ENABLED(CONFIG_KCSAN_IGNORE_ATOMICS)) {                                    \
                        check_access(ptr, bits / BITS_PER_BYTE,                                    \
                                     KCSAN_ACCESS_COMPOUND | KCSAN_ACCESS_WRITE |                  \
-                                            KCSAN_ACCESS_ATOMIC);                                 \
+                                            KCSAN_ACCESS_ATOMIC, _RET_IP_);                       \
                }                                                                                  \
                __atomic_compare_exchange_n(ptr, &exp, val, 0, mo, fail_mo);                       \
                return exp;                                                                        \

diff --git a/kernel/kcsan/kcsan.h b/kernel/kcsan/kcsan.h
index f36e25c497ed80850eee338a16402037f6be2ed6..ae33c2a7f07e3e1cab35cf6eabb62d0f24caf897 100644 (file)
--- a/kernel/kcsan/kcsan.h
+++ b/kernel/kcsan/kcsan.h
@@ -121,7 +121,7 @@ enum kcsan_value_change {
  * to be consumed by the reporting thread. No report is printed yet.
  */
 void kcsan_report_set_info(const volatile void *ptr, size_t size, int access_type,
-                          int watchpoint_idx);
+                          unsigned long ip, int watchpoint_idx);
 
 /*
  * The calling thread observed that the watchpoint it set up was hit and
@@ -129,14 +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,
-                              u64 old, u64 new, u64 mask);
+                              unsigned long ip, 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,
-                                u64 old, u64 new, u64 mask);
+                                unsigned long ip, u64 old, u64 new, u64 mask);
 
 #endif /* _KERNEL_KCSAN_KCSAN_H */

diff --git a/kernel/kcsan/report.c b/kernel/kcsan/report.c
index 21137929d42831d213efa910d491bb23325597a0..50c4119f5cc057c1a11ef899fcdb98fa8b39220b 100644 (file)
--- a/kernel/kcsan/report.c
+++ b/kernel/kcsan/report.c
@@ -31,6 +31,7 @@ struct access_info {
        int                     access_type;
        int                     task_pid;
        int                     cpu_id;
+       unsigned long           ip;
 };
 
 /*
@@ -576,21 +577,22 @@ discard:
 }
 
 static struct access_info prepare_access_info(const volatile void *ptr, size_t size,
-                                             int access_type)
+                                             int access_type, unsigned long ip)
 {
        return (struct access_info) {
                .ptr            = ptr,
                .size           = size,
                .access_type    = access_type,
                .task_pid       = in_task() ? task_pid_nr(current) : -1,
-               .cpu_id         = raw_smp_processor_id()
+               .cpu_id         = raw_smp_processor_id(),
+               .ip             = ip,
        };
 }
 
 void kcsan_report_set_info(const volatile void *ptr, size_t size, int access_type,
-                          int watchpoint_idx)
+                          unsigned long ip, int watchpoint_idx)
 {
-       const struct access_info ai = prepare_access_info(ptr, size, access_type);
+       const struct access_info ai = prepare_access_info(ptr, size, access_type, ip);
        unsigned long flags;
 
        kcsan_disable_current();
@@ -603,10 +605,10 @@ 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,
-                              u64 old, u64 new, u64 mask)
+                              unsigned long ip, 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);
+       const struct access_info ai = prepare_access_info(ptr, size, access_type, ip);
        struct other_info *other_info = &other_infos[watchpoint_idx];
        unsigned long flags = 0;
 
@@ -637,9 +639,9 @@ out:
 }
 
 void kcsan_report_unknown_origin(const volatile void *ptr, size_t size, int access_type,
-                                u64 old, u64 new, u64 mask)
+                                unsigned long ip, u64 old, u64 new, u64 mask)
 {
-       const struct access_info ai = prepare_access_info(ptr, size, access_type);
+       const struct access_info ai = prepare_access_info(ptr, size, access_type, ip);
        unsigned long flags;
 
        kcsan_disable_current();