lkml.org 
[lkml]   [2004]   [Feb]   [22]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patches in this message
/
Date
From
Subject[1/3] kgdb-lite for 2.6.3
Hi!

Here's kgdb-lite for 2.6.3: core-lite + i386-lite + 8250. Should be
both functional, and suitable for merging (maybe even to -vanilla?)

Pavel

Index: linux-2.6.3-kgdb/include/linux/debugger.h
===================================================================
--- linux-2.6.3-kgdb.orig/include/linux/debugger.h 2003-01-30 15:54:37.000000000 +0530
+++ linux-2.6.3-kgdb/include/linux/debugger.h 2004-02-21 16:56:46.000000000 +0530
@@ -0,0 +1,70 @@
+#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) \
+{ \
+ if (0) \
+ 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_ */
Index: linux-2.6.3-kgdb/include/linux/kgdb.h
===================================================================
--- linux-2.6.3-kgdb.orig/include/linux/kgdb.h 2003-01-30 15:54:37.000000000 +0530
+++ linux-2.6.3-kgdb/include/linux/kgdb.h 2004-02-21 17:56:21.488684112 +0530
@@ -0,0 +1,113 @@
+#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_hexToLong(char **ptr, long *longValue);
+char *kgdb_mem2hex(char *mem, char *buf, int count);
+char *kgdb_hex2mem(char *buf, char *mem, int count);
+int kgdb_get_mem (char *addr, unsigned char *buf, int count);
+
+#endif /* _KGDB_H_ */
Index: linux-2.6.3-kgdb/init/main.c
===================================================================
--- linux-2.6.3-kgdb.orig/init/main.c 2004-02-21 16:52:54.000000000 +0530
+++ linux-2.6.3-kgdb/init/main.c 2004-02-21 16:56:46.000000000 +0530
@@ -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();
Index: linux-2.6.3-kgdb/kernel/kgdbstub.c
===================================================================
--- linux-2.6.3-kgdb.orig/kernel/kgdbstub.c 2003-01-30 15:54:37.000000000 +0530
+++ linux-2.6.3-kgdb/kernel/kgdbstub.c 2004-02-21 17:56:21.480685328 +0530
@@ -0,0 +1,1267 @@
+/*
+ * 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@suse.cz>
+ *
+ * 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@emsyssoft.com )
+ *
+ * Several enhancements by George Anzinger <george@mvista.com>
+ * Generic KGDB Support
+ * Implemented by Anurekh Saxena (anurekh.saxena@timesys.com)
+ *
+ * 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@gcom.com>
+ * Integrated into 2.2.5 kernel by Tigran Aivazian <tigran@sco.com>
+ */
+
+#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 (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_hexToLong(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
+
+int kgdb_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 = kgdb_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;
+ struct pt_regs *shadowregs;
+
+ /* 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()) {
+ shadowregs = kgdb_shadow_regs(linux_regs,
+ kgdb_usethreadid - pid_max -
+ num_online_cpus());
+ if (!shadowregs) {
+ error_packet(remcomOutBuffer, -EINVAL);
+ break;
+ }
+ regs_to_gdb_regs(gdb_regs, shadowregs);
+ } 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_hexToLong(&ptr, &addr) > 0 && *ptr++ == ',' &&
+ kgdb_hexToLong(&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_hexToLong(&ptr, &addr) > 0 && *(ptr++) == ','
+ && kgdb_hexToLong(&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++;
+ }
+ }
+ *(--ptr) = '\0';
+ 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_hexToLong(&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_hexToLong(&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_hexToLong(&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_hexToLong(&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_hexToLong(&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);
Index: linux-2.6.3-kgdb/kernel/Makefile
===================================================================
--- linux-2.6.3-kgdb.orig/kernel/Makefile 2004-02-21 16:52:53.000000000 +0530
+++ linux-2.6.3-kgdb/kernel/Makefile 2004-02-21 16:56:46.000000000 +0530
@@ -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@linuxcare.com.au>, the -fno-omit-frame-pointer is
Index: linux-2.6.3-kgdb/kernel/sched.c
===================================================================
--- linux-2.6.3-kgdb.orig/kernel/sched.c 2004-02-21 16:52:53.000000000 +0530
+++ linux-2.6.3-kgdb/kernel/sched.c 2004-02-21 16:56:46.000000000 +0530
@@ -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))
@@ -2961,6 +2962,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;
Index: linux-2.6.3-kgdb/Makefile
===================================================================
--- linux-2.6.3-kgdb.orig/Makefile 2004-02-21 16:52:54.000000000 +0530
+++ linux-2.6.3-kgdb/Makefile 2004-02-21 16:56:46.000000000 +0530
@@ -440,6 +440,8 @@

ifndef CONFIG_FRAME_POINTER
CFLAGS += -fomit-frame-pointer
+else
+CFLAGS += -fno-omit-frame-pointer
endif

ifdef CONFIG_DEBUG_INFO
Index: linux-2.6.3-kgdb-lite/arch/i386/Kconfig
===================================================================
--- linux-2.6.3-kgdb-lite.orig/arch/i386/Kconfig 2004-02-21 16:52:34.725440552 +0530
+++ linux-2.6.3-kgdb-lite/arch/i386/Kconfig 2004-02-21 16:58:15.255672088 +0530
@@ -1253,6 +1253,20 @@
If you say Y here, various routines which may sleep will become very
noisy if they are called with a spinlock held.

+config KGDB
+ bool "KGDB: kernel debugging with remote gdb"
+ depends on DEBUG_KERNEL
+ select DEBUG_INFO
+ select FRAME_POINTER
+ help
+ If you say Y here, it will be possible to remotely debug the
+ kernel using gdb. This enlarges your kernel image disk size by
+ several megabytes and requires a machine with more than 128 MB
+ RAM to avoid excessive linking time.
+ Documentation of kernel debugger available at
+ http://kgdb.sourceforge.net
+ This is only useful for kernel hackers. If unsure, say N.
+
config FRAME_POINTER
bool "Compile the kernel with frame pointers"
help
Index: linux-2.6.3-kgdb-lite/arch/i386/kernel/i386-stub.c
===================================================================
--- linux-2.6.3-kgdb-lite.orig/arch/i386/kernel/i386-stub.c 2003-01-30 15:54:37.000000000 +0530
+++ linux-2.6.3-kgdb-lite/arch/i386/kernel/i386-stub.c 2004-02-21 16:57:53.022052112 +0530
@@ -0,0 +1,373 @@
+/*
+ *
+ * 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.
+ */
+/*
+ * Contributor: Lake Stevens Instrument Division$
+ * Written by: Glenn Engel $
+ * Updated by: Amit Kale<akale@veritas.com>
+ * Modified for 386 by Jim Kingdon, Cygnus Support.
+ * Origianl kgdb, compatibility with 2.1.xx kernel by David Grothe <dave@gcom.com>
+ */
+
+#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 <asm/vm86.h>
+#include <asm/system.h>
+#include <asm/ptrace.h> /* for linux pt_regs struct */
+#include <linux/kgdb.h>
+#ifdef CONFIG_GDB_CONSOLE
+#include <linux/console.h>
+#endif
+#include <linux/init.h>
+#include <linux/debugger.h>
+
+/* Put the error code here just in case the user cares. */
+int gdb_i386errcode;
+/* Likewise, the vector number here (since GDB only gets the signal
+ number through the usual means, and that's not very specific). */
+int gdb_i386vector = -1;
+
+#if KGDB_MAX_NO_CPUS != 8
+#error change the definition of slavecpulocks
+#endif
+
+void regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *regs)
+{
+ gdb_regs[_EAX] = regs->eax;
+ gdb_regs[_EBX] = regs->ebx;
+ gdb_regs[_ECX] = regs->ecx;
+ gdb_regs[_EDX] = regs->edx;
+ gdb_regs[_ESI] = regs->esi;
+ gdb_regs[_EDI] = regs->edi;
+ gdb_regs[_EBP] = regs->ebp;
+ gdb_regs[ _DS] = regs->xds;
+ gdb_regs[ _ES] = regs->xes;
+ gdb_regs[ _PS] = regs->eflags;
+ gdb_regs[ _CS] = regs->xcs;
+ gdb_regs[ _PC] = regs->eip;
+ gdb_regs[_ESP] = (int) (&regs->esp) ;
+ gdb_regs[ _SS] = __KERNEL_DS;
+ gdb_regs[ _FS] = 0xFFFF;
+ gdb_regs[ _GS] = 0xFFFF;
+}
+
+void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *p)
+{
+ gdb_regs[_EAX] = 0;
+ gdb_regs[_EBX] = 0;
+ gdb_regs[_ECX] = 0;
+ gdb_regs[_EDX] = 0;
+ gdb_regs[_ESI] = 0;
+ gdb_regs[_EDI] = 0;
+ gdb_regs[_EBP] = *(int *)p->thread.esp;
+ gdb_regs[_DS] = __KERNEL_DS;
+ gdb_regs[_ES] = __KERNEL_DS;
+ gdb_regs[_PS] = 0;
+ gdb_regs[_CS] = __KERNEL_CS;
+ gdb_regs[_PC] = p->thread.eip;
+ gdb_regs[_ESP] = p->thread.esp;
+ gdb_regs[_SS] = __KERNEL_DS;
+ gdb_regs[_FS] = 0xFFFF;
+ gdb_regs[_GS] = 0xFFFF;
+}
+
+void gdb_regs_to_regs(unsigned long *gdb_regs, struct pt_regs *regs)
+{
+ regs->eax = gdb_regs[_EAX] ;
+ regs->ebx = gdb_regs[_EBX] ;
+ regs->ecx = gdb_regs[_ECX] ;
+ regs->edx = gdb_regs[_EDX] ;
+ regs->esi = gdb_regs[_ESI] ;
+ regs->edi = gdb_regs[_EDI] ;
+ regs->ebp = gdb_regs[_EBP] ;
+ regs->xds = gdb_regs[ _DS] ;
+ regs->xes = gdb_regs[ _ES] ;
+ regs->eflags= gdb_regs[ _PS] ;
+ regs->xcs = gdb_regs[ _CS] ;
+ regs->eip = gdb_regs[ _PC] ;
+#if 0 /* can't change these */
+ regs->esp = gdb_regs[_ESP] ;
+ regs->xss = gdb_regs[ _SS] ;
+ regs->fs = gdb_regs[ _FS] ;
+ regs->gs = gdb_regs[ _GS] ;
+#endif
+
+}
+
+struct hw_breakpoint {
+ unsigned enabled;
+ unsigned type;
+ unsigned len;
+ unsigned addr;
+} breakinfo[4] = { {
+enabled:0}, {
+enabled:0}, {
+enabled:0}, {
+enabled:0}};
+
+void kgdb_correct_hw_break(void)
+{
+ int breakno;
+ int correctit;
+ int breakbit;
+ unsigned dr7;
+
+ asm volatile ("movl %%db7, %0\n":"=r" (dr7)
+ :);
+ do {
+ unsigned addr0, addr1, addr2, addr3;
+ asm volatile ("movl %%db0, %0\n"
+ "movl %%db1, %1\n"
+ "movl %%db2, %2\n"
+ "movl %%db3, %3\n":"=r" (addr0), "=r"(addr1),
+ "=r"(addr2), "=r"(addr3):);
+ } while (0);
+ correctit = 0;
+ for (breakno = 0; breakno < 3; breakno++) {
+ breakbit = 2 << (breakno << 1);
+ if (!(dr7 & breakbit) && breakinfo[breakno].enabled) {
+ correctit = 1;
+ dr7 |= breakbit;
+ dr7 &= ~(0xf0000 << (breakno << 2));
+ dr7 |= (((breakinfo[breakno].len << 2) |
+ breakinfo[breakno].type) << 16) <<
+ (breakno << 2);
+ switch (breakno) {
+ case 0:
+ asm volatile ("movl %0, %%dr0\n"::"r"
+ (breakinfo[breakno].addr));
+ break;
+
+ case 1:
+ asm volatile ("movl %0, %%dr1\n"::"r"
+ (breakinfo[breakno].addr));
+ break;
+
+ case 2:
+ asm volatile ("movl %0, %%dr2\n"::"r"
+ (breakinfo[breakno].addr));
+ break;
+
+ case 3:
+ asm volatile ("movl %0, %%dr3\n"::"r"
+ (breakinfo[breakno].addr));
+ break;
+ }
+ } else if ((dr7 & breakbit) && !breakinfo[breakno].enabled) {
+ correctit = 1;
+ dr7 &= ~breakbit;
+ dr7 &= ~(0xf0000 << (breakno << 2));
+ }
+ }
+ if (correctit) {
+ asm volatile ("movl %0, %%db7\n"::"r" (dr7));
+ }
+}
+
+int kgdb_remove_hw_break(unsigned long addr, int type)
+{
+ int i, idx = -1;
+ for (i = 0; i < 4; i ++) {
+ if (breakinfo[i].addr == addr && breakinfo[i].enabled) {
+ idx = i;
+ break;
+ }
+ }
+ if (idx == -1)
+ return -1;
+
+ breakinfo[idx].enabled = 0;
+ return 0;
+}
+
+int kgdb_set_hw_break(unsigned long addr, int type)
+{
+ int i, idx = -1;
+ for (i = 0; i < 4; i ++) {
+ if (!breakinfo[i].enabled) {
+ idx = i;
+ break;
+ }
+ }
+ if (idx == -1)
+ return -1;
+
+ breakinfo[idx].enabled = 1;
+ breakinfo[idx].type = type;
+ breakinfo[idx].len = 1;
+ breakinfo[idx].addr = addr;
+ return 0;
+}
+
+int remove_hw_break(unsigned breakno)
+{
+ if (!breakinfo[breakno].enabled) {
+ return -1;
+ }
+ breakinfo[breakno].enabled = 0;
+ return 0;
+}
+
+int set_hw_break(unsigned breakno,
+ unsigned type, unsigned len, unsigned addr)
+{
+ if (breakinfo[breakno].enabled) {
+ return -1;
+ }
+ breakinfo[breakno].enabled = 1;
+ breakinfo[breakno].type = type;
+ breakinfo[breakno].len = len;
+ breakinfo[breakno].addr = addr;
+ return 0;
+}
+
+void kgdb_printexceptioninfo(int exceptionNo, int errorcode, char *buffer)
+{
+ unsigned dr6;
+ int i;
+ switch (exceptionNo) {
+ case 1: /* debug exception */
+ break;
+ case 3: /* breakpoint */
+ sprintf(buffer, "Software breakpoint");
+ return;
+ default:
+ sprintf(buffer, "Details not available");
+ return;
+ }
+ asm volatile ("movl %%db6, %0\n":"=r" (dr6)
+ :);
+ if (dr6 & 0x4000) {
+ sprintf(buffer, "Single step");
+ return;
+ }
+ for (i = 0; i < 4; ++i) {
+ if (dr6 & (1 << i)) {
+ sprintf(buffer, "Hardware breakpoint %d", i);
+ return;
+ }
+ }
+ sprintf(buffer, "Unknown trap");
+ return;
+}
+
+void kgdb_disable_hw_debug(struct pt_regs *regs)
+{
+ /* Disable hardware debugging while we are in kgdb */
+ asm volatile("movl %0,%%db7": /* no output */ : "r"(0));
+}
+
+void kgdb_post_master_code(struct pt_regs *regs, int eVector, int err_code)
+{
+ /* Master processor is completely in the debugger */
+ gdb_i386vector = eVector;
+ gdb_i386errcode = err_code;
+}
+
+int kgdb_arch_handle_exception(int exceptionVector, int signo,
+ int err_code, char *remcomInBuffer, char *remcomOutBuffer,
+ struct pt_regs *linux_regs)
+{
+ long addr, length;
+ long breakno, breaktype;
+ char *ptr;
+ int newPC;
+ int dr6;
+
+ switch (remcomInBuffer[0]) {
+ case 'c':
+ case 's':
+ if (kgdb_contthread && kgdb_contthread != current) {
+ strcpy(remcomOutBuffer, "E00");
+ break;
+ }
+
+ kgdb_contthread = NULL;
+
+ /* try to read optional parameter, pc unchanged if no parm */
+ ptr = &remcomInBuffer[1];
+ if (kgdb_hexToLong(&ptr, &addr)) {
+ linux_regs->eip = addr;
+ }
+ newPC = linux_regs->eip;
+
+ /* clear the trace bit */
+ linux_regs->eflags &= 0xfffffeff;
+
+ /* set the trace bit if we're stepping */
+ if (remcomInBuffer[0] == 's') {
+ linux_regs->eflags |= 0x100;
+ debugger_step = 1;
+ }
+
+ asm volatile ("movl %%db6, %0\n" : "=r" (dr6));
+ if (!(dr6 & 0x4000)) {
+ for (breakno = 0; breakno < 4; ++breakno) {
+ if (dr6 & (1 << breakno)) {
+ if (breakinfo[breakno].type == 0) {
+ /* Set restore flag */
+ linux_regs->eflags |= 0x10000;
+ break;
+ }
+ }
+ }
+ }
+ kgdb_correct_hw_break();
+ asm volatile ("movl %0, %%db6\n"::"r" (0));
+
+ return (0);
+
+ case 'Y':
+ ptr = &remcomInBuffer[1];
+ kgdb_hexToLong(&ptr, &breakno);
+ ptr++;
+ kgdb_hexToLong(&ptr, &breaktype);
+ ptr++;
+ kgdb_hexToLong(&ptr, &length);
+ ptr++;
+ kgdb_hexToLong(&ptr, &addr);
+ if (set_hw_break(breakno & 0x3, breaktype & 0x3,
+ length & 0x3, addr) == 0) {
+ strcpy(remcomOutBuffer, "OK");
+ } else {
+ strcpy(remcomOutBuffer, "ERROR");
+ }
+ break;
+
+ /* Remove hardware breakpoint */
+ case 'y':
+ ptr = &remcomInBuffer[1];
+ kgdb_hexToLong(&ptr, &breakno);
+ if (remove_hw_break(breakno & 0x3) == 0) {
+ strcpy(remcomOutBuffer, "OK");
+ } else {
+ strcpy(remcomOutBuffer, "ERROR");
+ }
+ break;
+
+ } /* switch */
+ return -1; /* this means that we do not want to exit from the handler */
+}
+
+struct kgdb_arch arch_kgdb_ops = {
+ .gdb_bpt_instr = {0xcc},
+ .flags = KGDB_HW_BREAKPOINT,
+};
Index: linux-2.6.3-kgdb-lite/arch/i386/kernel/Makefile
===================================================================
--- linux-2.6.3-kgdb-lite.orig/arch/i386/kernel/Makefile 2004-02-21 16:52:34.387491928 +0530
+++ linux-2.6.3-kgdb-lite/arch/i386/kernel/Makefile 2004-02-21 16:57:53.022052112 +0530
@@ -31,6 +31,7 @@
obj-$(CONFIG_ACPI_SRAT) += srat.o
obj-$(CONFIG_HPET_TIMER) += time_hpet.o
obj-$(CONFIG_EFI) += efi.o efi_stub.o
+obj-$(CONFIG_KGDB) += i386-stub.o

