kgdb.c 4.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * PA-RISC KGDB support
  4. *
  5. * Copyright (c) 2019 Sven Schnelle <[email protected]>
  6. * Copyright (c) 2022 Helge Deller <[email protected]>
  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. const struct kgdb_arch arch_kgdb_ops = {
  21. .gdb_bpt_instr = { 0x03, 0xff, 0xa0, 0x1f }
  22. };
  23. static int __kgdb_notify(struct die_args *args, unsigned long cmd)
  24. {
  25. struct pt_regs *regs = args->regs;
  26. if (kgdb_handle_exception(1, args->signr, cmd, regs))
  27. return NOTIFY_DONE;
  28. return NOTIFY_STOP;
  29. }
  30. static int kgdb_notify(struct notifier_block *self,
  31. unsigned long cmd, void *ptr)
  32. {
  33. unsigned long flags;
  34. int ret;
  35. local_irq_save(flags);
  36. ret = __kgdb_notify(ptr, cmd);
  37. local_irq_restore(flags);
  38. return ret;
  39. }
  40. static struct notifier_block kgdb_notifier = {
  41. .notifier_call = kgdb_notify,
  42. .priority = -INT_MAX,
  43. };
  44. int kgdb_arch_init(void)
  45. {
  46. return register_die_notifier(&kgdb_notifier);
  47. }
  48. void kgdb_arch_exit(void)
  49. {
  50. unregister_die_notifier(&kgdb_notifier);
  51. }
  52. void pt_regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *regs)
  53. {
  54. struct parisc_gdb_regs *gr = (struct parisc_gdb_regs *)gdb_regs;
  55. memset(gr, 0, sizeof(struct parisc_gdb_regs));
  56. memcpy(gr->gpr, regs->gr, sizeof(gr->gpr));
  57. memcpy(gr->fr, regs->fr, sizeof(gr->fr));
  58. gr->sr0 = regs->sr[0];
  59. gr->sr1 = regs->sr[1];
  60. gr->sr2 = regs->sr[2];
  61. gr->sr3 = regs->sr[3];
  62. gr->sr4 = regs->sr[4];
  63. gr->sr5 = regs->sr[5];
  64. gr->sr6 = regs->sr[6];
  65. gr->sr7 = regs->sr[7];
  66. gr->sar = regs->sar;
  67. gr->iir = regs->iir;
  68. gr->isr = regs->isr;
  69. gr->ior = regs->ior;
  70. gr->ipsw = regs->ipsw;
  71. gr->cr27 = regs->cr27;
  72. gr->iaoq_f = regs->iaoq[0];
  73. gr->iasq_f = regs->iasq[0];
  74. gr->iaoq_b = regs->iaoq[1];
  75. gr->iasq_b = regs->iasq[1];
  76. }
  77. void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *regs)
  78. {
  79. struct parisc_gdb_regs *gr = (struct parisc_gdb_regs *)gdb_regs;
  80. memcpy(regs->gr, gr->gpr, sizeof(regs->gr));
  81. memcpy(regs->fr, gr->fr, sizeof(regs->fr));
  82. regs->sr[0] = gr->sr0;
  83. regs->sr[1] = gr->sr1;
  84. regs->sr[2] = gr->sr2;
  85. regs->sr[3] = gr->sr3;
  86. regs->sr[4] = gr->sr4;
  87. regs->sr[5] = gr->sr5;
  88. regs->sr[6] = gr->sr6;
  89. regs->sr[7] = gr->sr7;
  90. regs->sar = gr->sar;
  91. regs->iir = gr->iir;
  92. regs->isr = gr->isr;
  93. regs->ior = gr->ior;
  94. regs->ipsw = gr->ipsw;
  95. regs->cr27 = gr->cr27;
  96. regs->iaoq[0] = gr->iaoq_f;
  97. regs->iasq[0] = gr->iasq_f;
  98. regs->iaoq[1] = gr->iaoq_b;
  99. regs->iasq[1] = gr->iasq_b;
  100. }
  101. void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs,
  102. struct task_struct *task)
  103. {
  104. struct pt_regs *regs = task_pt_regs(task);
  105. unsigned long gr30, iaoq;
  106. gr30 = regs->gr[30];
  107. iaoq = regs->iaoq[0];
  108. regs->gr[30] = regs->ksp;
  109. regs->iaoq[0] = regs->kpc;
  110. pt_regs_to_gdb_regs(gdb_regs, regs);
  111. regs->gr[30] = gr30;
  112. regs->iaoq[0] = iaoq;
  113. }
  114. static void step_instruction_queue(struct pt_regs *regs)
  115. {
  116. regs->iaoq[0] = regs->iaoq[1];
  117. regs->iaoq[1] += 4;
  118. }
  119. void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long ip)
  120. {
  121. regs->iaoq[0] = ip;
  122. regs->iaoq[1] = ip + 4;
  123. }
  124. int kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)
  125. {
  126. int ret = copy_from_kernel_nofault(bpt->saved_instr,
  127. (char *)bpt->bpt_addr, BREAK_INSTR_SIZE);
  128. if (ret)
  129. return ret;
  130. __patch_text((void *)bpt->bpt_addr,
  131. *(unsigned int *)&arch_kgdb_ops.gdb_bpt_instr);
  132. return ret;
  133. }
  134. int kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)
  135. {
  136. __patch_text((void *)bpt->bpt_addr, *(unsigned int *)&bpt->saved_instr);
  137. return 0;
  138. }
  139. int kgdb_arch_handle_exception(int trap, int signo,
  140. int err_code, char *inbuf, char *outbuf,
  141. struct pt_regs *regs)
  142. {
  143. unsigned long addr;
  144. char *p = inbuf + 1;
  145. switch (inbuf[0]) {
  146. case 'D':
  147. case 'c':
  148. case 'k':
  149. kgdb_contthread = NULL;
  150. kgdb_single_step = 0;
  151. if (kgdb_hex2long(&p, &addr))
  152. kgdb_arch_set_pc(regs, addr);
  153. else if (trap == 9 && regs->iir ==
  154. PARISC_KGDB_COMPILED_BREAK_INSN)
  155. step_instruction_queue(regs);
  156. return 0;
  157. case 's':
  158. kgdb_single_step = 1;
  159. if (kgdb_hex2long(&p, &addr)) {
  160. kgdb_arch_set_pc(regs, addr);
  161. } else if (trap == 9 && regs->iir ==
  162. PARISC_KGDB_COMPILED_BREAK_INSN) {
  163. step_instruction_queue(regs);
  164. mtctl(-1, 0);
  165. } else {
  166. mtctl(0, 0);
  167. }
  168. regs->gr[0] |= PSW_R;
  169. return 0;
  170. }
  171. return -1;
  172. }