| 1 | |
| 2 | |
| 3 | * arch/hexagon/kernel/kgdb.c - Hexagon KGDB Support
|
| 4 | *
|
| 5 | * Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
|
| 6 |
|
| 7 |
|
| 8 | #include <linux/irq.h>
|
| 9 | #include <linux/sched.h>
|
| 10 | #include <linux/sched/task_stack.h>
|
| 11 | #include <linux/kdebug.h>
|
| 12 | #include <linux/kgdb.h>
|
| 13 |
|
| 14 |
|
| 15 | #define GDB_SIZEOF_REG 4
|
| 16 |
|
| 17 | |
| 18 | * Keep these at three letters to pretty-print.
|
| 19 | struct dbg_reg_def_t dbg_reg_def[DBG_MAX_REG_NUM] = {
|
| 20 | { " r0", GDB_SIZEOF_REG, offsetof(struct pt_regs, r00)},
|
| 21 | { " r1", GDB_SIZEOF_REG, offsetof(struct pt_regs, r01)},
|
| 22 | { " r2", GDB_SIZEOF_REG, offsetof(struct pt_regs, r02)},
|
| 23 | { " r3", GDB_SIZEOF_REG, offsetof(struct pt_regs, r03)},
|
| 24 | { " r4", GDB_SIZEOF_REG, offsetof(struct pt_regs, r04)},
|
| 25 | { " r5", GDB_SIZEOF_REG, offsetof(struct pt_regs, r05)},
|
| 26 | { " r6", GDB_SIZEOF_REG, offsetof(struct pt_regs, r06)},
|
| 27 | { " r7", GDB_SIZEOF_REG, offsetof(struct pt_regs, r07)},
|
| 28 | { " r8", GDB_SIZEOF_REG, offsetof(struct pt_regs, r08)},
|
| 29 | { " r9", GDB_SIZEOF_REG, offsetof(struct pt_regs, r09)},
|
| 30 | { "r10", GDB_SIZEOF_REG, offsetof(struct pt_regs, r10)},
|
| 31 | { "r11", GDB_SIZEOF_REG, offsetof(struct pt_regs, r11)},
|
| 32 | { "r12", GDB_SIZEOF_REG, offsetof(struct pt_regs, r12)},
|
| 33 | { "r13", GDB_SIZEOF_REG, offsetof(struct pt_regs, r13)},
|
| 34 | { "r14", GDB_SIZEOF_REG, offsetof(struct pt_regs, r14)},
|
| 35 | { "r15", GDB_SIZEOF_REG, offsetof(struct pt_regs, r15)},
|
| 36 | { "r16", GDB_SIZEOF_REG, offsetof(struct pt_regs, r16)},
|
| 37 | { "r17", GDB_SIZEOF_REG, offsetof(struct pt_regs, r17)},
|
| 38 | { "r18", GDB_SIZEOF_REG, offsetof(struct pt_regs, r18)},
|
| 39 | { "r19", GDB_SIZEOF_REG, offsetof(struct pt_regs, r19)},
|
| 40 | { "r20", GDB_SIZEOF_REG, offsetof(struct pt_regs, r20)},
|
| 41 | { "r21", GDB_SIZEOF_REG, offsetof(struct pt_regs, r21)},
|
| 42 | { "r22", GDB_SIZEOF_REG, offsetof(struct pt_regs, r22)},
|
| 43 | { "r23", GDB_SIZEOF_REG, offsetof(struct pt_regs, r23)},
|
| 44 | { "r24", GDB_SIZEOF_REG, offsetof(struct pt_regs, r24)},
|
| 45 | { "r25", GDB_SIZEOF_REG, offsetof(struct pt_regs, r25)},
|
| 46 | { "r26", GDB_SIZEOF_REG, offsetof(struct pt_regs, r26)},
|
| 47 | { "r27", GDB_SIZEOF_REG, offsetof(struct pt_regs, r27)},
|
| 48 | { "r28", GDB_SIZEOF_REG, offsetof(struct pt_regs, r28)},
|
| 49 | { "r29", GDB_SIZEOF_REG, offsetof(struct pt_regs, r29)},
|
| 50 | { "r30", GDB_SIZEOF_REG, offsetof(struct pt_regs, r30)},
|
| 51 | { "r31", GDB_SIZEOF_REG, offsetof(struct pt_regs, r31)},
|
| 52 |
|
| 53 | { "usr", GDB_SIZEOF_REG, offsetof(struct pt_regs, usr)},
|
| 54 | { "preds", GDB_SIZEOF_REG, offsetof(struct pt_regs, preds)},
|
| 55 | { " m0", GDB_SIZEOF_REG, offsetof(struct pt_regs, m0)},
|
| 56 | { " m1", GDB_SIZEOF_REG, offsetof(struct pt_regs, m1)},
|
| 57 | { "sa0", GDB_SIZEOF_REG, offsetof(struct pt_regs, sa0)},
|
| 58 | { "sa1", GDB_SIZEOF_REG, offsetof(struct pt_regs, sa1)},
|
| 59 | { "lc0", GDB_SIZEOF_REG, offsetof(struct pt_regs, lc0)},
|
| 60 | { "lc1", GDB_SIZEOF_REG, offsetof(struct pt_regs, lc1)},
|
| 61 | { " gp", GDB_SIZEOF_REG, offsetof(struct pt_regs, gp)},
|
| 62 | { "ugp", GDB_SIZEOF_REG, offsetof(struct pt_regs, ugp)},
|
| 63 | { "cs0", GDB_SIZEOF_REG, offsetof(struct pt_regs, cs0)},
|
| 64 | { "cs1", GDB_SIZEOF_REG, offsetof(struct pt_regs, cs1)},
|
| 65 | { "psp", GDB_SIZEOF_REG, offsetof(struct pt_regs, hvmer.vmpsp)},
|
| 66 | { "elr", GDB_SIZEOF_REG, offsetof(struct pt_regs, hvmer.vmel)},
|
| 67 | { "est", GDB_SIZEOF_REG, offsetof(struct pt_regs, hvmer.vmest)},
|
| 68 | { "badva", GDB_SIZEOF_REG, offsetof(struct pt_regs, hvmer.vmbadva)},
|
| 69 | { "restart_r0", GDB_SIZEOF_REG, offsetof(struct pt_regs, restart_r0)},
|
| 70 | { "syscall_nr", GDB_SIZEOF_REG, offsetof(struct pt_regs, syscall_nr)},
|
| 71 | };
|
| 72 |
|
| 73 | const struct kgdb_arch arch_kgdb_ops = {
|
| 74 |
|
| 75 | .gdb_bpt_instr = {0x54, 0x00, 0xdb, 0x0c},
|
| 76 | };
|
| 77 |
|
| 78 | char *dbg_get_reg(int regno, void *mem, struct pt_regs *regs)
|
| 79 | {
|
| 80 | if (regno >= DBG_MAX_REG_NUM || regno < 0)
|
| 81 | return NULL;
|
| 82 |
|
| 83 | *((unsigned long *) mem) = *((unsigned long *) ((void *)regs +
|
| 84 | dbg_reg_def[regno].offset));
|
| 85 |
|
| 86 | return dbg_reg_def[regno].name;
|
| 87 | }
|
| 88 |
|
| 89 | int dbg_set_reg(int regno, void *mem, struct pt_regs *regs)
|
| 90 | {
|
| 91 | if (regno >= DBG_MAX_REG_NUM || regno < 0)
|
| 92 | return -EINVAL;
|
| 93 |
|
| 94 | *((unsigned long *) ((void *)regs + dbg_reg_def[regno].offset)) =
|
| 95 | *((unsigned long *) mem);
|
| 96 |
|
| 97 | return 0;
|
| 98 | }
|
| 99 |
|
| 100 | void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc)
|
| 101 | {
|
| 102 | instruction_pointer(regs) = pc;
|
| 103 | }
|
| 104 |
|
| 105 |
|
| 106 |
|
| 107 | void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs,
|
| 108 | struct task_struct *task)
|
| 109 | {
|
| 110 | struct pt_regs *thread_regs;
|
| 111 |
|
| 112 | if (task == NULL)
|
| 113 | return;
|
| 114 |
|
| 115 |
|
| 116 | memset(gdb_regs, 0, NUMREGBYTES);
|
| 117 |
|
| 118 |
|
| 119 | thread_regs = task_pt_regs(task);
|
| 120 | gdb_regs[0] = thread_regs->r00;
|
| 121 | }
|
| 122 |
|
| 123 | |
| 124 | * kgdb_arch_handle_exception - Handle architecture specific GDB packets.
|
| 125 | * @vector: The error vector of the exception that happened.
|
| 126 | * @signo: The signal number of the exception that happened.
|
| 127 | * @err_code: The error code of the exception that happened.
|
| 128 | * @remcom_in_buffer: The buffer of the packet we have read.
|
| 129 | * @remcom_out_buffer: The buffer of %BUFMAX bytes to write a packet into.
|
| 130 | * @regs: The &struct pt_regs of the current process.
|
| 131 | *
|
| 132 | * This function MUST handle the 'c' and 's' command packets,
|
| 133 | * as well packets to set / remove a hardware breakpoint, if used.
|
| 134 | * If there are additional packets which the hardware needs to handle,
|
| 135 | * they are handled here. The code should return -1 if it wants to
|
| 136 | * process more packets, and a %0 or %1 if it wants to exit from the
|
| 137 | * kgdb callback.
|
| 138 | *
|
| 139 | * Not yet working.
|
| 140 |
|
| 141 | int kgdb_arch_handle_exception(int vector, int signo, int err_code,
|
| 142 | char *remcom_in_buffer, char *remcom_out_buffer,
|
| 143 | struct pt_regs *linux_regs)
|
| 144 | {
|
| 145 | switch (remcom_in_buffer[0]) {
|
| 146 | case 's':
|
| 147 | case 'c':
|
| 148 | return 0;
|
| 149 | }
|
| 150 |
|
| 151 | return -1;
|
| 152 | }
|
| 153 |
|
| 154 | static int __kgdb_notify(struct die_args *args, unsigned long cmd)
|
| 155 | {
|
| 156 |
|
| 157 | if (atomic_read(&kgdb_active) != -1) {
|
| 158 | kgdb_nmicallback(smp_processor_id(), args->regs);
|
| 159 | return NOTIFY_STOP;
|
| 160 | }
|
| 161 |
|
| 162 | if (user_mode(args->regs))
|
| 163 | return NOTIFY_DONE;
|
| 164 |
|
| 165 | if (kgdb_handle_exception(args->trapnr & 0xff, args->signr, args->err,
|
| 166 | args->regs))
|
| 167 | return NOTIFY_DONE;
|
| 168 |
|
| 169 | return NOTIFY_STOP;
|
| 170 | }
|
| 171 |
|
| 172 | static int
|
| 173 | kgdb_notify(struct notifier_block *self, unsigned long cmd, void *ptr)
|
| 174 | {
|
| 175 | unsigned long flags;
|
| 176 | int ret;
|
| 177 |
|
| 178 | local_irq_save(flags);
|
| 179 | ret = __kgdb_notify(ptr, cmd);
|
| 180 | local_irq_restore(flags);
|
| 181 |
|
| 182 | return ret;
|
| 183 | }
|
| 184 |
|
| 185 | static struct notifier_block kgdb_notifier = {
|
| 186 | .notifier_call = kgdb_notify,
|
| 187 |
|
| 188 | |
| 189 | * Lowest-prio notifier priority, we want to be notified last:
|
| 190 |
|
| 191 | .priority = -INT_MAX,
|
| 192 | };
|
| 193 |
|
| 194 | |
| 195 | * kgdb_arch_init - Perform any architecture specific initialization.
|
| 196 | *
|
| 197 | * This function will handle the initialization of any architecture
|
| 198 | * specific callbacks.
|
| 199 |
|
| 200 | int kgdb_arch_init(void)
|
| 201 | {
|
| 202 | return register_die_notifier(&kgdb_notifier);
|
| 203 | }
|
| 204 |
|
| 205 | |
| 206 | * kgdb_arch_exit - Perform any architecture specific uninitalization.
|
| 207 | *
|
| 208 | * This function will handle the uninitalization of any architecture
|
| 209 | * specific callbacks, for dynamic registration and unregistration.
|
| 210 |
|
| 211 | void kgdb_arch_exit(void)
|
| 212 | {
|
| 213 | unregister_die_notifier(&kgdb_notifier);
|
| 214 | }
|