1 /* 2 * arch/hexagon/kernel/kgdb.c - Hexagon KGDB Support 3 * 4 * Copyright (c) 2011-2012, The Linux Foundation. All rights reserved. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 and 8 * only version 2 as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 18 * 02110-1301, USA. 19 */ 20 21 #include <linux/irq.h> 22 #include <linux/sched.h> 23 #include <linux/sched/task_stack.h> 24 #include <linux/kdebug.h> 25 #include <linux/kgdb.h> 26 27 /* All registers are 4 bytes, for now */ 28 #define GDB_SIZEOF_REG 4 29 30 /* The register names are used during printing of the regs; 31 * Keep these at three letters to pretty-print. */ 32 struct dbg_reg_def_t dbg_reg_def[DBG_MAX_REG_NUM] = { 33 { " r0", GDB_SIZEOF_REG, offsetof(struct pt_regs, r00)}, 34 { " r1", GDB_SIZEOF_REG, offsetof(struct pt_regs, r01)}, 35 { " r2", GDB_SIZEOF_REG, offsetof(struct pt_regs, r02)}, 36 { " r3", GDB_SIZEOF_REG, offsetof(struct pt_regs, r03)}, 37 { " r4", GDB_SIZEOF_REG, offsetof(struct pt_regs, r04)}, 38 { " r5", GDB_SIZEOF_REG, offsetof(struct pt_regs, r05)}, 39 { " r6", GDB_SIZEOF_REG, offsetof(struct pt_regs, r06)}, 40 { " r7", GDB_SIZEOF_REG, offsetof(struct pt_regs, r07)}, 41 { " r8", GDB_SIZEOF_REG, offsetof(struct pt_regs, r08)}, 42 { " r9", GDB_SIZEOF_REG, offsetof(struct pt_regs, r09)}, 43 { "r10", GDB_SIZEOF_REG, offsetof(struct pt_regs, r10)}, 44 { "r11", GDB_SIZEOF_REG, offsetof(struct pt_regs, r11)}, 45 { "r12", GDB_SIZEOF_REG, offsetof(struct pt_regs, r12)}, 46 { "r13", GDB_SIZEOF_REG, offsetof(struct pt_regs, r13)}, 47 { "r14", GDB_SIZEOF_REG, offsetof(struct pt_regs, r14)}, 48 { "r15", GDB_SIZEOF_REG, offsetof(struct pt_regs, r15)}, 49 { "r16", GDB_SIZEOF_REG, offsetof(struct pt_regs, r16)}, 50 { "r17", GDB_SIZEOF_REG, offsetof(struct pt_regs, r17)}, 51 { "r18", GDB_SIZEOF_REG, offsetof(struct pt_regs, r18)}, 52 { "r19", GDB_SIZEOF_REG, offsetof(struct pt_regs, r19)}, 53 { "r20", GDB_SIZEOF_REG, offsetof(struct pt_regs, r20)}, 54 { "r21", GDB_SIZEOF_REG, offsetof(struct pt_regs, r21)}, 55 { "r22", GDB_SIZEOF_REG, offsetof(struct pt_regs, r22)}, 56 { "r23", GDB_SIZEOF_REG, offsetof(struct pt_regs, r23)}, 57 { "r24", GDB_SIZEOF_REG, offsetof(struct pt_regs, r24)}, 58 { "r25", GDB_SIZEOF_REG, offsetof(struct pt_regs, r25)}, 59 { "r26", GDB_SIZEOF_REG, offsetof(struct pt_regs, r26)}, 60 { "r27", GDB_SIZEOF_REG, offsetof(struct pt_regs, r27)}, 61 { "r28", GDB_SIZEOF_REG, offsetof(struct pt_regs, r28)}, 62 { "r29", GDB_SIZEOF_REG, offsetof(struct pt_regs, r29)}, 63 { "r30", GDB_SIZEOF_REG, offsetof(struct pt_regs, r30)}, 64 { "r31", GDB_SIZEOF_REG, offsetof(struct pt_regs, r31)}, 65 66 { "usr", GDB_SIZEOF_REG, offsetof(struct pt_regs, usr)}, 67 { "preds", GDB_SIZEOF_REG, offsetof(struct pt_regs, preds)}, 68 { " m0", GDB_SIZEOF_REG, offsetof(struct pt_regs, m0)}, 69 { " m1", GDB_SIZEOF_REG, offsetof(struct pt_regs, m1)}, 70 { "sa0", GDB_SIZEOF_REG, offsetof(struct pt_regs, sa0)}, 71 { "sa1", GDB_SIZEOF_REG, offsetof(struct pt_regs, sa1)}, 72 { "lc0", GDB_SIZEOF_REG, offsetof(struct pt_regs, lc0)}, 73 { "lc1", GDB_SIZEOF_REG, offsetof(struct pt_regs, lc1)}, 74 { " gp", GDB_SIZEOF_REG, offsetof(struct pt_regs, gp)}, 75 { "ugp", GDB_SIZEOF_REG, offsetof(struct pt_regs, ugp)}, 76 { "cs0", GDB_SIZEOF_REG, offsetof(struct pt_regs, cs0)}, 77 { "cs1", GDB_SIZEOF_REG, offsetof(struct pt_regs, cs1)}, 78 { "psp", GDB_SIZEOF_REG, offsetof(struct pt_regs, hvmer.vmpsp)}, 79 { "elr", GDB_SIZEOF_REG, offsetof(struct pt_regs, hvmer.vmel)}, 80 { "est", GDB_SIZEOF_REG, offsetof(struct pt_regs, hvmer.vmest)}, 81 { "badva", GDB_SIZEOF_REG, offsetof(struct pt_regs, hvmer.vmbadva)}, 82 { "restart_r0", GDB_SIZEOF_REG, offsetof(struct pt_regs, restart_r0)}, 83 { "syscall_nr", GDB_SIZEOF_REG, offsetof(struct pt_regs, syscall_nr)}, 84 }; 85 86 struct kgdb_arch arch_kgdb_ops = { 87 /* trap0(#0xDB) 0x0cdb0054 */ 88 .gdb_bpt_instr = {0x54, 0x00, 0xdb, 0x0c}, 89 }; 90 91 char *dbg_get_reg(int regno, void *mem, struct pt_regs *regs) 92 { 93 if (regno >= DBG_MAX_REG_NUM || regno < 0) 94 return NULL; 95 96 *((unsigned long *) mem) = *((unsigned long *) ((void *)regs + 97 dbg_reg_def[regno].offset)); 98 99 return dbg_reg_def[regno].name; 100 } 101 102 int dbg_set_reg(int regno, void *mem, struct pt_regs *regs) 103 { 104 if (regno >= DBG_MAX_REG_NUM || regno < 0) 105 return -EINVAL; 106 107 *((unsigned long *) ((void *)regs + dbg_reg_def[regno].offset)) = 108 *((unsigned long *) mem); 109 110 return 0; 111 } 112 113 void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc) 114 { 115 instruction_pointer(regs) = pc; 116 } 117 118 #ifdef CONFIG_SMP 119 120 /** 121 * kgdb_roundup_cpus - Get other CPUs into a holding pattern 122 * @flags: Current IRQ state 123 * 124 * On SMP systems, we need to get the attention of the other CPUs 125 * and get them be in a known state. This should do what is needed 126 * to get the other CPUs to call kgdb_wait(). Note that on some arches, 127 * the NMI approach is not used for rounding up all the CPUs. For example, 128 * in case of MIPS, smp_call_function() is used to roundup CPUs. In 129 * this case, we have to make sure that interrupts are enabled before 130 * calling smp_call_function(). The argument to this function is 131 * the flags that will be used when restoring the interrupts. There is 132 * local_irq_save() call before kgdb_roundup_cpus(). 133 * 134 * On non-SMP systems, this is not called. 135 */ 136 137 static void hexagon_kgdb_nmi_hook(void *ignored) 138 { 139 kgdb_nmicallback(raw_smp_processor_id(), get_irq_regs()); 140 } 141 142 void kgdb_roundup_cpus(unsigned long flags) 143 { 144 local_irq_enable(); 145 smp_call_function(hexagon_kgdb_nmi_hook, NULL, 0); 146 local_irq_disable(); 147 } 148 #endif 149 150 151 /* Not yet working */ 152 void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, 153 struct task_struct *task) 154 { 155 struct pt_regs *thread_regs; 156 157 if (task == NULL) 158 return; 159 160 /* Initialize to zero */ 161 memset(gdb_regs, 0, NUMREGBYTES); 162 163 /* Otherwise, we have only some registers from switch_to() */ 164 thread_regs = task_pt_regs(task); 165 gdb_regs[0] = thread_regs->r00; 166 } 167 168 /** 169 * kgdb_arch_handle_exception - Handle architecture specific GDB packets. 170 * @vector: The error vector of the exception that happened. 171 * @signo: The signal number of the exception that happened. 172 * @err_code: The error code of the exception that happened. 173 * @remcom_in_buffer: The buffer of the packet we have read. 174 * @remcom_out_buffer: The buffer of %BUFMAX bytes to write a packet into. 175 * @regs: The &struct pt_regs of the current process. 176 * 177 * This function MUST handle the 'c' and 's' command packets, 178 * as well packets to set / remove a hardware breakpoint, if used. 179 * If there are additional packets which the hardware needs to handle, 180 * they are handled here. The code should return -1 if it wants to 181 * process more packets, and a %0 or %1 if it wants to exit from the 182 * kgdb callback. 183 * 184 * Not yet working. 185 */ 186 int kgdb_arch_handle_exception(int vector, int signo, int err_code, 187 char *remcom_in_buffer, char *remcom_out_buffer, 188 struct pt_regs *linux_regs) 189 { 190 switch (remcom_in_buffer[0]) { 191 case 's': 192 case 'c': 193 return 0; 194 } 195 /* Stay in the debugger. */ 196 return -1; 197 } 198 199 static int __kgdb_notify(struct die_args *args, unsigned long cmd) 200 { 201 /* cpu roundup */ 202 if (atomic_read(&kgdb_active) != -1) { 203 kgdb_nmicallback(smp_processor_id(), args->regs); 204 return NOTIFY_STOP; 205 } 206 207 if (user_mode(args->regs)) 208 return NOTIFY_DONE; 209 210 if (kgdb_handle_exception(args->trapnr & 0xff, args->signr, args->err, 211 args->regs)) 212 return NOTIFY_DONE; 213 214 return NOTIFY_STOP; 215 } 216 217 static int 218 kgdb_notify(struct notifier_block *self, unsigned long cmd, void *ptr) 219 { 220 unsigned long flags; 221 int ret; 222 223 local_irq_save(flags); 224 ret = __kgdb_notify(ptr, cmd); 225 local_irq_restore(flags); 226 227 return ret; 228 } 229 230 static struct notifier_block kgdb_notifier = { 231 .notifier_call = kgdb_notify, 232 233 /* 234 * Lowest-prio notifier priority, we want to be notified last: 235 */ 236 .priority = -INT_MAX, 237 }; 238 239 /** 240 * kgdb_arch_init - Perform any architecture specific initialization. 241 * 242 * This function will handle the initialization of any architecture 243 * specific callbacks. 244 */ 245 int kgdb_arch_init(void) 246 { 247 return register_die_notifier(&kgdb_notifier); 248 } 249 250 /** 251 * kgdb_arch_exit - Perform any architecture specific uninitalization. 252 * 253 * This function will handle the uninitalization of any architecture 254 * specific callbacks, for dynamic registration and unregistration. 255 */ 256 void kgdb_arch_exit(void) 257 { 258 unregister_die_notifier(&kgdb_notifier); 259 } 260