1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/interrupt.h>
3 #include <linux/kdebug.h>
4 #include <linux/kmemcheck.h>
5 #include <linux/kernel.h>
6 #include <linux/types.h>
7 #include <linux/ptrace.h>
8 #include <linux/stacktrace.h>
9 #include <linux/string.h>
14 enum kmemcheck_error_type {
15 KMEMCHECK_ERROR_INVALID_ACCESS,
19 #define SHADOW_COPY_SIZE (1 << CONFIG_KMEMCHECK_SHADOW_COPY_SHIFT)
21 struct kmemcheck_error {
22 enum kmemcheck_error_type type;
25 /* KMEMCHECK_ERROR_INVALID_ACCESS */
27 /* Kind of access that caused the error */
28 enum kmemcheck_shadow state;
29 /* Address and size of the erroneous read */
30 unsigned long address;
36 struct stack_trace trace;
37 unsigned long trace_entries[32];
39 /* We compress it to a char. */
40 unsigned char shadow_copy[SHADOW_COPY_SIZE];
41 unsigned char memory_copy[SHADOW_COPY_SIZE];
45 * Create a ring queue of errors to output. We can't call printk() directly
46 * from the kmemcheck traps, since this may call the console drivers and
47 * result in a recursive fault.
49 static struct kmemcheck_error error_fifo[CONFIG_KMEMCHECK_QUEUE_SIZE];
50 static unsigned int error_count;
51 static unsigned int error_rd;
52 static unsigned int error_wr;
53 static unsigned int error_missed_count;
55 static struct kmemcheck_error *error_next_wr(void)
57 struct kmemcheck_error *e;
59 if (error_count == ARRAY_SIZE(error_fifo)) {
64 e = &error_fifo[error_wr];
65 if (++error_wr == ARRAY_SIZE(error_fifo))
71 static struct kmemcheck_error *error_next_rd(void)
73 struct kmemcheck_error *e;
78 e = &error_fifo[error_rd];
79 if (++error_rd == ARRAY_SIZE(error_fifo))
85 void kmemcheck_error_recall(void)
87 static const char *desc[] = {
88 [KMEMCHECK_SHADOW_UNALLOCATED] = "unallocated",
89 [KMEMCHECK_SHADOW_UNINITIALIZED] = "uninitialized",
90 [KMEMCHECK_SHADOW_INITIALIZED] = "initialized",
91 [KMEMCHECK_SHADOW_FREED] = "freed",
94 static const char short_desc[] = {
95 [KMEMCHECK_SHADOW_UNALLOCATED] = 'a',
96 [KMEMCHECK_SHADOW_UNINITIALIZED] = 'u',
97 [KMEMCHECK_SHADOW_INITIALIZED] = 'i',
98 [KMEMCHECK_SHADOW_FREED] = 'f',
101 struct kmemcheck_error *e;
109 case KMEMCHECK_ERROR_INVALID_ACCESS:
110 printk(KERN_WARNING "WARNING: kmemcheck: Caught %d-bit read from %s memory (%p)\n",
111 8 * e->size, e->state < ARRAY_SIZE(desc) ?
112 desc[e->state] : "(invalid shadow state)",
113 (void *) e->address);
115 printk(KERN_WARNING);
116 for (i = 0; i < SHADOW_COPY_SIZE; ++i)
117 printk(KERN_CONT "%02x", e->memory_copy[i]);
118 printk(KERN_CONT "\n");
120 printk(KERN_WARNING);
121 for (i = 0; i < SHADOW_COPY_SIZE; ++i) {
122 if (e->shadow_copy[i] < ARRAY_SIZE(short_desc))
123 printk(KERN_CONT " %c", short_desc[e->shadow_copy[i]]);
125 printk(KERN_CONT " ?");
127 printk(KERN_CONT "\n");
128 printk(KERN_WARNING "%*c\n", 2 + 2
129 * (int) (e->address & (SHADOW_COPY_SIZE - 1)), '^');
131 case KMEMCHECK_ERROR_BUG:
132 printk(KERN_EMERG "ERROR: kmemcheck: Fatal error\n");
136 __show_regs(&e->regs, 1);
137 print_stack_trace(&e->trace, 0);
140 static void do_wakeup(unsigned long data)
142 while (error_count > 0)
143 kmemcheck_error_recall();
145 if (error_missed_count > 0) {
146 printk(KERN_WARNING "kmemcheck: Lost %d error reports because "
147 "the queue was too small\n", error_missed_count);
148 error_missed_count = 0;
152 static DECLARE_TASKLET(kmemcheck_tasklet, &do_wakeup, 0);
155 * Save the context of an error report.
157 void kmemcheck_error_save(enum kmemcheck_shadow state,
158 unsigned long address, unsigned int size, struct pt_regs *regs)
160 static unsigned long prev_ip;
162 struct kmemcheck_error *e;
166 /* Don't report several adjacent errors from the same EIP. */
167 if (regs->ip == prev_ip)
175 e->type = KMEMCHECK_ERROR_INVALID_ACCESS;
178 e->address = address;
182 memcpy(&e->regs, regs, sizeof(*regs));
184 /* Save stack trace */
185 e->trace.nr_entries = 0;
186 e->trace.entries = e->trace_entries;
187 e->trace.max_entries = ARRAY_SIZE(e->trace_entries);
189 save_stack_trace_regs(regs, &e->trace);
191 /* Round address down to nearest 16 bytes */
192 shadow_copy = kmemcheck_shadow_lookup(address
193 & ~(SHADOW_COPY_SIZE - 1));
194 BUG_ON(!shadow_copy);
196 memcpy(e->shadow_copy, shadow_copy, SHADOW_COPY_SIZE);
198 kmemcheck_show_addr(address);
199 memory_copy = (void *) (address & ~(SHADOW_COPY_SIZE - 1));
200 memcpy(e->memory_copy, memory_copy, SHADOW_COPY_SIZE);
201 kmemcheck_hide_addr(address);
203 tasklet_hi_schedule_first(&kmemcheck_tasklet);
207 * Save the context of a kmemcheck bug.
209 void kmemcheck_error_save_bug(struct pt_regs *regs)
211 struct kmemcheck_error *e;
217 e->type = KMEMCHECK_ERROR_BUG;
219 memcpy(&e->regs, regs, sizeof(*regs));
221 e->trace.nr_entries = 0;
222 e->trace.entries = e->trace_entries;
223 e->trace.max_entries = ARRAY_SIZE(e->trace_entries);
225 save_stack_trace(&e->trace);
227 tasklet_hi_schedule_first(&kmemcheck_tasklet);