~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/arm/kernel/kgdb.c

Version: ~ [ linux-5.18-rc6 ] ~ [ linux-5.17.6 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.38 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.114 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.192 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.241 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.277 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.312 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp