Commit eacbfce1 authored by Sven Schnelle's avatar Sven Schnelle Committed by Helge Deller
Browse files

parisc: add KGDB support 



This patch add KGDB support to PA-RISC. It also implements
single-stepping utilizing the recovery counter.

Signed-off-by: default avatarSven Schnelle <svens@stackframe.org>
Signed-off-by: default avatarHelge Deller <deller@gmx.de>
parent 620a53d5

arch/parisc/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -54,6 +54,7 @@ config PARISC 
	select CPU_NO_EFFICIENT_FFS

	select NEED_DMA_MAP_STATE

	select NEED_SG_DMA_LENGTH

	select HAVE_ARCH_KGDB



	help

	  The PA-RISC microprocessor is designed by Hewlett-Packard and used

arch/parisc/include/asm/kgdb.h

0 → 100644
+68 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

/*

 * PA-RISC KGDB support

 *

 * Copyright (c) 2019 Sven Schnelle <svens@stackframe.org>

 *

 */



#ifndef __PARISC_KGDB_H__

#define __PARISC_KGDB_H__



#define BREAK_INSTR_SIZE		4

#define PARISC_KGDB_COMPILED_BREAK_INSN	0x3ffc01f

#define PARISC_KGDB_BREAK_INSN		0x3ffa01f





#define NUMREGBYTES			sizeof(struct parisc_gdb_regs)

#define BUFMAX				4096



#define CACHE_FLUSH_IS_SAFE		1



#ifndef __ASSEMBLY__



static inline void arch_kgdb_breakpoint(void)

{

	asm(".word %0" : : "i"(PARISC_KGDB_COMPILED_BREAK_INSN) : "memory");

}



struct parisc_gdb_regs {

	unsigned long gpr[32];

	unsigned long sar;

	unsigned long iaoq_f;

	unsigned long iasq_f;

	unsigned long iaoq_b;

	unsigned long iasq_b;

	unsigned long eiem;

	unsigned long iir;

	unsigned long isr;

	unsigned long ior;

	unsigned long ipsw;

	unsigned long __unused0;

	unsigned long sr4;

	unsigned long sr0;

	unsigned long sr1;

	unsigned long sr2;

	unsigned long sr3;

	unsigned long sr5;

	unsigned long sr6;

	unsigned long sr7;

	unsigned long cr0;

	unsigned long pid1;

	unsigned long pid2;

	unsigned long scrccr;

	unsigned long pid3;

	unsigned long pid4;

	unsigned long cr24;

	unsigned long cr25;

	unsigned long cr26;

	unsigned long cr27;

	unsigned long cr28;

	unsigned long cr29;

	unsigned long cr30;



	u64 fr[32];

};



#endif

#endif

arch/parisc/kernel/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -33,3 +33,4 @@ obj-$(CONFIG_64BIT) += perf.o perf_asm.o $(obj64-y) 
obj-$(CONFIG_PARISC_CPU_TOPOLOGY)	+= topology.o

obj-$(CONFIG_FUNCTION_TRACER)		+= ftrace.o

obj-$(CONFIG_FUNCTION_GRAPH_TRACER)	+= ftrace.o

obj-$(CONFIG_KGDB)			+= kgdb.o

arch/parisc/kernel/kgdb.c

0 → 100644
+209 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * PA-RISC KGDB support

 *

 * Copyright (c) 2019 Sven Schnelle <svens@stackframe.org>

 *

 */



#include <linux/kgdb.h>

#include <linux/string.h>

#include <linux/sched.h>

#include <linux/notifier.h>

#include <linux/kdebug.h>

#include <linux/uaccess.h>

#include <asm/ptrace.h>

#include <asm/traps.h>

#include <asm/processor.h>

#include <asm/patch.h>

#include <asm/cacheflush.h>



const struct kgdb_arch arch_kgdb_ops = {

	.gdb_bpt_instr = { 0x03, 0xff, 0xa0, 0x1f }

};



static int __kgdb_notify(struct die_args *args, unsigned long cmd)

{

	struct pt_regs *regs = args->regs;



	if (kgdb_handle_exception(1, args->signr, cmd, regs))

		return NOTIFY_DONE;

	return NOTIFY_STOP;

}



static int kgdb_notify(struct notifier_block *self,

		       unsigned long cmd, void *ptr)

{

	unsigned long flags;

	int ret;



	local_irq_save(flags);

	ret = __kgdb_notify(ptr, cmd);

	local_irq_restore(flags);



	return ret;

}



static struct notifier_block kgdb_notifier = {

	.notifier_call	= kgdb_notify,

	.priority	= -INT_MAX,

};



int kgdb_arch_init(void)

{

	return register_die_notifier(&kgdb_notifier);

}



void kgdb_arch_exit(void)

{

	unregister_die_notifier(&kgdb_notifier);

}



void pt_regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *regs)

{

	struct parisc_gdb_regs *gr = (struct parisc_gdb_regs *)gdb_regs;



	memset(gr, 0, sizeof(struct parisc_gdb_regs));



	memcpy(gr->gpr, regs->gr, sizeof(gr->gpr));

	memcpy(gr->fr, regs->fr, sizeof(gr->fr));



	gr->sr0 = regs->sr[0];

	gr->sr1 = regs->sr[1];

	gr->sr2 = regs->sr[2];

	gr->sr3 = regs->sr[3];

	gr->sr4 = regs->sr[4];

	gr->sr5 = regs->sr[5];

	gr->sr6 = regs->sr[6];

	gr->sr7 = regs->sr[7];



	gr->sar = regs->sar;

	gr->iir = regs->iir;

	gr->isr = regs->isr;

	gr->ior = regs->ior;

	gr->ipsw = regs->ipsw;

	gr->cr27 = regs->cr27;



	gr->iaoq_f = regs->iaoq[0];

	gr->iasq_f = regs->iasq[0];



	gr->iaoq_b = regs->iaoq[1];

	gr->iasq_b = regs->iasq[1];

}



