Re: kgdb-lite for 2.6.2

From: Amit S. Kale
Date: Wed Feb 18 2004 - 00:07:31 EST

Next message: Andrew Morton: "Re: [PATCH][0/6] A different KGDB stub"
Previous message: Amit S. Kale: "Re: [PATCH][0/6] A different KGDB stub"
In reply to: Amit S. Kale: "Re: kgdb-lite for 2.6.2"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

There is one bug report of a kernel segfault for this kgdb core. It occurs
when same breakpoint is hit on two processors. I am waiting on feedback for a
fix for this problem from Luben. Luben, Any progress?

If someone else volunteers to test the fix on an SMP machine, I'll send a kgdb
with this fix.

Thanks.
-Amit

On Tuesday 17 Feb 2004 6:07 pm, Amit S. Kale wrote:
> On Tuesday 17 Feb 2004 5:06 pm, Pavel Machek wrote:
> > Hi!
> >
> > kgdb-lite is version of kgdb with thread support and console-over-kgdb
> > support removed, to reduce impact on generic code.
>
> console-over-kgdb code is present, though the kernel configuration option
> for the same is removed. We can add that later.
>
> module.c changes are absent. Without them module unloading in gdb will not
> work correctly. Automatic module loading stuff is anyway broken on 2.6
> kgdbs. That's because module information structures have changed. I'll be
> fixing that soon.
>
> -Amit
>
> > This is only arch-independend part. Does it look like it could be
> > included in the -mm?
> > Pavel
> >
> >
> > --- clean.2.5/Makefile 2004-02-05 01:53:53.000000000 +0100
> > +++ linux-mm/Makefile 2004-02-16 23:09:06.000000000 +0100
> > @@ -440,6 +440,8 @@
> >
> > ifndef CONFIG_FRAME_POINTER
> > CFLAGS += -fomit-frame-pointer
> > +else
> > +CFLAGS += -fno-omit-frame-pointer
> > endif
> >
> > ifdef CONFIG_DEBUG_INFO
> > --- clean.2.5/drivers/serial/8250.c 2004-01-09 20:24:22.000000000 +0100
> > +++ linux-mm/drivers/serial/8250.c 2004-02-16 23:09:06.000000000 +0100
> > @@ -1198,12 +1198,17 @@
> > spin_unlock_irqrestore(&up->port.lock, flags);
> > }
> >
> > +static int released_irq = -1;
> > +
> > static int serial8250_startup(struct uart_port *port)
> > {
> > struct uart_8250_port *up = (struct uart_8250_port *)port;
> > unsigned long flags;
> > int retval;
> >
> > + if (up->port.irq == released_irq)
> > + return -EBUSY;
> > +
> > up->capabilities = uart_config[up->port.type].flags;
> >
> > if (up->port.type == PORT_16C950) {
> > @@ -1869,6 +1874,10 @@
> > for (i = 0; i < UART_NR; i++) {
> > struct uart_8250_port *up = &serial8250_ports[i];
> >
> > + if (up->port.irq == released_irq) {
> > + continue;
> > + }
> > +
> > up->port.line = i;
> > up->port.ops = &serial8250_pops;
> > init_timer(&up->timer);
> > @@ -2138,6 +2147,36 @@
> > uart_resume_port(&serial8250_reg, &serial8250_ports[line].port);
> > }
> >
> > +/*
> > + * Find all the ports using the given irq and shut them down.
> > + * Result should be that the irq will be released.
> > + * At most one irq can be released this way.
> > + * Once an irq is released, any attempts to initialize a port with that
> > irq + * will fail with EBUSY.
> > + */
> > +
> > +int serial8250_release_irq(int irq)
> > +{
> > + struct uart_8250_port *up;
> > + int ttyS;
> > +
> > + if (released_irq != -1) {
> > + return -EBUSY;
> > + }
> > + released_irq = irq;
> > + for (ttyS = 0; ttyS < UART_NR; ttyS++){
> > + up = &serial8250_ports[ttyS];
> > + if (up->port.irq == irq && (irq_lists + irq)->head) {
> > +#ifdef CONFIG_DEBUG_SPINLOCK /* ugly business... */
> > + if(up->port.lock.magic != SPINLOCK_MAGIC)
> > + spin_lock_init(&up->port.lock);
> > +#endif
> > + serial8250_shutdown(&up->port);
> > + }
> > + }
> > + return 0;
> > +}
> > +
> > static int __init serial8250_init(void)
> > {
> > int ret, i;
> > --- clean.2.5/drivers/serial/Kconfig 2004-02-05 01:54:11.000000000 +0100
> > +++ linux-mm/drivers/serial/Kconfig 2004-02-16 23:09:06.000000000 +0100
> > @@ -6,6 +6,13 @@
> >
> > menu "Serial drivers"
> >
> > +config KGDB_8250
> > + bool "KGDB: On generic serial port (8250)"
> > + depends on KGDB
> > + help
> > + Uses generic serial port (8250) for kgdb. This is independent of the
> > + option 9250/16550 and compatible serial port.
> > +
> > #
> > # The new 8250/16550 serial drivers
> > config SERIAL_8250
> > --- clean.2.5/drivers/serial/Makefile 2003-09-28 22:06:15.000000000 +0200
> > +++ linux-mm/drivers/serial/Makefile 2004-02-16 23:09:06.000000000 +0100
> > @@ -32,3 +32,5 @@
> > obj-$(CONFIG_V850E_UART) += v850e_uart.o
> > obj-$(CONFIG_SERIAL98) += serial98.o
> > obj-$(CONFIG_SERIAL_PMACZILOG) += pmac_zilog.o
> > +
> > +obj-$(CONFIG_KGDB_8250) += kgdb_8250.o
> > --- clean.2.5/drivers/serial/kgdb_8250.c 2004-02-17 11:37:58.000000000
> > +0100 +++ linux-mm/drivers/serial/kgdb_8250.c 2004-02-16
> > 23:32:39.000000000 +0100 @@ -0,0 +1,396 @@
> > +/*
> > + * 8250 interface for kgdb.
> > + *
> > + * Restructured for making kgdb capable of handling different types of
> > serial + * interfaces, by Amit Kale (amitkale@xxxxxxxxxxxxx)
> > + *
> > + * Written (hacked together) by David Grothe (dave@xxxxxxxx)
> > + *
> > + * Modified by Scott Foehner (sfoehner@xxxxxxxxxxxx) to allow connect
> > + * on boot-up
> > + *
> > + */
> > +
> > +#include <linux/module.h>
> > +#include <linux/errno.h>
> > +#include <linux/signal.h>
> > +#include <linux/sched.h>
> > +#include <linux/timer.h>
> > +#include <linux/interrupt.h>
> > +#include <linux/tty.h>
> > +#include <linux/tty_flip.h>
> > +#include <linux/serial.h>
> > +#include <linux/serial_core.h>
> > +#include <linux/serial_reg.h>
> > +#include <linux/serialP.h>
> > +#include <linux/config.h>
> > +#include <linux/major.h>
> > +#include <linux/string.h>
> > +#include <linux/fcntl.h>
> > +#include <linux/termios.h>
> > +#include <linux/kgdb.h>
> > +
> > +#include <asm/system.h>
> > +#include <asm/io.h>
> > +#include <asm/segment.h>
> > +#include <asm/bitops.h>
> > +#include <asm/system.h>
> > +#include <asm/irq.h>
> > +#include <asm/atomic.h>
> > +
> > +#define GDB_BUF_SIZE 512 /* power of 2, please */
> > +
> > +static char kgdb8250_buf[GDB_BUF_SIZE];
> > +static int kgdb8250_buf_in_inx;
> > +static atomic_t kgdb8250_buf_in_cnt;
> > +static int kgdb8250_buf_out_inx;
> > +
> > +
> > +static int kgdb8250_got_dollar = -3, kgdb8250_got_H = -3,
> > + kgdb8250_interrupt_iteration = 0;
> > +
> > +/* We only allow for 4 ports to be registered. We default to standard
> > + * PC values. */
> > +static struct uart_port rs_table[4] = {
> > + { .line = 0x3f8, .irq = 4 },
> > + { .line = 0x2f8, .irq = 3 },
> > + { .line = 0x3e8, .irq = 4 },
> > + { .line = 0x2e8, .irq = 3 },
> > +};
> > +static void (*serial_outb)(unsigned char, unsigned long);
> > +static unsigned long (*serial_inb)(unsigned long);
> > +
> > +int serial8250_release_irq(int irq);
> > +
> > +int kgdb8250_irq;
> > +unsigned long kgdb8250_port;
> > +
> > +int kgdb8250_baud = 115200;
> > +int kgdb8250_ttyS;
> > +
> > +static unsigned long direct_inb(unsigned long addr)
> > +{
> > + return readb(addr);
> > +}
> > +
> > +static void direct_outb(unsigned char val, unsigned long addr)
> > +{
> > + writeb(val, addr);
> > +}
> > +
> > +static unsigned long io_inb(unsigned long port)
> > +{
> > + return inb(port);
> > +}
> > +
> > +static void io_outb(unsigned char val, unsigned long port)
> > +{
> > + outb(val, port);
> > +}
> > +
> > +/*
> > + * Get a byte from the hardware data buffer and return it
> > + * Get a char if available, return -EAGAIN if nothing available.
> > + */
> > +static int read_data_bfr(void)
> > +{
> > + if (serial_inb(kgdb8250_port + UART_LSR) & UART_LSR_DR)
> > + return(serial_inb(kgdb8250_port + UART_RX));
> > +
> > + return -EAGAIN;
> > +}
> > +
> > +/*
> > + * Empty the receive buffer first, then look at the interface hardware.
> > + * It waits for a character from the serial interface and then returns
> > it. + */
> > +static int kgdb8250_read_char(void)
> > +{
> > + int retchar;
> > + if (atomic_read(&kgdb8250_buf_in_cnt) != 0)
> > + {
> > + /* intr routine has q'd chars read them from buffer */
> > + int chr;
> > +
> > + chr = kgdb8250_buf[kgdb8250_buf_out_inx++];
> > + kgdb8250_buf_out_inx &= (GDB_BUF_SIZE - 1);
> > + atomic_dec(&kgdb8250_buf_in_cnt);
> > + return chr;
> > + }
> > + do {
> > + /* read from hardware */
> > + retchar = read_data_bfr();
> > + } while (retchar < 0);
> > + return retchar;
> > +}
> > +
> > +/*
> > + * Wait until the interface can accept a char, then write it.
> > + */
> > +static void kgdb8250_write_char(int chr)
> > +{
> > + while (!(serial_inb(kgdb8250_port + UART_LSR) & UART_LSR_THRE))
> > + /* Do nothing */;
> > +
> > + serial_outb(chr, kgdb8250_port+UART_TX);
> > +
> > +}
> > +
> > +/*
> > + * This is the receiver interrupt routine for the GDB stub.
> > + * It will receive a limited number of characters of input
> > + * from the gdb host machine and save them up in a buffer.
> > + *
> > + * When kgdb8250_read_char() is called it
> > + * draws characters out of the buffer until it is empty and
> > + * then reads directly from the serial port.
> > + *
> > + * We do not attempt to write chars from the interrupt routine
> > + * since the stubs do all of that via kgdb8250_write_char() which
> > + * writes one byte after waiting for the interface to become
> > + * ready.
> > + *
> > + * The debug stubs like to run with interrupts disabled since,
> > + * after all, they run as a consequence of a breakpoint in
> > + * the kernel.
> > + *
> > + * Perhaps someone who knows more about the tty driver than I
> > + * care to learn can make this work for any low level serial
> > + * driver.
> > + */
> > +static irqreturn_t kgdb8250_interrupt(int irq, void *dev_id,
> > + struct pt_regs * regs)
> > +{
> > + int chr;
> > + int iir;
> > +
> > + do
> > + {
> > + chr = read_data_bfr();
> > + iir = serial_inb(kgdb8250_port + UART_IIR);
> > + if (chr < 0) continue ;
> > +
> > + /* Check whether gdb sent interrupt */
> > + if (chr == 3)
> > + {
> > + breakpoint();
> > + continue ;
> > + }
> > +
> > + if(atomic_read(&kgdb_killed_or_detached)) {
> > + if (chr == '$')
> > + kgdb8250_got_dollar = kgdb8250_interrupt_iteration;
> > + if (kgdb8250_interrupt_iteration == kgdb8250_got_dollar + 1 &&
> > + chr == 'H')
> > + kgdb8250_got_H = kgdb8250_interrupt_iteration;
> > + else if (kgdb8250_interrupt_iteration == kgdb8250_got_H + 1 &&
> > + chr == 'c') {
> > + kgdb8250_buf[kgdb8250_buf_in_inx++] = chr;
> > + atomic_inc(&kgdb8250_buf_in_cnt);
> > + atomic_set(&kgdb_might_be_resumed, 1);
> > + wmb();
> > + breakpoint();
> > + atomic_set(&kgdb_might_be_resumed, 0);
> > + kgdb8250_interrupt_iteration = 0;
> > + kgdb8250_got_dollar = -3;
> > + kgdb8250_got_H = -3;
> > + continue;
> > + }
> > + }
> > +
> > + if (atomic_read(&kgdb8250_buf_in_cnt) >= GDB_BUF_SIZE)
> > + {
> > + /* buffer overflow, clear it */
> > + kgdb8250_buf_in_inx = 0 ;
> > + atomic_set(&kgdb8250_buf_in_cnt, 0) ;
> > + kgdb8250_buf_out_inx = 0 ;
> > + break ;
> > + }
> > +
> > + kgdb8250_buf[kgdb8250_buf_in_inx++] = chr ;
> > + kgdb8250_buf_in_inx &= (GDB_BUF_SIZE - 1) ;
> > + atomic_inc(&kgdb8250_buf_in_cnt) ;
> > + }
> > + while (iir & UART_IIR_RDI);
> > +
> > + if (atomic_read(&kgdb_killed_or_detached))
> > + kgdb8250_interrupt_iteration ++;
> > +
> > + return IRQ_HANDLED;
> > +
> > +}
> > +
> > +/*
> > + * Initializes serial port.
> > + * ttyS - integer specifying which serial port to use for debugging
> > + * baud - baud rate of specified serial port
> > + */
> > +static int kgdb8250_init(int ttyS, int baud)
> > +{
> > + unsigned cval;
> > + int bits = 8;
> > + int parity = 'n';
> > + int cflag = CREAD | HUPCL | CLOCAL;
> > + int quot = 0;
> > +
> > + /*
> > + * Now construct a cflag setting.
> > + */
> > + switch(baud) {
> > + case 1200:
> > + cflag |= B1200;
> > + break;
> > + case 2400:
> > + cflag |= B2400;
> > + break;
> > + case 4800:
> > + cflag |= B4800;
> > + break;
> > + case 19200:
> > + cflag |= B19200;
> > + break;
> > + case 38400:
> > + cflag |= B38400;
> > + break;
> > + case 57600:
> > + cflag |= B57600;
> > + break;
> > + case 115200:
> > + cflag |= B115200;
> > + break;
> > + default:
> > + baud = 9600;
> > + /* Fall through */
> > + case 9600:
> > + cflag |= B9600;
> > + break;
> > + }
> > + switch(bits) {
> > + case 7:
> > + cflag |= CS7;
> > + break;
> > + default:
> > + case 8:
> > + cflag |= CS8;
> > + break;
> > + }
> > + switch(parity) {
> > + case 'o': case 'O':
> > + cflag |= PARODD;
> > + break;
> > + case 'e': case 'E':
> > + cflag |= PARENB;
> > + break;
> > + }
> > +
> > + /*
> > + * Divisor, bytesize and parity
> > + *
> > + */
> > +
> > + quot = (1843200/16) / baud;
> > + cval = cflag & (CSIZE | CSTOPB);
> > + cval >>= 4;
> > + if (cflag & PARENB)
> > + cval |= UART_LCR_PARITY;
> > + if (!(cflag & PARODD))
> > + cval |= UART_LCR_EPAR;
> > +
> > +
> > + /*
> > + * Disable UART interrupts, set DTR and RTS high
> > + * and set speed.
> > + */
> > + cval = 0x3;
> > + serial_outb(cval | UART_LCR_DLAB, kgdb8250_port + UART_LCR);
> > /* set DLAB */ + serial_outb(quot & 0xff, kgdb8250_port +
> > UART_DLL); /* LS of divisor */ + serial_outb(quot >> 8,
> > kgdb8250_port + UART_DLM); /* MS of divisor */ +
> > serial_outb(cval, kgdb8250_port + UART_LCR); /* reset DLAB
> > */ +
> > serial_outb(UART_IER_RDI, kgdb8250_port + UART_IER); /* turn on
> > interrupts*/ + serial_outb(UART_MCR_OUT2 | UART_MCR_DTR |
> > UART_MCR_RTS, kgdb8250_port + UART_MCR); +
> > + /*
> > + * If we read 0xff from the LSR, there is no UART here.
> > + */
> > + if (serial_inb(kgdb8250_port + UART_LSR) == 0xff)
> > + return -ENODEV;
> > + return 0;
> > +}
> > +
> > +int kgdb8250_hook(void)
> > +{
> > + int retval;
> > +
> > + /*
> > + * Set port and irq number.
> > + */
> > + kgdb8250_irq = rs_table[kgdb8250_ttyS].irq;
> > + switch(rs_table[kgdb8250_ttyS].iotype)
> > + {
> > + case SERIAL_IO_MEM:
> > + kgdb8250_port = (unsigned long)rs_table[kgdb8250_ttyS].membase;
> > + serial_inb = direct_inb;
> > + serial_outb = direct_outb;
> > + break;
> > + default:
> > + kgdb8250_port = rs_table[kgdb8250_ttyS].line;
> > + serial_inb = io_inb;
> > + serial_outb = io_outb;
> > + }
> > +
> > +#ifdef CONFIG_SERIAL_8250
> > + if ((retval = serial8250_release_irq(kgdb8250_irq)) < 0)
> > + return retval;
> > +#endif
> > +
> > + if ((retval = kgdb8250_init(kgdb8250_ttyS, kgdb8250_baud)) < 0)
> > + return retval;
> > +
> > + retval = request_irq(kgdb8250_irq, kgdb8250_interrupt, SA_INTERRUPT,
> > + "GDB-stub", NULL);
> > + return retval;
> > +}
> > +
> > +void
> > +kgdb8250_add_port(int i, struct uart_port *serial_req)
> > +{
> > + rs_table[i].iotype = serial_req->iotype;
> > + rs_table[i].line = serial_req->line;
> > + rs_table[i].membase = serial_req->membase;
> > + rs_table[i].regshift = serial_req->regshift;
> > +}
> > +
> > +struct kgdb_serial kgdb8250_serial_driver = {
> > + .read_char = kgdb8250_read_char,
> > + .write_char = kgdb8250_write_char,
> > + .hook = kgdb8250_hook
> > +};
> > +
> > +/*
> > + * Syntax for this cmdline option is
> > + * kgdb8250=ttyno,baudrate
> > + */
> > +
> > +static int __init kgdb8250_opt(char *str)
> > +{
> > + if (*str < '0' || *str > '3')
> > + goto errout;
> > + kgdb8250_ttyS = *str - '0';
> > + str++;
> > + if (*str != ',')
> > + goto errout;
> > + str++;
> > + kgdb8250_baud = simple_strtoul(str, NULL, 10);
> > + if (kgdb8250_baud != 9600 && kgdb8250_baud != 19200 &&
> > + kgdb8250_baud != 38400 && kgdb8250_baud != 57600 &&
> > + kgdb8250_baud != 115200)
> > + goto errout;
> > + kgdb_serial = &kgdb8250_serial_driver;
> > + return 1;
> > +
> > +errout:
> > + printk("Invalid syntax for option kgdb8250=\n");
> > + return 0;
> > +}
> > +
> > +__setup("kgdb8250=", kgdb8250_opt);
> > --- clean.2.5/drivers/serial/serial_core.c 2004-02-05 01:54:11.000000000
> > +0100 +++ linux-mm/drivers/serial/serial_core.c 2004-02-16
> > 23:09:06.000000000 +0100 @@ -917,7 +917,11 @@
> > static void uart_break_ctl(struct tty_struct *tty, int break_state)
> > {
> > struct uart_state *state = tty->driver_data;
> > - struct uart_port *port = state->port;
> > + struct uart_port *port;
> > +
> > + if (!state)
> > + return;
> > + port = state->port;
> >
> > BUG_ON(!kernel_locked());
> >
> > --- clean.2.5/include/linux/debugger.h 2004-02-17 11:38:14.000000000
> > +0100 +++ linux-mm/include/linux/debugger.h 2004-02-16 23:09:06.000000000
> > +0100 @@ -0,0 +1,66 @@
> > +#ifndef _DEBUGGER_H_
> > +#define _DEBUGGER_H_
> > +
> > +/*
> > + * Copyright (C) 2003-2004 Amit S. Kale
> > + *
> > + * Definition switchout for debuggers
> > + */
> > +
> > +/*
> > + * KGDB
> > + */
> > +#ifdef CONFIG_KGDB
> > +
> > +typedef int gdb_debug_hook(int exVector, int signo, int err_code,
> > + struct pt_regs *regs);
> > +extern gdb_debug_hook *linux_debug_hook;
> > +#define CHK_DEBUGGER(trapnr,signr,error_code,regs,after) \
> > + { \
> > + if (linux_debug_hook != (gdb_debug_hook *) NULL && !user_mode(regs)) \
> > + { \
> > + (*linux_debug_hook)(trapnr, signr, error_code, regs) ; \
> > + after; \
> > + } \
> > + }
> > +
> > +void kgdb_nmihook(int cpu, void *regs);
> > +static inline void debugger_nmihook(int cpu, void *regs)
> > +{
> > + kgdb_nmihook(cpu, regs);
> > +}
> > +
> > +void kgdb_entry(void);
> > +static inline void debugger_entry(void)
> > +{
> > + kgdb_entry();
> > +}
> > +
> > +extern int debugger_step;
> > +extern atomic_t debugger_active;
> > +
> > +/*
> > + * No debugger in the kernel
> > + */
> > +#else
> > +
> > +#define CHK_DEBUGGER(trapnr,signr,error_code,regs,after)
> > +
> > +static inline void debugger_nmihook(int cpu, void *regs)
> > +{
> > + /* Do nothing */
> > +}
> > +
> > +static inline void debugger_entry(void)
> > +{
> > + /* Do nothing */
> > +}
> > +
> > +#define debugger_step 0
> > +static const atomic_t debugger_active = { 0 };
> > +#define debugger_memerr_expected 0
> > +
> > +#endif
> > +
> > +
> > +#endif /* _DEBUGGER_H_ */
> > --- clean.2.5/include/linux/kgdb.h 2004-02-17 11:38:23.000000000 +0100
> > +++ linux-mm/include/linux/kgdb.h 2004-02-16 23:09:06.000000000 +0100
> > @@ -0,0 +1,112 @@
> > +#ifndef _KGDB_H_
> > +#define _KGDB_H_
> > +
> > +/*
> > + * Copyright (C) 2001-2004 Amit S. Kale
> > + */
> > +
> > +#include <linux/ptrace.h>
> > +#include <asm/kgdb.h>
> > +#include <linux/spinlock.h>
> > +#include <asm/atomic.h>
> > +#include <linux/debugger.h>
> > +
> > +/* To enter the debugger explicitly. */
> > +void breakpoint(void);
> > +
> > +#ifndef KGDB_MAX_NO_CPUS
> > +#if CONFIG_NR_CPUS > 8
> > +#error KGDB can handle max 8 CPUs
> > +#endif
> > +#define KGDB_MAX_NO_CPUS 8
> > +#endif
> > +
> > +extern atomic_t kgdb_setting_breakpoint;
> > +extern atomic_t kgdb_killed_or_detached;
> > +extern atomic_t kgdb_might_be_resumed;
> > +
> > +extern struct task_struct *kgdb_usethread, *kgdb_contthread;
> > +
> > +enum kgdb_bptype
> > +{
> > + bp_breakpoint = '0',
> > + bp_hardware_breakpoint,
> > + bp_write_watchpoint,
> > + bp_read_watchpoint,
> > + bp_access_watchpoint
> > +};
> > +
> > +enum kgdb_bpstate
> > +{
> > + bp_disabled,
> > + bp_enabled
> > +};
> > +
> > +struct kgdb_bkpt
> > +{
> > + unsigned long bpt_addr;
> > + unsigned char saved_instr[BREAK_INSTR_SIZE];
> > + enum kgdb_bptype type;
> > + enum kgdb_bpstate state;
> > +};
> > +
> > +#ifndef BREAK_INSTR_SIZE
> > +#error BREAK_INSTR_SIZE needed by kgdb
> > +#endif
> > +
> > +#ifndef MAX_BREAKPOINTS
> > +#define MAX_BREAKPOINTS 16
> > +#endif
> > +
> > +#define KGDB_HW_BREAKPOINT 1
> > +
> > +/* These are functions that the arch specific code can, and in some
> > cases + * must, provide. */
> > +extern int kgdb_arch_init(void);
> > +extern void regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs
> > *regs); +extern void sleeping_thread_to_gdb_regs(unsigned long
> > *gdb_regs,struct task_struct *p); +extern void gdb_regs_to_regs(unsigned
> > long *gdb_regs, struct pt_regs *regs); +extern void
> > kgdb_printexceptioninfo(int exceptionNo, int errorcode, + char *buffer);
> > +extern void kgdb_disable_hw_debug(struct pt_regs *regs);
> > +extern void kgdb_post_master_code(struct pt_regs *regs, int eVector,
> > + int err_code);
> > +extern int kgdb_arch_handle_exception(int vector, int signo, int
> > err_code, + char *InBuffer, char *outBuffer, struct pt_regs *regs);
> > +extern int kgdb_arch_set_break(unsigned long addr, int type);
> > +extern int kgdb_arch_remove_break(unsigned long addr, int type);
> > +extern void kgdb_correct_hw_break(void);
> > +extern void kgdb_shadowinfo(struct pt_regs *regs, char *buffer, unsigned
> > threadid); +extern struct task_struct *kgdb_get_shadow_thread(struct
> > pt_regs *regs, + int threadid);
> > +extern struct pt_regs *kgdb_shadow_regs(struct pt_regs *regs, int
> > threadid); +
> > +struct kgdb_arch {
> > + unsigned char gdb_bpt_instr[BREAK_INSTR_SIZE];
> > + unsigned long flags;
> > + unsigned shadowth;
> > +};
> > +
> > +/* Thread reference */
> > +typedef unsigned char threadref[8];
> > +
> > +struct kgdb_serial {
> > + int (*read_char)(void);
> > + void (*write_char)(int);
> > + void (*flush)(void);
> > + int (*hook)(void);
> > +};
> > +
> > +extern struct kgdb_serial *kgdb_serial;
> > +extern struct kgdb_arch arch_kgdb_ops;
> > +extern int kgdb_initialized;
> > +
> > +struct uart_port;
> > +
> > +extern void kgdb8250_add_port(int i, struct uart_port *serial_req);
> > +
> > +int kgdb_hex2long(char **ptr, long *longValue);
> > +char *kgdb_mem2hex(char *mem, char *buf, int count);
> > +char *kgdb_hex2mem(char *buf, char *mem, int count);
> > +
> > +#endif /* _KGDB_H_ */
> > --- clean.2.5/init/main.c 2004-02-05 01:54:30.000000000 +0100
> > +++ linux-mm/init/main.c 2004-02-16 23:09:06.000000000 +0100
> > @@ -39,6 +39,7 @@
> > #include <linux/writeback.h>
> > #include <linux/cpu.h>
> > #include <linux/efi.h>
> > +#include <linux/debugger.h>
> >
> > #include <asm/io.h>
> > #include <asm/bugs.h>
> > @@ -580,6 +581,7 @@
> > do_pre_smp_initcalls();
> >
> > smp_init();
> > + debugger_entry();
> > do_basic_setup();
> >
> > prepare_namespace();
> > --- clean.2.5/kernel/Makefile 2003-10-09 00:14:41.000000000 +0200
> > +++ linux-mm/kernel/Makefile 2004-02-16 23:09:06.000000000 +0100
> > @@ -19,6 +19,7 @@
> > obj-$(CONFIG_COMPAT) += compat.o
> > obj-$(CONFIG_IKCONFIG) += configs.o
> > obj-$(CONFIG_IKCONFIG_PROC) += configs.o
> > +obj-$(CONFIG_KGDB) += kgdbstub.o
> >
> > ifneq ($(CONFIG_IA64),y)
> > # According to Alan Modra <alan@xxxxxxxxxxxxxxxx>, the
> > -fno-omit-frame-pointer is --- clean.2.5/kernel/kgdbstub.c 2004-02-17
> > 11:38:39.000000000 +0100 +++ linux-mm/kernel/kgdbstub.c 2004-02-16
> > 23:09:06.000000000 +0100 @@ -0,0 +1,1271 @@
> > +/*
> > + * This program is free software; you can redistribute it and/or modify
> > it + * under the terms of the GNU General Public License as published by
> > the + * Free Software Foundation; either version 2, or (at your option)
> > any + * later version.
> > + *
> > + * This program is distributed in the hope that it will be useful, but
> > + * WITHOUT ANY WARRANTY; without even the implied warranty of
> > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> > + * General Public License for more details.
> > + */
> > +
> > +/*
> > + * Copyright (C) 2000-2001 VERITAS Software Corporation.
> > + * Copyright (C) 2002-2004 Timesys Corporation
> > + * Copyright (C) 2003-2004 Amit S. Kale
> > + * Copyright (C) 2004 Pavel Machek <pavel@xxxxxxx>
> > + *
> > + * Restructured KGDB for 2.6 kernels.
> > + * thread support, support for multiple processors,support for
> > ia-32(x86) + * hardware debugging, Console support, handling nmi watchdog
> > + * - Amit S. Kale ( amitkale@xxxxxxxxxxxxx )
> > + *
> > + * Several enhancements by George Anzinger <george@xxxxxxxxxx>
> > + * Generic KGDB Support
> > + * Implemented by Anurekh Saxena (anurekh.saxena@xxxxxxxxxxx)
> > + *
> > + * Contributor: Lake Stevens Instrument Division
> > + * Written by: Glenn Engel
> > + *
> > + * Modified for 386 by Jim Kingdon, Cygnus Support.
> > + * Origianl kgdb, compatibility with 2.1.xx kernel by David Grothe
> > <dave@xxxxxxxx> + * Integrated into 2.2.5 kernel by Tigran Aivazian
> > <tigran@xxxxxxx> + */
> > +
> > +#include <linux/string.h>
> > +#include <linux/kernel.h>
> > +#include <linux/sched.h>
> > +#include <linux/smp.h>
> > +#include <linux/spinlock.h>
> > +#include <linux/delay.h>
> > +#include <linux/mm.h>
> > +#include <asm/system.h>
> > +#include <asm/ptrace.h>
> > +#include <asm/uaccess.h>
> > +#include <linux/kgdb.h>
> > +#include <asm/atomic.h>
> > +#include <linux/notifier.h>
> > +#include <linux/module.h>
> > +#include <asm/cacheflush.h>
> > +#ifdef CONFIG_KGDB_CONSOLE
> > +#include <linux/console.h>
> > +#endif
> > +#include <linux/init.h>
> > +
> > +extern int pid_max;
> > +
> > +#define BUF_THREAD_ID_SIZE 16
> > +
> > +/*
> > + * kgdb_initialized indicates that kgdb is setup and is all ready to
> > serve + * breakpoints and other kernel exceptions. kgdb_connected
> > indicates that kgdb + * has connected to kgdb.
> > + */
> > +int kgdb_initialized = 0;
> > +static volatile int kgdb_connected;
> > +
> > +/* If non-zero, wait for a gdb connection when kgdb_entry is called */
> > +int kgdb_enter = 0;
> > +
> > +/* Set to 1 to make kgdb allow access to user addresses. Can be set from
> > gdb + * also at runtime. */
> > +int kgdb_useraccess = 0;
> > +
> > +struct kgdb_serial *kgdb_serial;
> > +
> > +/*
> > + * Holds information about breakpoints in a kernel. These breakpoints
> > are + * added and removed by gdb.
> > + */
> > +struct kgdb_bkpt kgdb_break[MAX_BREAKPOINTS];
> > +
> > +struct kgdb_arch *kgdb_ops = &arch_kgdb_ops;
> > +
> > +static const char hexchars[] = "0123456789abcdef";
> > +
> > +static spinlock_t slavecpulocks[KGDB_MAX_NO_CPUS];
> > +static volatile int procindebug[KGDB_MAX_NO_CPUS];
> > +atomic_t kgdb_setting_breakpoint;
> > +atomic_t kgdb_killed_or_detached;
> > +atomic_t kgdb_might_be_resumed;
> > +struct task_struct *kgdb_usethread, *kgdb_contthread;
> > +
> > +int debugger_step;
> > +atomic_t debugger_active;
> > +
> > +/* This will point to kgdb_handle_exception by default.
> > + * The architecture code can override this in its init function
> > + */
> > +gdb_debug_hook *linux_debug_hook;
> > +
> > +static char remcomInBuffer[BUFMAX];
> > +static char remcomOutBuffer[BUFMAX];
> > +
> > +/*
> > + * The following are the stub functions for code which is arch specific
> > + * and can be omitted on some arches
> > + * This function will handle the initalization of any architecture
> > specific + * hooks. If there is a suitable early output driver,
> > kgdb_serial + * can be pointed at it now.
> > + */
> > +int __attribute__ ((weak))
> > +kgdb_arch_init(void)
> > +{
> > + return 0;
> > +}
> > +
> > +void __attribute__ ((weak))
> > +regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *regs)
> > +{
> > +}
> > +
> > +void __attribute__ ((weak))
> > +sleeping_thread_to_gdb_regs(unsigned long *gdb_regs,struct task_struct
> > *p) +{
> > +}
> > +
> > +void __attribute__ ((weak))
> > +gdb_regs_to_regs(unsigned long *gdb_regs, struct pt_regs *regs)
> > +{
> > +}
> > +
> > +void __attribute__ ((weak))
> > +kgdb_printexceptioninfo(int exceptionNo, int errorcode, char *buffer)
> > +{
> > +}
> > +
> > +void __attribute__ ((weak))
> > +kgdb_disable_hw_debug(struct pt_regs *regs)
> > +{
> > +}
> > +
> > +void __attribute__ ((weak))
> > +kgdb_post_master_code(struct pt_regs *regs, int eVector, int err_code)
> > +{
> > +}
> > +
> > +/*
> > + * Handle any additional commands. This must handle the 'c' and 's'
> > + * command packets.
> > + * Return -1 to loop over other commands, and 0 to exit from KGDB
> > + */
> > +int __attribute__ ((weak))
> > +kgdb_arch_handle_exception(int vector, int signo, int err_code, char
> > *InBuffer, + char *outBuffer, struct pt_regs *regs)
> > +{
> > + return 0;
> > +}
> > +
> > +int __attribute__ ((weak))
> > +kgdb_arch_set_break(unsigned long addr, int type)
> > +{
> > + return 0;
> > +}
> > +
> > +int __attribute__ ((weak))
> > +kgdb_arch_remove_break(unsigned long addr, int type)
> > +{
> > + return 0;
> > +}
> > +
> > +void __attribute__ ((weak))
> > +kgdb_correct_hw_break(void)
> > +{
> > +}
> > +
> > +void __attribute__ ((weak))
> > +kgdb_shadowinfo(struct pt_regs *regs, char *buffer, unsigned threadid)
> > +{
> > +}
> > +
> > +struct task_struct __attribute__ ((weak))
> > +*kgdb_get_shadow_thread(struct pt_regs *regs, int threadid)
> > +{
> > + return NULL;
> > +}
> > +
> > +struct pt_regs __attribute__ ((weak))
> > +*kgdb_shadow_regs(struct pt_regs *regs, int threadid)
> > +{
> > + return NULL;
> > +}
> > +
> > +static int hex(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;
> > + char ch;
> > +
> > + do {
> > + /* wait around for the start character, ignore all other characters */
> > + while ((ch = (kgdb_serial->read_char() & 0x7f)) != '$');
> > + checksum = 0;
> > + xmitcsum = -1;
> > +
> > + count = 0;
> > +
> > + /* now, read until a # or end of buffer is found */
> > + while (count < (BUFMAX - 1)) {
> > + ch = kgdb_serial->read_char() & 0x7f;
> > + if (ch == '#')
> > + break;
> > + checksum = checksum + ch;
> > + buffer[count] = ch;
> > + count = count + 1;
> > + }
> > + buffer[count] = 0;
> > +
> > + if (ch == '#') {
> > + xmitcsum = hex(kgdb_serial->read_char() & 0x7f) << 4;
> > + xmitcsum += hex(kgdb_serial->read_char() & 0x7f);
> > +
> > + if (checksum != xmitcsum)
> > + kgdb_serial->write_char('-'); /* failed checksum */
> > + else {
> > + kgdb_serial->write_char('+'); /* successful transfer */
> > + /* if a sequence char is present, reply the sequence ID */
> > + if (buffer[2] == ':') {
> > + kgdb_serial->write_char(buffer[0]);
> > + kgdb_serial->write_char(buffer[1]);
> > + /* remove sequence chars from buffer */
> > + count = strlen(buffer);
> > + for (i = 3; i <= count; i++)
> > + buffer[i - 3] = buffer[i];
> > + }
> > + }
> > + if (kgdb_serial->flush)
> > + kgdb_serial->flush();
> > + }
> > + } while (checksum != xmitcsum);
> > +}
> > +
> > +/*
> > + * Send the packet in buffer.
> > + * Check for gdb connection if asked for.
> > + */
> > +static void putpacket(char *buffer, int checkconnect)
> > +{
> > + unsigned char checksum;
> > + int count;
> > + char ch;
> > + static char gdbseq[] = "$Hc-1#09";
> > + int i;
> > + int send_count;
> > +
> > + /* $<packet info>#<checksum>. */
> > + do {
> > + kgdb_serial->write_char('$');
> > + checksum = 0;
> > + count = 0;
> > + send_count = 0;
> > +
> > + while ((ch = buffer[count])) {
> > + kgdb_serial->write_char(ch);
> > + checksum += ch;
> > + count ++;
> > + send_count ++;
> > + }
> > +
> > + kgdb_serial->write_char('#');
> > + kgdb_serial->write_char(hexchars[checksum >> 4]);
> > + kgdb_serial->write_char(hexchars[checksum % 16]);
> > + if (kgdb_serial->flush)
> > + kgdb_serial->flush();
> > +
> > + i = 0;
> > + while ((ch = kgdb_serial->read_char()) == gdbseq[i++] &&
> > + checkconnect) {
> > + if (!gdbseq[i]) {
> > + kgdb_serial->write_char('+');
> > + if (kgdb_serial->flush)
> > + kgdb_serial->flush();
> > + breakpoint();
> > +
> > + /*
> > + * GDB is available now.
> > + * Retransmit this packet.
> > + */
> > + break;
> > + }
> > + }
> > + if (checkconnect && ch == 3) {
> > + kgdb_serial->write_char('+');
> > + if (kgdb_serial->flush)
> > + kgdb_serial->flush();
> > + breakpoint();
> > + }
> > + } while (( ch & 0x7f) != '+');
> > +
> > +}
> > +
> > +static int get_char(char *addr, unsigned char *data)
> > +{
> > + mm_segment_t fs;
> > + int ret = 0;
> > +
> > + if (!kgdb_useraccess && (unsigned long)addr < TASK_SIZE) {
> > + return -EINVAL;
> > + }
> > + wmb();
> > + fs = get_fs();
> > + set_fs(KERNEL_DS);
> > +
> > + if (get_user(*data, addr) != 0) {
> > + ret = -EFAULT;
> > + }
> > +
> > + set_fs(fs);
> > + return ret;
> > +}
> > +
> > +static int set_char(char *addr, int data)
> > +{
> > + mm_segment_t fs;
> > + int ret = 0;
> > +
> > + if (!kgdb_useraccess && (unsigned long)addr < TASK_SIZE) {
> > + return -EINVAL;
> > + }
> > + wmb();
> > + fs = get_fs();
> > + set_fs(KERNEL_DS);
> > +
> > + if (put_user(data, addr) != 0) {
> > + ret = -EFAULT;
> > + }
> > +
> > + set_fs(fs);
> > + return ret;
> > +}
> > +
> > +/*
> > + * convert the memory pointed to by mem into hex, placing result in buf
> > + * return a pointer to the last char put in buf (null). May return an
> > error. + */
> > +char *kgdb_mem2hex(char *mem, char *buf, int count)
> > +{
> > + int i;
> > + unsigned char ch;
> > + int error;
> > +
> > + for (i = 0; i < count; i++) {
> > +
> > + if ((error = get_char(mem++, &ch)) < 0)
> > + return ERR_PTR(error);
> > +
> > + *buf++ = hexchars[ch >> 4];
> > + *buf++ = hexchars[ch % 16];
> > + }
> > + *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 return an error.
> > + */
> > +char *kgdb_hex2mem(char *buf, char *mem, int count)
> > +{
> > + int i;
> > + unsigned char ch;
> > + int error;
> > +
> > + for (i = 0; i < count; i++) {
> > + ch = hex(*buf++) << 4;
> > + ch = ch + hex(*buf++);
> > + if ((error = set_char(mem++, ch)) < 0)
> > + return ERR_PTR(error);
> > + }
> > + return (mem);
> > +}
> > +
> > +/*
> > + * While we find nice hex chars, build a longValue.
> > + * Return number of chars processed.
> > + */
> > +int kgdb_hex2long(char **ptr, long *longValue)
> > +{
> > + int numChars = 0;
> > + int hexValue;
> > +
> > + *longValue = 0;
> > +
> > + while (**ptr) {
> > + hexValue = hex(**ptr);
> > + if (hexValue >= 0) {
> > + *longValue = (*longValue << 4) | hexValue;
> > + numChars++;
> > + } else
> > + break;
> > +
> > + (*ptr)++;
> > + }
> > +
> > + return (numChars);
> > +}
> > +
> > +static inline char *pack_hex_byte(char *pkt, int byte)
> > +{
> > + *pkt++ = hexchars[(byte >> 4) & 0xf];
> > + *pkt++ = hexchars[(byte & 0xf)];
> > + return pkt;
> > +}
> > +
> > +static inline void error_packet(char *pkt, int error)
> > +{
> > + error = -error;
> > + pkt[0] = 'E';
> > + pkt[1] = hexchars[(error / 10)];
> > + pkt[2] = hexchars[(error % 10)];
> > + pkt[3] = '\0';
> > +}
> > +
> > +static void ok_packet(char *pkt)
> > +{
> > + strcpy(pkt, "OK");
> > +}
> > +
> > +static char *pack_threadid(char *pkt, threadref *id)
> > +{
> > + char *limit;
> > + unsigned char *altid;
> > +
> > + altid = (unsigned char *) id;
> > + limit = pkt + BUF_THREAD_ID_SIZE;
> > + while (pkt < limit)
> > + pkt = pack_hex_byte(pkt, *altid++);
> > +
> > + return pkt;
> > +}
> > +
> > +void int_to_threadref(threadref *id, int value)
> > +{
> > + unsigned char *scan;
> > +
> > + scan = (unsigned char *) id;
> > + {
> > + int i = 4;
> > + while (i--)
> > + *scan++ = 0;
> > + }
> > + *scan++ = (value >> 24) & 0xff;
> > + *scan++ = (value >> 16) & 0xff;
> > + *scan++ = (value >> 8) & 0xff;
> > + *scan++ = (value & 0xff);
> > +}
> > +
> > +static struct task_struct *getthread(struct pt_regs *regs,int tid)
> > +{
> > + int i;
> > + struct list_head *l;
> > + struct task_struct *p;
> > + struct pid *pid;
> > +
> > + if (tid >= pid_max + num_online_cpus() + kgdb_ops->shadowth) {
> > + return NULL;
> > + }
> > + if (tid >= pid_max + num_online_cpus()) {
> > + return kgdb_get_shadow_thread(regs, tid - pid_max -
> > + num_online_cpus());
> > + }
> > + if (tid >= pid_max) {
> > + i = 0;
> > + for_each_task_pid(0, PIDTYPE_PID, p, l, pid) {
> > + if (tid == pid_max + i) {
> > + return p;
> > + }
> > + i++;
> > + }
> > + return NULL;
> > + }
> > + if (!tid) {
> > + return NULL;
> > + }
> > + return find_task_by_pid(tid);
> > +}
> > +
> > +#ifdef CONFIG_SMP
> > +void kgdb_wait(struct pt_regs *regs)
> > +{
> > + unsigned long flags;
> > + int processor;
> > +
> > + local_irq_save(flags);
> > + processor = smp_processor_id();
> > + procindebug[processor] = 1;
> > + current->thread.debuggerinfo = regs;
> > +
> > + /* Wait till master processor goes completely into the debugger. FIXME:
> > this looks racy */ + while (!procindebug[atomic_read(&debugger_active) -
> > 1]) {
> > + int i = 10; /* an arbitrary number */
> > +
> > + while (--i)
> > + asm volatile ("nop": : : "memory");
> > + barrier();
> > + }
> > +
> > + /* Wait till master processor is done with debugging */
> > + spin_lock(slavecpulocks + processor);
> > +
> > + /* This has been taken from x86 kgdb implementation and
> > + * will be needed by architectures that have SMP support
> > + */
> > + kgdb_correct_hw_break();
> > +
> > + /* Signal the master processor that we are done */
> > + procindebug[processor] = 0;
> > + spin_unlock(slavecpulocks + processor);
> > + local_irq_restore(flags);
> > +}
> > +#endif
> > +
> > +static int get_mem (char *addr, unsigned char *buf, int count)
> > +{
> > + int error;
> > + while (count) {
> > + if((error = get_char(addr++, buf)) < 0)
> > + return error;
> > + buf++;
> > + count--;
> > + }
> > + return 0;
> > +}
> > +
> > +static int set_mem (char *addr,unsigned char *buf, int count)
> > +{
> > + int error;
> > + while (count) {
> > + if ((error = set_char(addr++,*buf++)) < 0)
> > + return error;
> > + count--;
> > + }
> > + return 0;
> > +}
> > +
> > +static int set_break (unsigned long addr)
> > +{
> > + int i, breakno = -1;
> > + int error;
> > +
> > + for (i = 0; i < MAX_BREAKPOINTS; i++) {
> > + if ((kgdb_break[i].state == bp_enabled) &&
> > + (kgdb_break[i].bpt_addr == addr)) {
> > + return -EEXIST;
> > + }
> > +
> > + if (kgdb_break[i].state == bp_disabled) {
> > + if ((breakno == -1) || (kgdb_break[i].bpt_addr == addr))
> > + breakno = i;
> > + }
> > + }
> > + if (breakno == -1)
> > + return -E2BIG;
> > +
> > + if ((error = get_mem((char *)addr, kgdb_break[breakno].saved_instr,
> > + BREAK_INSTR_SIZE)) < 0)
> > + return error;
> > +
> > + if ((error = set_mem((char *)addr, kgdb_ops->gdb_bpt_instr,
> > + BREAK_INSTR_SIZE)) < 0)
> > + return error;
> > + flush_cache_range (current->mm, addr, addr + BREAK_INSTR_SIZE);
> > + flush_icache_range (addr, addr + BREAK_INSTR_SIZE);
> > +
> > + kgdb_break[breakno].state = bp_enabled;
> > + kgdb_break[breakno].type = bp_breakpoint;
> > + kgdb_break[breakno].bpt_addr = addr;
> > +
> > + return 0;
> > +}
> > +
> > +static int remove_break (unsigned long addr)
> > +{
> > + int i;
> > + int error;
> > +
> > + for (i=0; i < MAX_BREAKPOINTS; i++) {
> > + if ((kgdb_break[i].state == bp_enabled) &&
> > + (kgdb_break[i].bpt_addr == addr)) {
> > + if ((error =set_mem((char *)addr, kgdb_break[i].saved_instr,
> > + BREAK_INSTR_SIZE)) < 0)
> > + return error;
> > + flush_cache_range (current->mm, addr, addr + BREAK_INSTR_SIZE);
> > + flush_icache_range (addr, addr + BREAK_INSTR_SIZE);
> > + kgdb_break[i].state = bp_disabled;
> > + return 0;
> > + }
> > + }
> > + return -ENOENT;
> > +}
> > +
> > +int remove_all_break(void)
> > +{
> > + int i;
> > + int error;
> > + for (i=0; i < MAX_BREAKPOINTS; i++) {
> > + if(kgdb_break[i].state == bp_enabled) {
> > + unsigned long addr = kgdb_break[i].bpt_addr;
> > + if ((error = set_mem((char *)addr, kgdb_break[i].saved_instr,
> > + BREAK_INSTR_SIZE)) < 0)
> > + return error;
> > + flush_cache_range (current->mm, addr, addr + BREAK_INSTR_SIZE);
> > + flush_icache_range (addr, addr + BREAK_INSTR_SIZE);
> > + }
> > + kgdb_break[i].state = bp_disabled;
> > + }
> > + return 0;
> > +}
> > +
> > +static inline int shadow_pid(int realpid)
> > +{
> > + if (realpid) {
> > + return realpid;
> > + }
> > + return pid_max + smp_processor_id();
> > +}
> > +
> > +/*
> > + * This function does all command procesing for interfacing to gdb.
> > + *
> > + * Locking hierarchy:
> > + * interface locks, if any (begin_session)
> > + * kgdb lock (debugger_active)
> > + *
> > + */
> > +int kgdb_handle_exception(int exVector, int signo, int err_code,
> > + struct pt_regs *linux_regs)
> > +{
> > + unsigned long length, addr;
> > + char *ptr;
> > + unsigned long flags;
> > + unsigned long gdb_regs[NUMREGBYTES / sizeof (unsigned long)];
> > + int i;
> > + long threadid;
> > + threadref thref;
> > + struct task_struct *thread = NULL;
> > + unsigned procid;
> > + static char tmpstr[256];
> > + int numshadowth = num_online_cpus() + kgdb_ops->shadowth;
> > + long kgdb_usethreadid = 0;
> > + int error = 0;
> > +
> > + /* Panic on recursive debugger calls. */
> > + if (atomic_read(&debugger_active) == smp_processor_id() + 1) {
> > + return 0;
> > + }
> > +
> > + /*
> > + * Interrupts will be restored by the 'trap return' code, except when
> > + * single stepping.
> > + */
> > + local_irq_save(flags);
> > +
> > + /* Hold debugger_active */
> > + procid = smp_processor_id();
> > + while (cmpxchg(&atomic_read(&debugger_active), 0, (procid + 1)) != 0) {
> > + int i = 25; /* an arbitrary number */
> > +
> > + while (--i)
> > + asm volatile ("nop": : : "memory");
> > + }
> > +
> > + debugger_step = 0;
> > +
> > + current->thread.debuggerinfo = linux_regs;
> > +
> > + kgdb_disable_hw_debug(linux_regs);
> > +
> > + for (i = 0; i < num_online_cpus(); i++) {
> > + spin_lock(&slavecpulocks[i]);
> > + }
> > +
> > + /* spin_lock code is good enough as a barrier so we don't
> > + * need one here */
> > + procindebug[smp_processor_id()] = 1;
> > +
> > + /* Clear the out buffer. */
> > + memset(remcomOutBuffer, 0, sizeof(remcomOutBuffer));
> > +
> > + /* Master processor is completely in the debugger */
> > + kgdb_post_master_code(linux_regs, exVector, err_code);
> > +
> > + if (atomic_read(&kgdb_killed_or_detached) &&
> > + atomic_read(&kgdb_might_be_resumed)) {
> > + getpacket(remcomInBuffer);
> > + if(remcomInBuffer[0] == 'H' && remcomInBuffer[1] =='c') {
> > + remove_all_break();
> > + atomic_set(&kgdb_killed_or_detached, 0);
> > + ok_packet(remcomOutBuffer);
> > + }
> > + else
> > + return 1;
> > + } else {
> > +
> > + /* reply to host that an exception has occurred */
> > + ptr = remcomOutBuffer;
> > + *ptr++ = 'T';
> > + *ptr++ = hexchars[(signo >> 4) % 16];
> > + *ptr++ = hexchars[signo % 16];
> > + ptr += strlen(strcpy(ptr, "thread:"));
> > + int_to_threadref(&thref, shadow_pid(current->pid));
> > + ptr = pack_threadid(ptr, &thref);
> > + *ptr++ = ';';
> > + *ptr = '\0';
> > + }
> > +
> > + putpacket(remcomOutBuffer, 0);
> > + kgdb_connected = 1;
> > +
> > + kgdb_usethread = current;
> > + kgdb_usethreadid = shadow_pid(current->pid);
> > +
> > + while (1) {
> > + int bpt_type = 0;
> > + error = 0;
> > +
> > + /* Clear the out buffer. */
> > + memset(remcomOutBuffer, 0, sizeof(remcomOutBuffer));
> > +
> > + getpacket(remcomInBuffer);
> > +
> > + switch (remcomInBuffer[0]) {
> > + case '?':
> > + remcomOutBuffer[0] = 'S';
> > + remcomOutBuffer[1] = hexchars[signo >> 4];
> > + remcomOutBuffer[2] = hexchars[signo % 16];
> > + break;
> > +
> > + case 'g': /* return the value of the CPU registers */
> > + thread = kgdb_usethread;
> > +
> > + if (!thread)
> > + thread = current;
> > +
> > + /* All threads that don't have debuggerinfo should be
> > + in __schedule() sleeping, since all other CPUs
> > + are in kgdb_wait, and thus have debuggerinfo. */
> > +
> > + if (kgdb_usethreadid >= pid_max + num_online_cpus()) {
> > + regs_to_gdb_regs(gdb_regs,
> > + kgdb_shadow_regs(linux_regs,
> > + kgdb_usethreadid - pid_max -
> > + num_online_cpus()));
> > + } else if (thread->thread.debuggerinfo) {
> > + if ((error = get_char(thread->thread.debuggerinfo,
> > + (unsigned char *)gdb_regs)) < 0) {
> > + error_packet(remcomOutBuffer, error);
> > + break;
> > + }
> > + regs_to_gdb_regs(gdb_regs,
> > + (struct pt_regs *)
> > + thread->thread.debuggerinfo);
> > + } else {
> > + /* Pull stuff saved during
> > + * switch_to; nothing else is
> > + * accessible (or even particularly relevant).
> > + * This should be enough for a stack trace. */
> > + sleeping_thread_to_gdb_regs(gdb_regs, thread);
> > + }
> > +
> > + kgdb_mem2hex((char *) gdb_regs, remcomOutBuffer, NUMREGBYTES);
> > + break;
> > +
> > + case 'G': /* set the value of the CPU registers - return OK */
> > + kgdb_hex2mem(&remcomInBuffer[1], (char *) gdb_regs,
> > + NUMREGBYTES);
> > +
> > + if (kgdb_usethread && kgdb_usethread != current)
> > + error_packet(remcomOutBuffer, -EINVAL);
> > + else {
> > + gdb_regs_to_regs(gdb_regs,
> > + (struct pt_regs *)
> > + current->thread.debuggerinfo);
> > + ok_packet(remcomOutBuffer);
> > + }
> > +
> > + break;
> > +
> > + /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
> > + case 'm':
> > + ptr = &remcomInBuffer[1];
> > + if (kgdb_hex2long(&ptr, &addr) > 0 && *ptr++ == ',' &&
> > + kgdb_hex2long(&ptr, &length) > 0) {
> > + if (IS_ERR(ptr = kgdb_mem2hex((char *) addr,
> > + remcomOutBuffer,
> > + length)))
> > + error_packet(remcomOutBuffer,
> > + PTR_ERR(ptr));
> > + } else
> > + error_packet(remcomOutBuffer, -EINVAL);
> > + break;
> > +
> > + /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
> > + case 'M':
> > + ptr = &remcomInBuffer[1];
> > + if (kgdb_hex2long(&ptr, &addr) > 0 && *(ptr++) == ','
> > + && kgdb_hex2long(&ptr, &length) > 0 &&
> > + *(ptr++) == ':') {
> > + if (IS_ERR(ptr = kgdb_hex2mem(ptr, (char *)addr,
> > + length)))
> > + error_packet(remcomOutBuffer,
> > + PTR_ERR(ptr));
> > + } else
> > + error_packet(remcomOutBuffer, -EINVAL);
> > + break;
> > +
> > + /* kill or detach. KGDB should treat this like a
> > + * continue.
> > + */
> > + case 'D':
> > + if ((error = remove_all_break()) < 0) {
> > + error_packet(remcomOutBuffer, error);
> > + } else {
> > + ok_packet(remcomOutBuffer);
> > + kgdb_connected = 0;
> > + }
> > + putpacket(remcomOutBuffer, 0);
> > + goto default_handle;
> > +
> > + case 'k':
> > + /* Don't care about error from remove_all_break */
> > + remove_all_break();
> > + kgdb_connected = 0;
> > + goto default_handle;
> > +
> > + /* query */
> > + case 'q':
> > + switch (remcomInBuffer[1]) {
> > + case 's':
> > + case 'f':
> > + if (memcmp(remcomInBuffer+2, "ThreadInfo",10))
> > + {
> > + error_packet(remcomOutBuffer,
> > + -EINVAL);
> > + break;
> > + }
> > + if (remcomInBuffer[1] == 'f') {
> > + threadid = 1;
> > + }
> > + remcomOutBuffer[0] = 'm';
> > + ptr = remcomOutBuffer + 1;
> > + for (i = 0; i < 32 && threadid < pid_max +
> > + numshadowth; threadid++) {
> > + thread = getthread(linux_regs,
> > + threadid);
> > + if (thread) {
> > + int_to_threadref(&thref,
> > + threadid);
> > + pack_threadid(ptr, &thref);
> > + ptr += 16;
> > + *(ptr++) = ',';
> > + i++;
> > + }
> > + }
> > + break;
> > +
> > + case 'C':
> > + /* Current thread id */
> > + strcpy(remcomOutBuffer, "QC");
> > +
> > + threadid = shadow_pid(current->pid);
> > +
> > + int_to_threadref(&thref, threadid);
> > + pack_threadid(remcomOutBuffer + 2, &thref);
> > + break;
> > +
> > + case 'E':
> > + /* Print exception info */
> > + kgdb_printexceptioninfo(exVector, err_code,
> > + remcomOutBuffer);
> > + break;
> > + case 'T':
> > + if (memcmp(remcomInBuffer+1,
> > + "ThreadExtraInfo,",16))
> > + {
> > + error_packet(remcomOutBuffer, -EINVAL);
> > + break;
> > + }
> > + threadid = 0;
> > + ptr = remcomInBuffer+17;
> > + kgdb_hex2long(&ptr, &threadid);
> > + if (!getthread(linux_regs, threadid)) {
> > + error_packet(remcomOutBuffer, -EINVAL);
> > + break;
> > + }
> > + if (threadid < pid_max) {
> > + kgdb_mem2hex(getthread(linux_regs,
> > + threadid)->comm,
> > + remcomOutBuffer, 16);
> > + } else if (threadid >= pid_max +
> > + num_online_cpus()) {
> > + kgdb_shadowinfo(linux_regs,
> > + remcomOutBuffer,
> > + threadid - pid_max -
> > + num_online_cpus());
> > + } else {
> > + sprintf(tmpstr, "Shadow task %d"
> > + " for pid 0",
> > + (int)(threadid - pid_max));
> > + kgdb_mem2hex(tmpstr, remcomOutBuffer,
> > + strlen(tmpstr));
> > + }
> > + break;
> > + }
> > + break;
> > +
> > + /* task related */
> > + case 'H':
> > + switch (remcomInBuffer[1]) {
> > + case 'g':
> > + ptr = &remcomInBuffer[2];
> > + kgdb_hex2long(&ptr, &threadid);
> > + thread = getthread(linux_regs, threadid);
> > + if (!thread && threadid > 0) {
> > + error_packet(remcomOutBuffer, -EINVAL);
> > + break;
> > + }
> > + kgdb_usethread = thread;
> > + kgdb_usethreadid = threadid;
> > + ok_packet(remcomOutBuffer);
> > + break;
> > +
> > + case 'c':
> > + atomic_set(&kgdb_killed_or_detached, 0);
> > + ptr = &remcomInBuffer[2];
> > + kgdb_hex2long(&ptr, &threadid);
> > + if (!threadid) {
> > + kgdb_contthread = 0;
> > + } else {
> > + thread = getthread(linux_regs, threadid);
> > + if (!thread && threadid > 0) {
> > + error_packet(remcomOutBuffer,
> > + -EINVAL);
> > + break;
> > + }
> > + kgdb_contthread = thread;
> > + }
> > + ok_packet(remcomOutBuffer);
> > + break;
> > + }
> > + break;
> > +
> > + /* Query thread status */
> > + case 'T':
> > + ptr = &remcomInBuffer[1];
> > + kgdb_hex2long(&ptr, &threadid);
> > + thread = getthread(linux_regs, threadid);
> > + if (thread)
> > + ok_packet(remcomOutBuffer);
> > + else
> > + error_packet(remcomOutBuffer, -EINVAL);
> > + break;
> > + case 'z':
> > + case 'Z':
> > + ptr = &remcomInBuffer[2];
> > + if (*(ptr++) != ',') {
> > + error_packet(remcomOutBuffer, -EINVAL);
> > + break;
> > + }
> > + kgdb_hex2long(&ptr, &addr);
> > +
> > + bpt_type = remcomInBuffer[1];
> > + if (bpt_type != bp_breakpoint) {
> > + if (bpt_type == bp_hardware_breakpoint &&
> > + !(kgdb_ops->flags & KGDB_HW_BREAKPOINT))
> > + break;
> > +
> > + /* if set_break is not defined, then
> > + * remove_break does not matter
> > + */
> > + if(!(kgdb_ops->flags & KGDB_HW_BREAKPOINT))
> > + break;
> > + }
> > +
> > + if (remcomInBuffer[0] == 'Z') {
> > + if (bpt_type == bp_breakpoint)
> > + error = set_break(addr);
> > + else
> > + error = kgdb_arch_set_break(addr,
> > + bpt_type);
> > + }
> > + else {
> > + if (bpt_type == bp_breakpoint)
> > + error = remove_break(addr);
> > + else
> > + error = kgdb_arch_remove_break(addr,
> > + bpt_type);
> > + }
> > +
> > + if (error == 0)
> > + ok_packet(remcomOutBuffer);
> > + else
> > + error_packet(remcomOutBuffer, error);
> > +
> > + break;
> > +
> > + default:
> > + default_handle:
> > + error = kgdb_arch_handle_exception(exVector, signo,
> > + err_code, remcomInBuffer,
> > + remcomOutBuffer, linux_regs);
> > +
> > + if(error >= 0 || remcomInBuffer[0] == 'D' ||
> > + remcomInBuffer[0] == 'k')
> > + goto kgdb_exit;
> > +
> > +
> > + } /* switch */
> > +
> > + /* reply to the request */
> > + putpacket(remcomOutBuffer, 0);
> > + }
> > +
> > +kgdb_exit:
> > + procindebug[smp_processor_id()] = 0;
> > +
> > + for (i = 0; i < num_online_cpus(); i++) {
> > + spin_unlock(&slavecpulocks[i]);
> > + }
> > + /* Wait till all the processors have quit
> > + * from the debugger
> > + */
> > + for (i = 0; i < num_online_cpus(); i++) {
> > + while (procindebug[i]) {
> > + int j = 10; /* an arbitrary number */
> > +
> > + while (--j) {
> > + asm volatile ("nop" : : : "memory");
> > + }
> > + barrier();
> > + }
> > + }
> > +
> > + /* Free debugger_active */
> > + atomic_set(&kgdb_killed_or_detached, 1);
> > + atomic_set(&debugger_active, 0);
> > + local_irq_restore(flags);
> > +
> > + return error;
> > +}
> > +
> > +/*
> > + * GDB places a breakpoint at this function to know dynamically
> > + * loaded objects. It's not defined static so that only one instance
> > with this + * name exists in the kernel.
> > + */
> > +
> > +int module_event(struct notifier_block * self, unsigned long val, void *
> > data) +{
> > + return 0;
> > +}
> > +
> > +static struct notifier_block kgdb_module_load_nb = {
> > + .notifier_call = module_event,
> > +};
> > +
> > +/* 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 (!kgdb_initialized) {
> > + kgdb_enter = 1;
> > + kgdb_entry();
> > + if (!kgdb_initialized) {
> > + printk("kgdb not enabled. Cannot do breakpoint\n");
> > + return;
> > + }
> > + }
> > +
> > + atomic_set(&kgdb_setting_breakpoint, 1);
> > + wmb();
> > + BREAKPOINT();
> > + wmb();
> > + atomic_set(&kgdb_setting_breakpoint, 0);
> > +}
> > +
> > +void kgdb_nmihook(int cpu, void *regs)
> > +{
> > +#ifdef CONFIG_SMP
> > + if (!procindebug[cpu] && atomic_read(&debugger_active) != (cpu + 1)) {
> > + kgdb_wait((struct pt_regs *)regs);
> > + }
> > +#endif
> > +}
> > +
> > +void kgdb_entry(void)
> > +{
> > + int i;
> > +
> > + if (kgdb_initialized) {
> > + /* KGDB was initialized */
> > + return;
> > + }
> > +
> > + for (i = 0; i < KGDB_MAX_NO_CPUS; i++)
> > + spin_lock_init(&slavecpulocks[i]);
> > +
> > + /* Free debugger_active */
> > + atomic_set(&debugger_active, 0);
> > +
> > + /* This flag is used, if gdb has detached and wants to start
> > + * another session
> > + */
> > + atomic_set(&kgdb_killed_or_detached, 1);
> > + atomic_set(&kgdb_might_be_resumed, 0);
> > +
> > + for (i = 0; i < MAX_BREAKPOINTS; i++)
> > + kgdb_break[i].state = bp_disabled;
> > +
> > + linux_debug_hook = kgdb_handle_exception;
> > +
> > + /* Let the arch do any initalization it needs to, including
> > + * pointing to a suitable early output device. */
> > + kgdb_arch_init();
> > +
> > + /* We can't do much if this fails */
> > + register_module_notifier(&kgdb_module_load_nb);
> > +
> > + atomic_set(&kgdb_setting_breakpoint, 0);
> > +
> > + if (!kgdb_serial || kgdb_serial->hook() < 0) {
> > + /* KGDB interface isn't ready yet */
> > + return;
> > + }
> > + kgdb_initialized = 1;
> > + if (!kgdb_enter) {
> > + return;
> > + }
> > + /*
> > + * Call the breakpoint() routine in GDB to start the debugging
> > + * session
> > + */
> > + printk(KERN_CRIT "Waiting for connection from remote gdb... ");
> > + breakpoint() ;
> > + printk("Connected.\n");
> > +}
> > +
> > +#ifdef CONFIG_KGDB_CONSOLE
> > +char kgdbconbuf[BUFMAX];
> > +
> > +void kgdb_console_write(struct console *co, const char *s, unsigned
> > count) +{
> > + int i;
> > + int wcount;
> > + char *bufptr;
> > + unsigned long flags;
> > +
> > + if (!kgdb_connected) {
> > + return;
> > + }
> > + local_irq_save(flags);
> > +
> > + kgdbconbuf[0] = 'O';
> > + bufptr = kgdbconbuf + 1;
> > + while (count > 0) {
> > + if ((count << 1) > (BUFMAX - 2)) {
> > + wcount = (BUFMAX - 2) >> 1;
> > + } else {
> > + wcount = count;
> > + }
> > + count -= wcount;
> > + for (i = 0; i < wcount; i++) {
> > + bufptr = pack_hex_byte(bufptr, s[i]);
> > + }
> > + *bufptr = '\0';
> > + s += wcount;
> > +
> > + putpacket(kgdbconbuf, 1);
> > +
> > + }
> > + local_irq_restore(flags);
> > +}
> > +
> > +/* Always fail so that kgdb console doesn't become the default console
> > */ +static int __init kgdb_console_setup(struct console *co, char
> > *options) +{
> > + return -1;
> > +}
> > +
> > +static struct console kgdbcons = {
> > + .name = "kgdb",
> > + .write = kgdb_console_write,
> > + .setup = kgdb_console_setup,
> > + .flags = CON_PRINTBUFFER | CON_ENABLED,
> > + .index = -1,
> > +};
> > +
> > +static int __init kgdb_console_init(void)
> > +{
> > + register_console(&kgdbcons);
> > + return 0;
> > +}
> > +console_initcall(kgdb_console_init);
> > +#endif
> > +
> > +EXPORT_SYMBOL(breakpoint);
> > +#ifdef CONFIG_KGDB_THREAD
> > +EXPORT_SYMBOL(kern_schedule);
> > +#endif
> > +
> > +static int __init opt_kgdb_enter(char *str)
> > +{
> > + kgdb_enter = 1;
> > + return 1;
> > +}
> > +
> > +static int __init opt_gdb(char *str)
> > +{
> > + kgdb_enter = 1;
> > + return 1;
> > +}
> > +
> > +/*
> > + * These options have been deprecated and are present only to maintain
> > + * compatibility with kgdb for 2.4 and earlier kernels.
> > + */
> > +#ifdef CONFIG_KGDB_8250
> > +extern int kgdb8250_baud;
> > +extern int kgdb8250_ttyS;
> > +static int __init opt_gdbttyS(char *str)
> > +{
> > + kgdb8250_ttyS = simple_strtoul(str, NULL, 10);
> > + return 1;
> > +}
> > +static int __init opt_gdbbaud(char *str)
> > +{
> > + kgdb8250_baud = simple_strtoul(str, NULL, 10);
> > + return 1;
> > +}
> > +#endif
> > +
> > +/*
> > + *
> > + * Sequence of following lines has to be maintained because gdb option
> > is a + * prefix of the other two options
> > + */
> > +
> > +#ifdef CONFIG_KGDB_8250
> > +__setup("gdbttyS=", opt_gdbttyS);
> > +__setup("gdbbaud=", opt_gdbbaud);
> > +#endif
> > +__setup("gdb", opt_gdb);
> > +__setup("kgdbwait", opt_kgdb_enter);
> > --- clean.2.5/kernel/sched.c 2004-02-05 01:54:30.000000000 +0100
> > +++ linux-mm/kernel/sched.c 2004-02-16 23:09:06.000000000 +0100
> > @@ -37,6 +37,7 @@
> > #include <linux/rcupdate.h>
> > #include <linux/cpu.h>
> > #include <linux/percpu.h>
> > +#include <linux/debugger.h>
> >
> > #ifdef CONFIG_NUMA
> > #define cpu_to_node_mask(cpu) node_to_cpumask(cpu_to_node(cpu))
> > @@ -2958,6 +2959,8 @@
> > #if defined(in_atomic)
> > static unsigned long prev_jiffy; /* ratelimiting */
> >
> > + if (atomic_read(&debugger_active))
> > + return;
> > if ((in_atomic() || irqs_disabled()) && system_running) {
> > if (time_before(jiffies, prev_jiffy + HZ) && prev_jiffy)
> > return;

-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/

Next message: Andrew Morton: "Re: [PATCH][0/6] A different KGDB stub"
Previous message: Amit S. Kale: "Re: [PATCH][0/6] A different KGDB stub"
In reply to: Amit S. Kale: "Re: kgdb-lite for 2.6.2"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]