/* * arch/mips/kernel/gdb-stub.c * * Originally written by Glenn Engel, Lake Stevens Instrument Division * * Contributed by HP Systems * * Modified for SPARC by Stu Grossman, Cygnus Support. * * Modified for Linux/MIPS (and MIPS in general) by Andreas Busse * Send complaints, suggestions etc. to <andy@waldorf-gmbh.de> * * Copyright (C) 1995 Andreas Busse * * Copyright (C) 2003 MontaVista Software Inc. * Author: Jun Sun, jsun@mvista.com or jsun@junsun.net */ /* * To enable debugger support, two things need to happen. One, a * call to set_debug_traps() is necessary in order to allow any breakpoints * or error conditions to be properly intercepted and reported to gdb. * Two, a breakpoint needs to be generated to begin communication. This * is most easily accomplished by a call to breakpoint(). Breakpoint() * simulates a breakpoint by executing a BREAK instruction. * * * The following gdb commands are supported: * * command function Return value * * g return the value of the CPU registers hex data or ENN * G set the value of the CPU registers OK or ENN * * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN * * c Resume at current address SNN ( signal NN) * cAA..AA Continue at address AA..AA SNN * * s Step one instruction SNN * sAA..AA Step one instruction from AA..AA SNN * * k kill * * ? What was the last sigval ? SNN (signal NN) * * bBB..BB Set baud rate to BB..BB OK or BNN, then sets * baud rate * * All commands and responses are sent with a packet which includes a * checksum. A packet consists of * * $<packet info>#<checksum>. * * where * <packet info> :: <characters representing the command or response> * <checksum> :: < two hex digits computed as modulo 256 sum of <packetinfo>> * * When a packet is received, it is first acknowledged with either '+' or '-'. * '+' indicates a successful transfer. '-' indicates a failed transfer. * * Example: * * Host: Reply: * $m0,10#2a +$00010203040506070809101112131415#42 * * * ============== * MORE EXAMPLES: * ============== * * For reference -- the following are the steps that one * company took (RidgeRun Inc) to get remote gdb debugging * going. In this scenario the host machine was a PC and the * target platform was a Galileo EVB64120A MIPS evaluation * board. * * Step 1: * First download gdb-5.0.tar.gz from the internet. * and then build/install the package. * * Example: * $ tar zxf gdb-5.0.tar.gz * $ cd gdb-5.0 * $ ./configure --target=mips-linux-elf * $ make * $ install * $ which mips-linux-elf-gdb * /usr/local/bin/mips-linux-elf-gdb * * Step 2: * Configure linux for remote debugging and build it. * * Example: * $ cd ~/linux * $ make menuconfig <go to "Kernel Hacking" and turn on remote debugging> * $ make * * Step 3: * Download the kernel to the remote target and start * the kernel running. It will promptly halt and wait * for the host gdb session to connect. It does this * since the "Kernel Hacking" option has defined * CONFIG_KGDB which in turn enables your calls * to: * set_debug_traps(); * breakpoint(); * * Step 4: * Start the gdb session on the host. * * Example: * $ mips-linux-elf-gdb vmlinux * (gdb) set remotebaud 115200 * (gdb) target remote /dev/ttyS1 * ...at this point you are connected to * the remote target and can use gdb * in the normal fasion. Setting * breakpoints, single stepping, * printing variables, etc. */ #include <linux/string.h> #include <linux/kernel.h> #include <linux/signal.h> #include <linux/sched.h> #include <linux/mm.h> #include <linux/console.h> #include <linux/init.h> #include <linux/smp.h> #include <linux/spinlock.h> #include <linux/slab.h> #include <linux/reboot.h> #include <asm/asm.h> #include <asm/cacheflush.h> #include <asm/mipsregs.h> #include <asm/pgtable.h> #include <asm/system.h> #include <asm/gdb-stub.h> #include <asm/inst.h> #include <asm/smp.h> /* * external low-level support routines */ extern int putDebugChar(char c); /* write a single character */ extern char getDebugChar(void); /* read and return a single char */ extern void trap_low(void); /* * breakpoint and test functions */ extern void breakpoint(void); extern void breakinst(void); extern void async_breakpoint(void); extern void async_breakinst(void); extern void adel(void); /* * local prototypes */ static void getpacket(char *buffer); static void putpacket(char *buffer); static int computeSignal(int tt); static int hex(unsigned char ch); static int hexToInt(char **ptr, int *intValue); static int hexToLong(char **ptr, long *longValue); static unsigned char *mem2hex(char *mem, char *buf, int count, int may_fault); void handle_exception(struct gdb_regs *regs); int kgdb_enabled; /* * spin locks for smp case */ static DEFINE_SPINLOCK(kgdb_lock); static raw_spinlock_t kgdb_cpulock[NR_CPUS] = { [0 ... NR_CPUS-1] = __RAW_SPIN_LOCK_UNLOCKED, }; /* * BUFMAX defines the maximum number of characters in inbound/outbound buffers * at least NUMREGBYTES*2 are needed for register packets */ #define BUFMAX 2048 static char input_buffer[BUFMAX]; static char output_buffer[BUFMAX]; static int initialized; /* !0 means we've been initialized */ static int kgdb_started; static const char hexchars[]="0123456789abcdef"; /* Used to prevent crashes in memory access. Note that they'll crash anyway if we haven't set up fault handlers yet... */ int kgdb_read_byte(unsigned char *address, unsigned char *dest); int kgdb_write_byte(unsigned char val, unsigned char *dest); /* * Convert ch from a hex digit to an int */ static int hex(unsigned char ch) { if (ch >= 'a' && ch <= 'f') return ch-'a'+10; if (ch >= '0' && ch <= '9') return ch-'0'; if (ch >= 'A' && ch <= 'F') return ch-'A'+10; return -1; } /* * scan for the sequence $<data>#<checksum> */ static void getpacket(char *buffer) { unsigned char checksum; unsigned char xmitcsum; int i; int count; unsigned char ch; do { /* * wait around for the start character, * ignore all other characters */ while ((ch = (getDebugChar() & 0x7f)) != '$') ; checksum = 0; xmitcsum = -1; count = 0; /* * now, read until a # or end of buffer is found */ while (count < BUFMAX) { ch = getDebugChar(); if (ch == '#') break; checksum = checksum + ch; buffer[count] = ch; count = count + 1; } if (count >= BUFMAX) continue; buffer[count] = 0; if (ch == '#') { xmitcsum = hex(getDebugChar() & 0x7f) << 4; xmitcsum |= hex(getDebugChar() & 0x7f); if (checksum != xmitcsum) putDebugChar('-'); /* failed checksum */ else { putDebugChar('+'); /* successful transfer */ /* * if a sequence char is present, * reply the sequence ID */ if (buffer[2] == ':') { putDebugChar(buffer[0]); putDebugChar(buffer[1]); /* * remove sequence chars from buffer */ count = strlen(buffer); for (i=3; i <= count; i++) buffer[i-3] = buffer[i]; } } } } while (checksum != xmitcsum); } /* * send the packet in buffer. */ static void putpacket(char *buffer) { unsigned char checksum; int count; unsigned char ch; /* * $<packet info>#<checksum>. */ do { putDebugChar('$'); checksum = 0; count = 0; while ((ch = buffer[count]) != 0) { if (!(putDebugChar(ch))) return; checksum += ch; count += 1; } putDebugChar('#'); putDebugChar(hexchars[checksum >> 4]); putDebugChar(hexchars[checksum & 0xf]); } while ((getDebugChar() & 0x7f) != '+'); } /* * Convert the memory pointed to by mem into hex, placing result in buf. * Return a pointer to the last char put in buf (null), in case of mem fault, * return 0. * may_fault is non-zero if we are reading from arbitrary memory, but is currently * not used. */ static unsigned char *mem2hex(char *mem, char *buf, int count, int may_fault) { unsigned char ch; while (count-- > 0) { if (kgdb_read_byte(mem++, &ch) != 0) return 0; *buf++ = hexchars[ch >> 4]; *buf++ = hexchars[ch & 0xf]; } *buf = 0; return buf; } /* * convert the hex array pointed to by buf into binary to be placed in mem * return a pointer to the character AFTER the last byte written * may_fault is non-zero if we are reading from arbitrary memory, but is currently * not used. */ static char *hex2mem(char *buf, char *mem, int count, int binary, int may_fault) { int i; unsigned char ch; for (i=0; i<count; i++) { if (binary) { ch = *buf++; if (ch == 0x7d) ch = 0x20 ^ *buf++; } else { ch = hex(*buf++) << 4; ch |= hex(*buf++); } if (kgdb_write_byte(ch, mem++) != 0) return 0; } return mem; } /* * This table contains the mapping between SPARC hardware trap types, and * signals, which are primarily what GDB understands. It also indicates * which hardware traps we need to commandeer when initializing the stub. */ static struct hard_trap_info { unsigned char tt; /* Trap type code for MIPS R3xxx and R4xxx */ unsigned char signo; /* Signal that we map this trap into */ } hard_trap_info[] = { { 6, SIGBUS }, /* instruction bus error */ { 7, SIGBUS }, /* data bus error */ { 9, SIGTRAP }, /* break */ { 10, SIGILL }, /* reserved instruction */ /* { 11, SIGILL }, */ /* CPU unusable */ { 12, SIGFPE }, /* overflow */ { 13, SIGTRAP }, /* trap */ { 14, SIGSEGV }, /* virtual instruction cache coherency */ { 15, SIGFPE }, /* floating point exception */ { 23, SIGSEGV }, /* watch */ { 31, SIGSEGV }, /* virtual data cache coherency */ { 0, 0} /* Must be last */ }; /* Save the normal trap handlers for user-mode traps. */ void *saved_vectors[32]; /* * Set up exception handlers for tracing and breakpoints */ void set_debug_traps(void) { struct hard_trap_info *ht; unsigned long flags; unsigned char c; local_irq_save(flags); for (ht = hard_trap_info; ht->tt && ht->signo; ht++) saved_vectors[ht->tt] = set_except_vector(ht->tt, trap_low); putDebugChar('+'); /* 'hello world' */ /* * In case GDB is started before us, ack any packets * (presumably "$?#xx") sitting there. */ while((c = getDebugChar()) != '$'); while((c = getDebugChar()) != '#'); c = getDebugChar(); /* eat first csum byte */ c = getDebugChar(); /* eat second csum byte */ putDebugChar('+'); /* ack it */ initialized = 1; local_irq_restore(flags); } void restore_debug_traps(void) { struct hard_trap_info *ht; unsigned long flags; local_irq_save(flags); for (ht = hard_trap_info; ht->tt && ht->signo; ht++) set_except_vector(ht->tt, saved_vectors[ht->tt]); local_irq_restore(flags); } /* * Convert the MIPS hardware trap type code to a Unix signal number. */ static int computeSignal(int tt) { struct hard_trap_info *ht; for (ht = hard_trap_info; ht->tt && ht->signo; ht++) if (ht->tt == tt) return ht->signo; return SIGHUP; /* default for things we don't know about */ } /* * While we find nice hex chars, build an int. * Return number of chars processed. */ static int hexToInt(char **ptr, int *intValue) { int numChars = 0; int hexValue; *intValue = 0; while (**ptr) { hexValue = hex(**ptr); if (hexValue < 0) break; *intValue = (*intValue << 4) | hexValue; numChars ++; (*ptr)++; } return (numChars); } static int hexToLong(char **ptr, long *longValue) { int numChars = 0; int hexValue; *longValue = 0; while (**ptr) { hexValue = hex(**ptr); if (hexValue < 0) break; *longValue = (*longValue << 4) | hexValue; numChars ++; (*ptr)++; } return numChars; } #if 0 /* * Print registers (on target console) * Used only to debug the stub... */ void show_gdbregs(struct gdb_regs * regs) { /* * Saved main processor registers */ printk("$0 : %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", regs->reg0, regs->reg1, regs->reg2, regs->reg3, regs->reg4, regs->reg5, regs->reg6, regs->reg7); printk("$8 : %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", regs->reg8, regs->reg9, regs->reg10, regs->reg11, regs->reg12, regs->reg13, regs->reg14, regs->reg15); printk("$16: %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", regs->reg16, regs->reg17, regs->reg18, regs->reg19, regs->reg20, regs->reg21, regs->reg22, regs->reg23); printk("$24: %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", regs->reg24, regs->reg25, regs->reg26, regs->reg27, regs->reg28, regs->reg29, regs->reg30, regs->reg31); /* * Saved cp0 registers */ printk("epc : %08lx\nStatus: %08lx\nCause : %08lx\n", regs->cp0_epc, regs->cp0_status, regs->cp0_cause); } #endif /* dead code */ /* * We single-step by setting breakpoints. When an exception * is handled, we need to restore the instructions hoisted * when the breakpoints were set. * * This is where we save the original instructions. */ static struct gdb_bp_save { unsigned long addr; unsigned int val; } step_bp[2]; #define BP 0x0000000d /* break opcode */ /* * Set breakpoint instructions for single stepping. */ static void single_step(struct gdb_regs *regs) { union mips_instruction insn; unsigned long targ; int is_branch, is_cond, i; targ = regs->cp0_epc; insn.word = *(unsigned int *)targ; is_branch = is_cond = 0; switch (insn.i_format.opcode) { /* * jr and jalr are in r_format format. */ case spec_op: switch (insn.r_format.func) { case jalr_op: case jr_op: targ = *(®s->reg0 + insn.r_format.rs); is_branch = 1; break; } break; /* * This group contains: * bltz_op, bgez_op, bltzl_op, bgezl_op, * bltzal_op, bgezal_op, bltzall_op, bgezall_op. */ case bcond_op: is_branch = is_cond = 1; targ += 4 + (insn.i_format.simmediate << 2); break; /* * These are unconditional and in j_format. */ case jal_op: case j_op: is_branch = 1; targ += 4; targ >>= 28; targ <<= 28; targ |= (insn.j_format.target << 2); break; /* * These are conditional. */ case beq_op: case beql_op: case bne_op: case bnel_op: case blez_op: case blezl_op: case bgtz_op: case bgtzl_op: case cop0_op: case cop1_op: case cop2_op: case cop1x_op: is_branch = is_cond = 1; targ += 4 + (insn.i_format.simmediate << 2); break; } if (is_branch) { i = 0; if (is_cond && targ != (regs->cp0_epc + 8)) { step_bp[i].addr = regs->cp0_epc + 8; step_bp[i++].val = *(unsigned *)(regs->cp0_epc + 8); *(unsigned *)(regs->cp0_epc + 8) = BP; } step_bp[i].addr = targ; step_bp[i].val = *(unsigned *)targ; *(unsigned *)targ = BP; } else { step_bp[0].addr = regs->cp0_epc + 4; step_bp[0].val = *(unsigned *)(regs->cp0_epc + 4); *(unsigned *)(regs->cp0_epc + 4) = BP; } } /* * If asynchronously interrupted by gdb, then we need to set a breakpoint * at the interrupted instruction so that we wind up stopped with a * reasonable stack frame. */ static struct gdb_bp_save async_bp; /* * Swap the interrupted EPC with our asynchronous breakpoint routine. * This is safer than stuffing the breakpoint in-place, since no cache * flushes (or resulting smp_call_functions) are required. The * assumption is that only one CPU will be handling asynchronous bp's, * and only one can be active at a time. */ extern spinlock_t smp_call_lock; void set_async_breakpoint(unsigned long *epc) { /* skip breaking into userland */ if ((*epc & 0x80000000) == 0) return; #ifdef CONFIG_SMP /* avoid deadlock if someone is make IPC */ if (spin_is_locked(&smp_call_lock)) return; #endif async_bp.addr = *epc; *epc = (unsigned long)async_breakpoint; } static void kgdb_wait(void *arg) { unsigned flags; int cpu = smp_processor_id(); local_irq_save(flags); __raw_spin_lock(&kgdb_cpulock[cpu]); __raw_spin_unlock(&kgdb_cpulock[cpu]); local_irq_restore(flags); } /* * GDB stub needs to call kgdb_wait on all processor with interrupts * disabled, so it uses it's own special variant. */ static int kgdb_smp_call_kgdb_wait(void) { #ifdef CONFIG_SMP struct call_data_struct data; int i, cpus = num_online_cpus() - 1; int cpu = smp_processor_id(); /* * Can die spectacularly if this CPU isn't yet marked online */ BUG_ON(!cpu_online(cpu)); if (!cpus) return 0; if (spin_is_locked(&smp_call_lock)) { /* * Some other processor is trying to make us do something * but we're not going to respond... give up */ return -1; } /* * We will continue here, accepting the fact that * the kernel may deadlock if another CPU attempts * to call smp_call_function now... */ data.func = kgdb_wait; data.info = NULL; atomic_set(&data.started, 0); data.wait = 0; spin_lock(&smp_call_lock); call_data = &data; mb(); /* Send a message to all other CPUs and wait for them to respond */ for (i = 0; i < NR_CPUS; i++) if (cpu_online(i) && i != cpu) core_send_ipi(i, SMP_CALL_FUNCTION); /* Wait for response */ /* FIXME: lock-up detection, backtrace on lock-up */ while (atomic_read(&data.started) != cpus) barrier(); call_data = NULL; spin_unlock(&smp_call_lock); #endif return 0; } /* * This function does all command processing for interfacing to gdb. It * returns 1 if you should skip the instruction at the trap address, 0 * otherwise. */ void handle_exception (struct gdb_regs *regs) { int trap; /* Trap type */ int sigval; long addr; int length; char *ptr; unsigned long *stack; int i; int bflag = 0; kgdb_started = 1; /* * acquire the big kgdb spinlock */ if (!spin_trylock(&kgdb_lock)) { /* * some other CPU has the lock, we should go back to * receive the gdb_wait IPC */ return; } /* * If we're in async_breakpoint(), restore the real EPC from * the breakpoint. */ if (regs->cp0_epc == (unsigned long)async_breakinst) { regs->cp0_epc = async_bp.addr; async_bp.addr = 0; } /* * acquire the CPU spinlocks */ for (i = num_online_cpus()-1; i >= 0; i--) if (__raw_spin_trylock(&kgdb_cpulock[i]) == 0) panic("kgdb: couldn't get cpulock %d\n", i); /* * force other cpus to enter kgdb */ kgdb_smp_call_kgdb_wait(); /* * If we're in breakpoint() increment the PC */ trap = (regs->cp0_cause & 0x7c) >> 2; if (trap == 9 && regs->cp0_epc == (unsigned long)breakinst) regs->cp0_epc += 4; /* * If we were single_stepping, restore the opcodes hoisted * for the breakpoint[s]. */ if (step_bp[0].addr) { *(unsigned *)step_bp[0].addr = step_bp[0].val; step_bp[0].addr = 0; if (step_bp[1].addr) { *(unsigned *)step_bp[1].addr = step_bp[1].val; step_bp[1].addr = 0; } } stack = (long *)regs->reg29; /* stack ptr */ sigval = computeSignal(trap); /* * reply to host that an exception has occurred */ ptr = output_buffer; /* * Send trap type (converted to signal) */ *ptr++ = 'T'; *ptr++ = hexchars[sigval >> 4]; *ptr++ = hexchars[sigval & 0xf]; /* * Send Error PC */ *ptr++ = hexchars[REG_EPC >> 4]; *ptr++ = hexchars[REG_EPC & 0xf]; *ptr++ = ':'; ptr = mem2hex((char *)®s->cp0_epc, ptr, sizeof(long), 0); *ptr++ = ';'; /* * Send frame pointer */ *ptr++ = hexchars[REG_FP >> 4]; *ptr++ = hexchars[REG_FP & 0xf]; *ptr++ = ':'; ptr = mem2hex((char *)®s->reg30, ptr, sizeof(long), 0); *ptr++ = ';'; /* * Send stack pointer */ *ptr++ = hexchars[REG_SP >> 4]; *ptr++ = hexchars[REG_SP & 0xf]; *ptr++ = ':'; ptr = mem2hex((char *)®s->reg29, ptr, sizeof(long), 0); *ptr++ = ';'; *ptr++ = 0; putpacket(output_buffer); /* send it off... */ /* * Wait for input from remote GDB */ while (1) { output_buffer[0] = 0; getpacket(input_buffer); switch (input_buffer[0]) { case '?': output_buffer[0] = 'S'; output_buffer[1] = hexchars[sigval >> 4]; output_buffer[2] = hexchars[sigval & 0xf]; output_buffer[3] = 0; break; /* * Detach debugger; let CPU run */ case 'D': putpacket(output_buffer); goto finish_kgdb; break; case 'd': /* toggle debug flag */ break; /* * Return the value of the CPU registers */ case 'g': ptr = output_buffer; ptr = mem2hex((char *)®s->reg0, ptr, 32*sizeof(long), 0); /* r0...r31 */ ptr = mem2hex((char *)®s->cp0_status, ptr, 6*sizeof(long), 0); /* cp0 */ ptr = mem2hex((char *)®s->fpr0, ptr, 32*sizeof(long), 0); /* f0...31 */ ptr = mem2hex((char *)®s->cp1_fsr, ptr, 2*sizeof(long), 0); /* cp1 */ ptr = mem2hex((char *)®s->frame_ptr, ptr, 2*sizeof(long), 0); /* frp */ ptr = mem2hex((char *)®s->cp0_index, ptr, 16*sizeof(long), 0); /* cp0 */ break; /* * set the value of the CPU registers - return OK */ case 'G': { ptr = &input_buffer[1]; hex2mem(ptr, (char *)®s->reg0, 32*sizeof(long), 0, 0); ptr += 32*(2*sizeof(long)); hex2mem(ptr, (char *)®s->cp0_status, 6*sizeof(long), 0, 0); ptr += 6*(2*sizeof(long)); hex2mem(ptr, (char *)®s->fpr0, 32*sizeof(long), 0, 0); ptr += 32*(2*sizeof(long)); hex2mem(ptr, (char *)®s->cp1_fsr, 2*sizeof(long), 0, 0); ptr += 2*(2*sizeof(long)); hex2mem(ptr, (char *)®s->frame_ptr, 2*sizeof(long), 0, 0); ptr += 2*(2*sizeof(long)); hex2mem(ptr, (char *)®s->cp0_index, 16*sizeof(long), 0, 0); strcpy(output_buffer,"OK"); } break; /* * mAA..AA,LLLL Read LLLL bytes at address AA..AA */ case 'm': ptr = &input_buffer[1]; if (hexToLong(&ptr, &addr) && *ptr++ == ',' && hexToInt(&ptr, &length)) { if (mem2hex((char *)addr, output_buffer, length, 1)) break; strcpy (output_buffer, "E03"); } else strcpy(output_buffer,"E01"); break; /* * XAA..AA,LLLL: Write LLLL escaped binary bytes at address AA.AA */ case 'X': bflag = 1; /* fall through */ /* * MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */ case 'M': ptr = &input_buffer[1]; if (hexToLong(&ptr, &addr) && *ptr++ == ',' && hexToInt(&ptr, &length) && *ptr++ == ':') { if (hex2mem(ptr, (char *)addr, length, bflag, 1)) strcpy(output_buffer, "OK"); else strcpy(output_buffer, "E03"); } else strcpy(output_buffer, "E02"); break; /* * cAA..AA Continue at address AA..AA(optional) */ case 'c': /* try to read optional parameter, pc unchanged if no parm */ ptr = &input_buffer[1]; if (hexToLong(&ptr, &addr)) regs->cp0_epc = addr; goto exit_kgdb_exception; break; /* * kill the program; let us try to restart the machine * Reset the whole machine. */ case 'k': case 'r': machine_restart("kgdb restarts machine"); break; /* * Step to next instruction */ case 's': /* * There is no single step insn in the MIPS ISA, so we * use breakpoints and continue, instead. */ single_step(regs); goto exit_kgdb_exception; /* NOTREACHED */ break; /* * Set baud rate (bBB) * FIXME: Needs to be written */ case 'b': { #if 0 int baudrate; extern void set_timer_3(); ptr = &input_buffer[1]; if (!hexToInt(&ptr, &baudrate)) { strcpy(output_buffer,"B01"); break; } /* Convert baud rate to uart clock divider */ switch (baudrate) { case 38400: baudrate = 16; break; case 19200: baudrate = 33; break; case 9600: baudrate = 65; break; default: baudrate = 0; strcpy(output_buffer,"B02"); goto x1; } if (baudrate) { putpacket("OK"); /* Ack before changing speed */ set_timer_3(baudrate); /* Set it */ } #endif } break; } /* switch */ /* * reply to the request */ putpacket(output_buffer); } /* while */ return; finish_kgdb: restore_debug_traps(); exit_kgdb_exception: /* release locks so other CPUs can go */ for (i = num_online_cpus()-1; i >= 0; i--) __raw_spin_unlock(&kgdb_cpulock[i]); spin_unlock(&kgdb_lock); __flush_cache_all(); return; } /* * This function will generate a breakpoint exception. It is used at the * beginning of a program to sync up with a debugger and can be used * otherwise as a quick means to stop program execution and "break" into * the debugger. */ void breakpoint(void) { if (!initialized) return; __asm__ __volatile__( ".globl breakinst\n\t" ".set\tnoreorder\n\t" "nop\n" "breakinst:\tbreak\n\t" "nop\n\t" ".set\treorder" ); } /* Nothing but the break; don't pollute any registers */ void async_breakpoint(void) { __asm__ __volatile__( ".globl async_breakinst\n\t" ".set\tnoreorder\n\t" "nop\n" "async_breakinst:\tbreak\n\t" "nop\n\t" ".set\treorder" ); } void adel(void) { __asm__ __volatile__( ".globl\tadel\n\t" "lui\t$8,0x8000\n\t" "lw\t$9,1($8)\n\t" ); } /* * malloc is needed by gdb client in "call func()", even a private one * will make gdb happy */ static void * __attribute_used__ malloc(size_t size) { return kmalloc(size, GFP_ATOMIC); } static void __attribute_used__ free (void *where) { kfree(where); } #ifdef CONFIG_GDB_CONSOLE void gdb_putsn(const char *str, int l) { char outbuf[18]; if (!kgdb_started) return; outbuf[0]='O'; while(l) { int i = (l>8)?8:l; mem2hex((char *)str, &outbuf[1], i, 0); outbuf[(i*2)+1]=0; putpacket(outbuf); str += i; l -= i; } } static void gdb_console_write(struct console *con, const char *s, unsigned n) { gdb_putsn(s, n); } static struct console gdb_console = { .name = "gdb", .write = gdb_console_write, .flags = CON_PRINTBUFFER, .index = -1 }; static int __init register_gdb_console(void) { register_console(&gdb_console); return 0; } console_initcall(register_gdb_console); #endif