kgdb.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * arch/hexagon/kernel/kgdb.c - Hexagon KGDB Support
  4 *
  5 * Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
  6 */
  7
  8#include <linux/irq.h>
  9#include <linux/sched.h>
 10#include <linux/sched/task_stack.h>
 11#include <linux/kdebug.h>
 12#include <linux/kgdb.h>
 13
 14/* All registers are 4 bytes, for now */
 15#define GDB_SIZEOF_REG 4
 16
 17/* The register names are used during printing of the regs;
 18 * Keep these at three letters to pretty-print. */
 19struct dbg_reg_def_t dbg_reg_def[DBG_MAX_REG_NUM] = {
 20	{ " r0", GDB_SIZEOF_REG, offsetof(struct pt_regs, r00)},
 21	{ " r1", GDB_SIZEOF_REG, offsetof(struct pt_regs, r01)},
 22	{ " r2", GDB_SIZEOF_REG, offsetof(struct pt_regs, r02)},
 23	{ " r3", GDB_SIZEOF_REG, offsetof(struct pt_regs, r03)},
 24	{ " r4", GDB_SIZEOF_REG, offsetof(struct pt_regs, r04)},
 25	{ " r5", GDB_SIZEOF_REG, offsetof(struct pt_regs, r05)},
 26	{ " r6", GDB_SIZEOF_REG, offsetof(struct pt_regs, r06)},
 27	{ " r7", GDB_SIZEOF_REG, offsetof(struct pt_regs, r07)},
 28	{ " r8", GDB_SIZEOF_REG, offsetof(struct pt_regs, r08)},
 29	{ " r9", GDB_SIZEOF_REG, offsetof(struct pt_regs, r09)},
 30	{ "r10", GDB_SIZEOF_REG, offsetof(struct pt_regs, r10)},
 31	{ "r11", GDB_SIZEOF_REG, offsetof(struct pt_regs, r11)},
 32	{ "r12", GDB_SIZEOF_REG, offsetof(struct pt_regs, r12)},
 33	{ "r13", GDB_SIZEOF_REG, offsetof(struct pt_regs, r13)},
 34	{ "r14", GDB_SIZEOF_REG, offsetof(struct pt_regs, r14)},
 35	{ "r15", GDB_SIZEOF_REG, offsetof(struct pt_regs, r15)},
 36	{ "r16", GDB_SIZEOF_REG, offsetof(struct pt_regs, r16)},
 37	{ "r17", GDB_SIZEOF_REG, offsetof(struct pt_regs, r17)},
 38	{ "r18", GDB_SIZEOF_REG, offsetof(struct pt_regs, r18)},
 39	{ "r19", GDB_SIZEOF_REG, offsetof(struct pt_regs, r19)},
 40	{ "r20", GDB_SIZEOF_REG, offsetof(struct pt_regs, r20)},
 41	{ "r21", GDB_SIZEOF_REG, offsetof(struct pt_regs, r21)},
 42	{ "r22", GDB_SIZEOF_REG, offsetof(struct pt_regs, r22)},
 43	{ "r23", GDB_SIZEOF_REG, offsetof(struct pt_regs, r23)},
 44	{ "r24", GDB_SIZEOF_REG, offsetof(struct pt_regs, r24)},
 45	{ "r25", GDB_SIZEOF_REG, offsetof(struct pt_regs, r25)},
 46	{ "r26", GDB_SIZEOF_REG, offsetof(struct pt_regs, r26)},
 47	{ "r27", GDB_SIZEOF_REG, offsetof(struct pt_regs, r27)},
 48	{ "r28", GDB_SIZEOF_REG, offsetof(struct pt_regs, r28)},
 49	{ "r29", GDB_SIZEOF_REG, offsetof(struct pt_regs, r29)},
 50	{ "r30", GDB_SIZEOF_REG, offsetof(struct pt_regs, r30)},
 51	{ "r31", GDB_SIZEOF_REG, offsetof(struct pt_regs, r31)},
 52
 53	{ "usr", GDB_SIZEOF_REG, offsetof(struct pt_regs, usr)},
 54	{ "preds", GDB_SIZEOF_REG, offsetof(struct pt_regs, preds)},
 55	{ " m0", GDB_SIZEOF_REG, offsetof(struct pt_regs, m0)},
 56	{ " m1", GDB_SIZEOF_REG, offsetof(struct pt_regs, m1)},
 57	{ "sa0", GDB_SIZEOF_REG, offsetof(struct pt_regs, sa0)},
 58	{ "sa1", GDB_SIZEOF_REG, offsetof(struct pt_regs, sa1)},
 59	{ "lc0", GDB_SIZEOF_REG, offsetof(struct pt_regs, lc0)},
 60	{ "lc1", GDB_SIZEOF_REG, offsetof(struct pt_regs, lc1)},
 61	{ " gp", GDB_SIZEOF_REG, offsetof(struct pt_regs, gp)},
 62	{ "ugp", GDB_SIZEOF_REG, offsetof(struct pt_regs, ugp)},
 63	{ "cs0", GDB_SIZEOF_REG, offsetof(struct pt_regs, cs0)},
 64	{ "cs1", GDB_SIZEOF_REG, offsetof(struct pt_regs, cs1)},
 65	{ "psp", GDB_SIZEOF_REG, offsetof(struct pt_regs, hvmer.vmpsp)},
 66	{ "elr", GDB_SIZEOF_REG, offsetof(struct pt_regs, hvmer.vmel)},
 67	{ "est", GDB_SIZEOF_REG, offsetof(struct pt_regs, hvmer.vmest)},
 68	{ "badva", GDB_SIZEOF_REG, offsetof(struct pt_regs, hvmer.vmbadva)},
 69	{ "restart_r0", GDB_SIZEOF_REG, offsetof(struct pt_regs, restart_r0)},
 70	{ "syscall_nr", GDB_SIZEOF_REG, offsetof(struct pt_regs, syscall_nr)},
 71};
 72
 73const struct kgdb_arch arch_kgdb_ops = {
 74	/* trap0(#0xDB) 0x0cdb0054 */
 75	.gdb_bpt_instr = {0x54, 0x00, 0xdb, 0x0c},
 76};
 77
 78char *dbg_get_reg(int regno, void *mem, struct pt_regs *regs)
 79{
 80	if (regno >= DBG_MAX_REG_NUM || regno < 0)
 81		return NULL;
 82
 83	*((unsigned long *) mem) = *((unsigned long *) ((void *)regs +
 84		dbg_reg_def[regno].offset));
 85
 86	return dbg_reg_def[regno].name;
 87}
 88
 89int dbg_set_reg(int regno, void *mem, struct pt_regs *regs)
 90{
 91	if (regno >= DBG_MAX_REG_NUM || regno < 0)
 92		return -EINVAL;
 93
 94	*((unsigned long *) ((void *)regs + dbg_reg_def[regno].offset)) =
 95		*((unsigned long *) mem);
 96
 97	return 0;
 98}
 99
