Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 1 | /* |
| 2 | * This file contains error reporting code. |
| 3 | * |
| 4 | * Copyright (c) 2014 Samsung Electronics Co., Ltd. |
Andrey Ryabinin | 2baf9e8 | 2015-08-14 15:35:13 -0700 | [diff] [blame] | 5 | * Author: Andrey Ryabinin <ryabinin.a.a@gmail.com> |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 6 | * |
Andrey Konovalov | 5d0926e | 2015-11-05 18:51:12 -0800 | [diff] [blame] | 7 | * Some code borrowed from https://github.com/xairy/kasan-prototype by |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 8 | * Andrey Konovalov <adech.fo@gmail.com> |
| 9 | * |
| 10 | * This program is free software; you can redistribute it and/or modify |
| 11 | * it under the terms of the GNU General Public License version 2 as |
| 12 | * published by the Free Software Foundation. |
| 13 | * |
| 14 | */ |
| 15 | |
Mark Rutland | b0845ce | 2017-03-31 15:12:04 -0700 | [diff] [blame] | 16 | #include <linux/bitops.h> |
Peter Zijlstra | 4f40c6e | 2017-02-03 13:13:12 -0800 | [diff] [blame] | 17 | #include <linux/ftrace.h> |
Mark Rutland | b0845ce | 2017-03-31 15:12:04 -0700 | [diff] [blame] | 18 | #include <linux/init.h> |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 19 | #include <linux/kernel.h> |
| 20 | #include <linux/mm.h> |
| 21 | #include <linux/printk.h> |
| 22 | #include <linux/sched.h> |
| 23 | #include <linux/slab.h> |
Alexander Potapenko | cd11016 | 2016-03-25 14:22:08 -0700 | [diff] [blame] | 24 | #include <linux/stackdepot.h> |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 25 | #include <linux/stacktrace.h> |
| 26 | #include <linux/string.h> |
| 27 | #include <linux/types.h> |
| 28 | #include <linux/kasan.h> |
Aneesh Kumar K.V | 527f215 | 2015-11-05 18:50:46 -0800 | [diff] [blame] | 29 | #include <linux/module.h> |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 30 | |
Andrey Ryabinin | bebf56a | 2015-02-13 14:40:17 -0800 | [diff] [blame] | 31 | #include <asm/sections.h> |
| 32 | |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 33 | #include "kasan.h" |
Andrey Ryabinin | 0316bec | 2015-02-13 14:39:42 -0800 | [diff] [blame] | 34 | #include "../slab.h" |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 35 | |
| 36 | /* Shadow layout customization. */ |
| 37 | #define SHADOW_BYTES_PER_BLOCK 1 |
| 38 | #define SHADOW_BLOCKS_PER_ROW 16 |
| 39 | #define SHADOW_BYTES_PER_ROW (SHADOW_BLOCKS_PER_ROW * SHADOW_BYTES_PER_BLOCK) |
| 40 | #define SHADOW_ROWS_AROUND_ADDR 2 |
| 41 | |
| 42 | static const void *find_first_bad_addr(const void *addr, size_t size) |
| 43 | { |
| 44 | u8 shadow_val = *(u8 *)kasan_mem_to_shadow(addr); |
| 45 | const void *first_bad_addr = addr; |
| 46 | |
| 47 | while (!shadow_val && first_bad_addr < addr + size) { |
| 48 | first_bad_addr += KASAN_SHADOW_SCALE_SIZE; |
| 49 | shadow_val = *(u8 *)kasan_mem_to_shadow(first_bad_addr); |
| 50 | } |
| 51 | return first_bad_addr; |
| 52 | } |
| 53 | |
Andrey Konovalov | 5e82cd1 | 2017-05-03 14:56:25 -0700 | [diff] [blame] | 54 | static bool addr_has_shadow(struct kasan_access_info *info) |
| 55 | { |
| 56 | return (info->access_addr >= |
| 57 | kasan_shadow_to_mem((void *)KASAN_SHADOW_START)); |
| 58 | } |
| 59 | |
| 60 | static const char *get_shadow_bug_type(struct kasan_access_info *info) |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 61 | { |
Andrey Konovalov | 0952d87 | 2015-11-05 18:50:58 -0800 | [diff] [blame] | 62 | const char *bug_type = "unknown-crash"; |
Andrey Konovalov | cdf6a27 | 2015-11-05 18:51:01 -0800 | [diff] [blame] | 63 | u8 *shadow_addr; |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 64 | |
| 65 | info->first_bad_addr = find_first_bad_addr(info->access_addr, |
| 66 | info->access_size); |
| 67 | |
Andrey Konovalov | cdf6a27 | 2015-11-05 18:51:01 -0800 | [diff] [blame] | 68 | shadow_addr = (u8 *)kasan_mem_to_shadow(info->first_bad_addr); |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 69 | |
Andrey Konovalov | cdf6a27 | 2015-11-05 18:51:01 -0800 | [diff] [blame] | 70 | /* |
| 71 | * If shadow byte value is in [0, KASAN_SHADOW_SCALE_SIZE) we can look |
| 72 | * at the next shadow byte to determine the type of the bad access. |
| 73 | */ |
| 74 | if (*shadow_addr > 0 && *shadow_addr <= KASAN_SHADOW_SCALE_SIZE - 1) |
| 75 | shadow_addr++; |
| 76 | |
| 77 | switch (*shadow_addr) { |
Andrey Konovalov | 0952d87 | 2015-11-05 18:50:58 -0800 | [diff] [blame] | 78 | case 0 ... KASAN_SHADOW_SCALE_SIZE - 1: |
Andrey Konovalov | cdf6a27 | 2015-11-05 18:51:01 -0800 | [diff] [blame] | 79 | /* |
| 80 | * In theory it's still possible to see these shadow values |
| 81 | * due to a data race in the kernel code. |
| 82 | */ |
Andrey Konovalov | 0952d87 | 2015-11-05 18:50:58 -0800 | [diff] [blame] | 83 | bug_type = "out-of-bounds"; |
Andrey Ryabinin | b8c73fc | 2015-02-13 14:39:28 -0800 | [diff] [blame] | 84 | break; |
Andrey Ryabinin | 0316bec | 2015-02-13 14:39:42 -0800 | [diff] [blame] | 85 | case KASAN_PAGE_REDZONE: |
| 86 | case KASAN_KMALLOC_REDZONE: |
Andrey Konovalov | 0952d87 | 2015-11-05 18:50:58 -0800 | [diff] [blame] | 87 | bug_type = "slab-out-of-bounds"; |
| 88 | break; |
Andrey Ryabinin | bebf56a | 2015-02-13 14:40:17 -0800 | [diff] [blame] | 89 | case KASAN_GLOBAL_REDZONE: |
Andrey Konovalov | 0952d87 | 2015-11-05 18:50:58 -0800 | [diff] [blame] | 90 | bug_type = "global-out-of-bounds"; |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 91 | break; |
Andrey Ryabinin | c420f16 | 2015-02-13 14:39:59 -0800 | [diff] [blame] | 92 | case KASAN_STACK_LEFT: |
| 93 | case KASAN_STACK_MID: |
| 94 | case KASAN_STACK_RIGHT: |
| 95 | case KASAN_STACK_PARTIAL: |
Andrey Konovalov | 0952d87 | 2015-11-05 18:50:58 -0800 | [diff] [blame] | 96 | bug_type = "stack-out-of-bounds"; |
| 97 | break; |
| 98 | case KASAN_FREE_PAGE: |
| 99 | case KASAN_KMALLOC_FREE: |
| 100 | bug_type = "use-after-free"; |
Andrey Ryabinin | c420f16 | 2015-02-13 14:39:59 -0800 | [diff] [blame] | 101 | break; |
Dmitry Vyukov | 828347f | 2016-11-30 15:54:16 -0800 | [diff] [blame] | 102 | case KASAN_USE_AFTER_SCOPE: |
| 103 | bug_type = "use-after-scope"; |
| 104 | break; |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 105 | } |
| 106 | |
Andrey Konovalov | 5e82cd1 | 2017-05-03 14:56:25 -0700 | [diff] [blame] | 107 | return bug_type; |
| 108 | } |
| 109 | |
| 110 | const char *get_wild_bug_type(struct kasan_access_info *info) |
| 111 | { |
| 112 | const char *bug_type = "unknown-crash"; |
| 113 | |
| 114 | if ((unsigned long)info->access_addr < PAGE_SIZE) |
| 115 | bug_type = "null-ptr-deref"; |
| 116 | else if ((unsigned long)info->access_addr < TASK_SIZE) |
| 117 | bug_type = "user-memory-access"; |
| 118 | else |
| 119 | bug_type = "wild-memory-access"; |
| 120 | |
| 121 | return bug_type; |
| 122 | } |
| 123 | |
Andrey Konovalov | 7d418f7 | 2017-05-03 14:56:28 -0700 | [diff] [blame] | 124 | static const char *get_bug_type(struct kasan_access_info *info) |
| 125 | { |
| 126 | if (addr_has_shadow(info)) |
| 127 | return get_shadow_bug_type(info); |
| 128 | return get_wild_bug_type(info); |
| 129 | } |
| 130 | |
Andrey Konovalov | 5e82cd1 | 2017-05-03 14:56:25 -0700 | [diff] [blame] | 131 | static void print_error_description(struct kasan_access_info *info) |
| 132 | { |
Andrey Konovalov | 7d418f7 | 2017-05-03 14:56:28 -0700 | [diff] [blame] | 133 | const char *bug_type = get_bug_type(info); |
Andrey Konovalov | 5e82cd1 | 2017-05-03 14:56:25 -0700 | [diff] [blame] | 134 | |
Andrey Konovalov | 7f0a84c | 2017-05-03 14:56:38 -0700 | [diff] [blame^] | 135 | pr_err("BUG: KASAN: %s in %pS\n", |
| 136 | bug_type, (void *)info->ip); |
| 137 | pr_err("%s of size %zu at addr %p by task %s/%d\n", |
Andrey Konovalov | 7d418f7 | 2017-05-03 14:56:28 -0700 | [diff] [blame] | 138 | info->is_write ? "Write" : "Read", info->access_size, |
Andrey Konovalov | 7f0a84c | 2017-05-03 14:56:38 -0700 | [diff] [blame^] | 139 | info->access_addr, current->comm, task_pid_nr(current)); |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 140 | } |
| 141 | |
Andrey Ryabinin | bebf56a | 2015-02-13 14:40:17 -0800 | [diff] [blame] | 142 | static inline bool kernel_or_module_addr(const void *addr) |
| 143 | { |
Aneesh Kumar K.V | 527f215 | 2015-11-05 18:50:46 -0800 | [diff] [blame] | 144 | if (addr >= (void *)_stext && addr < (void *)_end) |
| 145 | return true; |
| 146 | if (is_module_address((unsigned long)addr)) |
| 147 | return true; |
| 148 | return false; |
Andrey Ryabinin | bebf56a | 2015-02-13 14:40:17 -0800 | [diff] [blame] | 149 | } |
| 150 | |
| 151 | static inline bool init_task_stack_addr(const void *addr) |
| 152 | { |
| 153 | return addr >= (void *)&init_thread_union.stack && |
| 154 | (addr <= (void *)&init_thread_union.stack + |
| 155 | sizeof(init_thread_union.stack)); |
| 156 | } |
| 157 | |
Andrey Ryabinin | 7e08897 | 2016-08-02 14:02:55 -0700 | [diff] [blame] | 158 | static DEFINE_SPINLOCK(report_lock); |
| 159 | |
| 160 | static void kasan_start_report(unsigned long *flags) |
| 161 | { |
| 162 | /* |
| 163 | * Make sure we don't end up in loop. |
| 164 | */ |
| 165 | kasan_disable_current(); |
| 166 | spin_lock_irqsave(&report_lock, *flags); |
| 167 | pr_err("==================================================================\n"); |
| 168 | } |
| 169 | |
| 170 | static void kasan_end_report(unsigned long *flags) |
| 171 | { |
| 172 | pr_err("==================================================================\n"); |
| 173 | add_taint(TAINT_BAD_PAGE, LOCKDEP_NOW_UNRELIABLE); |
| 174 | spin_unlock_irqrestore(&report_lock, *flags); |
Dmitry Vyukov | 5c5c1f3 | 2016-12-12 16:44:53 -0800 | [diff] [blame] | 175 | if (panic_on_warn) |
| 176 | panic("panic_on_warn set ...\n"); |
Andrey Ryabinin | 7e08897 | 2016-08-02 14:02:55 -0700 | [diff] [blame] | 177 | kasan_enable_current(); |
| 178 | } |
| 179 | |
Andrey Konovalov | b6b72f4 | 2017-05-03 14:56:31 -0700 | [diff] [blame] | 180 | static void print_track(struct kasan_track *track, const char *prefix) |
Alexander Potapenko | 7ed2f9e | 2016-03-25 14:21:59 -0700 | [diff] [blame] | 181 | { |
Andrey Konovalov | b6b72f4 | 2017-05-03 14:56:31 -0700 | [diff] [blame] | 182 | pr_err("%s by task %u:\n", prefix, track->pid); |
Alexander Potapenko | cd11016 | 2016-03-25 14:22:08 -0700 | [diff] [blame] | 183 | if (track->stack) { |
| 184 | struct stack_trace trace; |
| 185 | |
| 186 | depot_fetch_stack(track->stack, &trace); |
| 187 | print_stack_trace(&trace, 0); |
| 188 | } else { |
| 189 | pr_err("(stack is not available)\n"); |
| 190 | } |
Alexander Potapenko | 7ed2f9e | 2016-03-25 14:21:59 -0700 | [diff] [blame] | 191 | } |
| 192 | |
Andrey Konovalov | db429f1 | 2017-05-03 14:56:34 -0700 | [diff] [blame] | 193 | static struct page *addr_to_page(const void *addr) |
| 194 | { |
| 195 | if ((addr >= (void *)PAGE_OFFSET) && |
| 196 | (addr < high_memory)) |
| 197 | return virt_to_head_page(addr); |
| 198 | return NULL; |
| 199 | } |
| 200 | |
| 201 | static void describe_object(struct kmem_cache *cache, void *object) |
Alexander Potapenko | 7ed2f9e | 2016-03-25 14:21:59 -0700 | [diff] [blame] | 202 | { |
| 203 | struct kasan_alloc_meta *alloc_info = get_alloc_info(cache, object); |
Alexander Potapenko | 7ed2f9e | 2016-03-25 14:21:59 -0700 | [diff] [blame] | 204 | |
Andrey Ryabinin | 47b5c2a | 2016-08-02 14:02:49 -0700 | [diff] [blame] | 205 | pr_err("Object at %p, in cache %s size: %d\n", object, cache->name, |
| 206 | cache->object_size); |
| 207 | |
Alexander Potapenko | 7ed2f9e | 2016-03-25 14:21:59 -0700 | [diff] [blame] | 208 | if (!(cache->flags & SLAB_KASAN)) |
| 209 | return; |
Andrey Ryabinin | b3cbd9b | 2016-08-02 14:02:52 -0700 | [diff] [blame] | 210 | |
Andrey Konovalov | b6b72f4 | 2017-05-03 14:56:31 -0700 | [diff] [blame] | 211 | print_track(&alloc_info->alloc_track, "Allocated"); |
| 212 | print_track(&alloc_info->free_track, "Freed"); |
Alexander Potapenko | 7ed2f9e | 2016-03-25 14:21:59 -0700 | [diff] [blame] | 213 | } |
Alexander Potapenko | 7ed2f9e | 2016-03-25 14:21:59 -0700 | [diff] [blame] | 214 | |
Andrey Ryabinin | 7e08897 | 2016-08-02 14:02:55 -0700 | [diff] [blame] | 215 | void kasan_report_double_free(struct kmem_cache *cache, void *object, |
| 216 | s8 shadow) |
| 217 | { |
| 218 | unsigned long flags; |
| 219 | |
| 220 | kasan_start_report(&flags); |
| 221 | pr_err("BUG: Double free or freeing an invalid pointer\n"); |
| 222 | pr_err("Unexpected shadow byte: 0x%hhX\n", shadow); |
Andrey Konovalov | db429f1 | 2017-05-03 14:56:34 -0700 | [diff] [blame] | 223 | dump_stack(); |
| 224 | describe_object(cache, object); |
Andrey Ryabinin | 7e08897 | 2016-08-02 14:02:55 -0700 | [diff] [blame] | 225 | kasan_end_report(&flags); |
| 226 | } |
| 227 | |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 228 | static void print_address_description(struct kasan_access_info *info) |
| 229 | { |
Andrey Ryabinin | b8c73fc | 2015-02-13 14:39:28 -0800 | [diff] [blame] | 230 | const void *addr = info->access_addr; |
Andrey Konovalov | db429f1 | 2017-05-03 14:56:34 -0700 | [diff] [blame] | 231 | struct page *page = addr_to_page(addr); |
Andrey Ryabinin | b8c73fc | 2015-02-13 14:39:28 -0800 | [diff] [blame] | 232 | |
Andrey Konovalov | db429f1 | 2017-05-03 14:56:34 -0700 | [diff] [blame] | 233 | if (page) |
Andrey Ryabinin | b8c73fc | 2015-02-13 14:39:28 -0800 | [diff] [blame] | 234 | dump_page(page, "kasan: bad access detected"); |
Andrey Konovalov | db429f1 | 2017-05-03 14:56:34 -0700 | [diff] [blame] | 235 | |
| 236 | dump_stack(); |
| 237 | |
| 238 | if (page && PageSlab(page)) { |
| 239 | struct kmem_cache *cache = page->slab_cache; |
| 240 | void *object = nearest_obj(cache, page, (void *)addr); |
| 241 | |
| 242 | describe_object(cache, object); |
Andrey Ryabinin | b8c73fc | 2015-02-13 14:39:28 -0800 | [diff] [blame] | 243 | } |
| 244 | |
Andrey Ryabinin | bebf56a | 2015-02-13 14:40:17 -0800 | [diff] [blame] | 245 | if (kernel_or_module_addr(addr)) { |
| 246 | if (!init_task_stack_addr(addr)) |
| 247 | pr_err("Address belongs to variable %pS\n", addr); |
| 248 | } |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 249 | } |
| 250 | |
| 251 | static bool row_is_guilty(const void *row, const void *guilty) |
| 252 | { |
| 253 | return (row <= guilty) && (guilty < row + SHADOW_BYTES_PER_ROW); |
| 254 | } |
| 255 | |
| 256 | static int shadow_pointer_offset(const void *row, const void *shadow) |
| 257 | { |
| 258 | /* The length of ">ff00ff00ff00ff00: " is |
| 259 | * 3 + (BITS_PER_LONG/8)*2 chars. |
| 260 | */ |
| 261 | return 3 + (BITS_PER_LONG/8)*2 + (shadow - row)*2 + |
| 262 | (shadow - row) / SHADOW_BYTES_PER_BLOCK + 1; |
| 263 | } |
| 264 | |
| 265 | static void print_shadow_for_address(const void *addr) |
| 266 | { |
| 267 | int i; |
| 268 | const void *shadow = kasan_mem_to_shadow(addr); |
| 269 | const void *shadow_row; |
| 270 | |
| 271 | shadow_row = (void *)round_down((unsigned long)shadow, |
| 272 | SHADOW_BYTES_PER_ROW) |
| 273 | - SHADOW_ROWS_AROUND_ADDR * SHADOW_BYTES_PER_ROW; |
| 274 | |
| 275 | pr_err("Memory state around the buggy address:\n"); |
| 276 | |
| 277 | for (i = -SHADOW_ROWS_AROUND_ADDR; i <= SHADOW_ROWS_AROUND_ADDR; i++) { |
| 278 | const void *kaddr = kasan_shadow_to_mem(shadow_row); |
| 279 | char buffer[4 + (BITS_PER_LONG/8)*2]; |
Aneesh Kumar K.V | f2377d4 | 2015-11-05 18:50:48 -0800 | [diff] [blame] | 280 | char shadow_buf[SHADOW_BYTES_PER_ROW]; |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 281 | |
| 282 | snprintf(buffer, sizeof(buffer), |
| 283 | (i == 0) ? ">%p: " : " %p: ", kaddr); |
Aneesh Kumar K.V | f2377d4 | 2015-11-05 18:50:48 -0800 | [diff] [blame] | 284 | /* |
| 285 | * We should not pass a shadow pointer to generic |
| 286 | * function, because generic functions may try to |
| 287 | * access kasan mapping for the passed address. |
| 288 | */ |
Aneesh Kumar K.V | f2377d4 | 2015-11-05 18:50:48 -0800 | [diff] [blame] | 289 | memcpy(shadow_buf, shadow_row, SHADOW_BYTES_PER_ROW); |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 290 | print_hex_dump(KERN_ERR, buffer, |
| 291 | DUMP_PREFIX_NONE, SHADOW_BYTES_PER_ROW, 1, |
Aneesh Kumar K.V | f2377d4 | 2015-11-05 18:50:48 -0800 | [diff] [blame] | 292 | shadow_buf, SHADOW_BYTES_PER_ROW, 0); |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 293 | |
| 294 | if (row_is_guilty(shadow_row, shadow)) |
| 295 | pr_err("%*c\n", |
| 296 | shadow_pointer_offset(shadow_row, shadow), |
| 297 | '^'); |
| 298 | |
| 299 | shadow_row += SHADOW_BYTES_PER_ROW; |
| 300 | } |
| 301 | } |
| 302 | |
Andrey Konovalov | e9121076 | 2015-11-05 18:50:55 -0800 | [diff] [blame] | 303 | static void kasan_report_error(struct kasan_access_info *info) |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 304 | { |
| 305 | unsigned long flags; |
| 306 | |
Andrey Ryabinin | 7e08897 | 2016-08-02 14:02:55 -0700 | [diff] [blame] | 307 | kasan_start_report(&flags); |
| 308 | |
Andrey Konovalov | 7d418f7 | 2017-05-03 14:56:28 -0700 | [diff] [blame] | 309 | print_error_description(info); |
| 310 | |
Andrey Konovalov | 5e82cd1 | 2017-05-03 14:56:25 -0700 | [diff] [blame] | 311 | if (!addr_has_shadow(info)) { |
Andrey Konovalov | e9121076 | 2015-11-05 18:50:55 -0800 | [diff] [blame] | 312 | dump_stack(); |
| 313 | } else { |
Andrey Konovalov | e9121076 | 2015-11-05 18:50:55 -0800 | [diff] [blame] | 314 | print_address_description(info); |
| 315 | print_shadow_for_address(info->first_bad_addr); |
| 316 | } |
Andrey Ryabinin | 7e08897 | 2016-08-02 14:02:55 -0700 | [diff] [blame] | 317 | |
| 318 | kasan_end_report(&flags); |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 319 | } |
| 320 | |
Mark Rutland | b0845ce | 2017-03-31 15:12:04 -0700 | [diff] [blame] | 321 | static unsigned long kasan_flags; |
| 322 | |
| 323 | #define KASAN_BIT_REPORTED 0 |
| 324 | #define KASAN_BIT_MULTI_SHOT 1 |
| 325 | |
| 326 | bool kasan_save_enable_multi_shot(void) |
| 327 | { |
| 328 | return test_and_set_bit(KASAN_BIT_MULTI_SHOT, &kasan_flags); |
| 329 | } |
| 330 | EXPORT_SYMBOL_GPL(kasan_save_enable_multi_shot); |
| 331 | |
| 332 | void kasan_restore_multi_shot(bool enabled) |
| 333 | { |
| 334 | if (!enabled) |
| 335 | clear_bit(KASAN_BIT_MULTI_SHOT, &kasan_flags); |
| 336 | } |
| 337 | EXPORT_SYMBOL_GPL(kasan_restore_multi_shot); |
| 338 | |
| 339 | static int __init kasan_set_multi_shot(char *str) |
| 340 | { |
| 341 | set_bit(KASAN_BIT_MULTI_SHOT, &kasan_flags); |
| 342 | return 1; |
| 343 | } |
| 344 | __setup("kasan_multi_shot", kasan_set_multi_shot); |
| 345 | |
| 346 | static inline bool kasan_report_enabled(void) |
| 347 | { |
| 348 | if (current->kasan_depth) |
| 349 | return false; |
| 350 | if (test_bit(KASAN_BIT_MULTI_SHOT, &kasan_flags)) |
| 351 | return true; |
| 352 | return !test_and_set_bit(KASAN_BIT_REPORTED, &kasan_flags); |
| 353 | } |
| 354 | |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 355 | void kasan_report(unsigned long addr, size_t size, |
| 356 | bool is_write, unsigned long ip) |
| 357 | { |
| 358 | struct kasan_access_info info; |
| 359 | |
Aneesh Kumar K.V | 0ba8663 | 2015-11-05 18:50:43 -0800 | [diff] [blame] | 360 | if (likely(!kasan_report_enabled())) |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 361 | return; |
| 362 | |
Peter Zijlstra | 4f40c6e | 2017-02-03 13:13:12 -0800 | [diff] [blame] | 363 | disable_trace_on_warning(); |
| 364 | |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 365 | info.access_addr = (void *)addr; |
| 366 | info.access_size = size; |
| 367 | info.is_write = is_write; |
| 368 | info.ip = ip; |
Andrey Konovalov | e9121076 | 2015-11-05 18:50:55 -0800 | [diff] [blame] | 369 | |
Andrey Ryabinin | 0b24bec | 2015-02-13 14:39:17 -0800 | [diff] [blame] | 370 | kasan_report_error(&info); |
| 371 | } |
| 372 | |
| 373 | |
| 374 | #define DEFINE_ASAN_REPORT_LOAD(size) \ |
| 375 | void __asan_report_load##size##_noabort(unsigned long addr) \ |
| 376 | { \ |
| 377 | kasan_report(addr, size, false, _RET_IP_); \ |
| 378 | } \ |
| 379 | EXPORT_SYMBOL(__asan_report_load##size##_noabort) |
| 380 | |
| 381 | #define DEFINE_ASAN_REPORT_STORE(size) \ |
| 382 | void __asan_report_store##size##_noabort(unsigned long addr) \ |
| 383 | { \ |
| 384 | kasan_report(addr, size, true, _RET_IP_); \ |
| 385 | } \ |
| 386 | EXPORT_SYMBOL(__asan_report_store##size##_noabort) |
| 387 | |
| 388 | DEFINE_ASAN_REPORT_LOAD(1); |
| 389 | DEFINE_ASAN_REPORT_LOAD(2); |
| 390 | DEFINE_ASAN_REPORT_LOAD(4); |
| 391 | DEFINE_ASAN_REPORT_LOAD(8); |
| 392 | DEFINE_ASAN_REPORT_LOAD(16); |
| 393 | DEFINE_ASAN_REPORT_STORE(1); |
| 394 | DEFINE_ASAN_REPORT_STORE(2); |
| 395 | DEFINE_ASAN_REPORT_STORE(4); |
| 396 | DEFINE_ASAN_REPORT_STORE(8); |
| 397 | DEFINE_ASAN_REPORT_STORE(16); |
| 398 | |
| 399 | void __asan_report_load_n_noabort(unsigned long addr, size_t size) |
| 400 | { |
| 401 | kasan_report(addr, size, false, _RET_IP_); |
| 402 | } |
| 403 | EXPORT_SYMBOL(__asan_report_load_n_noabort); |
| 404 | |
| 405 | void __asan_report_store_n_noabort(unsigned long addr, size_t size) |
| 406 | { |
| 407 | kasan_report(addr, size, true, _RET_IP_); |
| 408 | } |
| 409 | EXPORT_SYMBOL(__asan_report_store_n_noabort); |