arch/parisc/kernel/kgdb.c

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