xref: /openbmc/linux/kernel/kcsan/report.c (revision 79cc1ba7)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * KCSAN reporting.
4  *
5  * Copyright (C) 2019, Google LLC.
6  */
7 
8 #include <linux/debug_locks.h>
9 #include <linux/delay.h>
10 #include <linux/jiffies.h>
11 #include <linux/kallsyms.h>
12 #include <linux/kernel.h>
13 #include <linux/lockdep.h>
14 #include <linux/preempt.h>
15 #include <linux/printk.h>
16 #include <linux/sched.h>
17 #include <linux/spinlock.h>
18 #include <linux/stacktrace.h>
19 
20 #include "kcsan.h"
21 #include "encoding.h"
22 
23 /*
24  * Max. number of stack entries to show in the report.
25  */
26 #define NUM_STACK_ENTRIES 64
27 
28 /* Common access info. */
29 struct access_info {
30 	const volatile void	*ptr;
31 	size_t			size;
32 	int			access_type;
33 	int			task_pid;
34 	int			cpu_id;
35 	unsigned long		ip;
36 };
37 
38 /*
39  * Other thread info: communicated from other racing thread to thread that set
40  * up the watchpoint, which then prints the complete report atomically.
41  */
42 struct other_info {
43 	struct access_info	ai;
44 	unsigned long		stack_entries[NUM_STACK_ENTRIES];
45 	int			num_stack_entries;
46 
47 	/*
48 	 * Optionally pass @current. Typically we do not need to pass @current
49 	 * via @other_info since just @task_pid is sufficient. Passing @current
50 	 * has additional overhead.
51 	 *
52 	 * To safely pass @current, we must either use get_task_struct/
53 	 * put_task_struct, or stall the thread that populated @other_info.
54 	 *
55 	 * We cannot rely on get_task_struct/put_task_struct in case
56 	 * release_report() races with a task being released, and would have to
57 	 * free it in release_report(). This may result in deadlock if we want
58 	 * to use KCSAN on the allocators.
59 	 *
60 	 * Since we also want to reliably print held locks for
61 	 * CONFIG_KCSAN_VERBOSE, the current implementation stalls the thread
62 	 * that populated @other_info until it has been consumed.
63 	 */
64 	struct task_struct	*task;
65 };
66 
67 /*
68  * To never block any producers of struct other_info, we need as many elements
69  * as we have watchpoints (upper bound on concurrent races to report).
70  */
71 static struct other_info other_infos[CONFIG_KCSAN_NUM_WATCHPOINTS + NUM_SLOTS-1];
72 
73 /*
74  * Information about reported races; used to rate limit reporting.
75  */
76 struct report_time {
77 	/*
78 	 * The last time the race was reported.
79 	 */
80 	unsigned long time;
81 
82 	/*
83 	 * The frames of the 2 threads; if only 1 thread is known, one frame
84 	 * will be 0.
85 	 */
86 	unsigned long frame1;
87 	unsigned long frame2;
88 };
89 
90 /*
91  * Since we also want to be able to debug allocators with KCSAN, to avoid
92  * deadlock, report_times cannot be dynamically resized with krealloc in
93  * rate_limit_report.
94  *
95  * Therefore, we use a fixed-size array, which at most will occupy a page. This
96  * still adequately rate limits reports, assuming that a) number of unique data
97  * races is not excessive, and b) occurrence of unique races within the
98  * same time window is limited.
99  */
100 #define REPORT_TIMES_MAX (PAGE_SIZE / sizeof(struct report_time))
101 #define REPORT_TIMES_SIZE                                                      \
102 	(CONFIG_KCSAN_REPORT_ONCE_IN_MS > REPORT_TIMES_MAX ?                   \
103 		 REPORT_TIMES_MAX :                                            \
104 		 CONFIG_KCSAN_REPORT_ONCE_IN_MS)
105 static struct report_time report_times[REPORT_TIMES_SIZE];
106 
107 /*
108  * Spinlock serializing report generation, and access to @other_infos. Although
109  * it could make sense to have a finer-grained locking story for @other_infos,
110  * report generation needs to be serialized either way, so not much is gained.
111  */
112 static DEFINE_RAW_SPINLOCK(report_lock);
113 
114 /*
115  * Checks if the race identified by thread frames frame1 and frame2 has
116  * been reported since (now - KCSAN_REPORT_ONCE_IN_MS).
117  */
rate_limit_report(unsigned long frame1,unsigned long frame2)118 static bool rate_limit_report(unsigned long frame1, unsigned long frame2)
119 {
120 	struct report_time *use_entry = &report_times[0];
121 	unsigned long invalid_before;
122 	int i;
123 
124 	BUILD_BUG_ON(CONFIG_KCSAN_REPORT_ONCE_IN_MS != 0 && REPORT_TIMES_SIZE == 0);
125 
126 	if (CONFIG_KCSAN_REPORT_ONCE_IN_MS == 0)
127 		return false;
128 
129 	invalid_before = jiffies - msecs_to_jiffies(CONFIG_KCSAN_REPORT_ONCE_IN_MS);
130 
131 	/* Check if a matching race report exists. */
132 	for (i = 0; i < REPORT_TIMES_SIZE; ++i) {
133 		struct report_time *rt = &report_times[i];
134 
135 		/*
136 		 * Must always select an entry for use to store info as we
137 		 * cannot resize report_times; at the end of the scan, use_entry
138 		 * will be the oldest entry, which ideally also happened before
139 		 * KCSAN_REPORT_ONCE_IN_MS ago.
140 		 */
141 		if (time_before(rt->time, use_entry->time))
142 			use_entry = rt;
143 
144 		/*
145 		 * Initially, no need to check any further as this entry as well
146 		 * as following entries have never been used.
147 		 */
148 		if (rt->time == 0)
149 			break;
150 
151 		/* Check if entry expired. */
152 		if (time_before(rt->time, invalid_before))
153 			continue; /* before KCSAN_REPORT_ONCE_IN_MS ago */
154 
155 		/* Reported recently, check if race matches. */
156 		if ((rt->frame1 == frame1 && rt->frame2 == frame2) ||
157 		    (rt->frame1 == frame2 && rt->frame2 == frame1))
158 			return true;
159 	}
160 
161 	use_entry->time = jiffies;
162 	use_entry->frame1 = frame1;
163 	use_entry->frame2 = frame2;
164 	return false;
165 }
166 
167 /*
168  * Special rules to skip reporting.
169  */
170 static bool
skip_report(enum kcsan_value_change value_change,unsigned long top_frame)171 skip_report(enum kcsan_value_change value_change, unsigned long top_frame)
172 {
173 	/* Should never get here if value_change==FALSE. */
174 	WARN_ON_ONCE(value_change == KCSAN_VALUE_CHANGE_FALSE);
175 
176 	/*
177 	 * The first call to skip_report always has value_change==TRUE, since we
178 	 * cannot know the value written of an instrumented access. For the 2nd
179 	 * call there are 6 cases with CONFIG_KCSAN_REPORT_VALUE_CHANGE_ONLY:
180 	 *
181 	 * 1. read watchpoint, conflicting write (value_change==TRUE): report;
182 	 * 2. read watchpoint, conflicting write (value_change==MAYBE): skip;
183 	 * 3. write watchpoint, conflicting write (value_change==TRUE): report;
184 	 * 4. write watchpoint, conflicting write (value_change==MAYBE): skip;
185 	 * 5. write watchpoint, conflicting read (value_change==MAYBE): skip;
186 	 * 6. write watchpoint, conflicting read (value_change==TRUE): report;
187 	 *
188 	 * Cases 1-4 are intuitive and expected; case 5 ensures we do not report
189 	 * data races where the write may have rewritten the same value; case 6
190 	 * is possible either if the size is larger than what we check value
191 	 * changes for or the access type is KCSAN_ACCESS_ASSERT.
192 	 */
193 	if (IS_ENABLED(CONFIG_KCSAN_REPORT_VALUE_CHANGE_ONLY) &&
194 	    value_change == KCSAN_VALUE_CHANGE_MAYBE) {
195 		/*
196 		 * The access is a write, but the data value did not change.
197 		 *
198 		 * We opt-out of this filter for certain functions at request of
199 		 * maintainers.
200 		 */
201 		char buf[64];
202 		int len = scnprintf(buf, sizeof(buf), "%ps", (void *)top_frame);
203 
204 		if (!strnstr(buf, "rcu_", len) &&
205 		    !strnstr(buf, "_rcu", len) &&
206 		    !strnstr(buf, "_srcu", len))
207 			return true;
208 	}
209 
210 	return kcsan_skip_report_debugfs(top_frame);
211 }
212 
get_access_type(int type)213 static const char *get_access_type(int type)
214 {
215 	if (type & KCSAN_ACCESS_ASSERT) {
216 		if (type & KCSAN_ACCESS_SCOPED) {
217 			if (type & KCSAN_ACCESS_WRITE)
218 				return "assert no accesses (reordered)";
219 			else
220 				return "assert no writes (reordered)";
221 		} else {
222 			if (type & KCSAN_ACCESS_WRITE)
223 				return "assert no accesses";
224 			else
225 				return "assert no writes";
226 		}
227 	}
228 
229 	switch (type) {
230 	case 0:
231 		return "read";
232 	case KCSAN_ACCESS_ATOMIC:
233 		return "read (marked)";
234 	case KCSAN_ACCESS_WRITE:
235 		return "write";
236 	case KCSAN_ACCESS_WRITE | KCSAN_ACCESS_ATOMIC:
237 		return "write (marked)";
238 	case KCSAN_ACCESS_COMPOUND | KCSAN_ACCESS_WRITE:
239 		return "read-write";
240 	case KCSAN_ACCESS_COMPOUND | KCSAN_ACCESS_WRITE | KCSAN_ACCESS_ATOMIC:
241 		return "read-write (marked)";
242 	case KCSAN_ACCESS_SCOPED:
243 		return "read (reordered)";
244 	case KCSAN_ACCESS_SCOPED | KCSAN_ACCESS_ATOMIC:
245 		return "read (marked, reordered)";
246 	case KCSAN_ACCESS_SCOPED | KCSAN_ACCESS_WRITE:
247 		return "write (reordered)";
248 	case KCSAN_ACCESS_SCOPED | KCSAN_ACCESS_WRITE | KCSAN_ACCESS_ATOMIC:
249 		return "write (marked, reordered)";
250 	case KCSAN_ACCESS_SCOPED | KCSAN_ACCESS_COMPOUND | KCSAN_ACCESS_WRITE:
251 		return "read-write (reordered)";
252 	case KCSAN_ACCESS_SCOPED | KCSAN_ACCESS_COMPOUND | KCSAN_ACCESS_WRITE | KCSAN_ACCESS_ATOMIC:
253 		return "read-write (marked, reordered)";
254 	default:
255 		BUG();
256 	}
257 }
258 
get_bug_type(int type)259 static const char *get_bug_type(int type)
260 {
261 	return (type & KCSAN_ACCESS_ASSERT) != 0 ? "assert: race" : "data-race";
262 }
263 
264 /* Return thread description: in task or interrupt. */
get_thread_desc(int task_id)265 static const char *get_thread_desc(int task_id)
266 {
267 	if (task_id != -1) {
268 		static char buf[32]; /* safe: protected by report_lock */
269 
270 		snprintf(buf, sizeof(buf), "task %i", task_id);
271 		return buf;
272 	}
273 	return "interrupt";
274 }
275 
276 /* Helper to skip KCSAN-related functions in stack-trace. */
get_stack_skipnr(const unsigned long stack_entries[],int num_entries)277 static int get_stack_skipnr(const unsigned long stack_entries[], int num_entries)
278 {
279 	char buf[64];
280 	char *cur;
281 	int len, skip;
282 
283 	for (skip = 0; skip < num_entries; ++skip) {
284 		len = scnprintf(buf, sizeof(buf), "%ps", (void *)stack_entries[skip]);
285 
286 		/* Never show tsan_* or {read,write}_once_size. */
287 		if (strnstr(buf, "tsan_", len) ||
288 		    strnstr(buf, "_once_size", len))
289 			continue;
290 
291 		cur = strnstr(buf, "kcsan_", len);
292 		if (cur) {
293 			cur += strlen("kcsan_");
294 			if (!str_has_prefix(cur, "test"))
295 				continue; /* KCSAN runtime function. */
296 			/* KCSAN related test. */
297 		}
298 
299 		/*
300 		 * No match for runtime functions -- @skip entries to skip to
301 		 * get to first frame of interest.
302 		 */
303 		break;
304 	}
305 
306 	return skip;
307 }
308 
309 /*
310  * Skips to the first entry that matches the function of @ip, and then replaces
311  * that entry with @ip, returning the entries to skip with @replaced containing
312  * the replaced entry.
313  */
314 static int
replace_stack_entry(unsigned long stack_entries[],int num_entries,unsigned long ip,unsigned long * replaced)315 replace_stack_entry(unsigned long stack_entries[], int num_entries, unsigned long ip,
316 		    unsigned long *replaced)
317 {
318 	unsigned long symbolsize, offset;
319 	unsigned long target_func;
320 	int skip;
321 
322 	if (kallsyms_lookup_size_offset(ip, &symbolsize, &offset))
323 		target_func = ip - offset;
324 	else
325 		goto fallback;
326 
327 	for (skip = 0; skip < num_entries; ++skip) {
328 		unsigned long func = stack_entries[skip];
329 
330 		if (!kallsyms_lookup_size_offset(func, &symbolsize, &offset))
331 			goto fallback;
332 		func -= offset;
333 
334 		if (func == target_func) {
335 			*replaced = stack_entries[skip];
336 			stack_entries[skip] = ip;
337 			return skip;
338 		}
339 	}
340 
341 fallback:
342 	/* Should not happen; the resulting stack trace is likely misleading. */
343 	WARN_ONCE(1, "Cannot find frame for %pS in stack trace", (void *)ip);
344 	return get_stack_skipnr(stack_entries, num_entries);
345 }
346 
347 static int
sanitize_stack_entries(unsigned long stack_entries[],int num_entries,unsigned long ip,unsigned long * replaced)348 sanitize_stack_entries(unsigned long stack_entries[], int num_entries, unsigned long ip,
349 		       unsigned long *replaced)
350 {
351 	return ip ? replace_stack_entry(stack_entries, num_entries, ip, replaced) :
352 			  get_stack_skipnr(stack_entries, num_entries);
353 }
354 
355 /* Compares symbolized strings of addr1 and addr2. */
sym_strcmp(void * addr1,void * addr2)356 static int sym_strcmp(void *addr1, void *addr2)
357 {
358 	char buf1[64];
359 	char buf2[64];
360 
361 	snprintf(buf1, sizeof(buf1), "%pS", addr1);
362 	snprintf(buf2, sizeof(buf2), "%pS", addr2);
363 
364 	return strncmp(buf1, buf2, sizeof(buf1));
365 }
366 
367 static void
print_stack_trace(unsigned long stack_entries[],int num_entries,unsigned long reordered_to)368 print_stack_trace(unsigned long stack_entries[], int num_entries, unsigned long reordered_to)
369 {
370 	stack_trace_print(stack_entries, num_entries, 0);
371 	if (reordered_to)
372 		pr_err("  |\n  +-> reordered to: %pS\n", (void *)reordered_to);
373 }
374 
print_verbose_info(struct task_struct * task)375 static void print_verbose_info(struct task_struct *task)
376 {
377 	if (!task)
378 		return;
379 
380 	/* Restore IRQ state trace for printing. */
381 	kcsan_restore_irqtrace(task);
382 
383 	pr_err("\n");
384 	debug_show_held_locks(task);
385 	print_irqtrace_events(task);
386 }
387 
print_report(enum kcsan_value_change value_change,const struct access_info * ai,struct other_info * other_info,u64 old,u64 new,u64 mask)388 static void print_report(enum kcsan_value_change value_change,
389 			 const struct access_info *ai,
390 			 struct other_info *other_info,
391 			 u64 old, u64 new, u64 mask)
392 {
393 	unsigned long reordered_to = 0;
394 	unsigned long stack_entries[NUM_STACK_ENTRIES] = { 0 };
395 	int num_stack_entries = stack_trace_save(stack_entries, NUM_STACK_ENTRIES, 1);
396 	int skipnr = sanitize_stack_entries(stack_entries, num_stack_entries, ai->ip, &reordered_to);
397 	unsigned long this_frame = stack_entries[skipnr];
398 	unsigned long other_reordered_to = 0;
399 	unsigned long other_frame = 0;
400 	int other_skipnr = 0; /* silence uninit warnings */
401 
402 	/*
403 	 * Must check report filter rules before starting to print.
404 	 */
405 	if (skip_report(KCSAN_VALUE_CHANGE_TRUE, stack_entries[skipnr]))
406 		return;
407 
408 	if (other_info) {
409 		other_skipnr = sanitize_stack_entries(other_info->stack_entries,
410 						      other_info->num_stack_entries,
411 						      other_info->ai.ip, &other_reordered_to);
412 		other_frame = other_info->stack_entries[other_skipnr];
413 
414 		/* @value_change is only known for the other thread */
415 		if (skip_report(value_change, other_frame))
416 			return;
417 	}
418 
419 	if (rate_limit_report(this_frame, other_frame))
420 		return;
421 
422 	/* Print report header. */
423 	pr_err("==================================================================\n");
424 	if (other_info) {
425 		int cmp;
426 
427 		/*
428 		 * Order functions lexographically for consistent bug titles.
429 		 * Do not print offset of functions to keep title short.
430 		 */
431 		cmp = sym_strcmp((void *)other_frame, (void *)this_frame);
432 		pr_err("BUG: KCSAN: %s in %ps / %ps\n",
433 		       get_bug_type(ai->access_type | other_info->ai.access_type),
434 		       (void *)(cmp < 0 ? other_frame : this_frame),
435 		       (void *)(cmp < 0 ? this_frame : other_frame));
436 	} else {
437 		pr_err("BUG: KCSAN: %s in %pS\n", get_bug_type(ai->access_type),
438 		       (void *)this_frame);
439 	}
440 
441 	pr_err("\n");
442 
443 	/* Print information about the racing accesses. */
444 	if (other_info) {
445 		pr_err("%s to 0x%px of %zu bytes by %s on cpu %i:\n",
446 		       get_access_type(other_info->ai.access_type), other_info->ai.ptr,
447 		       other_info->ai.size, get_thread_desc(other_info->ai.task_pid),
448 		       other_info->ai.cpu_id);
449 
450 		/* Print the other thread's stack trace. */
451 		print_stack_trace(other_info->stack_entries + other_skipnr,
452 				  other_info->num_stack_entries - other_skipnr,
453 				  other_reordered_to);
454 		if (IS_ENABLED(CONFIG_KCSAN_VERBOSE))
455 			print_verbose_info(other_info->task);
456 
457 		pr_err("\n");
458 		pr_err("%s to 0x%px of %zu bytes by %s on cpu %i:\n",
459 		       get_access_type(ai->access_type), ai->ptr, ai->size,
460 		       get_thread_desc(ai->task_pid), ai->cpu_id);
461 	} else {
462 		pr_err("race at unknown origin, with %s to 0x%px of %zu bytes by %s on cpu %i:\n",
463 		       get_access_type(ai->access_type), ai->ptr, ai->size,
464 		       get_thread_desc(ai->task_pid), ai->cpu_id);
465 	}
466 	/* Print stack trace of this thread. */
467 	print_stack_trace(stack_entries + skipnr, num_stack_entries - skipnr, reordered_to);
468 	if (IS_ENABLED(CONFIG_KCSAN_VERBOSE))
469 		print_verbose_info(current);
470 
471 	/* Print observed value change. */
472 	if (ai->size <= 8) {
473 		int hex_len = ai->size * 2;
474 		u64 diff = old ^ new;
475 
476 		if (mask)
477 			diff &= mask;
478 		if (diff) {
479 			pr_err("\n");
480 			pr_err("value changed: 0x%0*llx -> 0x%0*llx\n",
481 			       hex_len, old, hex_len, new);
482 			if (mask) {
483 				pr_err(" bits changed: 0x%0*llx with mask 0x%0*llx\n",
484 				       hex_len, diff, hex_len, mask);
485 			}
486 		}
487 	}
488 
489 	/* Print report footer. */
490 	pr_err("\n");
491 	pr_err("Reported by Kernel Concurrency Sanitizer on:\n");
492 	dump_stack_print_info(KERN_DEFAULT);
493 	pr_err("==================================================================\n");
494 
495 	check_panic_on_warn("KCSAN");
496 }
497 
release_report(unsigned long * flags,struct other_info * other_info)498 static void release_report(unsigned long *flags, struct other_info *other_info)
499 {
500 	/*
501 	 * Use size to denote valid/invalid, since KCSAN entirely ignores
502 	 * 0-sized accesses.
503 	 */
504 	other_info->ai.size = 0;
505 	raw_spin_unlock_irqrestore(&report_lock, *flags);
506 }
507 
508 /*
509  * Sets @other_info->task and awaits consumption of @other_info.
510  *
511  * Precondition: report_lock is held.
512  * Postcondition: report_lock is held.
513  */
set_other_info_task_blocking(unsigned long * flags,const struct access_info * ai,struct other_info * other_info)514 static void set_other_info_task_blocking(unsigned long *flags,
515 					 const struct access_info *ai,
516 					 struct other_info *other_info)
517 {
518 	/*
519 	 * We may be instrumenting a code-path where current->state is already
520 	 * something other than TASK_RUNNING.
521 	 */
522 	const bool is_running = task_is_running(current);
523 	/*
524 	 * To avoid deadlock in case we are in an interrupt here and this is a
525 	 * race with a task on the same CPU (KCSAN_INTERRUPT_WATCHER), provide a
526 	 * timeout to ensure this works in all contexts.
527 	 *
528 	 * Await approximately the worst case delay of the reporting thread (if
529 	 * we are not interrupted).
530 	 */
531 	int timeout = max(kcsan_udelay_task, kcsan_udelay_interrupt);
532 
533 	other_info->task = current;
534 	do {
535 		if (is_running) {
536 			/*
537 			 * Let lockdep know the real task is sleeping, to print
538 			 * the held locks (recall we turned lockdep off, so
539 			 * locking/unlocking @report_lock won't be recorded).
540 			 */
541 			set_current_state(TASK_UNINTERRUPTIBLE);
542 		}
543 		raw_spin_unlock_irqrestore(&report_lock, *flags);
544 		/*
545 		 * We cannot call schedule() since we also cannot reliably
546 		 * determine if sleeping here is permitted -- see in_atomic().
547 		 */
548 
549 		udelay(1);
550 		raw_spin_lock_irqsave(&report_lock, *flags);
551 		if (timeout-- < 0) {
552 			/*
553 			 * Abort. Reset @other_info->task to NULL, since it
554 			 * appears the other thread is still going to consume
555 			 * it. It will result in no verbose info printed for
556 			 * this task.
557 			 */
558 			other_info->task = NULL;
559 			break;
560 		}
561 		/*
562 		 * If invalid, or @ptr nor @current matches, then @other_info
563 		 * has been consumed and we may continue. If not, retry.
564 		 */
565 	} while (other_info->ai.size && other_info->ai.ptr == ai->ptr &&
566 		 other_info->task == current);
567 	if (is_running)
568 		set_current_state(TASK_RUNNING);
569 }
570 
571 /* Populate @other_info; requires that the provided @other_info not in use. */
prepare_report_producer(unsigned long * flags,const struct access_info * ai,struct other_info * other_info)572 static void prepare_report_producer(unsigned long *flags,
573 				    const struct access_info *ai,
574 				    struct other_info *other_info)
575 {
576 	raw_spin_lock_irqsave(&report_lock, *flags);
577 
578 	/*
579 	 * The same @other_infos entry cannot be used concurrently, because
580 	 * there is a one-to-one mapping to watchpoint slots (@watchpoints in
581 	 * core.c), and a watchpoint is only released for reuse after reporting
582 	 * is done by the consumer of @other_info. Therefore, it is impossible
583 	 * for another concurrent prepare_report_producer() to set the same
584 	 * @other_info, and are guaranteed exclusivity for the @other_infos
585 	 * entry pointed to by @other_info.
586 	 *
587 	 * To check this property holds, size should never be non-zero here,
588 	 * because every consumer of struct other_info resets size to 0 in
589 	 * release_report().
590 	 */
591 	WARN_ON(other_info->ai.size);
592 
593 	other_info->ai = *ai;
594 	other_info->num_stack_entries = stack_trace_save(other_info->stack_entries, NUM_STACK_ENTRIES, 2);
595 
596 	if (IS_ENABLED(CONFIG_KCSAN_VERBOSE))
597 		set_other_info_task_blocking(flags, ai, other_info);
598 
599 	raw_spin_unlock_irqrestore(&report_lock, *flags);
600 }
601 
602 /* Awaits producer to fill @other_info and then returns. */
prepare_report_consumer(unsigned long * flags,const struct access_info * ai,struct other_info * other_info)603 static bool prepare_report_consumer(unsigned long *flags,
604 				    const struct access_info *ai,
605 				    struct other_info *other_info)
606 {
607 
608 	raw_spin_lock_irqsave(&report_lock, *flags);
609 	while (!other_info->ai.size) { /* Await valid @other_info. */
610 		raw_spin_unlock_irqrestore(&report_lock, *flags);
611 		cpu_relax();
612 		raw_spin_lock_irqsave(&report_lock, *flags);
613 	}
614 
615 	/* Should always have a matching access based on watchpoint encoding. */
616 	if (WARN_ON(!matching_access((unsigned long)other_info->ai.ptr & WATCHPOINT_ADDR_MASK, other_info->ai.size,
617 				     (unsigned long)ai->ptr & WATCHPOINT_ADDR_MASK, ai->size)))
618 		goto discard;
619 
620 	if (!matching_access((unsigned long)other_info->ai.ptr, other_info->ai.size,
621 			     (unsigned long)ai->ptr, ai->size)) {
622 		/*
623 		 * If the actual accesses to not match, this was a false
624 		 * positive due to watchpoint encoding.
625 		 */
626 		atomic_long_inc(&kcsan_counters[KCSAN_COUNTER_ENCODING_FALSE_POSITIVES]);
627 		goto discard;
628 	}
629 
630 	return true;
631 
632 discard:
633 	release_report(flags, other_info);
634 	return false;
635 }
636 
prepare_access_info(const volatile void * ptr,size_t size,int access_type,unsigned long ip)637 static struct access_info prepare_access_info(const volatile void *ptr, size_t size,
638 					      int access_type, unsigned long ip)
639 {
640 	return (struct access_info) {
641 		.ptr		= ptr,
642 		.size		= size,
643 		.access_type	= access_type,
644 		.task_pid	= in_task() ? task_pid_nr(current) : -1,
645 		.cpu_id		= raw_smp_processor_id(),
646 		/* Only replace stack entry with @ip if scoped access. */
647 		.ip		= (access_type & KCSAN_ACCESS_SCOPED) ? ip : 0,
648 	};
649 }
650 
kcsan_report_set_info(const volatile void * ptr,size_t size,int access_type,unsigned long ip,int watchpoint_idx)651 void kcsan_report_set_info(const volatile void *ptr, size_t size, int access_type,
652 			   unsigned long ip, int watchpoint_idx)
653 {
654 	const struct access_info ai = prepare_access_info(ptr, size, access_type, ip);
655 	unsigned long flags;
656 
657 	kcsan_disable_current();
658 	lockdep_off(); /* See kcsan_report_known_origin(). */
659 
660 	prepare_report_producer(&flags, &ai, &other_infos[watchpoint_idx]);
661 
662 	lockdep_on();
663 	kcsan_enable_current();
664 }
665 
kcsan_report_known_origin(const volatile void * ptr,size_t size,int access_type,unsigned long ip,enum kcsan_value_change value_change,int watchpoint_idx,u64 old,u64 new,u64 mask)666 void kcsan_report_known_origin(const volatile void *ptr, size_t size, int access_type,
667 			       unsigned long ip, enum kcsan_value_change value_change,
668 			       int watchpoint_idx, u64 old, u64 new, u64 mask)
669 {
670 	const struct access_info ai = prepare_access_info(ptr, size, access_type, ip);
671 	struct other_info *other_info = &other_infos[watchpoint_idx];
672 	unsigned long flags = 0;
673 
674 	kcsan_disable_current();
675 	/*
676 	 * Because we may generate reports when we're in scheduler code, the use
677 	 * of printk() could deadlock. Until such time that all printing code
678 	 * called in print_report() is scheduler-safe, accept the risk, and just
679 	 * get our message out. As such, also disable lockdep to hide the
680 	 * warning, and avoid disabling lockdep for the rest of the kernel.
681 	 */
682 	lockdep_off();
683 
684 	if (!prepare_report_consumer(&flags, &ai, other_info))
685 		goto out;
686 	/*
687 	 * Never report if value_change is FALSE, only when it is
688 	 * either TRUE or MAYBE. In case of MAYBE, further filtering may
689 	 * be done once we know the full stack trace in print_report().
690 	 */
691 	if (value_change != KCSAN_VALUE_CHANGE_FALSE)
692 		print_report(value_change, &ai, other_info, old, new, mask);
693 
694 	release_report(&flags, other_info);
695 out:
696 	lockdep_on();
697 	kcsan_enable_current();
698 }
699 
kcsan_report_unknown_origin(const volatile void * ptr,size_t size,int access_type,unsigned long ip,u64 old,u64 new,u64 mask)700 void kcsan_report_unknown_origin(const volatile void *ptr, size_t size, int access_type,
701 				 unsigned long ip, u64 old, u64 new, u64 mask)
702 {
703 	const struct access_info ai = prepare_access_info(ptr, size, access_type, ip);
704 	unsigned long flags;
705 
706 	kcsan_disable_current();
707 	lockdep_off(); /* See kcsan_report_known_origin(). */
708 
709 	raw_spin_lock_irqsave(&report_lock, flags);
710 	print_report(KCSAN_VALUE_CHANGE_TRUE, &ai, NULL, old, new, mask);
711 	raw_spin_unlock_irqrestore(&report_lock, flags);
712 
713 	lockdep_on();
714 	kcsan_enable_current();
715 }
716