linux/include/linux/kgdb.h
<<
>>
Prefs
   1/*
   2 * This provides the callbacks and functions that KGDB needs to share between
   3 * the core, I/O and arch-specific portions.
   4 *
   5 * Author: Amit Kale <amitkale@linsyssoft.com> and
   6 *         Tom Rini <trini@kernel.crashing.org>
   7 *
   8 * 2001-2004 (c) Amit S. Kale and 2003-2005 (c) MontaVista Software, Inc.
   9 * This file is licensed under the terms of the GNU General Public License
  10 * version 2. This program is licensed "as is" without any warranty of any
  11 * kind, whether express or implied.
  12 */
  13#ifndef _KGDB_H_
  14#define _KGDB_H_
  15
  16#include <linux/serial_8250.h>
  17#include <linux/linkage.h>
  18#include <linux/init.h>
  19#include <linux/atomic.h>
  20#ifdef CONFIG_HAVE_ARCH_KGDB
  21#include <asm/kgdb.h>
  22#endif
  23
  24#ifdef CONFIG_KGDB
  25struct pt_regs;
  26
  27/**
  28 *      kgdb_skipexception - (optional) exit kgdb_handle_exception early
  29 *      @exception: Exception vector number
  30 *      @regs: Current &struct pt_regs.
  31 *
  32 *      On some architectures it is required to skip a breakpoint
  33 *      exception when it occurs after a breakpoint has been removed.
  34 *      This can be implemented in the architecture specific portion of kgdb.
  35 */
  36extern int kgdb_skipexception(int exception, struct pt_regs *regs);
  37
  38struct tasklet_struct;
  39struct task_struct;
  40struct uart_port;
  41
  42/**
  43 *      kgdb_breakpoint - compiled in breakpoint
  44 *
  45 *      This will be implemented as a static inline per architecture.  This
  46 *      function is called by the kgdb core to execute an architecture
  47 *      specific trap to cause kgdb to enter the exception processing.
  48 *
  49 */
  50void kgdb_breakpoint(void);
  51
  52extern int kgdb_connected;
  53extern int kgdb_io_module_registered;
  54
  55extern atomic_t                 kgdb_setting_breakpoint;
  56extern atomic_t                 kgdb_cpu_doing_single_step;
  57
  58extern struct task_struct       *kgdb_usethread;
  59extern struct task_struct       *kgdb_contthread;
  60
  61enum kgdb_bptype {
  62        BP_BREAKPOINT = 0,
  63        BP_HARDWARE_BREAKPOINT,
  64        BP_WRITE_WATCHPOINT,
  65        BP_READ_WATCHPOINT,
  66        BP_ACCESS_WATCHPOINT,
  67        BP_POKE_BREAKPOINT,
  68};
  69
  70enum kgdb_bpstate {
  71        BP_UNDEFINED = 0,
  72        BP_REMOVED,
  73        BP_SET,
  74        BP_ACTIVE
  75};
  76
  77struct kgdb_bkpt {
  78        unsigned long           bpt_addr;
  79        unsigned char           saved_instr[BREAK_INSTR_SIZE];
  80        enum kgdb_bptype        type;
  81        enum kgdb_bpstate       state;
  82};
  83
  84struct dbg_reg_def_t {
  85        char *name;
  86        int size;
  87        int offset;
  88};
  89
  90#ifndef DBG_MAX_REG_NUM
  91#define DBG_MAX_REG_NUM 0
  92#else
  93extern struct dbg_reg_def_t dbg_reg_def[];
  94extern char *dbg_get_reg(int regno, void *mem, struct pt_regs *regs);
  95extern int dbg_set_reg(int regno, void *mem, struct pt_regs *regs);
  96#endif
  97#ifndef KGDB_MAX_BREAKPOINTS
  98# define KGDB_MAX_BREAKPOINTS   1000
  99#endif
 100
 101#define KGDB_HW_BREAKPOINT      1
 102
 103/*
 104 * Functions each KGDB-supporting architecture must provide:
 105 */
 106
 107/**
 108 *      kgdb_arch_init - Perform any architecture specific initalization.
 109 *
 110 *      This function will handle the initalization of any architecture
 111 *      specific callbacks.
 112 */
 113extern int kgdb_arch_init(void);
 114
 115/**
 116 *      kgdb_arch_exit - Perform any architecture specific uninitalization.
 117 *
 118 *      This function will handle the uninitalization of any architecture
 119 *      specific callbacks, for dynamic registration and unregistration.
 120 */
 121extern void kgdb_arch_exit(void);
 122
 123/**
 124 *      pt_regs_to_gdb_regs - Convert ptrace regs to GDB regs
 125 *      @gdb_regs: A pointer to hold the registers in the order GDB wants.
 126 *      @regs: The &struct pt_regs of the current process.
 127 *
 128 *      Convert the pt_regs in @regs into the format for registers that
 129 *      GDB expects, stored in @gdb_regs.
 130 */
 131extern void pt_regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *regs);
 132
 133/**
 134 *      sleeping_thread_to_gdb_regs - Convert ptrace regs to GDB regs
 135 *      @gdb_regs: A pointer to hold the registers in the order GDB wants.
 136 *      @p: The &struct task_struct of the desired process.
 137 *
 138 *      Convert the register values of the sleeping process in @p to
 139 *      the format that GDB expects.
 140 *      This function is called when kgdb does not have access to the
 141 *      &struct pt_regs and therefore it should fill the gdb registers
 142 *      @gdb_regs with what has been saved in &struct thread_struct
 143 *      thread field during switch_to.
 144 */
 145extern void
 146sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *p);
 147
 148/**
 149 *      gdb_regs_to_pt_regs - Convert GDB regs to ptrace regs.
 150 *      @gdb_regs: A pointer to hold the registers we've received from GDB.
 151 *      @regs: A pointer to a &struct pt_regs to hold these values in.
 152 *
 153 *      Convert the GDB regs in @gdb_regs into the pt_regs, and store them
 154 *      in @regs.
 155 */
 156extern void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *regs);
 157
 158/**
 159 *      kgdb_arch_handle_exception - Handle architecture specific GDB packets.
 160 *      @vector: The error vector of the exception that happened.
 161 *      @signo: The signal number of the exception that happened.
 162 *      @err_code: The error code of the exception that happened.
 163 *      @remcom_in_buffer: The buffer of the packet we have read.
 164 *      @remcom_out_buffer: The buffer of %BUFMAX bytes to write a packet into.
 165 *      @regs: The &struct pt_regs of the current process.
 166 *
 167 *      This function MUST handle the 'c' and 's' command packets,
 168 *      as well packets to set / remove a hardware breakpoint, if used.
 169 *      If there are additional packets which the hardware needs to handle,
 170 *      they are handled here.  The code should return -1 if it wants to
 171 *      process more packets, and a %0 or %1 if it wants to exit from the
 172 *      kgdb callback.
 173 */
 174extern int
 175kgdb_arch_handle_exception(int vector, int signo, int err_code,
 176                           char *remcom_in_buffer,
 177                           char *remcom_out_buffer,
 178                           struct pt_regs *regs);
 179
 180/**
 181 *      kgdb_roundup_cpus - Get other CPUs into a holding pattern
 182 *      @flags: Current IRQ state
 183 *
 184 *      On SMP systems, we need to get the attention of the other CPUs
 185 *      and get them into a known state.  This should do what is needed
 186 *      to get the other CPUs to call kgdb_wait(). Note that on some arches,
 187 *      the NMI approach is not used for rounding up all the CPUs. For example,
 188 *      in case of MIPS, smp_call_function() is used to roundup CPUs. In
 189 *      this case, we have to make sure that interrupts are enabled before
 190 *      calling smp_call_function(). The argument to this function is
 191 *      the flags that will be used when restoring the interrupts. There is
 192 *      local_irq_save() call before kgdb_roundup_cpus().
 193 *
 194 *      On non-SMP systems, this is not called.
 195 */
 196extern void kgdb_roundup_cpus(unsigned long flags);
 197
 198/**
 199 *      kgdb_arch_set_pc - Generic call back to the program counter
 200 *      @regs: Current &struct pt_regs.
 201 *  @pc: The new value for the program counter
 202 *
 203 *      This function handles updating the program counter and requires an
 204 *      architecture specific implementation.
 205 */
 206extern void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc);
 207
 208
 209/* Optional functions. */
 210extern int kgdb_validate_break_address(unsigned long addr);
 211extern int kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt);
 212extern int kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt);
 213
 214/**
 215 *      kgdb_arch_late - Perform any architecture specific initalization.
 216 *
 217 *      This function will handle the late initalization of any
 218 *      architecture specific callbacks.  This is an optional function for
 219 *      handling things like late initialization of hw breakpoints.  The
 220 *      default implementation does nothing.
 221 */
 222extern void kgdb_arch_late(void);
 223
 224
 225/**
 226 * struct kgdb_arch - Describe architecture specific values.
 227 * @gdb_bpt_instr: The instruction to trigger a breakpoint.
 228 * @flags: Flags for the breakpoint, currently just %KGDB_HW_BREAKPOINT.
 229 * @set_breakpoint: Allow an architecture to specify how to set a software
 230 * breakpoint.
 231 * @remove_breakpoint: Allow an architecture to specify how to remove a
 232 * software breakpoint.
 233 * @set_hw_breakpoint: Allow an architecture to specify how to set a hardware
 234 * breakpoint.
 235 * @remove_hw_breakpoint: Allow an architecture to specify how to remove a
 236 * hardware breakpoint.
 237 * @disable_hw_break: Allow an architecture to specify how to disable
 238 * hardware breakpoints for a single cpu.
 239 * @remove_all_hw_break: Allow an architecture to specify how to remove all
 240 * hardware breakpoints.
 241 * @correct_hw_break: Allow an architecture to specify how to correct the
 242 * hardware debug registers.
 243 */
 244struct kgdb_arch {
 245        unsigned char           gdb_bpt_instr[BREAK_INSTR_SIZE];
 246        unsigned long           flags;
 247
 248        int     (*set_breakpoint)(unsigned long, char *);
 249        int     (*remove_breakpoint)(unsigned long, char *);
 250        int     (*set_hw_breakpoint)(unsigned long, int, enum kgdb_bptype);
 251        int     (*remove_hw_breakpoint)(unsigned long, int, enum kgdb_bptype);
 252        void    (*disable_hw_break)(struct pt_regs *regs);
 253        void    (*remove_all_hw_break)(void);
 254        void    (*correct_hw_break)(void);
 255};
 256
 257/**
 258 * struct kgdb_io - Describe the interface for an I/O driver to talk with KGDB.
 259 * @name: Name of the I/O driver.
 260 * @read_char: Pointer to a function that will return one char.
 261 * @write_char: Pointer to a function that will write one char.
 262 * @flush: Pointer to a function that will flush any pending writes.
 263 * @init: Pointer to a function that will initialize the device.
 264 * @pre_exception: Pointer to a function that will do any prep work for
 265 * the I/O driver.
 266 * @post_exception: Pointer to a function that will do any cleanup work
 267 * for the I/O driver.
 268 * @is_console: 1 if the end device is a console 0 if the I/O device is
 269 * not a console
 270 */
 271struct kgdb_io {
 272        const char              *name;
 273        int                     (*read_char) (void);
 274        void                    (*write_char) (u8);
 275        void                    (*flush) (void);
 276        int                     (*init) (void);
 277        void                    (*pre_exception) (void);
 278        void                    (*post_exception) (void);
 279        int                     is_console;
 280};
 281
 282extern struct kgdb_arch         arch_kgdb_ops;
 283
 284extern unsigned long __weak kgdb_arch_pc(int exception, struct pt_regs *regs);
 285
 286extern int kgdb_register_io_module(struct kgdb_io *local_kgdb_io_ops);
 287extern void kgdb_unregister_io_module(struct kgdb_io *local_kgdb_io_ops);
 288extern struct kgdb_io *dbg_io_ops;
 289
 290extern int kgdb_hex2long(char **ptr, unsigned long *long_val);
 291extern char *kgdb_mem2hex(char *mem, char *buf, int count);
 292extern int kgdb_hex2mem(char *buf, char *mem, int count);
 293
 294extern int kgdb_isremovedbreak(unsigned long addr);
 295extern void kgdb_schedule_breakpoint(void);
 296
 297extern int
 298kgdb_handle_exception(int ex_vector, int signo, int err_code,
 299                      struct pt_regs *regs);
 300extern int kgdb_nmicallback(int cpu, void *regs);
 301extern void gdbstub_exit(int status);
 302
 303extern int                      kgdb_single_step;
 304extern atomic_t                 kgdb_active;
 305#define in_dbg_master() \
 306        (raw_smp_processor_id() == atomic_read(&kgdb_active))
 307extern bool dbg_is_early;
 308extern void __init dbg_late_init(void);
 309#else /* ! CONFIG_KGDB */
 310#define in_dbg_master() (0)
 311#define dbg_late_init()
 312#endif /* ! CONFIG_KGDB */
 313#endif /* _KGDB_H_ */
 314
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.