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