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 20#include <asm/atomic.h> 21#include <asm/kgdb.h> 22 23struct pt_regs; 24 25/** 26 * kgdb_skipexception - (optional) exit kgdb_handle_exception early 27 * @exception: Exception vector number 28 * @regs: Current &struct pt_regs. 29 * 30 * On some architectures it is required to skip a breakpoint 31 * exception when it occurs after a breakpoint has been removed. 32 * This can be implemented in the architecture specific portion of 33 * for kgdb. 34 */ 35extern int kgdb_skipexception(int exception, struct pt_regs *regs); 36 37/** 38 * kgdb_post_primary_code - (optional) Save error vector/code numbers. 39 * @regs: Original pt_regs. 40 * @e_vector: Original error vector. 41 * @err_code: Original error code. 42 * 43 * This is usually needed on architectures which support SMP and 44 * KGDB. This function is called after all the secondary cpus have 45 * been put to a know spin state and the primary CPU has control over 46 * KGDB. 47 */ 48extern void kgdb_post_primary_code(struct pt_regs *regs, int e_vector, 49 int err_code); 50 51/** 52 * kgdb_disable_hw_debug - (optional) Disable hardware debugging hook 53 * @regs: Current &struct pt_regs. 54 * 55 * This function will be called if the particular architecture must 56 * disable hardware debugging while it is processing gdb packets or 57 * handling exception. 58 */ 59extern void kgdb_disable_hw_debug(struct pt_regs *regs); 60 61struct tasklet_struct; 62struct task_struct; 63struct uart_port; 64 65/** 66 * kgdb_breakpoint - compiled in breakpoint 67 * 68 * This will be impelmented a static inline per architecture. This 69 * function is called by the kgdb core to execute an architecture 70 * specific trap to cause kgdb to enter the exception processing. 71 * 72 */ 73void kgdb_breakpoint(void); 74 75extern int kgdb_connected; 76 77extern atomic_t kgdb_setting_breakpoint; 78extern atomic_t kgdb_cpu_doing_single_step; 79 80extern struct task_struct *kgdb_usethread; 81extern struct task_struct *kgdb_contthread; 82 83enum kgdb_bptype { 84 BP_BREAKPOINT = 0, 85 BP_HARDWARE_BREAKPOINT, 86 BP_WRITE_WATCHPOINT, 87 BP_READ_WATCHPOINT, 88 BP_ACCESS_WATCHPOINT 89}; 90 91enum kgdb_bpstate { 92 BP_UNDEFINED = 0, 93 BP_REMOVED, 94 BP_SET, 95 BP_ACTIVE 96}; 97 98struct kgdb_bkpt { 99 unsigned long bpt_addr; 100 unsigned char saved_instr[BREAK_INSTR_SIZE]; 101 enum kgdb_bptype type; 102 enum kgdb_bpstate state; 103}; 104 105#ifndef KGDB_MAX_BREAKPOINTS 106# define KGDB_MAX_BREAKPOINTS 1000 107#endif 108 109#define KGDB_HW_BREAKPOINT 1 110 111/* 112 * Functions each KGDB-supporting architecture must provide: 113 */ 114 115/** 116 * kgdb_arch_init - Perform any architecture specific initalization. 117 * 118 * This function will handle the initalization of any architecture 119 * specific callbacks. 120 */ 121extern int kgdb_arch_init(void); 122 123/** 124 * kgdb_arch_exit - Perform any architecture specific uninitalization. 125 * 126 * This function will handle the uninitalization of any architecture 127 * specific callbacks, for dynamic registration and unregistration. 128 */ 129extern void kgdb_arch_exit(void); 130 131/** 132 * pt_regs_to_gdb_regs - Convert ptrace regs to GDB regs 133 * @gdb_regs: A pointer to hold the registers in the order GDB wants. 134 * @regs: The &struct pt_regs of the current process. 135 * 136 * Convert the pt_regs in @regs into the format for registers that 137 * GDB expects, stored in @gdb_regs. 138 */ 139extern void pt_regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *regs); 140 141/** 142 * sleeping_thread_to_gdb_regs - Convert ptrace regs to GDB regs 143 * @gdb_regs: A pointer to hold the registers in the order GDB wants. 144 * @p: The &struct task_struct of the desired process. 145 * 146 * Convert the register values of the sleeping process in @p to 147 * the format that GDB expects. 148 * This function is called when kgdb does not have access to the 149 * &struct pt_regs and therefore it should fill the gdb registers 150 * @gdb_regs with what has been saved in &struct thread_struct 151 * thread field during switch_to. 152 */ 153extern void 154sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *p); 155 156/** 157 * gdb_regs_to_pt_regs - Convert GDB regs to ptrace regs. 158 * @gdb_regs: A pointer to hold the registers we've received from GDB. 159 * @regs: A pointer to a &struct pt_regs to hold these values in. 160 * 161 * Convert the GDB regs in @gdb_regs into the pt_regs, and store them 162 * in @regs. 163 */ 164extern void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *regs); 165 166/** 167 * kgdb_arch_handle_exception - Handle architecture specific GDB packets. 168 * @vector: The error vector of the exception that happened. 169 * @signo: The signal number of the exception that happened. 170 * @err_code: The error code of the exception that happened. 171 * @remcom_in_buffer: The buffer of the packet we have read. 172 * @remcom_out_buffer: The buffer of %BUFMAX bytes to write a packet into. 173 * @regs: The &struct pt_regs of the current process. 174 * 175 * This function MUST handle the 'c' and 's' command packets, 176 * as well packets to set / remove a hardware breakpoint, if used. 177 * If there are additional packets which the hardware needs to handle, 178 * they are handled here. The code should return -1 if it wants to 179 * process more packets, and a %0 or %1 if it wants to exit from the 180 * kgdb callback. 181 */ 182extern int 183kgdb_arch_handle_exception(int vector, int signo, int err_code, 184 char *remcom_in_buffer, 185 char *remcom_out_buffer, 186 struct pt_regs *regs); 187 188/** 189 * kgdb_roundup_cpus - Get other CPUs into a holding pattern 190 * @flags: Current IRQ state 191 * 192 * On SMP systems, we need to get the attention of the other CPUs 193 * and get them be in a known state. This should do what is needed 194 * to get the other CPUs to call kgdb_wait(). Note that on some arches, 195 * the NMI approach is not used for rounding up all the CPUs. For example, 196 * in case of MIPS, smp_call_function() is used to roundup CPUs. In 197 * this case, we have to make sure that interrupts are enabled before 198 * calling smp_call_function(). The argument to this function is 199 * the flags that will be used when restoring the interrupts. There is 200 * local_irq_save() call before kgdb_roundup_cpus(). 201 * 202 * On non-SMP systems, this is not called. 203 */ 204extern void kgdb_roundup_cpus(unsigned long flags); 205 206/* Optional functions. */ 207extern int kgdb_validate_break_address(unsigned long addr); 208extern int kgdb_arch_set_breakpoint(unsigned long addr, char *saved_instr); 209extern int kgdb_arch_remove_breakpoint(unsigned long addr, char *bundle); 210 211/** 212 * struct kgdb_arch - Describe architecture specific values. 213 * @gdb_bpt_instr: The instruction to trigger a breakpoint. 214 * @flags: Flags for the breakpoint, currently just %KGDB_HW_BREAKPOINT. 215 * @set_breakpoint: Allow an architecture to specify how to set a software 216 * breakpoint. 217 * @remove_breakpoint: Allow an architecture to specify how to remove a 218 * software breakpoint. 219 * @set_hw_breakpoint: Allow an architecture to specify how to set a hardware 220 * breakpoint. 221 * @remove_hw_breakpoint: Allow an architecture to specify how to remove a 222 * hardware breakpoint. 223 * @remove_all_hw_break: Allow an architecture to specify how to remove all 224 * hardware breakpoints. 225 * @correct_hw_break: Allow an architecture to specify how to correct the 226 * hardware debug registers. 227 */ 228struct kgdb_arch { 229 unsigned char gdb_bpt_instr[BREAK_INSTR_SIZE]; 230 unsigned long flags; 231 232 int (*set_breakpoint)(unsigned long, char *); 233 int (*remove_breakpoint)(unsigned long, char *); 234 int (*set_hw_breakpoint)(unsigned long, int, enum kgdb_bptype); 235 int (*remove_hw_breakpoint)(unsigned long, int, enum kgdb_bptype); 236 void (*remove_all_hw_break)(void); 237 void (*correct_hw_break)(void); 238}; 239 240/** 241 * struct kgdb_io - Describe the interface for an I/O driver to talk with KGDB. 242 * @name: Name of the I/O driver. 243 * @read_char: Pointer to a function that will return one char. 244 * @write_char: Pointer to a function that will write one char. 245 * @flush: Pointer to a function that will flush any pending writes. 246 * @init: Pointer to a function that will initialize the device. 247 * @pre_exception: Pointer to a function that will do any prep work for 248 * the I/O driver. 249 * @post_exception: Pointer to a function that will do any cleanup work 250 * for the I/O driver. 251 */ 252struct kgdb_io { 253 const char *name; 254 int (*read_char) (void); 255 void (*write_char) (u8); 256 void (*flush) (void); 257 int (*init) (void); 258 void (*pre_exception) (void); 259 void (*post_exception) (void); 260}; 261 262extern struct kgdb_arch arch_kgdb_ops; 263 264extern unsigned long __weak kgdb_arch_pc(int exception, struct pt_regs *regs); 265 266extern int kgdb_register_io_module(struct kgdb_io *local_kgdb_io_ops); 267extern void kgdb_unregister_io_module(struct kgdb_io *local_kgdb_io_ops); 268 269extern int kgdb_hex2long(char **ptr, unsigned long *long_val); 270extern int kgdb_mem2hex(char *mem, char *buf, int count); 271extern int kgdb_hex2mem(char *buf, char *mem, int count); 272 273extern int kgdb_isremovedbreak(unsigned long addr); 274 275extern int 276kgdb_handle_exception(int ex_vector, int signo, int err_code, 277 struct pt_regs *regs); 278extern int kgdb_nmicallback(int cpu, void *regs); 279 280extern int kgdb_single_step; 281extern atomic_t kgdb_active; 282 283#endif /* _KGDB_H_ */ 284