EXTRA_AFLAGS := -traditional

Index: linux-2.6.3-kgdb-lite/arch/i386/kernel/nmi.c
===================================================================
--- linux-2.6.3-kgdb-lite.orig/arch/i386/kernel/nmi.c 2004-02-21 16:52:34.413487976 +0530
+++ linux-2.6.3-kgdb-lite/arch/i386/kernel/nmi.c 2004-02-21 16:57:53.023051960 +0530
@@ -25,6 +25,7 @@
#include <linux/module.h>
#include <linux/nmi.h>
#include <linux/sysdev.h>
+#include <linux/debugger.h>

#include <asm/smp.h>
#include <asm/mtrr.h>
@@ -420,14 +421,25 @@
int sum, cpu = smp_processor_id();

sum = irq_stat[cpu].apic_timer_irqs;
+ if (atomic_read(&debugger_active)) {

- if (last_irq_sums[cpu] == sum) {
+ /*
+ * The machine is in debugger, hold this cpu if already
+ * not held.
+ */
+ debugger_nmihook(cpu, regs);
+ alert_counter[cpu] = 0;
+
+ } else if (last_irq_sums[cpu] == sum) {
/*
* Ayiee, looks like this CPU is stuck ...
* wait a few IRQs (5 seconds) before doing the oops ...
*/
alert_counter[cpu]++;
if (alert_counter[cpu] == 5*nmi_hz) {
+
+ CHK_DEBUGGER(2,SIGSEGV,0,regs,)
+
spin_lock(&nmi_print_lock);
/*
* We are in trouble anyway, lets at least try
Index: linux-2.6.3-kgdb-lite/arch/i386/kernel/signal.c
===================================================================
--- linux-2.6.3-kgdb-lite.orig/arch/i386/kernel/signal.c 2004-02-21 16:52:34.408488736 +0530
+++ linux-2.6.3-kgdb-lite/arch/i386/kernel/signal.c 2004-02-21 16:57:53.023051960 +0530
@@ -580,7 +580,8 @@
* have been cleared if the watchpoint triggered
* inside the kernel.
*/
- __asm__("movl %0,%%db7" : : "r" (current->thread.debugreg[7]));
+ if (current->thread.debugreg[7])
+ __asm__("movl %0,%%db7" : : "r" (current->thread.debugreg[7]));

/* Whee! Actually deliver the signal. */
handle_signal(signr, &info, oldset, regs);
Index: linux-2.6.3-kgdb-lite/arch/i386/kernel/traps.c
===================================================================
--- linux-2.6.3-kgdb-lite.orig/arch/i386/kernel/traps.c 2004-02-21 16:52:34.386492080 +0530
+++ linux-2.6.3-kgdb-lite/arch/i386/kernel/traps.c 2004-02-21 16:57:53.024051808 +0530
@@ -51,6 +51,7 @@

#include <linux/irq.h>
#include <linux/module.h>
+#include <linux/debugger.h>

#include "mach_traps.h"

@@ -256,6 +257,7 @@
{
static int die_counter;

+ CHK_DEBUGGER(1,SIGTRAP,err,regs,)
console_verbose();
spin_lock_irq(&die_lock);
bust_spinlocks(1);
@@ -330,6 +332,7 @@
#define DO_ERROR(trapnr, signr, str, name) \
asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
{ \
+ CHK_DEBUGGER(trapnr,signr,error_code,regs,)\
do_trap(trapnr, signr, str, 0, regs, error_code, NULL); \
}

@@ -347,7 +350,10 @@
#define DO_VM86_ERROR(trapnr, signr, str, name) \
asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
{ \
+ CHK_DEBUGGER(trapnr,signr,error_code,regs,goto skip_trap)\
do_trap(trapnr, signr, str, 1, regs, error_code, NULL); \
+skip_trap: \
+ return; \
}

#define DO_VM86_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \
@@ -547,7 +553,7 @@
tsk->thread.debugreg[6] = condition;

/* Mask out spurious TF errors due to lazy TF clearing */
- if (condition & DR_STEP) {
+ if (condition & DR_STEP && !debugger_step) {
/*
* The TF error should be masked out only if the current
* process is not traced and if the TRAP flag has been set
@@ -570,11 +576,13 @@
info.si_errno = 0;
info.si_code = TRAP_BRKPT;

- /* If this is a kernel mode trap, save the user PC on entry to
- * the kernel, that's what the debugger can make sense of.
- */
- info.si_addr = ((regs->xcs & 3) == 0) ? (void *)tsk->thread.eip :
- (void *)regs->eip;
+
+ /* If this is a kernel mode trap, we need to reset db7 to allow us
+ * to continue sanely */
+ if ((regs->xcs & 3) == 0)
+ goto clear_dr7;
+
+ info.si_addr = (void *)regs->eip;
force_sig_info(SIGTRAP, &info, tsk);

/* Disable additional traps. They'll be re-enabled when
@@ -584,6 +592,7 @@
__asm__("movl %0,%%db7"
: /* no output */
: "r" (0));
+ CHK_DEBUGGER(1,SIGTRAP,error_code,regs,)
return;

debug_vm86:
Index: linux-2.6.3-kgdb-lite/arch/i386/mm/fault.c
===================================================================
--- linux-2.6.3-kgdb-lite.orig/arch/i386/mm/fault.c 2004-02-21 16:52:34.491476120 +0530
+++ linux-2.6.3-kgdb-lite/arch/i386/mm/fault.c 2004-02-21 16:57:53.025051656 +0530
@@ -2,6 +2,11 @@
* linux/arch/i386/mm/fault.c
*
* Copyright (C) 1995 Linus Torvalds
+ *
+ * Change History
+ *
+ * Tigran Aivazian <tigran@sco.com> Remote debugging support.
+ *
*/

#include <linux/signal.h>
@@ -21,6 +26,7 @@
#include <linux/vt_kern.h> /* For unblank_screen() */
#include <linux/highmem.h>
#include <linux/module.h>
+#include <linux/debugger.h>

#include <asm/system.h>
#include <asm/uaccess.h>
@@ -399,6 +405,8 @@
if (is_prefetch(regs, address))
return;

+ CHK_DEBUGGER(14, SIGSEGV,error_code, regs,)
+
/*
* Oops. The kernel tried to access some bad page. We'll have to
* terminate things with extreme prejudice.
@@ -406,6 +414,7 @@

bust_spinlocks(1);

+
if (address < PAGE_SIZE)
printk(KERN_ALERT "Unable to handle kernel NULL pointer dereference");
else
Index: linux-2.6.3-kgdb-lite/include/asm-i386/kgdb.h
===================================================================
--- linux-2.6.3-kgdb-lite.orig/include/asm-i386/kgdb.h 2003-01-30 15:54:37.000000000 +0530
+++ linux-2.6.3-kgdb-lite/include/asm-i386/kgdb.h 2004-02-21 16:57:53.025051656 +0530
@@ -0,0 +1,49 @@
+#ifndef _ASM_KGDB_H_
+#define _ASM_KGDB_H_
+
+/*
+ * Copyright (C) 2001-2004 Amit S. Kale
+ */
+
+#include <linux/ptrace.h>
+
+/* gdb locks */
+#define KGDB_MAX_NO_CPUS 8
+
+/************************************************************************/
+/* BUFMAX defines the maximum number of characters in inbound/outbound buffers*/
+/* at least NUMREGBYTES*2 are needed for register packets */
+/* Longer buffer is needed to list all threads */
+#define BUFMAX 1024
+
+/* Number of bytes of registers. */
+#define NUMREGBYTES 64
+/*
+ * Note that this register image is in a different order than
+ * the register image that Linux produces at interrupt time.
+ *
+ * Linux's register image is defined by struct pt_regs in ptrace.h.
+ * Just why GDB uses a different order is a historical mystery.
+ */
+enum regnames { _EAX, /* 0 */
+ _ECX, /* 1 */
+ _EDX, /* 2 */
+ _EBX, /* 3 */
+ _ESP, /* 4 */
+ _EBP, /* 5 */
+ _ESI, /* 6 */
+ _EDI, /* 7 */
+ _PC, /* 8 also known as eip */
+ _PS, /* 9 also known as eflags */
+ _CS, /* 10 */
+ _SS, /* 11 */
+ _DS, /* 12 */
+ _ES, /* 13 */
+ _FS, /* 14 */
+ _GS /* 15 */
+};
+
+#define BREAKPOINT() asm(" int $3");
+#define BREAK_INSTR_SIZE 1
+
+#endif /* _ASM_KGDB_H_ */
Index: linux-2.6.3-kgdb-lite/include/asm-i386/processor.h
===================================================================
--- linux-2.6.3-kgdb-lite.orig/include/asm-i386/processor.h 2004-02-21 16:52:47.026570496 +0530
+++ linux-2.6.3-kgdb-lite/include/asm-i386/processor.h 2004-02-21 16:57:53.026051504 +0530
@@ -425,6 +425,8 @@
unsigned int saved_fs, saved_gs;
/* IO permissions */
unsigned long *io_bitmap_ptr;
+ void * debuggerinfo;
+
};

#define INIT_THREAD { \

Index: linux-2.6.3-kgdb/drivers/serial/8250.c
===================================================================
--- linux-2.6.3-kgdb.orig/drivers/serial/8250.c 2004-02-19 13:35:55.000000000 +0530
+++ linux-2.6.3-kgdb/drivers/serial/8250.c 2004-02-19 14:09:16.367939176 +0530
@@ -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;
Index: linux-2.6.3-kgdb/drivers/serial/Kconfig
===================================================================
--- linux-2.6.3-kgdb.orig/drivers/serial/Kconfig 2004-02-19 13:35:55.000000000 +0530
+++ linux-2.6.3-kgdb/drivers/serial/Kconfig 2004-02-19 14:09:16.369938872 +0530
@@ -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
Index: linux-2.6.3-kgdb/drivers/serial/kgdb_8250.c
===================================================================
--- linux-2.6.3-kgdb.orig/drivers/serial/kgdb_8250.c 2003-01-30 15:54:37.000000000 +0530
+++ linux-2.6.3-kgdb/drivers/serial/kgdb_8250.c 2004-02-19 14:09:16.370938720 +0530
@@ -0,0 +1,396 @@
+/*
+ * 8250 interface for kgdb.
+ *
+ * Restructured for making kgdb capable of handling different types of serial
+ * interfaces, by Amit Kale (amitkale@emsyssoft.com)
+ *
+ * Written (hacked together) by David Grothe (dave@gcom.com)
+ *
+ * Modified by Scott Foehner (sfoehner@engr.sgi.com) 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);
Index: linux-2.6.3-kgdb/drivers/serial/Makefile
===================================================================
--- linux-2.6.3-kgdb.orig/drivers/serial/Makefile 2004-02-19 13:35:55.000000000 +0530
+++ linux-2.6.3-kgdb/drivers/serial/Makefile 2004-02-19 14:09:16.379937352 +0530
@@ -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
Index: linux-2.6.3-kgdb/drivers/serial/serial_core.c
===================================================================
--- linux-2.6.3-kgdb.orig/drivers/serial/serial_core.c 2004-02-19 13:35:55.000000000 +0530
+++ linux-2.6.3-kgdb/drivers/serial/serial_core.c 2004-02-19 14:09:16.381937048 +0530
@@ -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());

--
When do you have a heart between your knees?
[Johanka's followup: and *two* hearts?]
-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/

\
 
 \ /
  Last update: 2005-03-22 14:01    [W:3.116 / U:0.024 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site