100void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc)
101{
102	instruction_pointer(regs) = pc;
103}
104
105
106/*  Not yet working  */
107void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs,
108				 struct task_struct *task)
109{
110	struct pt_regs *thread_regs;
111
112	if (task == NULL)
113		return;
114
115	/* Initialize to zero */
116	memset(gdb_regs, 0, NUMREGBYTES);
117
118	/* Otherwise, we have only some registers from switch_to() */
119	thread_regs = task_pt_regs(task);
120	gdb_regs[0] = thread_regs->r00;
121}
122
123/**
124 * kgdb_arch_handle_exception - Handle architecture specific GDB packets.
125 * @vector: The error vector of the exception that happened.
126 * @signo: The signal number of the exception that happened.
127 * @err_code: The error code of the exception that happened.
128 * @remcom_in_buffer: The buffer of the packet we have read.
129 * @remcom_out_buffer: The buffer of %BUFMAX bytes to write a packet into.
130 * @regs: The &struct pt_regs of the current process.
131 *
132 * This function MUST handle the 'c' and 's' command packets,
133 * as well packets to set / remove a hardware breakpoint, if used.
134 * If there are additional packets which the hardware needs to handle,
135 * they are handled here.  The code should return -1 if it wants to
136 * process more packets, and a %0 or %1 if it wants to exit from the
137 * kgdb callback.
138 *
139 * Not yet working.
140 */
141int kgdb_arch_handle_exception(int vector, int signo, int err_code,
142			       char *remcom_in_buffer, char *remcom_out_buffer,
143			       struct pt_regs *linux_regs)
144{
145	switch (remcom_in_buffer[0]) {
146	case 's':
147	case 'c':
148		return 0;
149	}
150	/* Stay in the debugger. */
151	return -1;
152}
153
154static int __kgdb_notify(struct die_args *args, unsigned long cmd)
155{
156	/* cpu roundup */
157	if (atomic_read(&kgdb_active) != -1) {
158		kgdb_nmicallback(smp_processor_id(), args->regs);
159		return NOTIFY_STOP;
160	}
161
162	if (user_mode(args->regs))
163		return NOTIFY_DONE;
164
165	if (kgdb_handle_exception(args->trapnr & 0xff, args->signr, args->err,
166				    args->regs))
167		return NOTIFY_DONE;
168
169	return NOTIFY_STOP;
170}
171
172static int
173kgdb_notify(struct notifier_block *self, unsigned long cmd, void *ptr)
174{
175	unsigned long flags;
176	int ret;
177
178	local_irq_save(flags);
179	ret = __kgdb_notify(ptr, cmd);
180	local_irq_restore(flags);
181
182	return ret;
183}
184
185static struct notifier_block kgdb_notifier = {
186	.notifier_call = kgdb_notify,
187
188	/*
189	 * Lowest-prio notifier priority, we want to be notified last:
190	 */
191	.priority = -INT_MAX,
192};
193
194/**
195 * kgdb_arch_init - Perform any architecture specific initialization.
196 *
197 * This function will handle the initialization of any architecture
198 * specific callbacks.
199 */
200int kgdb_arch_init(void)
201{
202	return register_die_notifier(&kgdb_notifier);
203}
204
205/**
206 * kgdb_arch_exit - Perform any architecture specific uninitalization.
207 *
208 * This function will handle the uninitalization of any architecture
209 * specific callbacks, for dynamic registration and unregistration.
210 */
211void kgdb_arch_exit(void)
212{
213	unregister_die_notifier(&kgdb_notifier);
214}