arch/hexagon/kernel/kgdb.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
dbg_get_reg
dbg_set_reg
kgdb_arch_set_pc
sleeping_thread_to_gdb_regs
kgdb_arch_handle_exception
__kgdb_notify
kgdb_notify
kgdb_arch_init
kgdb_arch_exit
   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. */
  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         /* trap0(#0xDB) 0x0cdb0054 */
  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 /*  Not yet working  */
 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         /* 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  */
 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         /* Stay in the debugger. */
 151         return -1;
 152 }
 153 
 154 static 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 
 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 }
/* [<][>][^][v][top][bottom][index][help] */
root/arch/hexagon/kernel/kgdb.c

DEFINITIONS
