Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * This file contains common generic and tag-based KASAN error reporting code.
4 : : *
5 : : * Copyright (c) 2014 Samsung Electronics Co., Ltd.
6 : : * Author: Andrey Ryabinin <ryabinin.a.a@gmail.com>
7 : : *
8 : : * Some code borrowed from https://github.com/xairy/kasan-prototype by
9 : : * Andrey Konovalov <andreyknvl@gmail.com>
10 : : *
11 : : * This program is free software; you can redistribute it and/or modify
12 : : * it under the terms of the GNU General Public License version 2 as
13 : : * published by the Free Software Foundation.
14 : : *
15 : : */
16 : :
17 : : #include <linux/bitops.h>
18 : : #include <linux/ftrace.h>
19 : : #include <linux/init.h>
20 : : #include <linux/kernel.h>
21 : : #include <linux/mm.h>
22 : : #include <linux/printk.h>
23 : : #include <linux/sched.h>
24 : : #include <linux/slab.h>
25 : : #include <linux/stackdepot.h>
26 : : #include <linux/stacktrace.h>
27 : : #include <linux/string.h>
28 : : #include <linux/types.h>
29 : : #include <linux/kasan.h>
30 : : #include <linux/module.h>
31 : : #include <linux/sched/task_stack.h>
32 : :
33 : : #include <linux/drifuzz.h>
34 : :
35 : : #include <asm/sections.h>
36 : :
37 : : #include "kasan.h"
38 : : #include "../slab.h"
39 : :
40 : : /* Shadow layout customization. */
41 : : #define SHADOW_BYTES_PER_BLOCK 1
42 : : #define SHADOW_BLOCKS_PER_ROW 16
43 : : #define SHADOW_BYTES_PER_ROW (SHADOW_BLOCKS_PER_ROW * SHADOW_BYTES_PER_BLOCK)
44 : : #define SHADOW_ROWS_AROUND_ADDR 2
45 : :
46 : : static unsigned long kasan_flags;
47 : :
48 : : #define KASAN_BIT_REPORTED 0
49 : : #define KASAN_BIT_MULTI_SHOT 1
50 : :
51 : 0 : bool kasan_save_enable_multi_shot(void)
52 : : {
53 : 0 : return test_and_set_bit(KASAN_BIT_MULTI_SHOT, &kasan_flags);
54 : : }
55 : : EXPORT_SYMBOL_GPL(kasan_save_enable_multi_shot);
56 : :
57 : 0 : void kasan_restore_multi_shot(bool enabled)
58 : : {
59 [ # # ]: 0 : if (!enabled)
60 : 0 : clear_bit(KASAN_BIT_MULTI_SHOT, &kasan_flags);
61 : 0 : }
62 : : EXPORT_SYMBOL_GPL(kasan_restore_multi_shot);
63 : :
64 : 0 : static int __init kasan_set_multi_shot(char *str)
65 : : {
66 : 0 : set_bit(KASAN_BIT_MULTI_SHOT, &kasan_flags);
67 : 0 : return 1;
68 : : }
69 : : __setup("kasan_multi_shot", kasan_set_multi_shot);
70 : :
71 : 0 : static void print_error_description(struct kasan_access_info *info)
72 : : {
73 : 0 : pr_err("BUG: KASAN: %s in %pS\n",
74 : : get_bug_type(info), (void *)info->ip);
75 [ # # ]: 0 : pr_err("%s of size %zu at addr %px by task %s/%d\n",
76 : : info->is_write ? "Write" : "Read", info->access_size,
77 : : info->access_addr, current->comm, task_pid_nr(current));
78 : 0 : }
79 : :
80 : : static DEFINE_SPINLOCK(report_lock);
81 : :
82 : 0 : static void start_report(unsigned long *flags)
83 : : {
84 : : /*
85 : : * Make sure we don't end up in loop.
86 : : */
87 : 0 : kasan_disable_current();
88 : 0 : spin_lock_irqsave(&report_lock, *flags);
89 : 0 : pr_err("==================================================================\n");
90 : 0 : }
91 : :
92 : 0 : static void end_report(unsigned long *flags)
93 : : {
94 : 0 : pr_err("==================================================================\n");
95 : 0 : add_taint(TAINT_BAD_PAGE, LOCKDEP_NOW_UNRELIABLE);
96 : 0 : spin_unlock_irqrestore(&report_lock, *flags);
97 [ # # ]: 0 : if (panic_on_warn)
98 : 0 : panic("panic_on_warn set ...\n");
99 : 0 : kasan_enable_current();
100 : 0 : }
101 : :
102 : : static void print_track(struct kasan_track *track, const char *prefix)
103 : : {
104 : : pr_err("%s by task %u:\n", prefix, track->pid);
105 : : if (track->stack) {
106 : : unsigned long *entries;
107 : : unsigned int nr_entries;
108 : :
109 : : nr_entries = stack_depot_fetch(track->stack, &entries);
110 : : stack_trace_print(entries, nr_entries, 0);
111 : : } else {
112 : : pr_err("(stack is not available)\n");
113 : : }
114 : : }
115 : :
116 : 0 : struct page *kasan_addr_to_page(const void *addr)
117 : : {
118 [ # # ]: 0 : if ((addr >= (void *)PAGE_OFFSET) &&
119 [ # # ]: 0 : (addr < high_memory))
120 [ # # ]: 0 : return virt_to_head_page(addr);
121 : : return NULL;
122 : : }
123 : :
124 : : static void describe_object_addr(struct kmem_cache *cache, void *object,
125 : : const void *addr)
126 : : {
127 : : unsigned long access_addr = (unsigned long)addr;
128 : : unsigned long object_addr = (unsigned long)object;
129 : : const char *rel_type;
130 : : int rel_bytes;
131 : :
132 : : pr_err("The buggy address belongs to the object at %px\n"
133 : : " which belongs to the cache %s of size %d\n",
134 : : object, cache->name, cache->object_size);
135 : :
136 : : if (!addr)
137 : : return;
138 : :
139 : : if (access_addr < object_addr) {
140 : : rel_type = "to the left";
141 : : rel_bytes = object_addr - access_addr;
142 : : } else if (access_addr >= object_addr + cache->object_size) {
143 : : rel_type = "to the right";
144 : : rel_bytes = access_addr - (object_addr + cache->object_size);
145 : : } else {
146 : : rel_type = "inside";
147 : : rel_bytes = access_addr - object_addr;
148 : : }
149 : :
150 : : pr_err("The buggy address is located %d bytes %s of\n"
151 : : " %d-byte region [%px, %px)\n",
152 : : rel_bytes, rel_type, cache->object_size, (void *)object_addr,
153 : : (void *)(object_addr + cache->object_size));
154 : : }
155 : :
156 : 0 : static struct kasan_track *kasan_get_free_track(struct kmem_cache *cache,
157 : : void *object, u8 tag)
158 : : {
159 : 0 : struct kasan_alloc_meta *alloc_meta;
160 : 0 : int i = 0;
161 : :
162 : 0 : alloc_meta = get_alloc_info(cache, object);
163 : :
164 : : #ifdef CONFIG_KASAN_SW_TAGS_IDENTIFY
165 : : for (i = 0; i < KASAN_NR_FREE_STACKS; i++) {
166 : : if (alloc_meta->free_pointer_tag[i] == tag)
167 : : break;
168 : : }
169 : : if (i == KASAN_NR_FREE_STACKS)
170 : : i = alloc_meta->free_track_idx;
171 : : #endif
172 : :
173 : 0 : return &alloc_meta->free_track[i];
174 : : }
175 : :
176 : 0 : static void describe_object(struct kmem_cache *cache, void *object,
177 : : const void *addr, u8 tag)
178 : : {
179 : 0 : struct kasan_alloc_meta *alloc_info = get_alloc_info(cache, object);
180 : :
181 [ # # ]: 0 : if (cache->flags & SLAB_KASAN) {
182 : 0 : struct kasan_track *free_track;
183 : :
184 : 0 : print_track(&alloc_info->alloc_track, "Allocated");
185 : 0 : pr_err("\n");
186 : 0 : free_track = kasan_get_free_track(cache, object, tag);
187 : 0 : print_track(free_track, "Freed");
188 : 0 : pr_err("\n");
189 : : }
190 : :
191 : 0 : describe_object_addr(cache, object, addr);
192 : 0 : }
193 : :
194 : 0 : static inline bool kernel_or_module_addr(const void *addr)
195 : : {
196 [ # # ]: 0 : if (addr >= (void *)_stext && addr < (void *)_end)
197 : : return true;
198 [ # # ]: 0 : if (is_module_address((unsigned long)addr))
199 : : return true;
200 : : return false;
201 : : }
202 : :
203 : 0 : static inline bool init_task_stack_addr(const void *addr)
204 : : {
205 [ # # # # ]: 0 : return addr >= (void *)&init_thread_union.stack &&
206 : : (addr <= (void *)&init_thread_union.stack +
207 : : sizeof(init_thread_union.stack));
208 : : }
209 : :
210 : 0 : static bool __must_check tokenize_frame_descr(const char **frame_descr,
211 : : char *token, size_t max_tok_len,
212 : : unsigned long *value)
213 : : {
214 : 0 : const char *sep = strchr(*frame_descr, ' ');
215 : :
216 [ # # ]: 0 : if (sep == NULL)
217 : 0 : sep = *frame_descr + strlen(*frame_descr);
218 : :
219 [ # # ]: 0 : if (token != NULL) {
220 : 0 : const size_t tok_len = sep - *frame_descr;
221 : :
222 [ # # ]: 0 : if (tok_len + 1 > max_tok_len) {
223 : 0 : pr_err("KASAN internal error: frame description too long: %s\n",
224 : : *frame_descr);
225 : 0 : return false;
226 : : }
227 : :
228 : : /* Copy token (+ 1 byte for '\0'). */
229 : 0 : strlcpy(token, *frame_descr, tok_len + 1);
230 : : }
231 : :
232 : : /* Advance frame_descr past separator. */
233 : 0 : *frame_descr = sep + 1;
234 : :
235 [ # # # # ]: 0 : if (value != NULL && kstrtoul(token, 10, value)) {
236 : 0 : pr_err("KASAN internal error: not a valid number: %s\n", token);
237 : 0 : return false;
238 : : }
239 : :
240 : : return true;
241 : : }
242 : :
243 : 0 : static void print_decoded_frame_descr(const char *frame_descr)
244 : : {
245 : : /*
246 : : * We need to parse the following string:
247 : : * "n alloc_1 alloc_2 ... alloc_n"
248 : : * where alloc_i looks like
249 : : * "offset size len name"
250 : : * or "offset size len name:line".
251 : : */
252 : :
253 : 0 : char token[64];
254 : 0 : unsigned long num_objects;
255 : :
256 [ # # ]: 0 : if (!tokenize_frame_descr(&frame_descr, token, sizeof(token),
257 : : &num_objects))
258 : 0 : return;
259 : :
260 : 0 : pr_err("\n");
261 [ # # ]: 0 : pr_err("this frame has %lu %s:\n", num_objects,
262 : : num_objects == 1 ? "object" : "objects");
263 : :
264 [ # # ]: 0 : while (num_objects--) {
265 : 0 : unsigned long offset;
266 : 0 : unsigned long size;
267 : :
268 : : /* access offset */
269 [ # # ]: 0 : if (!tokenize_frame_descr(&frame_descr, token, sizeof(token),
270 : : &offset))
271 : 0 : return;
272 : : /* access size */
273 [ # # ]: 0 : if (!tokenize_frame_descr(&frame_descr, token, sizeof(token),
274 : : &size))
275 : : return;
276 : : /* name length (unused) */
277 [ # # ]: 0 : if (!tokenize_frame_descr(&frame_descr, NULL, 0, NULL))
278 : : return;
279 : : /* object name */
280 [ # # ]: 0 : if (!tokenize_frame_descr(&frame_descr, token, sizeof(token),
281 : : NULL))
282 : : return;
283 : :
284 : : /* Strip line number; without filename it's not very helpful. */
285 : 0 : strreplace(token, ':', '\0');
286 : :
287 : : /* Finally, print object information. */
288 : 0 : pr_err(" [%lu, %lu) '%s'", offset, offset + size, token);
289 : : }
290 : : }
291 : :
292 : 0 : static bool __must_check get_address_stack_frame_info(const void *addr,
293 : : unsigned long *offset,
294 : : const char **frame_descr,
295 : : const void **frame_pc)
296 : : {
297 : 0 : unsigned long aligned_addr;
298 : 0 : unsigned long mem_ptr;
299 : 0 : const u8 *shadow_bottom;
300 : 0 : const u8 *shadow_ptr;
301 : 0 : const unsigned long *frame;
302 : :
303 : 0 : BUILD_BUG_ON(IS_ENABLED(CONFIG_STACK_GROWSUP));
304 : :
305 : : /*
306 : : * NOTE: We currently only support printing frame information for
307 : : * accesses to the task's own stack.
308 : : */
309 [ # # ]: 0 : if (!object_is_on_stack(addr))
310 : : return false;
311 : :
312 : 0 : aligned_addr = round_down((unsigned long)addr, sizeof(long));
313 : 0 : mem_ptr = round_down(aligned_addr, KASAN_SHADOW_SCALE_SIZE);
314 : 0 : shadow_ptr = kasan_mem_to_shadow((void *)aligned_addr);
315 : 0 : shadow_bottom = kasan_mem_to_shadow(end_of_stack(current));
316 : :
317 [ # # # # ]: 0 : while (shadow_ptr >= shadow_bottom && *shadow_ptr != KASAN_STACK_LEFT) {
318 : 0 : shadow_ptr--;
319 : 0 : mem_ptr -= KASAN_SHADOW_SCALE_SIZE;
320 : : }
321 : :
322 [ # # # # ]: 0 : while (shadow_ptr >= shadow_bottom && *shadow_ptr == KASAN_STACK_LEFT) {
323 : 0 : shadow_ptr--;
324 : 0 : mem_ptr -= KASAN_SHADOW_SCALE_SIZE;
325 : : }
326 : :
327 [ # # ]: 0 : if (shadow_ptr < shadow_bottom)
328 : : return false;
329 : :
330 : 0 : frame = (const unsigned long *)(mem_ptr + KASAN_SHADOW_SCALE_SIZE);
331 [ # # ]: 0 : if (frame[0] != KASAN_CURRENT_STACK_FRAME_MAGIC) {
332 : 0 : pr_err("KASAN internal error: frame info validation failed; invalid marker: %lu\n",
333 : : frame[0]);
334 : 0 : return false;
335 : : }
336 : :
337 : 0 : *offset = (unsigned long)addr - (unsigned long)frame;
338 : 0 : *frame_descr = (const char *)frame[1];
339 : 0 : *frame_pc = (void *)frame[2];
340 : :
341 : 0 : return true;
342 : : }
343 : :
344 : 0 : static void print_address_stack_frame(const void *addr)
345 : : {
346 : 0 : unsigned long offset;
347 : 0 : const char *frame_descr;
348 : 0 : const void *frame_pc;
349 : :
350 : 0 : if (IS_ENABLED(CONFIG_KASAN_SW_TAGS))
351 : 0 : return;
352 : :
353 [ # # ]: 0 : if (!get_address_stack_frame_info(addr, &offset, &frame_descr,
354 : : &frame_pc))
355 : : return;
356 : :
357 : : /*
358 : : * get_address_stack_frame_info only returns true if the given addr is
359 : : * on the current task's stack.
360 : : */
361 : 0 : pr_err("\n");
362 : 0 : pr_err("addr %px is located in stack of task %s/%d at offset %lu in frame:\n",
363 : : addr, current->comm, task_pid_nr(current), offset);
364 : 0 : pr_err(" %pS\n", frame_pc);
365 : :
366 [ # # ]: 0 : if (!frame_descr)
367 : : return;
368 : :
369 : 0 : print_decoded_frame_descr(frame_descr);
370 : : }
371 : :
372 : 0 : static void print_address_description(void *addr, u8 tag)
373 : : {
374 : 0 : struct page *page = kasan_addr_to_page(addr);
375 : :
376 : 0 : dump_stack();
377 : 0 : pr_err("\n");
378 : :
379 [ # # # # ]: 0 : if (page && PageSlab(page)) {
380 : 0 : struct kmem_cache *cache = page->slab_cache;
381 : 0 : void *object = nearest_obj(cache, page, addr);
382 : :
383 : 0 : describe_object(cache, object, addr, tag);
384 : : }
385 : :
386 [ # # # # ]: 0 : if (kernel_or_module_addr(addr) && !init_task_stack_addr(addr)) {
387 : 0 : pr_err("The buggy address belongs to the variable:\n");
388 : 0 : pr_err(" %pS\n", addr);
389 : : }
390 : :
391 [ # # ]: 0 : if (page) {
392 : 0 : pr_err("The buggy address belongs to the page:\n");
393 : 0 : dump_page(page, "kasan: bad access detected");
394 : : }
395 : :
396 : 0 : print_address_stack_frame(addr);
397 : 0 : }
398 : :
399 : 0 : static bool row_is_guilty(const void *row, const void *guilty)
400 : : {
401 [ # # ]: 0 : return (row <= guilty) && (guilty < row + SHADOW_BYTES_PER_ROW);
402 : : }
403 : :
404 : 0 : static int shadow_pointer_offset(const void *row, const void *shadow)
405 : : {
406 : : /* The length of ">ff00ff00ff00ff00: " is
407 : : * 3 + (BITS_PER_LONG/8)*2 chars.
408 : : */
409 : 0 : return 3 + (BITS_PER_LONG/8)*2 + (shadow - row)*2 +
410 : 0 : (shadow - row) / SHADOW_BYTES_PER_BLOCK + 1;
411 : : }
412 : :
413 : 0 : static void print_shadow_for_address(const void *addr)
414 : : {
415 : 0 : int i;
416 : 0 : const void *shadow = kasan_mem_to_shadow(addr);
417 : 0 : const void *shadow_row;
418 : :
419 : 0 : shadow_row = (void *)round_down((unsigned long)shadow,
420 : : SHADOW_BYTES_PER_ROW)
421 : 0 : - SHADOW_ROWS_AROUND_ADDR * SHADOW_BYTES_PER_ROW;
422 : :
423 : 0 : pr_err("Memory state around the buggy address:\n");
424 : :
425 [ # # ]: 0 : for (i = -SHADOW_ROWS_AROUND_ADDR; i <= SHADOW_ROWS_AROUND_ADDR; i++) {
426 [ # # ]: 0 : const void *kaddr = kasan_shadow_to_mem(shadow_row);
427 : 0 : char buffer[4 + (BITS_PER_LONG/8)*2];
428 : 0 : char shadow_buf[SHADOW_BYTES_PER_ROW];
429 : :
430 [ # # ]: 0 : snprintf(buffer, sizeof(buffer),
431 : : (i == 0) ? ">%px: " : " %px: ", kaddr);
432 : : /*
433 : : * We should not pass a shadow pointer to generic
434 : : * function, because generic functions may try to
435 : : * access kasan mapping for the passed address.
436 : : */
437 : 0 : memcpy(shadow_buf, shadow_row, SHADOW_BYTES_PER_ROW);
438 : 0 : print_hex_dump(KERN_ERR, buffer,
439 : : DUMP_PREFIX_NONE, SHADOW_BYTES_PER_ROW, 1,
440 : : shadow_buf, SHADOW_BYTES_PER_ROW, 0);
441 : :
442 [ # # # # ]: 0 : if (row_is_guilty(shadow_row, shadow))
443 : 0 : pr_err("%*c\n",
444 : : shadow_pointer_offset(shadow_row, shadow),
445 : : '^');
446 : :
447 : 0 : shadow_row += SHADOW_BYTES_PER_ROW;
448 : : }
449 : 0 : }
450 : :
451 : 3933132 : static bool report_enabled(void)
452 : : {
453 [ - + ]: 3933132 : if (current->kasan_depth)
454 : : return false;
455 [ # # ]: 0 : if (test_bit(KASAN_BIT_MULTI_SHOT, &kasan_flags))
456 : : return true;
457 : 0 : return !test_and_set_bit(KASAN_BIT_REPORTED, &kasan_flags);
458 : : }
459 : :
460 : 0 : void kasan_report_invalid_free(void *object, unsigned long ip)
461 : : {
462 : 0 : unsigned long flags;
463 : 0 : u8 tag = get_tag(object);
464 : :
465 : 0 : object = reset_tag(object);
466 : 0 : start_report(&flags);
467 : 0 : pr_err("BUG: KASAN: double-free or invalid-free in %pS\n", (void *)ip);
468 : 0 : print_tags(tag, object);
469 : 0 : pr_err("\n");
470 : 0 : print_address_description(object, tag);
471 : 0 : pr_err("\n");
472 : 0 : print_shadow_for_address(object);
473 : 0 : end_report(&flags);
474 : 0 : handle_kasan();
475 : 0 : }
476 : :
477 : 3933132 : void __kasan_report(unsigned long addr, size_t size, bool is_write, unsigned long ip)
478 : : {
479 : 3933132 : struct kasan_access_info info;
480 : 3933132 : void *tagged_addr;
481 : 3933132 : void *untagged_addr;
482 : 3933132 : unsigned long flags;
483 : :
484 [ + - ]: 3933132 : if (likely(!report_enabled()))
485 : 3933132 : return;
486 : :
487 : 0 : disable_trace_on_warning();
488 : :
489 : 0 : tagged_addr = (void *)addr;
490 : 0 : untagged_addr = reset_tag(tagged_addr);
491 : :
492 : 0 : info.access_addr = tagged_addr;
493 [ # # ]: 0 : if (addr_has_shadow(untagged_addr))
494 : 0 : info.first_bad_addr = find_first_bad_addr(tagged_addr, size);
495 : : else
496 : 0 : info.first_bad_addr = untagged_addr;
497 : 0 : info.access_size = size;
498 : 0 : info.is_write = is_write;
499 : 0 : info.ip = ip;
500 : :
501 : 0 : start_report(&flags);
502 : :
503 : 0 : print_error_description(&info);
504 : 0 : if (addr_has_shadow(untagged_addr))
505 : : print_tags(get_tag(tagged_addr), info.first_bad_addr);
506 : 0 : pr_err("\n");
507 : :
508 [ # # ]: 0 : if (addr_has_shadow(untagged_addr)) {
509 : 0 : print_address_description(untagged_addr, get_tag(tagged_addr));
510 : 0 : pr_err("\n");
511 : 0 : print_shadow_for_address(info.first_bad_addr);
512 : : } else {
513 : 0 : dump_stack();
514 : : }
515 : :
516 : 0 : end_report(&flags);
517 : 0 : handle_kasan();
518 : : }
519 : :
520 : : #ifdef CONFIG_KASAN_INLINE
521 : : /*
522 : : * With CONFIG_KASAN_INLINE, accesses to bogus pointers (outside the high
523 : : * canonical half of the address space) cause out-of-bounds shadow memory reads
524 : : * before the actual access. For addresses in the low canonical half of the
525 : : * address space, as well as most non-canonical addresses, that out-of-bounds
526 : : * shadow memory access lands in the non-canonical part of the address space.
527 : : * Help the user figure out what the original bogus pointer was.
528 : : */
529 : 0 : void kasan_non_canonical_hook(unsigned long addr)
530 : : {
531 : 0 : unsigned long orig_addr;
532 : 0 : const char *bug_type;
533 : :
534 [ # # ]: 0 : if (addr < KASAN_SHADOW_OFFSET)
535 : : return;
536 : :
537 : 0 : orig_addr = (addr - KASAN_SHADOW_OFFSET) << KASAN_SHADOW_SCALE_SHIFT;
538 : : /*
539 : : * For faults near the shadow address for NULL, we can be fairly certain
540 : : * that this is a KASAN shadow memory access.
541 : : * For faults that correspond to shadow for low canonical addresses, we
542 : : * can still be pretty sure - that shadow region is a fairly narrow
543 : : * chunk of the non-canonical address space.
544 : : * But faults that look like shadow for non-canonical addresses are a
545 : : * really large chunk of the address space. In that case, we still
546 : : * print the decoded address, but make it clear that this is not
547 : : * necessarily what's actually going on.
548 : : */
549 [ # # ]: 0 : if (orig_addr < PAGE_SIZE)
550 : : bug_type = "null-ptr-deref";
551 [ # # # # : 0 : else if (orig_addr < TASK_SIZE)
# # ]
552 : : bug_type = "probably user-memory-access";
553 : : else
554 : 0 : bug_type = "maybe wild-memory-access";
555 : 0 : pr_alert("KASAN: %s in range [0x%016lx-0x%016lx]\n", bug_type,
556 : : orig_addr, orig_addr + KASAN_SHADOW_MASK);
557 : 0 : dump_stack();
558 : 0 : handle_kasan();
559 : : }
560 : : #endif
|
