LXR linux/arch/hexagon/kernel/kgdb.c

   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. */
  32struct 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
  86struct kgdb_arch arch_kgdb_ops = {
  87        /* trap0(#0xDB) 0x0cdb0054 */
  88        .gdb_bpt_instr = {0x54, 0x00, 0xdb, 0x0c},
  89};
  90
  91char *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
 102int 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
 113void 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
 137static void hexagon_kgdb_nmi_hook(void *ignored)
 138{
 139        kgdb_nmicallback(raw_smp_processor_id(), get_irq_regs());
 140}
 141
 142void 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  */
 152void 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 */
 186int 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
 199static 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
 217static int
 218kgdb_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
 230static 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 */
 245int 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 */
 256void kgdb_arch_exit(void)
 257{
 258        unregister_die_notifier(&kgdb_notifier);
 259}
 260