void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *regs)

{

	struct parisc_gdb_regs *gr = (struct parisc_gdb_regs *)gdb_regs;





	memcpy(regs->gr, gr->gpr, sizeof(regs->gr));

	memcpy(regs->fr, gr->fr, sizeof(regs->fr));



	regs->sr[0] = gr->sr0;

	regs->sr[1] = gr->sr1;

	regs->sr[2] = gr->sr2;

	regs->sr[3] = gr->sr3;

	regs->sr[4] = gr->sr4;

	regs->sr[5] = gr->sr5;

	regs->sr[6] = gr->sr6;

	regs->sr[7] = gr->sr7;



	regs->sar = gr->sar;

	regs->iir = gr->iir;

	regs->isr = gr->isr;

	regs->ior = gr->ior;

	regs->ipsw = gr->ipsw;

	regs->cr27 = gr->cr27;



	regs->iaoq[0] = gr->iaoq_f;

	regs->iasq[0] = gr->iasq_f;



	regs->iaoq[1] = gr->iaoq_b;

	regs->iasq[1] = gr->iasq_b;

}



void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs,

				struct task_struct *task)

{

	struct pt_regs *regs = task_pt_regs(task);

	unsigned long gr30, iaoq;



	gr30 = regs->gr[30];

	iaoq = regs->iaoq[0];



	regs->gr[30] = regs->ksp;

	regs->iaoq[0] = regs->kpc;

	pt_regs_to_gdb_regs(gdb_regs, regs);



	regs->gr[30] = gr30;

	regs->iaoq[0] = iaoq;



}



static void step_instruction_queue(struct pt_regs *regs)

{

	regs->iaoq[0] = regs->iaoq[1];

	regs->iaoq[1] += 4;

}



void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long ip)

{

	regs->iaoq[0] = ip;

	regs->iaoq[1] = ip + 4;

}



int kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)

{

	int ret = probe_kernel_read(bpt->saved_instr, (char *)bpt->bpt_addr,

				BREAK_INSTR_SIZE);

	if (ret)

		return ret;



	__patch_text((void *)bpt->bpt_addr,

			*(unsigned int *)&arch_kgdb_ops.gdb_bpt_instr);

	return ret;

}



int kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)

{

	__patch_text((void *)bpt->bpt_addr, *(unsigned int *)&bpt->saved_instr);

	return 0;

}



int kgdb_arch_handle_exception(int trap, int signo,

		int err_code, char *inbuf, char *outbuf,

		struct pt_regs *regs)

{

	unsigned long addr;

	char *p = inbuf + 1;



	switch (inbuf[0]) {

	case 'D':

	case 'c':

	case 'k':

		kgdb_contthread = NULL;

		kgdb_single_step = 0;



		if (kgdb_hex2long(&p, &addr))

			kgdb_arch_set_pc(regs, addr);

		else if (trap == 9 && regs->iir ==

				PARISC_KGDB_COMPILED_BREAK_INSN)

			step_instruction_queue(regs);

		return 0;

	case 's':

		kgdb_single_step = 1;

		if (kgdb_hex2long(&p, &addr)) {

			kgdb_arch_set_pc(regs, addr);

		} else if (trap == 9 && regs->iir ==

				PARISC_KGDB_COMPILED_BREAK_INSN) {

			step_instruction_queue(regs);

			mtctl(-1, 0);

		} else {

			mtctl(0, 0);

		}

		regs->gr[0] |= PSW_R;

		return 0;



	}

	return -1;

}

arch/parisc/kernel/traps.c

+17 −0
Original line number Diff line number Diff line
@@ -42,6 +42,7 @@ 
#include <asm/unwind.h>

#include <asm/tlbflush.h>

#include <asm/cacheflush.h>

#include <linux/kgdb.h>



#include "../math-emu/math-emu.h"	/* for handle_fpe() */
@@ -293,6 +294,14 @@ static void handle_break(struct pt_regs *regs) 
			(tt == BUG_TRAP_TYPE_NONE) ? 9 : 0);

	}



#ifdef CONFIG_KGDB

	if (unlikely(iir == PARISC_KGDB_COMPILED_BREAK_INSN ||

		iir == PARISC_KGDB_BREAK_INSN)) {

		kgdb_handle_exception(9, SIGTRAP, 0, regs);

		return;

	}

#endif



	if (unlikely(iir != GDB_BREAK_INSN))

		parisc_printk_ratelimited(0, regs,

			KERN_DEBUG "break %d,%d: pid=%d command='%s'\n",
@@ -518,6 +527,14 @@ void notrace handle_interruption(int code, struct pt_regs *regs) 
	case  3:

		/* Recovery counter trap */

		regs->gr[0] &= ~PSW_R;



#ifdef CONFIG_KGDB

		if (kgdb_single_step) {

			kgdb_handle_exception(0, SIGTRAP, 0, regs);

			return;

		}

#endif



		if (user_space(regs))

			handle_gdb_break(regs, TRAP_TRACE);

		/* else this must be the start of a syscall - just let it run */