kgdb.c 4.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Nios2 KGDB support
  4. *
  5. * Copyright (C) 2015 Altera Corporation
  6. * Copyright (C) 2011 Tobias Klauser <tklauser@distanz.ch>
  7. *
  8. * Based on the code posted by Kazuyasu on the Altera Forum at:
  9. * http://www.alteraforum.com/forum/showpost.php?p=77003&postcount=20
  10. */
  11. #include <linux/ptrace.h>
  12. #include <linux/kgdb.h>
  13. #include <linux/kdebug.h>
  14. #include <linux/io.h>
  15. static int wait_for_remote_debugger;
  16. struct dbg_reg_def_t dbg_reg_def[DBG_MAX_REG_NUM] =
  17. {
  18. { "zero", GDB_SIZEOF_REG, -1 },
  19. { "at", GDB_SIZEOF_REG, offsetof(struct pt_regs, r1) },
  20. { "r2", GDB_SIZEOF_REG, offsetof(struct pt_regs, r2) },
  21. { "r3", GDB_SIZEOF_REG, offsetof(struct pt_regs, r3) },
  22. { "r4", GDB_SIZEOF_REG, offsetof(struct pt_regs, r4) },
  23. { "r5", GDB_SIZEOF_REG, offsetof(struct pt_regs, r5) },
  24. { "r6", GDB_SIZEOF_REG, offsetof(struct pt_regs, r6) },
  25. { "r7", GDB_SIZEOF_REG, offsetof(struct pt_regs, r7) },
  26. { "r8", GDB_SIZEOF_REG, offsetof(struct pt_regs, r8) },
  27. { "r9", GDB_SIZEOF_REG, offsetof(struct pt_regs, r9) },
  28. { "r10", GDB_SIZEOF_REG, offsetof(struct pt_regs, r10) },
  29. { "r11", GDB_SIZEOF_REG, offsetof(struct pt_regs, r11) },
  30. { "r12", GDB_SIZEOF_REG, offsetof(struct pt_regs, r12) },
  31. { "r13", GDB_SIZEOF_REG, offsetof(struct pt_regs, r13) },
  32. { "r14", GDB_SIZEOF_REG, offsetof(struct pt_regs, r14) },
  33. { "r15", GDB_SIZEOF_REG, offsetof(struct pt_regs, r15) },
  34. { "r16", GDB_SIZEOF_REG, -1 },
  35. { "r17", GDB_SIZEOF_REG, -1 },
  36. { "r18", GDB_SIZEOF_REG, -1 },
  37. { "r19", GDB_SIZEOF_REG, -1 },
  38. { "r20", GDB_SIZEOF_REG, -1 },
  39. { "r21", GDB_SIZEOF_REG, -1 },
  40. { "r22", GDB_SIZEOF_REG, -1 },
  41. { "r23", GDB_SIZEOF_REG, -1 },
  42. { "et", GDB_SIZEOF_REG, -1 },
  43. { "bt", GDB_SIZEOF_REG, -1 },
  44. { "gp", GDB_SIZEOF_REG, offsetof(struct pt_regs, gp) },
  45. { "sp", GDB_SIZEOF_REG, offsetof(struct pt_regs, sp) },
  46. { "fp", GDB_SIZEOF_REG, offsetof(struct pt_regs, fp) },
  47. { "ea", GDB_SIZEOF_REG, -1 },
  48. { "ba", GDB_SIZEOF_REG, -1 },
  49. { "ra", GDB_SIZEOF_REG, offsetof(struct pt_regs, ra) },
  50. { "pc", GDB_SIZEOF_REG, offsetof(struct pt_regs, ea) },
  51. { "status", GDB_SIZEOF_REG, -1 },
  52. { "estatus", GDB_SIZEOF_REG, offsetof(struct pt_regs, estatus) },
  53. { "bstatus", GDB_SIZEOF_REG, -1 },
  54. { "ienable", GDB_SIZEOF_REG, -1 },
  55. { "ipending", GDB_SIZEOF_REG, -1},
  56. { "cpuid", GDB_SIZEOF_REG, -1 },
  57. { "ctl6", GDB_SIZEOF_REG, -1 },
  58. { "exception", GDB_SIZEOF_REG, -1 },
  59. { "pteaddr", GDB_SIZEOF_REG, -1 },
  60. { "tlbacc", GDB_SIZEOF_REG, -1 },
  61. { "tlbmisc", GDB_SIZEOF_REG, -1 },
  62. { "eccinj", GDB_SIZEOF_REG, -1 },
  63. { "badaddr", GDB_SIZEOF_REG, -1 },
  64. { "config", GDB_SIZEOF_REG, -1 },
  65. { "mpubase", GDB_SIZEOF_REG, -1 },
  66. { "mpuacc", GDB_SIZEOF_REG, -1 },
  67. };
  68. char *dbg_get_reg(int regno, void *mem, struct pt_regs *regs)
  69. {
  70. if (regno >= DBG_MAX_REG_NUM || regno < 0)
  71. return NULL;
  72. if (dbg_reg_def[regno].offset != -1)
  73. memcpy(mem, (void *)regs + dbg_reg_def[regno].offset,
  74. dbg_reg_def[regno].size);
  75. else
  76. memset(mem, 0, dbg_reg_def[regno].size);
  77. return dbg_reg_def[regno].name;
  78. }
  79. int dbg_set_reg(int regno, void *mem, struct pt_regs *regs)
  80. {
  81. if (regno >= DBG_MAX_REG_NUM || regno < 0)
  82. return -EINVAL;
  83. if (dbg_reg_def[regno].offset != -1)
  84. memcpy((void *)regs + dbg_reg_def[regno].offset, mem,
  85. dbg_reg_def[regno].size);
  86. return 0;
  87. }
  88. void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *p)
  89. {
  90. memset((char *)gdb_regs, 0, NUMREGBYTES);
  91. gdb_regs[GDB_SP] = p->thread.kregs->sp;
  92. gdb_regs[GDB_PC] = p->thread.kregs->ea;
  93. }
  94. void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc)
  95. {
  96. regs->ea = pc;
  97. }
  98. int kgdb_arch_handle_exception(int vector, int signo, int err_code,
  99. char *remcom_in_buffer, char *remcom_out_buffer,
  100. struct pt_regs *regs)
  101. {
  102. char *ptr;
  103. unsigned long addr;
  104. switch (remcom_in_buffer[0]) {
  105. case 's':
  106. case 'c':
  107. /* handle the optional parameters */
  108. ptr = &remcom_in_buffer[1];
  109. if (kgdb_hex2long(&ptr, &addr))
  110. regs->ea = addr;
  111. return 0;
  112. }
  113. return -1; /* this means that we do not want to exit from the handler */
  114. }
  115. asmlinkage void kgdb_breakpoint_c(struct pt_regs *regs)
  116. {
  117. /*
  118. * The breakpoint entry code has moved the PC on by 4 bytes, so we must
  119. * move it back. This could be done on the host but we do it here
  120. */
  121. if (!wait_for_remote_debugger)
  122. regs->ea -= 4;
  123. else /* pass the first trap 30 code */
  124. wait_for_remote_debugger = 0;
  125. kgdb_handle_exception(30, SIGTRAP, 0, regs);
  126. }
  127. int kgdb_arch_init(void)
  128. {
  129. wait_for_remote_debugger = 1;
  130. return 0;
  131. }
  132. void kgdb_arch_exit(void)
  133. {
  134. /* Nothing to do */
  135. }
  136. const struct kgdb_arch arch_kgdb_ops = {
  137. /* Breakpoint instruction: trap 30 */
  138. .gdb_bpt_instr = { 0xba, 0x6f, 0x3b, 0x00 },
  139. };