GNU Linux-libre 4.19.264-gnu1
[releases.git] / arch / arm / kernel / kgdb.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * arch/arm/kernel/kgdb.c
4  *
5  * ARM KGDB support
6  *
7  * Copyright (c) 2002-2004 MontaVista Software, Inc
8  * Copyright (c) 2008 Wind River Systems, Inc.
9  *
10  * Authors:  George Davis <davis_g@mvista.com>
11  *           Deepak Saxena <dsaxena@plexity.net>
12  */
13 #include <linux/irq.h>
14 #include <linux/kdebug.h>
15 #include <linux/kgdb.h>
16 #include <linux/uaccess.h>
17
18 #include <asm/patch.h>
19 #include <asm/traps.h>
20
21 struct dbg_reg_def_t dbg_reg_def[DBG_MAX_REG_NUM] =
22 {
23         { "r0", 4, offsetof(struct pt_regs, ARM_r0)},
24         { "r1", 4, offsetof(struct pt_regs, ARM_r1)},
25         { "r2", 4, offsetof(struct pt_regs, ARM_r2)},
26         { "r3", 4, offsetof(struct pt_regs, ARM_r3)},
27         { "r4", 4, offsetof(struct pt_regs, ARM_r4)},
28         { "r5", 4, offsetof(struct pt_regs, ARM_r5)},
29         { "r6", 4, offsetof(struct pt_regs, ARM_r6)},
30         { "r7", 4, offsetof(struct pt_regs, ARM_r7)},
31         { "r8", 4, offsetof(struct pt_regs, ARM_r8)},
32         { "r9", 4, offsetof(struct pt_regs, ARM_r9)},
33         { "r10", 4, offsetof(struct pt_regs, ARM_r10)},
34         { "fp", 4, offsetof(struct pt_regs, ARM_fp)},
35         { "ip", 4, offsetof(struct pt_regs, ARM_ip)},
36         { "sp", 4, offsetof(struct pt_regs, ARM_sp)},
37         { "lr", 4, offsetof(struct pt_regs, ARM_lr)},
38         { "pc", 4, offsetof(struct pt_regs, ARM_pc)},
39         { "f0", 12, -1 },
40         { "f1", 12, -1 },
41         { "f2", 12, -1 },
42         { "f3", 12, -1 },
43         { "f4", 12, -1 },
44         { "f5", 12, -1 },
45         { "f6", 12, -1 },
46         { "f7", 12, -1 },
47         { "fps", 4, -1 },
48         { "cpsr", 4, offsetof(struct pt_regs, ARM_cpsr)},
49 };
50
51 char *dbg_get_reg(int regno, void *mem, struct pt_regs *regs)
52 {
53         if (regno >= DBG_MAX_REG_NUM || regno < 0)
54                 return NULL;
55
56         if (dbg_reg_def[regno].offset != -1)
57                 memcpy(mem, (void *)regs + dbg_reg_def[regno].offset,
58                        dbg_reg_def[regno].size);
59         else
60                 memset(mem, 0, dbg_reg_def[regno].size);
61         return dbg_reg_def[regno].name;
62 }
63
64 int dbg_set_reg(int regno, void *mem, struct pt_regs *regs)
65 {
66         if (regno >= DBG_MAX_REG_NUM || regno < 0)
67                 return -EINVAL;
68
69         if (dbg_reg_def[regno].offset != -1)
70                 memcpy((void *)regs + dbg_reg_def[regno].offset, mem,
71                        dbg_reg_def[regno].size);
72         return 0;
73 }
74
75 void
76 sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *task)
77 {
78         struct thread_info *ti;
79         int regno;
80
81         /* Just making sure... */
82         if (task == NULL)
83                 return;
84
85         /* Initialize to zero */
86         for (regno = 0; regno < GDB_MAX_REGS; regno++)
87                 gdb_regs[regno] = 0;
88
89         /* Otherwise, we have only some registers from switch_to() */
90         ti                      = task_thread_info(task);
91         gdb_regs[_R4]           = ti->cpu_context.r4;
92         gdb_regs[_R5]           = ti->cpu_context.r5;
93         gdb_regs[_R6]           = ti->cpu_context.r6;
94         gdb_regs[_R7]           = ti->cpu_context.r7;
95         gdb_regs[_R8]           = ti->cpu_context.r8;
96         gdb_regs[_R9]           = ti->cpu_context.r9;
97         gdb_regs[_R10]          = ti->cpu_context.sl;
98         gdb_regs[_FP]           = ti->cpu_context.fp;
99         gdb_regs[_SPT]          = ti->cpu_context.sp;
100         gdb_regs[_PC]           = ti->cpu_context.pc;
101 }
102
103 void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc)
104 {
105         regs->ARM_pc = pc;
106 }
107
108 static int compiled_break;
109
110 int kgdb_arch_handle_exception(int exception_vector, int signo,
111                                int err_code, char *remcom_in_buffer,
112                                char *remcom_out_buffer,
113                                struct pt_regs *linux_regs)
114 {
115         unsigned long addr;
116         char *ptr;
117
118         switch (remcom_in_buffer[0]) {
119         case 'D':
120         case 'k':
121         case 'c':
122                 /*
123                  * Try to read optional parameter, pc unchanged if no parm.
124                  * If this was a compiled breakpoint, we need to move
125                  * to the next instruction or we will just breakpoint
126                  * over and over again.
127                  */
128                 ptr = &remcom_in_buffer[1];
129                 if (kgdb_hex2long(&ptr, &addr))
130                         linux_regs->ARM_pc = addr;
131                 else if (compiled_break == 1)
132                         linux_regs->ARM_pc += 4;
133
134                 compiled_break = 0;
135
136                 return 0;
137         }
138
139         return -1;
140 }
141
142 static int kgdb_brk_fn(struct pt_regs *regs, unsigned int instr)
143 {
144         kgdb_handle_exception(1, SIGTRAP, 0, regs);
145
146         return 0;
147 }
148
149 static int kgdb_compiled_brk_fn(struct pt_regs *regs, unsigned int instr)
150 {
151         compiled_break = 1;
152         kgdb_handle_exception(1, SIGTRAP, 0, regs);
153
154         return 0;
155 }
156
157 static struct undef_hook kgdb_brkpt_hook = {
158         .instr_mask             = 0xffffffff,
159         .instr_val              = KGDB_BREAKINST,
160         .cpsr_mask              = MODE_MASK,
161         .cpsr_val               = SVC_MODE,
162         .fn                     = kgdb_brk_fn
163 };
164
165 static struct undef_hook kgdb_compiled_brkpt_hook = {
166         .instr_mask             = 0xffffffff,
167         .instr_val              = KGDB_COMPILED_BREAK,
168         .cpsr_mask              = MODE_MASK,
169         .cpsr_val               = SVC_MODE,
170         .fn                     = kgdb_compiled_brk_fn
171 };
172
173 static void kgdb_call_nmi_hook(void *ignored)
174 {
175        kgdb_nmicallback(raw_smp_processor_id(), get_irq_regs());
176 }
177
178 void kgdb_roundup_cpus(unsigned long flags)
179 {
180        local_irq_enable();
181        smp_call_function(kgdb_call_nmi_hook, NULL, 0);
182        local_irq_disable();
183 }
184
185 static int __kgdb_notify(struct die_args *args, unsigned long cmd)
186 {
187         struct pt_regs *regs = args->regs;
188
189         if (kgdb_handle_exception(1, args->signr, cmd, regs))
190                 return NOTIFY_DONE;
191         return NOTIFY_STOP;
192 }
193 static int
194 kgdb_notify(struct notifier_block *self, unsigned long cmd, void *ptr)
195 {
196         unsigned long flags;
197         int ret;
198
199         local_irq_save(flags);
200         ret = __kgdb_notify(ptr, cmd);
201         local_irq_restore(flags);
202
203         return ret;
204 }
205
206 static struct notifier_block kgdb_notifier = {
207         .notifier_call  = kgdb_notify,
208         .priority       = -INT_MAX,
209 };
210
211
212 /**
213  *      kgdb_arch_init - Perform any architecture specific initalization.
214  *
215  *      This function will handle the initalization of any architecture
216  *      specific callbacks.
217  */
218 int kgdb_arch_init(void)
219 {
220         int ret = register_die_notifier(&kgdb_notifier);
221
222         if (ret != 0)
223                 return ret;
224
225         register_undef_hook(&kgdb_brkpt_hook);
226         register_undef_hook(&kgdb_compiled_brkpt_hook);
227
228         return 0;
229 }
230
231 /**
232  *      kgdb_arch_exit - Perform any architecture specific uninitalization.
233  *
234  *      This function will handle the uninitalization of any architecture
235  *      specific callbacks, for dynamic registration and unregistration.
236  */
237 void kgdb_arch_exit(void)
238 {
239         unregister_undef_hook(&kgdb_brkpt_hook);
240         unregister_undef_hook(&kgdb_compiled_brkpt_hook);
241         unregister_die_notifier(&kgdb_notifier);
242 }
243
244 int kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)
245 {
246         int err;
247
248         /* patch_text() only supports int-sized breakpoints */
249         BUILD_BUG_ON(sizeof(int) != BREAK_INSTR_SIZE);
250
251         err = probe_kernel_read(bpt->saved_instr, (char *)bpt->bpt_addr,
252                                 BREAK_INSTR_SIZE);
253         if (err)
254                 return err;
255
256         /* Machine is already stopped, so we can use __patch_text() directly */
257         __patch_text((void *)bpt->bpt_addr,
258                      *(unsigned int *)arch_kgdb_ops.gdb_bpt_instr);
259
260         return err;
261 }
262
263 int kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)
264 {
265         /* Machine is already stopped, so we can use __patch_text() directly */
266         __patch_text((void *)bpt->bpt_addr, *(unsigned int *)bpt->saved_instr);
267
268         return 0;
269 }
270
271 /*
272  * Register our undef instruction hooks with ARM undef core.
273  * We register a hook specifically looking for the KGB break inst
274  * and we handle the normal undef case within the do_undefinstr
275  * handler.
276  */
277 struct kgdb_arch arch_kgdb_ops = {
278 #ifndef __ARMEB__
279         .gdb_bpt_instr          = {0xfe, 0xde, 0xff, 0xe7}
280 #else /* ! __ARMEB__ */
281         .gdb_bpt_instr          = {0xe7, 0xff, 0xde, 0xfe}
282 #endif
283 };