1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * PA-RISC KGDB support
  4 *
  5 * Copyright (c) 2019 Sven Schnelle <svens@stackframe.org>
  6 *
  7 */
  8
  9#include <linux/kgdb.h>
 10#include <linux/string.h>
 11#include <linux/sched.h>
 12#include <linux/notifier.h>
 13#include <linux/kdebug.h>
 14#include <linux/uaccess.h>
 15#include <asm/ptrace.h>
 16#include <asm/traps.h>
 17#include <asm/processor.h>
 18#include <asm/patch.h>
 19#include <asm/cacheflush.h>
 20
 21const struct kgdb_arch arch_kgdb_ops = {
 22	.gdb_bpt_instr = { 0x03, 0xff, 0xa0, 0x1f }
 23};
 24
 25static int __kgdb_notify(struct die_args *args, unsigned long cmd)
 26{
 27	struct pt_regs *regs = args->regs;
 28
 29	if (kgdb_handle_exception(1, args->signr, cmd, regs))
 30		return NOTIFY_DONE;
 31	return NOTIFY_STOP;
 32}
 33
 34static int kgdb_notify(struct notifier_block *self,
 35		       unsigned long cmd, void *ptr)
 36{
 37	unsigned long flags;
 38	int ret;
 39
 40	local_irq_save(flags);
 41	ret = __kgdb_notify(ptr, cmd);
 42	local_irq_restore(flags);
 43
 44	return ret;
 45}
 46
 47static struct notifier_block kgdb_notifier = {
 48	.notifier_call	= kgdb_notify,
 49	.priority	= -INT_MAX,
 50};
 51
 52int kgdb_arch_init(void)
 53{
 54	return register_die_notifier(&kgdb_notifier);
 55}
 56
 57void kgdb_arch_exit(void)
 58{
 59	unregister_die_notifier(&kgdb_notifier);
 60}
 61
 62void pt_regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *regs)
 63{
 64	struct parisc_gdb_regs *gr = (struct parisc_gdb_regs *)gdb_regs;
 65
 66	memset(gr, 0, sizeof(struct parisc_gdb_regs));
 67
 68	memcpy(gr->gpr, regs->gr, sizeof(gr->gpr));
 69	memcpy(gr->fr, regs->fr, sizeof(gr->fr));
 70
 71	gr->sr0 = regs->sr[0];
 72	gr->sr1 = regs->sr[1];
 73	gr->sr2 = regs->sr[2];
 74	gr->sr3 = regs->sr[3];
 75	gr->sr4 = regs->sr[4];
 76	gr->sr5 = regs->sr[5];
 77	gr->sr6 = regs->sr[6];
 78	gr->sr7 = regs->sr[7];
 79
 80	gr->sar = regs->sar;
 81	gr->iir = regs->iir;
 82	gr->isr = regs->isr;
 83	gr->ior = regs->ior;
 84	gr->ipsw = regs->ipsw;
 85	gr->cr27 = regs->cr27;
 86
 87	gr->iaoq_f = regs->iaoq[0];
 88	gr->iasq_f = regs->iasq[0];
 89
 90	gr->iaoq_b = regs->iaoq[1];
 91	gr->iasq_b = regs->iasq[1];
 92}
 93
 94void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *regs)
 95{
 96	struct parisc_gdb_regs *gr = (struct parisc_gdb_regs *)gdb_regs;
 97
 98
 99	memcpy(regs->gr, gr->gpr, sizeof(regs->gr));
100	memcpy(regs->fr, gr->fr, sizeof(regs->fr));
101
102	regs->sr[0] = gr->sr0;
103	regs->sr[1] = gr->sr1;
104	regs->sr[2] = gr->sr2;
105	regs->sr[3] = gr->sr3;
106	regs->sr[4] = gr->sr4;
107	regs->sr[5] = gr->sr5;
108	regs->sr[6] = gr->sr6;
109	regs->sr[7] = gr->sr7;
110
111	regs->sar = gr->sar;
112	regs->iir = gr->iir;
113	regs->isr = gr->isr;
114	regs->ior = gr->ior;
115	regs->ipsw = gr->ipsw;
116	regs->cr27 = gr->cr27;
117
118	regs->iaoq[0] = gr->iaoq_f;
119	regs->iasq[0] = gr->iasq_f;
120
121	regs->iaoq[1] = gr->iaoq_b;
122	regs->iasq[1] = gr->iasq_b;
123}
124
125void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs,
126				struct task_struct *task)
127{
128	struct pt_regs *regs = task_pt_regs(task);
129	unsigned long gr30, iaoq;
130
131	gr30 = regs->gr[30];
132	iaoq = regs->iaoq[0];
133
134	regs->gr[30] = regs->ksp;
135	regs->iaoq[0] = regs->kpc;
136	pt_regs_to_gdb_regs(gdb_regs, regs);
137
138	regs->gr[30] = gr30;
139	regs->iaoq[0] = iaoq;
140
141}
142
143static void step_instruction_queue(struct pt_regs *regs)
144{
145	regs->iaoq[0] = regs->iaoq[1];
146	regs->iaoq[1] += 4;
147}
148
149void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long ip)
150{
151	regs->iaoq[0] = ip;
152	regs->iaoq[1] = ip + 4;
153}
154
155int kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)
156{
157	int ret = probe_kernel_read(bpt->saved_instr, (char *)bpt->bpt_addr,
158				BREAK_INSTR_SIZE);
159	if (ret)
160		return ret;
161
162	__patch_text((void *)bpt->bpt_addr,
163			*(unsigned int *)&arch_kgdb_ops.gdb_bpt_instr);
164	return ret;
165}
166
167int kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)
168{
169	__patch_text((void *)bpt->bpt_addr, *(unsigned int *)&bpt->saved_instr);
170	return 0;
171}
172
173int kgdb_arch_handle_exception(int trap, int signo,
174		int err_code, char *inbuf, char *outbuf,
175		struct pt_regs *regs)
176{
177	unsigned long addr;
178	char *p = inbuf + 1;
179
180	switch (inbuf[0]) {
181	case 'D':
182	case 'c':
183	case 'k':
184		kgdb_contthread = NULL;
185		kgdb_single_step = 0;
186
187		if (kgdb_hex2long(&p, &addr))
188			kgdb_arch_set_pc(regs, addr);
189		else if (trap == 9 && regs->iir ==
190				PARISC_KGDB_COMPILED_BREAK_INSN)
191			step_instruction_queue(regs);
192		return 0;
193	case 's':
194		kgdb_single_step = 1;
195		if (kgdb_hex2long(&p, &addr)) {
196			kgdb_arch_set_pc(regs, addr);
197		} else if (trap == 9 && regs->iir ==
198				PARISC_KGDB_COMPILED_BREAK_INSN) {
199			step_instruction_queue(regs);
200			mtctl(-1, 0);
201		} else {
202			mtctl(0, 0);
203		}
204		regs->gr[0] |= PSW_R;
205		return 0;
206
207	}
208	return -1;
209}