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

   1// SPDX-License-Identifier: GPL-2.0-only
   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/* All registers are 4 bytes, for now */
  15#define GDB_SIZEOF_REG 4
  16
  17/* The register names are used during printing of the regs;
  18 * Keep these at three letters to pretty-print. */
  19struct 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
  73const struct kgdb_arch arch_kgdb_ops = {
  74        /* trap0(#0xDB) 0x0cdb0054 */
  75        .gdb_bpt_instr = {0x54, 0x00, 0xdb, 0x0c},
  76};
  77
  78char *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
  89int 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
 100void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc)
 101{
 102        instruction_pointer(regs) = pc;
 103}
 104
 105
 106/*  Not yet working  */
 107void 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        /* Initialize to zero */
 116        memset(gdb_regs, 0, NUMREGBYTES);
 117
 118        /* Otherwise, we have only some registers from switch_to() */
 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 */
 141int 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        /* Stay in the debugger. */
 151        return -1;
 152}
 153
 154static int __kgdb_notify(struct die_args *args, unsigned long cmd)
 155{
 156        /* cpu roundup */
 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
 172static int
 173kgdb_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
 185static 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 */
 200int 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 */
 211void kgdb_arch_exit(void)
 212{
 213        unregister_die_notifier(&kgdb_notifier);
 214}
 215