diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/Documentation/i386/gdb-serial.txt 200-kgdb/Documentation/i386/gdb-serial.txt
--- 140-objrmap/Documentation/i386/gdb-serial.txt	Wed Dec 31 16:00:00 1969
+++ 200-kgdb/Documentation/i386/gdb-serial.txt	Tue Sep  2 10:14:10 2003
@@ -0,0 +1,386 @@
+Version
+=======
+
+This version of the gdbstub package was developed and tested on
+kernel version 2.3.48.  It will not install on a 2.2 kernel.  It may
+not work on earlier versions of 2.3 kernels.  It is possible that
+it will continue to work on later versions of 2.3 and then
+versions of 2.4 (I hope).
+
+
+Debugging Setup
+===============
+
+Designate one machine as the "development" machine.  This is the
+machine on which you run your compiles and which has your source
+code for the kernel.  Designate a second machine as the "target"
+machine.  This is the machine that will run your experimental
+kernel.
+
+The two machines will be connected together via a serial line out
+one or the other of the COM ports of the PC.  You will need a modem
+eliminator and the appropriate cables.
+
+On the DEVELOPMENT machine you need to apply the patch for the gdb
+hooks.  You have probably already done that if you are reading this
+file.
+
+On your DEVELOPMENT machine, go to your kernel source directory and
+do "make menuconfig".  Go down to the kernel hacking menu item and
+open it up.  Enable the kernel gdb stub code by selecting that item.
+
+Save and exit the menuconfig program.  Then do "make clean" and
+"make bzImage" (or whatever target you want to make).  This gets
+the kernel compiled with the "-g" option set -- necessary for
+debugging.
+
+You have just built the kernel on your DEVELOPMENT machine that you
+intend to run on our TARGET machine.
+
+To install this new kernel, use the following installation procedure.
+Remember, you are on the DEVELOPMENT machine patching the kernel source
+for the kernel that you intend to run on the TARGET machine.
+
+Copy this kernel to your target machine using your usual procedures.
+I usually arrange to copy development:/usr/src/linux/arch/i386/boot/zImage
+to /vmlinuz on the TARGET machine via a LAN based NFS access.  That is,
+I run the cp command on the target and copy from the development machine
+via the LAN.  Run Lilo on the new kernel on the target machine so that it
+will boot!  Then boot the kernel on the target machine.
+
+There is an utility program named "gdbstart" in the
+development:/usr/src/linux/arch/i386/kernel directory.
+You should copy this program over to your target machine, probably into
+/sbin.  This utility program is run on the target machine to
+activate the kernel hooks for the debugger.  It is invoked as follows:
+
+    gdbstart [-s speed] [-t tty-dev]
+    defaults:  /dev/ttyS0 with speed unmodified by gdbstart
+
+Don't run the program just yet.  We'll get to that in a bit.
+
+Decide on which tty port you want the machines to communicate, then
+cable them up back-to-back using the null modem.  COM1 is /dev/ttyS0
+and COM2 is /dev/ttyS1.
+
+On the DEVELOPMENT machine, create a file called .gdbinit in the
+directory /usr/src/linux.  An example .gdbinit file looks like this:
+
+define rmt
+set remotebaud 38400
+target remote /dev/ttyS0
+end
+
+Assuming that you added my gdbinit stuff to your .gdbinit, edit .gdbinit
+and find the section that looks like this:
+
+	define rmt
+	set remotebaud 38400
+	target remote /dev/ttyS0
+	end
+
+Change the "target" definition so that it specifies the tty port that
+you intend to use.  Change the "remotebaud" definition to match the
+data rate that you are going to use for the com line.
+
+On the TARGET machine I find it helpful to create shell script file
+named "debug" in the root home directory with the following contents:
+
+	gdbstart -s 38400 -t /dev/ttyS0 <<EOF
+	<blank line>
+	EOF
+
+This runs the gdbstart program and gives it the carriage return that
+it prompts for.  This sets the data rate from the target machine's side.
+
+You are now ready to try it out.
+
+On your TARGET machine, freshly rebooted with your gdbstub-equipped
+kernel, type "debug" in the root home directory.  The system will appear
+to hang with some messages on the screen from the debug stub.  What
+it is doing is waiting for contact from the development machine.
+
+On your DEVELOPMENT machine, cd /usr/src/linux and enter "gdb vmlinux".
+When gdb gets the symbols loaded and prompts you, enter "rmt" (that's
+the macro from the .gdbinit file that you just edited).  If everything
+is working correctly you should see gdb print out a few lines indicating
+that a breakpoint has been taken.  It will actually show a line of
+code in the target kernel inside the gdbstub activation code.
+
+The gdb interaction should look something like this:
+
+    linux-dev:/usr/src/linux# gdb vmlinux
+    GDB is free software and you are welcome to distribute copies of it
+     under certain conditions; type "show copying" to see the conditions.
+    There is absolutely no warranty for GDB; type "show warranty" for details.
+    GDB 4.15.1 (i486-slackware-linux), 
+    Copyright 1995 Free Software Foundation, Inc...
+    (gdb) rmt
+    breakpoint () at i386-stub.c:750
+    750     }
+    (gdb) 
+
+
+You can now use whatever gdb commands you like to set breakpoints.
+Enter "continue" to start your target machine executing again.  At this
+point the target system will run at full speed until it encounters
+your breakpoint or gets a segment violation in the kernel, or whatever.
+
+
+Triggering gdbstub at Kernel Boot Time
+======================================
+
+The gdbstub patch now has the ability for gdb to connect to the kernel during
+bootup (as opposed to waiting for the system to come all the way up and then
+running the gdbstart program on the target machine).  This new functionality was
+added by Scott Foehner <sfoehner@engr.sgi.com> at SGI.
+
+To force a kernel that has been compiled with gdbstub to pause during the boot
+process and wait for a connection from gdb, the paramter "gdb" should be passed
+to the kernel. This can be done by typing "gdb" after the name of the kernel
+on the LILO command line.  The patch defaults to use ttyS1 at a baud rate of
+38400. These parameters can be changed by using "gdbttyS=<port number>" and
+"gdbbaud=<baud rate>" on the command line.
+
+Example:
+
+LILO boot: linux gdb gdbttyS=1 gdbbaud=38400
+
+Note that this command is entered on the TARGET machine as it is booting
+the kernel that was compiled on the DEVELOPMENT machine.
+
+An alternate approach is to place a line in the /etc/lilo.conf file on
+your TARGET machine.  Under the heading for the kernel that you intend
+to boot, place a line that looks like this:
+
+    append = "gdb gdbttyS=1 gdbbaud=38400"
+
+This will cause the kernel to enter the gdbstub automatically at boot
+time.
+
+BE SURE to run "lilo" after changing the /etc/lilo.conf file.
+
+
+The "gdbstart" Program
+=====================
+
+This utility program is used to set up the com port and data rate
+for the connection from the target system to the development system.
+Its usage has been described above.
+
+This version of the patch uses the same tty ioctl for kernel versions
+2.0.30 onwards.  Thus, the gdbstart utility does not need to be re-compiled
+to install the patch in a later version of the kernel.  The ioctl added
+to the kernel for this purpose is far enough "off the end" of existing
+ioctls (as of 2.1.120) that it should not interfere with any new kernel
+tty ioctls for quite some time (famous last words).
+
+The source for the gdbstart program resides in the arch/i386/kernel directory.
+
+
+Debugging hints
+===============
+
+You can break into the target machine at any time from the development
+machine by typing ^C.  If the target machine has interrupts enabled
+this will stop it in the kernel and enter the debugger.
+
+There is unfortunately no way of breaking into the kernel if it is
+in a loop with interrupts disabled, so if this happens to you then
+you need to place exploratory breakpoints or printk's into the kernel
+to find out where it is looping.
+
+There is a copy of an e-mail in the kgdb distribution directory which
+describes how to create an NMI on an ISA bus machine using a paper
+clip.  I have a sophisticated version of this made by wiring a push
+button switch into a PC104/ISA bus adapter card.  The adapter card
+nicely furnishes wire wrap pins for all the ISA bus signals.
+
+When you are done debugging the kernel on the target machine it is
+a good idea to leave it in a running state.  This makes reboots
+faster, bypassing the fsck.  So do a gdb "continue" as the last gdb
+command if this is possible.  To terminate gdb itself on the development
+machine and leave the target machine running, type ^Z to suspend gdb
+and then kill it with "kill %1" or something similar.
+
+If gdbstub Does Not Work
+========================
+
+If it doesn't work, you will have to troubleshoot it.  Do the easy things
+first like double checking your cabling and data rates.  You might
+try some non-kernel based programs to see if the back-to-back connection
+works properly.  Just something simple like cat /etc/hosts >/dev/ttyS0
+on one machine and cat /dev/ttyS0 on the other will tell you if you
+can send data from one machine to the other.  There is no point in tearing
+out your hair in the kernel if the line doesn't work.
+
+All of the real action takes place in the file
+/usr/src/linux/arch/i386/kernel/gdbstub.c.  That is the code on the target
+machine that interacts with gdb on the development machine.  In gdb you can
+turn on a debug switch with the following command:
+
+	set remotedebug
+
+This will print out the protocol messages that gdb is exchanging with
+the target machine.
+
+Another place to look is /usr/src/linux/drivers/char/gdbserial.c
+That is the code that talks to the serial port on the target side.
+There might be a problem there.
+
+If you are really desperate you can use printk debugging in the
+gdbstub code in the target kernel until you get it working.  In particular,
+there is a global variable in /usr/src/linux/arch/i386/kernel/gdbstub.c
+named "remote_debug".  Compile your kernel with this set to 1, rather
+than 0 and the debug stub will print out lots of stuff as it does
+what it does.
+
+
+Debugging Loadable Modules
+==========================
+
+This technique comes courtesy of Edouard Parmelan
+<Edouard.Parmelan@quadratec.fr>
+
+When you run gdb, enter the command
+
+source gdbinit-modules
+
+This will read in a file of gdb macros that was installed in your
+kernel source directory with kgdb was installed.  This file implements
+the following commands:
+
+mod-list
+    Lists the loaded modules in the form <module-address> <module-name>
+
+mod-print-symbols <module-address>
+    Prints all the symbols in the indicated module.
+
+mod-add-symbols <module-address> <object-file-path-name>
+    Loads the symbols from the object file and associates them
+    with the indicated module.
+
+After you have loaded the module that you want to debug, use the command
+mod-list to find the <module-address> of your module.  Then use that
+address in the mod-add-symbols command to load your module's symbols.
+From that point onward you can debug your module as if it were a part
+of the kernel.
+
+The file gdbinit-modules also contains a command named mod-add-lis as
+an example of how to construct a command of your own to load your
+favorite module.  The idea is to "can" the pathname of the module
+in the command so you don't have to type so much.
+
+Threads
+=======
+
+Each process in a target machine is seen as a gdb thread. gdb thread related
+commands (info threads, thread n) can be used. 
+
+ia-32 hardware breakpoints
+==========================
+
+gdb stub contains support for hardware breakpoints using debugging features
+of ia-32(x86) processors. These breakpoints do not need code modification.
+They use debugging registers. 4 hardware breakpoints are available in ia-32
+processors.
+
+Each hardware breakpoint can be of one of the following three types.
+1. Execution breakpoint - An Execution breakpoint is triggered when code at the
+	breakpoint address is executed.
+
+	As limited number of hardware breakpoints are available, it is advisable
+	to use software breakpoints ( break command ) instead of execution
+	hardware breakpoints, unless modification of code is to be avoided.
+
+2. Write breakpoint - A write breakpoint is triggered when memory location at the
+	breakpoint address is written.
+
+	A write or can be placed for data of variable length. Length of a write
+	breakpoint indicates length of the datatype to be watched. Length is 1
+	for 1 byte data , 2 for 2 byte data, 3 for 4 byte data.
+
+3. Access breakpoint - An access breakpoint is triggered when memory location at
+	the breakpoint address is either read or written.
+
+	Access breakpoints also have lengths similar to write breakpoints.
+
+IO breakpoints in ia-32 are not supported.
+
+Since gdb stub at present does not use the protocol used by gdb for hardware
+breakpoints, hardware breakpoints are accessed through gdb macros. gdb macros
+for hardware breakpoints are described below.
+
+hwebrk	- Places an execution breakpoint
+	hwebrk breakpointno address
+hwwbrk	- Places a write breakpoint
+	hwwbrk breakpointno length address
+hwabrk	- Places an access breakpoint
+	hwabrk breakpointno length address
+hwrmbrk	- Removes a breakpoint
+	hwrmbrk breakpointno
+exinfo	- Tells whether a software or hardware breakpoint has occured.
+	Prints number of the hardware breakpoint if a hardware breakpoint has
+	occured.
+
+Arguments required by these commands are as follows
+breakpointno	- 0 to 3
+length		- 1 to 3
+address		- Memory location in hex digits ( without 0x ) e.g c015e9bc
+
+MP support
+==========
+
+When a breakpoint occurs or user issues a break ( Ctrl + C ) to gdb client,
+all the processors are forced to enter the debugger. Current thread
+corresponds to the thread running on the processor where breakpoint occured.
+Threads running on other processor(s) appear similar to other non running
+threads in the 'info threads' output.
+
+ia-32 hardware debugging registers on all processors are set to same values.
+Hence any hardware breakpoints may occur on any processor.
+
+gdb troubleshooting
+===================
+
+1. gdb hangs
+Kill it. restart gdb. Connect to target machine.
+
+2. gdb cannot connect to target machine (after killing a gdb and restarting
+another)
+If the target machine was not inside debugger when you killed gdb, gdb cannot
+connect because the target machine won't respond.
+In this case echo "Ctrl+C"(ascii 3) in the serial line.
+e.g. echo -e "\003" > /dev/ttyS1 
+This forces that target machine into debugger after which you can connect.
+
+3. gdb cannot connect even after echoing Ctrl+C into serial line
+Try changing serial line settings min to 1 and time to 0
+e.g. stty min 1 time 0 < /dev/ttyS1
+Try echoing again
+
+check serial line speed and set it to correct value if required
+e.g. stty ispeed 115200 ospeed 115200 < /dev/ttyS1
+
+Final Items
+===========
+
+I picked up this code from Dave Grothe and enhanced it.
+
+If you make some really cool modification to this stuff, or if you 
+fix a bug, please let me know.
+
+Amit S. Kale
+<akale@veritas.com>
+
+(First kgdb by David Grothe <dave@gcom.com>)
+
+(modified by Tigran Aivazian <tigran@sco.com>)
+    Putting gdbstub into the kernel config menu.
+
+(modified by Scott Foehner <sfoehner@engr.sgi.com>)
+    Hooks for entering gdbstub at boot time.
+
+(modified by Amit S. Kale <akale@veritas.com>)
+    Threads, ia-32 hw debugging, mp support, console support,
+    nmi watchdog handling.
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/Documentation/sysrq.txt 200-kgdb/Documentation/sysrq.txt
--- 140-objrmap/Documentation/sysrq.txt	Wed Mar 26 22:54:28 2003
+++ 200-kgdb/Documentation/sysrq.txt	Tue Sep  2 10:14:10 2003
@@ -77,6 +77,8 @@ On all -  write a character to /proc/sys
 'l'     - Send a SIGKILL to all processes, INCLUDING init. (Your system
           will be non-functional after this.)
 
+'g'	- Enter the kernel debugger (if configured and supported).
+
 'h'     - Will display help ( actually any other key than those listed
           above will display help. but 'h' is easy to remember :-)
 
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/Makefile 200-kgdb/Makefile
--- 140-objrmap/Makefile	Tue Sep  2 09:55:40 2003
+++ 200-kgdb/Makefile	Tue Sep  2 10:14:10 2003
@@ -356,6 +356,10 @@ ifdef CONFIG_DEBUG_INFO
 CFLAGS		+= -g
 endif
 
+ifdef CONFIG_X86_REMOTE_DEBUG
+CFLAGS += -g
+endif
+
 #
 # INSTALL_PATH specifies where to place the updated kernel and system map
 # images.  Uncomment if you want to place them anywhere other than root.
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/arch/i386/Kconfig 200-kgdb/arch/i386/Kconfig
--- 140-objrmap/arch/i386/Kconfig	Tue Sep  2 10:08:30 2003
+++ 200-kgdb/arch/i386/Kconfig	Tue Sep  2 10:14:10 2003
@@ -1328,6 +1328,17 @@ config DEBUG_SLAB
 	  allocation as well as poisoning memory on free to catch use of freed
 	  memory.
 
+config X86_REMOTE_DEBUG
+	bool "KGDB: Remote (serial) kernel debugging with gdb"
+
+config KGDB_THREAD
+	bool "KGDB: Thread analysis"
+	depends on X86_REMOTE_DEBUG
+
+config GDB_CONSOLE
+	bool "KGDB: Console messages through gdb"
+	depends on X86_REMOTE_DEBUG
+
 config DEBUG_IOVIRT
 	bool "Memory mapped I/O debugging"
 	depends on DEBUG_KERNEL
@@ -1413,7 +1424,9 @@ config DEBUG_SPINLOCK_SLEEP
 	  noisy if they are called with a spinlock held.	
 
 config FRAME_POINTER
-	bool "Compile the kernel with frame pointers"
+	bool
+	default y if X86_REMOTE_DEBUG
+	default n if !X86_REMOTE_DEBUG
 	help
 	  If you say Y here the resulting kernel image will be slightly larger
 	  and slower, but it will give very useful debugging information.
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/arch/i386/kernel/Makefile 200-kgdb/arch/i386/kernel/Makefile
--- 140-objrmap/arch/i386/kernel/Makefile	Tue Sep  2 09:55:41 2003
+++ 200-kgdb/arch/i386/kernel/Makefile	Tue Sep  2 10:14:10 2003
@@ -17,6 +17,7 @@ obj-$(CONFIG_MCA)		+= mca.o
 obj-$(CONFIG_X86_MSR)		+= msr.o
 obj-$(CONFIG_X86_CPUID)		+= cpuid.o
 obj-$(CONFIG_MICROCODE)		+= microcode.o
+obj-$(CONFIG_X86_REMOTE_DEBUG)	+= gdbstub.o
 obj-$(CONFIG_PM)		+= suspend.o
 obj-$(CONFIG_APM)		+= apm.o
 obj-$(CONFIG_SOFTWARE_SUSPEND)	+= suspend_asm.o
@@ -31,6 +32,14 @@ obj-$(CONFIG_EDD)             	+= edd.o
 obj-$(CONFIG_MODULES)		+= module.o
 obj-y				+= sysenter.o vsyscall.o
 obj-$(CONFIG_ACPI_SRAT) 	+= srat.o
+
+ifdef CONFIG_X86_REMOTE_DEBUG
+GDBSTART=gdbstart
+GDBCLEAN= -rm -f gdbstart /sbin/gdbstart
+else
+GDBSTART=
+GDBCLEAN=
+endif
 
 EXTRA_AFLAGS   := -traditional
 
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/arch/i386/kernel/entry.S 200-kgdb/arch/i386/kernel/entry.S
--- 140-objrmap/arch/i386/kernel/entry.S	Tue Sep  2 09:55:41 2003
+++ 200-kgdb/arch/i386/kernel/entry.S	Tue Sep  2 10:14:10 2003
@@ -224,7 +224,7 @@ need_resched:
 	jz restore_all
 	movl $PREEMPT_ACTIVE,TI_PRE_COUNT(%ebp)
 	sti
-	call schedule
+	call user_schedule
 	movl $0,TI_PRE_COUNT(%ebp)
 	cli
 	jmp need_resched
@@ -306,7 +306,7 @@ work_pending:
 	testb $_TIF_NEED_RESCHED, %cl
 	jz work_notifysig
 work_resched:
-	call schedule
+	call user_schedule
 	cli				# make sure we don't miss an interrupt
 					# setting need_resched or sigpending
 					# between sampling and the iret
@@ -571,6 +571,31 @@ ENTRY(coprocessor_segment_overrun)
 ENTRY(invalid_TSS)
 	pushl $do_invalid_TSS
 	jmp error_code
+
+#ifdef CONFIG_KGDB_THREAD
+ENTRY(kern_schedule)
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ss		
+	pushl	%ebp
+	pushfl
+	pushl	%cs
+	pushl	4(%ebp)
+	pushl	%eax		
+	pushl	%es
+	pushl	%ds
+	pushl	%eax
+	pushl	(%ebp)
+	pushl	%edi
+	pushl	%esi
+	pushl	%edx
+	pushl	%ecx
+	pushl	%ebx
+	call	kern_do_schedule
+	movl	%ebp, %esp
+	pop	%ebp
+	ret
+#endif
 
 ENTRY(segment_not_present)
 	pushl $do_segment_not_present
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/arch/i386/kernel/gdbstart.c 200-kgdb/arch/i386/kernel/gdbstart.c
--- 140-objrmap/arch/i386/kernel/gdbstart.c	Wed Dec 31 16:00:00 1969
+++ 200-kgdb/arch/i386/kernel/gdbstart.c	Tue Sep  2 10:14:10 2003
@@ -0,0 +1,147 @@
+/*
+ * This program opens a tty file and issues the GDB stub activating
+ * ioctl on it.
+ */
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <asm/ioctls.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <stdlib.h>
+#include <termios.h>
+#include <unistd.h>
+
+char		*tty_name = "/dev/ttyS0" ;	/* COM1 port */
+int		 speed = 9600 ;			/* default speed */
+struct termios	 save_ts ;			/* original term struct */
+
+void print_usage(void)
+{
+    printf("gdbstub [-s speed] [-t tty-dev]\n") ;
+    printf("  defaults:  /dev/ttyS0 with speed unmodified by this program\n");
+
+} /* print_usage */
+
+void tty_err(char *msg)
+{
+    char	buf[100] ;
+
+    strcpy(buf, msg) ;
+    strcat(buf, ": ") ;
+    strcat(buf, tty_name) ;
+    perror(buf) ;
+    exit(1) ;
+
+} /* tty_err */
+
+
+void setup_term(int fd)
+{
+    struct termios	ts ;
+    int			speed_code ;
+
+    if (tcgetattr(fd, &ts) < 0) tty_err("tcgetattr") ;
+
+    save_ts = ts ;
+    switch (speed)
+    {
+    case 4800:
+	speed_code = B4800 ;
+	break ;
+    case 9600:
+	speed_code = B9600 ;
+	break ;
+    case 19200:
+	speed_code = B19200 ;
+	break ;
+    case 38400:
+	speed_code = B38400 ;
+	break ;
+    case 57600:
+	speed_code = B57600 ;
+	break ;
+    case 115200:
+	speed_code = B115200 ;
+	break ;
+    case 230400:
+	speed_code = B230400 ;
+	break ;
+    default:
+	printf("Invalid speed: %d\n", speed) ;
+	exit(1) ;
+    }
+
+    ts.c_cflag = CS8 | CREAD | CLOCAL ;
+    if (cfsetospeed(&ts, speed_code) < 0) tty_err("cfsetospeed") ;
+    if (cfsetispeed(&ts, speed_code) < 0) tty_err("cfsetispeed") ;
+
+    if (tcsetattr(fd, TCSANOW, &ts) < 0) tty_err("tcsetattr") ;
+
+} /* setup_term */
+
+int main(int argc, char **argv)
+{
+    int		opt ;
+    int		fil ;
+    int		rslt ;
+
+    while ((opt = getopt(argc, argv, "hs:t:")) > 0)
+    {
+	switch (opt)
+	{
+	case 's':
+	    speed = atol(optarg) ;
+	    break ;
+	case 't':
+	    tty_name = optarg ;
+	    break ;
+	case ':':
+	    printf("Invalid option\n") ;
+	    break ;
+	case '?':
+	case 'h':
+	default:
+	    print_usage() ;
+	    return 1;
+	}
+    }
+
+    fil = open(tty_name, O_RDWR) ;
+    if (fil < 0)
+    {
+	perror(tty_name) ;
+	return 1;
+    }
+
+
+    setup_term(fil) ;
+
+    /*
+     * When we issue this ioctl, control will not return until
+     * the debugger running on the remote host machine says "go".
+     */
+    printf("\nAbout to activate GDB stub in the kernel on %s\n", tty_name) ;
+    printf("Hit CR to continue, kill program to abort -- ") ;
+    getchar() ;
+    sync() ;
+    rslt = ioctl(fil, TIOCGDB, 0) ;
+    if (rslt < 0)
+    {
+	perror("TIOCGDB ioctl") ;
+	return 1;
+    }
+
+    printf("\nGDB stub successfully activated\n") ;
+
+    for (;;)
+    {
+	pause() ;
+    }
+
+    if (tcsetattr(fil, TCSANOW, &save_ts) < 0) tty_err("tcsetattr") ;
+
+    exit(0);
+} /* main */
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/arch/i386/kernel/gdbstub.c 200-kgdb/arch/i386/kernel/gdbstub.c
--- 140-objrmap/arch/i386/kernel/gdbstub.c	Wed Dec 31 16:00:00 1969
+++ 200-kgdb/arch/i386/kernel/gdbstub.c	Tue Sep  2 10:14:10 2003
@@ -0,0 +1,1208 @@
+/*
+ *
+ * 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.
+ */
+/****************************************************************************
+ *  Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $
+ *
+ *  Module name: remcom.c $
+ *  Revision: 1.34 $
+ *  Date: 91/03/09 12:29:49 $
+ *  Contributor:     Lake Stevens Instrument Division$
+ *
+ *  Description:     low level support for gdb debugger. $
+ *
+ *  Considerations:  only works on target hardware $
+ *
+ *  Written by:      Glenn Engel $
+ *  Updated by:	     Amit Kale<akale@veritas.com>
+ *  ModuleState:     Experimental $
+ *
+ *  NOTES:           See Below $
+ *
+ *  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>
+ *      thread support,
+ *      support for multiple processors,
+ *  	support for ia-32(x86) hardware debugging,
+ *  	Console support,
+ *  	handling nmi watchdog
+ *  	Amit S. Kale ( akale@veritas.com )
+ *
+ *
+ *  To enable debugger support, two things need to happen.  One, a
+ *  call to set_debug_traps() is necessary in order to allow any breakpoints
+ *  or error conditions to be properly intercepted and reported to gdb.
+ *  Two, a breakpoint needs to be generated to begin communication.  This
+ *  is most easily accomplished by a call to breakpoint().  Breakpoint()
+ *  simulates a breakpoint by executing an int 3.
+ *
+ *************
+ *
+ *    The following gdb commands are supported:
+ *
+ * command          function                               Return value
+ *
+ *    g             return the value of the CPU registers  hex data or ENN
+ *    G             set the value of the CPU registers     OK or ENN
+ *
+ *    mAA..AA,LLLL  Read LLLL bytes at address AA..AA      hex data or ENN
+ *    MAA..AA,LLLL: Write LLLL bytes at address AA.AA      OK or ENN
+ *
+ *    c             Resume at current address              SNN   ( signal NN)
+ *    cAA..AA       Continue at address AA..AA             SNN
+ *
+ *    s             Step one instruction                   SNN
+ *    sAA..AA       Step one instruction from AA..AA       SNN
+ *
+ *    k             kill
+ *
+ *    ?             What was the last sigval ?             SNN   (signal NN)
+ *
+ * All commands and responses are sent with a packet which includes a
+ * checksum.  A packet consists of
+ *
+ * $<packet info>#<checksum>.
+ *
+ * where
+ * <packet info> :: <characters representing the command or response>
+ * <checksum>    :: < two hex digits computed as modulo 256 sum of <packetinfo>>
+ *
+ * When a packet is received, it is first acknowledged with either '+' or '-'.
+ * '+' indicates a successful transfer.  '-' indicates a failed transfer.
+ *
+ * Example:
+ *
+ * Host:                  Reply:
+ * $m0,10#2a               +$00010203040506070809101112131415#42
+ *
+ ****************************************************************************/
+
+#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/gdb.h>
+#ifdef CONFIG_GDB_CONSOLE
+#include <linux/console.h>
+#endif
+#include <linux/init.h>
+
+/************************************************************************
+ *
+ * external low-level support routines
+ */
+typedef void (*Function) (void);	/* pointer to a function */
+
+/* Thread reference */
+typedef unsigned char threadref[8];
+
+extern int putDebugChar(int);	/* write a single character      */
+extern int getDebugChar(void);	/* read and return a single char */
+
+extern int pid_max;
+
+/************************************************************************/
+/* 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
+
+static char initialized;	/* boolean flag. != 0 means we've been initialized */
+
+static const char hexchars[] = "0123456789abcdef";
+
+/* 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 */
+
+/***************************  ASSEMBLY CODE MACROS *************************/
+/* 									   */
+
+#define BREAKPOINT() asm("   int $3");
+
+/* 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;
+
+static spinlock_t slavecpulocks[KGDB_MAX_NO_CPUS];
+volatile int procindebug[KGDB_MAX_NO_CPUS];
+
+#ifdef CONFIG_SMP
+spinlock_t kgdb_spinlock = SPIN_LOCK_UNLOCKED;
+spinlock_t kgdb_nmispinlock = SPIN_LOCK_UNLOCKED;
+#else
+unsigned kgdb_spinlock = 0;
+unsigned kgdb_nmispinlock = 0;
+#endif
+
+static void
+kgdb_usercode(void)
+{
+}
+
+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>     */
+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 = (getDebugChar() & 0x7f)) != '$') ;
+		checksum = 0;
+		xmitcsum = -1;
+
+		count = 0;
+
+		/* now, read until a # or end of buffer is found */
+		while (count < BUFMAX) {
+			ch = getDebugChar() & 0x7f;
+			if (ch == '#')
+				break;
+			checksum = checksum + ch;
+			buffer[count] = ch;
+			count = count + 1;
+		}
+		buffer[count] = 0;
+
+		if (ch == '#') {
+			xmitcsum = hex(getDebugChar() & 0x7f) << 4;
+			xmitcsum += hex(getDebugChar() & 0x7f);
+
+			if (checksum != xmitcsum)
+				putDebugChar('-');	/* failed checksum */
+			else {
+				putDebugChar('+');	/* successful transfer */
+				/* if a sequence char is present, reply the sequence ID */
+				if (buffer[2] == ':') {
+					putDebugChar(buffer[0]);
+					putDebugChar(buffer[1]);
+					/* remove sequence chars from buffer */
+					count = strlen(buffer);
+					for (i = 3; i <= count; i++)
+						buffer[i - 3] = buffer[i];
+				}
+			}
+		}
+	} while (checksum != xmitcsum);
+
+}
+
+/* send the packet in buffer.  */
+
+void
+putpacket(char *buffer)
+{
+	unsigned char checksum;
+	int count;
+	char ch;
+
+	/*  $<packet info>#<checksum>. */
+	do {
+		putDebugChar('$');
+		checksum = 0;
+		count = 0;
+
+		while ((ch = buffer[count])) {
+			if (!putDebugChar(ch))
+				return;
+			checksum += ch;
+			count += 1;
+		}
+
+		putDebugChar('#');
+		putDebugChar(hexchars[checksum >> 4]);
+		putDebugChar(hexchars[checksum % 16]);
+
+	} while ((getDebugChar() & 0x7f) != '+');
+
+}
+
+static char remcomInBuffer[BUFMAX];
+static char remcomOutBuffer[BUFMAX];
+static short error;
+
+static void
+regs_to_gdb_regs(int *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;
+}				/* regs_to_gdb_regs */
+
+static void
+gdb_regs_to_regs(int *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
+
+}				/* gdb_regs_to_regs */
+
+/* Indicate to caller of mem2hex or hex2mem that there has been an
+   error.  */
+static volatile int kgdb_memerr = 0;
+volatile int kgdb_memerr_expected = 0;
+static volatile int kgdb_memerr_cnt = 0;
+static int garbage_loc = -1;
+
+int
+get_char(char *addr)
+{
+	return *addr;
+}
+
+void
+set_char(char *addr, int val)
+{
+	*addr = val;
+}
+
+/* convert the memory pointed to by mem into hex, placing result in buf */
+/* return a pointer to the last char put in buf (null) */
+/* If MAY_FAULT is non-zero, then we should set kgdb_memerr in response to
+   a fault; if zero treat a fault like any other fault in the stub.  */
+char *
+mem2hex(char *mem, char *buf, int count, int may_fault)
+{
+	int i;
+	unsigned char ch;
+
+	if (may_fault) {
+		kgdb_memerr_expected = 1;
+		kgdb_memerr = 0;
+	}
+	for (i = 0; i < count; i++) {
+
+		ch = get_char(mem++);
+
+		if (may_fault && kgdb_memerr) {
+			*buf = 0;	/* truncate buffer */
+			return (buf);
+		}
+		*buf++ = hexchars[ch >> 4];
+		*buf++ = hexchars[ch % 16];
+	}
+	*buf = 0;
+	if (may_fault)
+		kgdb_memerr_expected = 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 */
+char *
+hex2mem(char *buf, char *mem, int count, int may_fault)
+{
+	int i;
+	unsigned char ch;
+
+	if (may_fault) {
+		kgdb_memerr_expected = 1;
+		kgdb_memerr = 0;
+	}
+	for (i = 0; i < count; i++) {
+		ch = hex(*buf++) << 4;
+		ch = ch + hex(*buf++);
+		set_char(mem++, ch);
+
+		if (may_fault && kgdb_memerr) {
+			return (mem);
+		}
+	}
+	if (may_fault)
+		kgdb_memerr_expected = 0;
+	return (mem);
+}
+
+/**********************************************/
+/* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
+/* RETURN NUMBER OF CHARS PROCESSED           */
+/**********************************************/
+int
+hexToInt(char **ptr, int *intValue)
+{
+	int numChars = 0;
+	int hexValue;
+
+	*intValue = 0;
+
+	while (**ptr) {
+		hexValue = hex(**ptr);
+		if (hexValue >= 0) {
+			*intValue = (*intValue << 4) | hexValue;
+			numChars++;
+		} else
+			break;
+
+		(*ptr)++;
+	}
+
+	return (numChars);
+}
+
+#ifdef CONFIG_KGDB_THREAD
+static int
+stubhex(int 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;
+}
+
+static int
+stub_unpack_int(char *buff, int fieldlength)
+{
+	int nibble;
+	int retval = 0;
+
+	while (fieldlength) {
+		nibble = stubhex(*buff++);
+		retval |= nibble;
+		fieldlength--;
+		if (fieldlength)
+			retval = retval << 4;
+	}
+	return retval;
+}
+#endif
+
+static char *
+pack_hex_byte(char *pkt, int byte)
+{
+	*pkt++ = hexchars[(byte >> 4) & 0xf];
+	*pkt++ = hexchars[(byte & 0xf)];
+	return pkt;
+}
+
+#define BUF_THREAD_ID_SIZE 16
+
+#ifdef CONFIG_KGDB_THREAD
+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;
+}
+
+static char *
+unpack_byte(char *buf, int *value)
+{
+	*value = stub_unpack_int(buf, 2);
+	return buf + 2;
+}
+
+static char *
+unpack_threadid(char *inbuf, threadref * id)
+{
+	char *altref;
+	char *limit = inbuf + BUF_THREAD_ID_SIZE;
+	int x, y;
+
+	altref = (char *) id;
+
+	while (inbuf < limit) {
+		x = stubhex(*inbuf++);
+		y = stubhex(*inbuf++);
+		*altref++ = (x << 4) | y;
+	}
+	return inbuf;
+}
+#endif
+
+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);
+}
+
+#ifdef CONFIG_KGDB_THREAD
+static int
+threadref_to_int(threadref * ref)
+{
+	int i, value = 0;
+	unsigned char *scan;
+
+	scan = (char *) ref;
+	scan += 4;
+	i = 4;
+	while (i-- > 0)
+		value = (value << 8) | ((*scan++) & 0xff);
+	return value;
+}
+
+struct task_struct *
+getthread(int pid)
+{
+	struct task_struct *thread;
+	thread = find_task_by_pid(pid);
+	if (thread) {
+		return thread;
+	}
+#if 0
+	thread = init_tasks[0];
+	do {
+		if (thread->pid == pid) {
+			return thread;
+		}
+		thread = thread->next_task;
+	} while (thread != init_tasks[0]);
+#endif
+	return NULL;
+}
+#endif
+
+struct hw_breakpoint {
+	unsigned enabled;
+	unsigned type;
+	unsigned len;
+	unsigned addr;
+} breakinfo[4] = { {
+enabled:0}, {
+enabled:0}, {
+enabled:0}, {
+enabled:0}};
+
+void
+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
+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
+gdb_wait(void *arg)
+{
+	unsigned long flags;
+	int processor;
+
+	local_irq_save(flags);
+	processor = smp_processor_id();
+	procindebug[processor] = 1;
+	current->thread.kgdbregs = arg;
+	spin_lock(slavecpulocks + processor);
+	correct_hw_break();
+	procindebug[processor] = 0;
+	local_irq_restore(flags);
+}
+
+void
+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;
+}
+
+/*
+ * This function does all command procesing for interfacing to gdb.
+ *
+ * NOTE:  The INT nn instruction leaves the state of the interrupt
+ *        enable flag UNCHANGED.  That means that when this routine
+ *        is entered via a breakpoint (INT 3) instruction from code
+ *        that has interrupts enabled, then interrupts will STILL BE
+ *        enabled when this routine is entered.  The first thing that
+ *        we do here is disable interrupts so as to prevent recursive
+ *        entries and bothersome serial interrupts while we are
+ *        trying to run the serial port in polled mode.
+ *
+ * For kernel version 2.1.xx the cli() actually gets a spin lock so
+ * it is always necessary to do a restore_flags before returning
+ * so as to let go of that lock.
+ */
+int
+handle_exception(int exceptionVector,
+		 int signo, int err_code, struct pt_regs *linux_regs)
+{
+	struct task_struct *usethread = NULL;
+	int addr, length;
+	int breakno, breaktype;
+	char *ptr;
+	int newPC;
+	unsigned long flags = ~0UL;
+	int gdb_regs[NUMREGBYTES / 4];
+	int i;
+	int dr6;
+	int reboot = 0;
+#ifdef CONFIG_KGDB_THREAD
+	int nothreads;
+	int maxthreads;
+	int threadid;
+	threadref thref;
+	struct task_struct *thread = NULL;
+#endif
+#define	regs	(*linux_regs)
+
+	/*
+	 * If the entry is not from the kernel then return to the Linux
+	 * trap handler and let it process the interrupt normally.
+	 */
+	if ((linux_regs->eflags & VM_MASK) || (3 & linux_regs->xcs)) {
+		return (0);
+	}
+
+	if (kgdb_memerr_expected) {
+		/*
+		 * This fault occured because of the get_char or set_char
+		 * routines.  These two routines use either eax of edx to
+		 * indirectly reference the location in memory that they
+		 * are working with.  For a page fault, when we return
+		 * the instruction will be retried, so we have to make
+		 * sure that these registers point to valid memory.
+		 */
+		kgdb_memerr = 1;	/* set mem error flag */
+		kgdb_memerr_expected = 0;
+		kgdb_memerr_cnt++;	/* helps in debugging */
+		regs.eax = (long) &garbage_loc;	/* make valid address */
+		regs.edx = (long) &garbage_loc;	/* make valid address */
+		return (0);
+	}
+#ifdef CONFIG_SMP
+	if (!spin_is_locked(&kgdb_nmispinlock))
+#else
+	if (!kgdb_nmispinlock)
+#endif
+	{
+
+		/* Get kgdb spinlock */
+#ifdef CONFIG_SMP
+		_raw_spin_lock(&kgdb_spinlock);
+#else
+		kgdb_spinlock = 1;
+#endif
+
+		local_irq_save(flags);
+
+		/* Disable hardware debugging while we are in kgdb */
+	      __asm__("movl %0,%%db7":	/* no output */
+	      :"r"(0));
+
+		for (i = 0; i < NR_CPUS; i++) {
+			spin_lock_init(&slavecpulocks[i]);
+			_raw_spin_lock(&slavecpulocks[i]);
+		}
+
+		if (num_online_cpus() > 1) {
+			/* Force other cpus in debugger */
+			if (smp_call_function(gdb_wait, NULL, 0, 99) != 0) {
+				return (1);
+			}
+		}
+
+		procindebug[smp_processor_id()] = 1;
+	}
+
+	gdb_i386vector = exceptionVector;
+	gdb_i386errcode = err_code;
+
+	/* reply to host that an exception has occurred */
+	remcomOutBuffer[0] = 'S';
+	remcomOutBuffer[1] = hexchars[signo >> 4];
+	remcomOutBuffer[2] = hexchars[signo % 16];
+	remcomOutBuffer[3] = 0;
+
+	putpacket(remcomOutBuffer);
+
+	while (1 == 1) {
+		error = 0;
+		remcomOutBuffer[0] = 0;
+		getpacket(remcomInBuffer);
+		switch (remcomInBuffer[0]) {
+		case '?':
+			remcomOutBuffer[0] = 'S';
+			remcomOutBuffer[1] = hexchars[signo >> 4];
+			remcomOutBuffer[2] = hexchars[signo % 16];
+			remcomOutBuffer[3] = 0;
+			break;
+		case 'g':	/* return the value of the CPU registers */
+			if (!usethread || usethread == current) {
+				regs_to_gdb_regs(gdb_regs, &regs);
+			} else {
+				memset(gdb_regs, 0, NUMREGBYTES);
+				if (usethread->thread.kgdbregs) {
+					kgdb_memerr_expected = 1;
+					kgdb_memerr = 0;
+					get_char((char *) usethread->thread.
+						 kgdbregs);
+					kgdb_memerr_expected = 0;
+					if (kgdb_memerr) {
+						gdb_regs[_PC] =
+						    (int) kgdb_usercode;
+					} else {
+						regs_to_gdb_regs(gdb_regs,
+								 usethread->
+								 thread.
+								 kgdbregs);
+					}
+				} else {
+					gdb_regs[_PC] = (int) kgdb_usercode;
+				}
+			}
+			mem2hex((char *) gdb_regs, remcomOutBuffer, NUMREGBYTES,
+				0);
+			break;
+		case 'G':	/* set the value of the CPU registers - return OK */
+			hex2mem(&remcomInBuffer[1], (char *) gdb_regs,
+				NUMREGBYTES, 0);
+			if (!usethread || usethread == current) {
+				gdb_regs_to_regs(gdb_regs, &regs);
+				strcpy(remcomOutBuffer, "OK");
+			} else {
+				strcpy(remcomOutBuffer, "E00");
+			}
+			break;
+
+			/* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
+		case 'm':
+			/* TRY TO READ %x,%x.  IF SUCCEED, SET PTR = 0 */
+			ptr = &remcomInBuffer[1];
+			if (hexToInt(&ptr, &addr))
+				if (*(ptr++) == ',')
+					if (hexToInt(&ptr, &length)) {
+						ptr = 0;
+						mem2hex((char *) addr,
+							remcomOutBuffer, length,
+							1);
+						if (kgdb_memerr) {
+							strcpy(remcomOutBuffer,
+							       "E03");
+						}
+					}
+
+			if (ptr) {
+				strcpy(remcomOutBuffer, "E01");
+			}
+			break;
+
+			/* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
+		case 'M':
+			/* TRY TO READ '%x,%x:'.  IF SUCCEED, SET PTR = 0 */
+			ptr = &remcomInBuffer[1];
+			if (hexToInt(&ptr, &addr))
+				if (*(ptr++) == ',')
+					if (hexToInt(&ptr, &length))
+						if (*(ptr++) == ':') {
+							hex2mem(ptr,
+								(char *) addr,
+								length, 1);
+
+							if (kgdb_memerr) {
+								strcpy
+								    (remcomOutBuffer,
+								     "E03");
+							} else {
+								strcpy
+								    (remcomOutBuffer,
+								     "OK");
+							}
+
+							ptr = 0;
+						}
+			if (ptr) {
+				strcpy(remcomOutBuffer, "E02");
+			}
+			break;
+
+			/* cAA..AA    Continue at address AA..AA(optional) */
+			/* sAA..AA   Step one instruction from AA..AA(optional) */
+		case 'c':
+		case 's':
+#ifdef CONFIG_SMP
+			if (spin_is_locked(&kgdb_nmispinlock))
+#else
+			if (kgdb_nmispinlock)
+#endif
+			{
+				strcpy(remcomOutBuffer, "E01");
+				break;
+			}
+
+			/* try to read optional parameter, pc unchanged if no parm */
+			ptr = &remcomInBuffer[1];
+			if (hexToInt(&ptr, &addr)) {
+				regs.eip = addr;
+			}
+
+			newPC = regs.eip;
+
+			/* clear the trace bit */
+			regs.eflags &= 0xfffffeff;
+
+			/* set the trace bit if we're stepping */
+			if (remcomInBuffer[0] == 's')
+				regs.eflags |= 0x100;
+
+			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 */
+							regs.eflags |= 0x10000;
+							break;
+						}
+					}
+				}
+			}
+			correct_hw_break();
+			asm volatile ("movl %0, %%db6\n"::"r" (0));
+			for (i = 0; i < NR_CPUS; i++) {
+				_raw_spin_unlock(&slavecpulocks[i]);
+			}
+
+			procindebug[smp_processor_id()] = 0;
+			/* Release kgdb spinlock */
+#ifdef CONFIG_SMP
+			_raw_spin_unlock(&kgdb_spinlock);
+#else
+			kgdb_spinlock = 0;
+#endif
+			if (flags != ~0UL)
+				local_irq_restore(flags);
+			return (0);
+
+			/* kill the program */
+		case 'k':
+			break;
+
+			/* query */
+		case 'q':
+			switch (remcomInBuffer[1]) {
+#ifdef CONFIG_KGDB_THREAD
+			case 'L':
+				/* List threads */
+				unpack_byte(remcomInBuffer + 3, &maxthreads);
+				unpack_threadid(remcomInBuffer + 5, &thref);
+
+				remcomOutBuffer[0] = 'q';
+				remcomOutBuffer[1] = 'M';
+				remcomOutBuffer[4] = '0';
+				pack_threadid(remcomOutBuffer + 5, &thref);
+
+				threadid = threadref_to_int(&thref);
+				for (nothreads = 0;
+				     nothreads < maxthreads
+				     && threadid < pid_max; threadid++) {
+					thread = getthread(threadid);
+					if (thread) {
+						int_to_threadref(&thref,
+								 threadid);
+						pack_threadid(remcomOutBuffer +
+							      21 +
+							      nothreads * 16,
+							      &thref);
+						nothreads++;
+					}
+				}
+				if (threadid == pid_max) {
+					remcomOutBuffer[4] = '1';
+				}
+				pack_hex_byte(remcomOutBuffer + 2, nothreads);
+				remcomOutBuffer[21 + nothreads * 16] = '\0';
+				break;
+
+			case 'C':
+				/* Current thread id */
+				remcomOutBuffer[0] = 'Q';
+				remcomOutBuffer[1] = 'C';
+				threadid = current->pid;
+				int_to_threadref(&thref, threadid);
+				pack_threadid(remcomOutBuffer + 2, &thref);
+				remcomOutBuffer[18] = '\0';
+				break;
+#endif
+
+			case 'E':
+				/* Print exception info */
+				printexceptioninfo(exceptionVector, err_code,
+						   remcomOutBuffer);
+				break;
+			}
+			break;
+
+#ifdef CONFIG_KGDB_THREAD
+			/* task related */
+		case 'H':
+			switch (remcomInBuffer[1]) {
+			case 'g':
+				ptr = &remcomInBuffer[2];
+				hexToInt(&ptr, &threadid);
+				thread = getthread(threadid);
+				if (!thread) {
+					remcomOutBuffer[0] = 'E';
+					remcomOutBuffer[1] = '\0';
+					break;
+				}
+				usethread = thread;
+				/* follow through */
+			case 'c':
+				remcomOutBuffer[0] = 'O';
+				remcomOutBuffer[1] = 'K';
+				remcomOutBuffer[2] = '\0';
+				break;
+			}
+			break;
+
+			/* Query thread status */
+		case 'T':
+			ptr = &remcomInBuffer[1];
+			hexToInt(&ptr, &threadid);
+			thread = getthread(threadid);
+			if (thread) {
+				remcomOutBuffer[0] = 'O';
+				remcomOutBuffer[1] = 'K';
+				remcomOutBuffer[2] = '\0';
+			} else {
+				remcomOutBuffer[0] = 'E';
+				remcomOutBuffer[1] = '\0';
+			}
+			break;
+#endif
+
+		case 'r':
+			reboot = 1;
+			strcpy(remcomOutBuffer, "OK");
+			break;
+		case 'Y':
+			ptr = &remcomInBuffer[1];
+			hexToInt(&ptr, &breakno);
+			ptr++;
+			hexToInt(&ptr, &breaktype);
+			ptr++;
+			hexToInt(&ptr, &length);
+			ptr++;
+			hexToInt(&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];
+			hexToInt(&ptr, &breakno);
+			if (remove_hw_break(breakno & 0x3) == 0) {
+				strcpy(remcomOutBuffer, "OK");
+			} else {
+				strcpy(remcomOutBuffer, "ERROR");
+			}
+			break;
+
+		}		/* switch */
+
+		/* reply to the request */
+		putpacket(remcomOutBuffer);
+		if (reboot == 1) {
+			static long no_idt[2];
+			__asm__ __volatile__("lidt %0"::"m"(no_idt));
+			__asm__ __volatile__("int3");
+		}
+	}
+}
+
+/* this function is used to set up exception handlers for tracing and
+   breakpoints */
+void
+set_debug_traps(void)
+{
+	/*
+	 * linux_debug_hook is defined in traps.c.  We store a pointer
+	 * to our own exception handler into it.
+	 */
+	linux_debug_hook = handle_exception;
+
+	/*
+	 * In case GDB is started before us, ack any packets (presumably
+	 * "$?#xx") sitting there.  */
+	putDebugChar('+');
+
+	initialized = 1;
+}
+
+/* This function will generate a breakpoint exception.  It is used at the
+   beginning of a program to sync up with a debugger and can be used
+   otherwise as a quick means to stop program execution and "break" into
+   the debugger. */
+
+void
+breakpoint(void)
+{
+	if (initialized)
+		BREAKPOINT();
+}
+
+#ifdef CONFIG_GDB_CONSOLE
+char gdbconbuf[BUFMAX];
+
+void
+gdb_console_write(struct console *co, const char *s, unsigned count)
+{
+	int i;
+	int wcount;
+	char *bufptr;
+
+	if (!gdb_initialized) {
+		return;
+	}
+	gdbconbuf[0] = 'O';
+	bufptr = gdbconbuf + 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(gdbconbuf);
+
+	}
+}
+#endif
+static int __init
+kgdb_opt_gdb(char *dummy)
+{
+	gdb_enter = 1;
+	return 1;
+}
+static int __init
+kgdb_opt_gdbttyS(char *str)
+{
+	gdb_ttyS = simple_strtoul(str, NULL, 10);
+	return 1;
+}
+static int __init
+kgdb_opt_gdbbaud(char *str)
+{
+	gdb_baud = simple_strtoul(str, NULL, 10);
+	return 1;
+}
+
+/*
+ * Sequence of these lines has to be maintained because gdb option is a prefix
+ * of the other two options
+ */
+
+__setup("gdbttyS=", kgdb_opt_gdbttyS);
+__setup("gdbbaud=", kgdb_opt_gdbbaud);
+__setup("gdb", kgdb_opt_gdb);
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/arch/i386/kernel/i386_ksyms.c 200-kgdb/arch/i386/kernel/i386_ksyms.c
--- 140-objrmap/arch/i386/kernel/i386_ksyms.c	Wed Jul  2 21:59:03 2003
+++ 200-kgdb/arch/i386/kernel/i386_ksyms.c	Tue Sep  2 10:14:10 2003
@@ -146,6 +146,20 @@ EXPORT_SYMBOL(smp_num_siblings);
 EXPORT_SYMBOL(cpu_sibling_map);
 #endif
 
+#ifdef CONFIG_X86_REMOTE_DEBUG
+void __this_fixmap_does_not_exist(void)
+{
+	BUG();
+}
+EXPORT_SYMBOL(__this_fixmap_does_not_exist);
+
+void __br_lock_usage_bug(void)
+{
+	BUG();
+}
+EXPORT_SYMBOL(__br_lock_usage_bug);
+#endif
+
 #ifdef CONFIG_SMP
 EXPORT_SYMBOL(cpu_data);
 EXPORT_SYMBOL(cpu_online_map);
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/arch/i386/kernel/nmi.c 200-kgdb/arch/i386/kernel/nmi.c
--- 140-objrmap/arch/i386/kernel/nmi.c	Wed Aug 13 20:24:18 2003
+++ 200-kgdb/arch/i386/kernel/nmi.c	Tue Sep  2 10:14:10 2003
@@ -25,6 +25,7 @@
 #include <linux/module.h>
 #include <linux/nmi.h>
 #include <linux/sysdev.h>
+#include <linux/gdb.h>
 
 #include <asm/smp.h>
 #include <asm/mtrr.h>
@@ -44,6 +45,20 @@ extern void show_registers(struct pt_reg
  */
 static int nmi_active;
 
+#ifdef CONFIG_X86_REMOTE_DEBUG
+extern gdb_debug_hook * linux_debug_hook;
+#define       CHK_REMOTE_DEBUG(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;                                                  \
+	}                                                               \
+}
+#else
+#define       CHK_REMOTE_DEBUG(trapnr,signr,error_code,regs,after)
+#endif
+
 #define K7_EVNTSEL_ENABLE	(1 << 22)
 #define K7_EVNTSEL_INT		(1 << 20)
 #define K7_EVNTSEL_OS		(1 << 17)
@@ -422,12 +437,59 @@ void nmi_watchdog_tick (struct pt_regs *
 	sum = irq_stat[cpu].apic_timer_irqs;
 
 	if (last_irq_sums[cpu] == sum) {
+#ifdef CONFIG_X86_REMOTE_DEBUG
+#ifdef CONFIG_SMP
+		if (spin_is_locked(&kgdb_spinlock))
+#else
+		if (kgdb_spinlock) 
+#endif
+		{
+			/* We are inside kgdb, this isn't a stuck cpu */
+			alert_counter[cpu] = 0;
+		} else {
+#ifdef CONFIG_SMP
+			if (spin_is_locked(&kgdb_nmispinlock))
+#else
+			if (kgdb_nmispinlock) 
+#endif
+			{
+				if (!procindebug[cpu]) {
+					procindebug[cpu] = 1;
+					current->thread.kgdbregs = regs;
+					while (1) {
+						/* nothing */
+					}
+				}
+				return;
+			}
+		}
+#endif
 		/*
 		 * 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) {
+#ifdef CONFIG_X86_REMOTE_DEBUG
+#ifdef CONFIG_SMP
+			if (spin_trylock(&kgdb_nmispinlock))
+#else
+			kgdb_nmispinlock = 1;
+#endif
+			{
+				procindebug[cpu] = 1;
+				CHK_REMOTE_DEBUG(2,SIGBUS,0,regs,)
+			} 
+#ifdef CONFIG_SMP
+			else {
+				procindebug[cpu] = 1;
+				current->thread.kgdbregs = regs;
+				while (1) {
+					/* nothing */
+				}
+			}
+#endif
+#endif
 			spin_lock(&nmi_print_lock);
 			/*
 			 * We are in trouble anyway, lets at least try
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/arch/i386/kernel/smp.c 200-kgdb/arch/i386/kernel/smp.c
--- 140-objrmap/arch/i386/kernel/smp.c	Tue Sep  2 09:55:42 2003
+++ 200-kgdb/arch/i386/kernel/smp.c	Tue Sep  2 10:14:10 2003
@@ -515,10 +515,17 @@ int smp_call_function (void (*func) (voi
 {
 	struct call_data_struct data;
 	int cpus = num_online_cpus()-1;
+	int count = 0;
+	int gdb;
 
-	if (!cpus)
+	if (cpus <= 0)
 		return 0;
 
+	gdb = 0;
+	if (wait == 99) {
+		wait = 0;
+		gdb = 1;
+	}
 	data.func = func;
 	data.info = info;
 	atomic_set(&data.started, 0);
@@ -534,12 +541,27 @@ int smp_call_function (void (*func) (voi
 	send_IPI_allbutself(CALL_FUNCTION_VECTOR);
 
 	/* Wait for response */
-	while (atomic_read(&data.started) != cpus)
+	while (atomic_read(&data.started) != cpus) {
+		if (gdb) {
+			if (count++ == 2000000) {
+				printk("%s: timeout\n", __FUNCTION__);
+				break;
+			}
+			if (count == 1000000) {
+				printk("looks bad\n");
+				printk("cpus=%d, started=%d\n", cpus,
+					atomic_read(&data.started));
+			}
+			if (count > 1000000)
+				udelay(1);
+		}
 		barrier();
+	}
 
 	if (wait)
 		while (atomic_read(&data.finished) != cpus)
 			barrier();
+
 	spin_unlock(&call_lock);
 
 	return 0;
@@ -581,9 +603,9 @@ asmlinkage void smp_reschedule_interrupt
 	ack_APIC_irq();
 }
 
-asmlinkage void smp_call_function_interrupt(void)
+asmlinkage void smp_call_function_interrupt(struct pt_regs regs)
 {
-	void (*func) (void *info) = call_data->func;
+	void (*func) (void *info, struct pt_regs *) = (void (*)(void *, struct pt_regs*))call_data->func;
 	void *info = call_data->info;
 	int wait = call_data->wait;
 
@@ -598,7 +620,7 @@ asmlinkage void smp_call_function_interr
 	 * At this point the info structure may be out of scope unless wait==1
 	 */
 	irq_enter();
-	(*func)(info);
+	(*func)(info, &regs);
 	irq_exit();
 
 	if (wait) {
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/arch/i386/kernel/traps.c 200-kgdb/arch/i386/kernel/traps.c
--- 140-objrmap/arch/i386/kernel/traps.c	Tue Sep  2 09:55:42 2003
+++ 200-kgdb/arch/i386/kernel/traps.c	Tue Sep  2 10:14:10 2003
@@ -53,6 +53,24 @@
 
 #include "mach_traps.h"
 
+#ifdef CONFIG_X86_REMOTE_DEBUG
+#include <linux/gdb.h>
+#endif
+
+#ifdef CONFIG_X86_REMOTE_DEBUG
+gdb_debug_hook * linux_debug_hook;
+#define	CHK_REMOTE_DEBUG(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;							\
+	}								\
+    }
+#else
+#define	CHK_REMOTE_DEBUG(trapnr,signr,error_code,regs,after)	
+#endif
+ 
 asmlinkage int system_call(void);
 asmlinkage void lcall7(void);
 asmlinkage void lcall27(void);
@@ -258,6 +276,7 @@ void die(const char * str, struct pt_reg
 	bust_spinlocks(1);
 	handle_BUG(regs);
 	printk("%s: %04lx [#%d]\n", str, err & 0xffff, ++die_counter);
+	CHK_REMOTE_DEBUG(1,SIGTRAP,err,regs,);
 	show_registers(regs);
 	bust_spinlocks(0);
 	spin_unlock_irq(&die_lock);
@@ -327,6 +346,7 @@ static inline void do_trap(int trapnr, i
 #define DO_ERROR(trapnr, signr, str, name) \
 asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
 { \
+	CHK_REMOTE_DEBUG(trapnr,signr,error_code,regs,)\
 	do_trap(trapnr, signr, str, 0, regs, error_code, NULL); \
 }
 
@@ -344,7 +364,9 @@ asmlinkage void do_##name(struct pt_regs
 #define DO_VM86_ERROR(trapnr, signr, str, name) \
 asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
 { \
+	CHK_REMOTE_DEBUG(trapnr,signr,error_code,regs,return)\
 	do_trap(trapnr, signr, str, 1, regs, error_code, NULL); \
+	return; \
 }
 
 #define DO_VM86_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \
@@ -387,8 +409,10 @@ gp_in_vm86:
 	return;
 
 gp_in_kernel:
-	if (!fixup_exception(regs))
+	if (!fixup_exception(regs)) {
+		CHK_REMOTE_DEBUG(13,SIGSEGV,error_code,regs,)
 		die("general protection fault", regs, error_code);
+	}
 }
 
 static void mem_parity_error(unsigned char reason, struct pt_regs * regs)
@@ -550,8 +574,10 @@ asmlinkage void do_debug(struct pt_regs 
 		 * allowing programs to debug themselves without the ptrace()
 		 * interface.
 		 */
+#ifndef CONFIG_X86_REMOTE_DEBUG
 		if ((regs->xcs & 3) == 0)
 			goto clear_TF_reenable;
+#endif
 		if ((tsk->ptrace & (PT_DTRACE|PT_PTRACED)) == PT_DTRACE)
 			goto clear_TF;
 	}
@@ -563,11 +589,13 @@ asmlinkage void do_debug(struct pt_regs 
 	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
@@ -577,13 +605,16 @@ clear_dr7:
 	__asm__("movl %0,%%db7"
 		: /* no output */
 		: "r" (0));
+	CHK_REMOTE_DEBUG(1,SIGTRAP,error_code,regs,)
 	return;
 
 debug_vm86:
 	handle_vm86_trap((struct kernel_vm86_regs *) regs, error_code, 1);
 	return;
 
+#ifndef CONFIG_X86_REMOTE_DEBUG
 clear_TF_reenable:
+#endif
 	set_tsk_thread_flag(tsk, TIF_SINGLESTEP);
 clear_TF:
 	regs->eflags &= ~TF_MASK;
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/arch/i386/mm/fault.c 200-kgdb/arch/i386/mm/fault.c
--- 140-objrmap/arch/i386/mm/fault.c	Fri May 30 19:01:59 2003
+++ 200-kgdb/arch/i386/mm/fault.c	Tue Sep  2 10:14:11 2003
@@ -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>
@@ -20,6 +25,9 @@
 #include <linux/tty.h>
 #include <linux/vt_kern.h>		/* For unblank_screen() */
 #include <linux/module.h>
+#ifdef CONFIG_X86_REMOTE_DEBUG
+#include <linux/gdb.h>
+#endif
 
 #include <asm/system.h>
 #include <asm/uaccess.h>
@@ -112,6 +120,15 @@ asmlinkage void do_page_fault(struct pt_
 	if (in_atomic() || !mm)
 		goto no_context;
 
+#ifdef CONFIG_X86_REMOTE_DEBUG
+	if (kgdb_memerr_expected) {
+		if (linux_debug_hook != (gdb_debug_hook *) NULL) {
+			(*linux_debug_hook)(14, SIGSEGV, error_code, regs) ;
+			return;            /* return w/modified regs */
+		}
+	}
+#endif
+
 	down_read(&mm->mmap_sem);
 
 	vma = find_vma(mm, address);
@@ -210,6 +227,19 @@ bad_area:
 		force_sig_info(SIGSEGV, &info, tsk);
 		return;
 	}
+
+#ifdef CONFIG_X86_REMOTE_DEBUG
+	if (kgdb_memerr_expected) {
+		if (linux_debug_hook != (gdb_debug_hook *) NULL) {
+			(*linux_debug_hook)(14, SIGSEGV, error_code, regs);
+			return; /* Return with modified registers */
+		}
+	} else {
+		if (linux_debug_hook != (gdb_debug_hook *) NULL) {
+			(*linux_debug_hook)(14, SIGSEGV, error_code, regs);
+		}
+	}
+#endif
 
 #ifdef CONFIG_X86_F00F_BUG
 	/*
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/arch/sparc64/kernel/rtrap.S 200-kgdb/arch/sparc64/kernel/rtrap.S
--- 140-objrmap/arch/sparc64/kernel/rtrap.S	Sat May 10 18:34:35 2003
+++ 200-kgdb/arch/sparc64/kernel/rtrap.S	Tue Sep  2 10:14:11 2003
@@ -33,7 +33,7 @@ __handle_softirq:
 		ba,a,pt			%xcc, __handle_softirq_continue
 		 nop
 __handle_preemption:
-		call			schedule
+		call			user_schedule
 		 wrpr			%g0, RTRAP_PSTATE, %pstate
 		ba,pt			%xcc, __handle_preemption_continue
 		 wrpr			%g0, RTRAP_PSTATE_IRQOFF, %pstate
@@ -48,7 +48,7 @@ __handle_user_windows:
 
 		be,pt			%xcc, 1f
 		 nop
-		call			schedule
+		call			user_schedule
 		 wrpr			%g0, RTRAP_PSTATE, %pstate
 		wrpr			%g0, RTRAP_PSTATE_IRQOFF, %pstate
 		ldx			[%g6 + TI_FLAGS], %l0
@@ -92,7 +92,7 @@ __handle_perfctrs:
 		be,pt			%xcc, 1f
 
 		 nop
-		call			schedule
+		call			user_schedule
 		 wrpr			%g0, RTRAP_PSTATE, %pstate
 		wrpr			%g0, RTRAP_PSTATE_IRQOFF, %pstate
 		ldx			[%g6 + TI_FLAGS], %l0
@@ -273,7 +273,7 @@ to_kernel:
 		 sethi			%hi(PREEMPT_ACTIVE), %l6
 		stw			%l6, [%g6 + TI_PRE_COUNT]
 		wrpr			0, %pil
-		call			schedule
+		call			user_schedule
 		 nop
 		ba,pt			%xcc, rtrap
 		 stw			%g0, [%g6 + TI_PRE_COUNT]
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/arch/x86_64/kernel/entry.S 200-kgdb/arch/x86_64/kernel/entry.S
--- 140-objrmap/arch/x86_64/kernel/entry.S	Fri May 30 19:02:02 2003
+++ 200-kgdb/arch/x86_64/kernel/entry.S	Tue Sep  2 10:14:11 2003
@@ -187,7 +187,7 @@ sysret_careful:
 	jnc sysret_signal
 	sti
 	pushq %rdi
-	call schedule
+	call user_schedule
 	popq  %rdi
 	jmp sysret_check
 
@@ -256,7 +256,7 @@ int_careful:
 	jnc  int_very_careful
 	sti
 	pushq %rdi
-	call schedule
+	call user_schedule
 	popq %rdi
 	jmp int_with_check
 
@@ -426,7 +426,7 @@ retint_careful:
 	jnc   retint_signal
 	sti
 	pushq %rdi
-	call  schedule
+	call  user_schedule
 	popq %rdi		
 	GET_THREAD_INFO(%rcx)
 	cli
@@ -460,7 +460,7 @@ retint_kernel:	
 	jc   retint_restore_args
 	movl $PREEMPT_ACTIVE,threadinfo_preempt_count(%rcx)
 	sti
-	call schedule
+	call user_schedule
 	cli
 	GET_THREAD_INFO(%rcx)
 	movl $0,threadinfo_preempt_count(%rcx) 
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/drivers/char/Makefile 200-kgdb/drivers/char/Makefile
--- 140-objrmap/drivers/char/Makefile	Sat Jun 14 18:37:27 2003
+++ 200-kgdb/drivers/char/Makefile	Tue Sep  2 10:14:11 2003
@@ -25,6 +25,7 @@ obj-$(CONFIG_COMPUTONE) += ip2.o ip2main
 obj-$(CONFIG_RISCOM8) += riscom8.o
 obj-$(CONFIG_ISI) += isicom.o
 obj-$(CONFIG_ESPSERIAL) += esp.o
+obj-$(CONFIG_X86_REMOTE_DEBUG) += gdbserial.o
 obj-$(CONFIG_SYNCLINK) += synclink.o
 obj-$(CONFIG_SYNCLINKMP) += synclinkmp.o
 obj-$(CONFIG_N_HDLC) += n_hdlc.o
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/drivers/char/gdbserial.c 200-kgdb/drivers/char/gdbserial.c
--- 140-objrmap/drivers/char/gdbserial.c	Wed Dec 31 16:00:00 1969
+++ 200-kgdb/drivers/char/gdbserial.c	Tue Sep  2 10:14:11 2003
@@ -0,0 +1,274 @@
+/*
+ * Serial interface GDB stub
+ *
+ * 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_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/gdb.h>
+#include <linux/nmi.h>
+#include <linux/init.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>
+
+#undef	PRNT			/* define for debug printing */
+
+#define	GDB_BUF_SIZE	512	/* power of 2, please */
+
+static char gdb_buf[GDB_BUF_SIZE];
+static int gdb_buf_in_inx;
+static atomic_t gdb_buf_in_cnt;
+static int gdb_buf_out_inx;
+
+extern void set_debug_traps(void);	/* GDB routine */
+extern int gdb_serial_setup(int ttyS, int baud, int *port, int *irq);
+extern void shutdown_for_gdb(struct async_struct *info);
+						/* in serial.c */
+
+int gdb_irq;
+int gdb_port;
+int gdb_ttyS = 1;		/* Default: ttyS1 */
+int gdb_baud = 38400;
+int gdb_enter = 0;		/* Default: do not do gdb_hook on boot */
+int gdb_initialized = 0;
+
+static int initialized = -1;
+
+/*
+ * Get a byte from the hardware data buffer and return it
+ */
+static int
+read_data_bfr(void)
+{
+	if (inb(gdb_port + UART_LSR) & UART_LSR_DR)
+		return (inb(gdb_port + UART_RX));
+
+	return (-1);
+
+}				/* read_data_bfr */
+
+/*
+ * Get a char if available, return -1 if nothing available.
+ * Empty the receive buffer first, then look at the interface hardware.
+ */
+static int
+read_char(void)
+{
+	if (atomic_read(&gdb_buf_in_cnt) != 0) {	/* intr routine has q'd chars */
+		int chr;
+
+		chr = gdb_buf[gdb_buf_out_inx++];
+		gdb_buf_out_inx &= (GDB_BUF_SIZE - 1);
+		atomic_dec(&gdb_buf_in_cnt);
+		return (chr);
+	}
+
+	return (read_data_bfr());	/* read from hardware */
+
+}				/* read_char */
+
+/*
+ * Wait until the interface can accept a char, then write it.
+ */
+static void
+write_char(int chr)
+{
+	while (!(inb(gdb_port + UART_LSR) & UART_LSR_THRE)) ;
+
+	outb(chr, gdb_port + UART_TX);
+
+}				/* write_char */
+
+/*
+ * 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 the gdb stub routine getDebugChar() 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 putDebugChar() 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
+gdb_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+	int chr;
+	int iir;
+
+	do {
+		chr = read_data_bfr();
+		iir = inb(gdb_port + UART_IIR);
+#ifdef PRNT
+		printk("gdb_interrupt: chr=%02x '%c'  after read iir=%02x\n",
+		       chr, chr > ' ' && chr < 0x7F ? chr : ' ', iir);
+#endif
+		if (chr < 0)
+			continue;
+
+		if (chr == 3) {	/* Ctrl-C means remote interrupt */
+			breakpoint();
+			continue;
+		}
+
+		if (atomic_read(&gdb_buf_in_cnt) >= GDB_BUF_SIZE) {	/* buffer overflow, clear it */
+			gdb_buf_in_inx = 0;
+			atomic_set(&gdb_buf_in_cnt, 0);
+			gdb_buf_out_inx = 0;
+			break;
+		}
+
+		gdb_buf[gdb_buf_in_inx++] = chr;
+		gdb_buf_in_inx &= (GDB_BUF_SIZE - 1);
+		atomic_inc(&gdb_buf_in_cnt);
+	}
+	while (iir & UART_IIR_RDI);
+	return IRQ_HANDLED;
+}				/* gdb_interrupt */
+
+/*
+ * Just a NULL routine for testing.
+ */
+void
+gdb_null(void)
+{
+}				/* gdb_null */
+
+extern int serial8250_init(void);
+
+int
+gdb_hook(void)
+{
+	int retval;
+
+#ifdef CONFIG_SMP
+	if (NR_CPUS > KGDB_MAX_NO_CPUS) {
+		printk
+		    ("kgdb: too manu cpus. Cannot enable debugger with more than 8 cpus\n");
+		return (-1);
+	}
+#endif
+
+	/*
+	 * Call first time just to get the ser ptr
+	 */
+
+	serial8250_init();
+
+	if (gdb_serial_setup(gdb_ttyS, gdb_baud, &gdb_port, &gdb_irq)) {
+		printk("gdb_serial_setup() error");
+		return (-1);
+	}
+
+	retval = request_irq(gdb_irq,
+			     gdb_interrupt, SA_INTERRUPT, "GDB-stub", NULL);
+	if (retval == 0)
+		initialized = 1;
+	else {
+		initialized = 0;
+		printk("gdb_hook: request_irq(irq=%d) failed: %d\n", gdb_irq,
+		       retval);
+	}
+
+	/*
+	 * Call GDB routine to setup the exception vectors for the debugger
+	 */
+	set_debug_traps();
+
+	/*
+	 * Call the breakpoint() routine in GDB to start the debugging
+	 * session.
+	 */
+	printk("Waiting for connection from remote gdb... ");
+	breakpoint();
+	gdb_null();
+
+	printk("Connected.\n");
+
+	gdb_initialized = 1;
+	return (0);
+
+}				/* gdb_hook_interrupt2 */
+
+/*
+ * getDebugChar
+ *
+ * This is a GDB stub routine.  It waits for a character from the
+ * serial interface and then returns it.  If there is no serial
+ * interface connection then it returns a bogus value which will
+ * almost certainly cause the system to hang.
+ */
+int
+getDebugChar(void)
+{
+	volatile int chr;
+
+#ifdef PRNT
+	printk("getDebugChar: ");
+#endif
+
+	while ((chr = read_char()) < 0)
+		touch_nmi_watchdog();
+
+#ifdef PRNT
+	printk("%c\n", chr > ' ' && chr < 0x7F ? chr : ' ');
+#endif
+	return (chr);
+
+}				/* getDebugChar */
+
+/*
+ * putDebugChar
+ *
+ * This is a GDB stub routine.  It waits until the interface is ready
+ * to transmit a char and then sends it.  If there is no serial
+ * interface connection then it simply returns to its caller, having
+ * pretended to send the char.
+ */
+void
+putDebugChar(int chr)
+{
+#ifdef PRNT
+	printk("putDebugChar: chr=%02x '%c'\n", chr,
+	       chr > ' ' && chr < 0x7F ? chr : ' ');
+#endif
+
+	write_char(chr);	/* this routine will wait */
+
+}				/* putDebugChar */
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/drivers/char/sysrq.c 200-kgdb/drivers/char/sysrq.c
--- 140-objrmap/drivers/char/sysrq.c	Fri May 30 19:02:05 2003
+++ 200-kgdb/drivers/char/sysrq.c	Tue Sep  2 10:14:11 2003
@@ -134,6 +134,18 @@ static struct sysrq_key_op sysrq_mountro
 
 /* END SYNC SYSRQ HANDLERS BLOCK */
 
+#ifdef CONFIG_X86_REMOTE_DEBUG
+static void sysrq_handle_gdb(int key, struct pt_regs *pt_regs,
+			struct tty_struct *tty) {
+	int gdb_hook(void);
+	gdb_hook();
+}
+static struct sysrq_key_op sysrq_gdb_op = {
+	handler:	sysrq_handle_gdb,
+	help_msg:	"Gdb",
+	action_msg:	"Entering debugger",
+};
+#endif
 
 /* SHOW SYSRQ HANDLERS BLOCK */
 
@@ -240,7 +252,11 @@ static struct sysrq_key_op *sysrq_key_ta
 /* d */	NULL,
 /* e */	&sysrq_term_op,
 /* f */	NULL,
+#ifdef CONFIG_X86_REMOTE_DEBUG
+/* g */	&sysrq_gdb_op,
+#else /* CONFIG_X86_REMOTE_DEBUG */
 /* g */	NULL,
+#endif /* CONFIG_X86_REMOTE_DEBUG */
 /* h */	NULL,
 /* i */	&sysrq_kill_op,
 /* j */	NULL,
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/drivers/char/tty_io.c 200-kgdb/drivers/char/tty_io.c
--- 140-objrmap/drivers/char/tty_io.c	Wed Aug 13 20:24:22 2003
+++ 200-kgdb/drivers/char/tty_io.c	Tue Sep  2 10:14:11 2003
@@ -91,6 +91,9 @@
 #include <linux/module.h>
 #include <linux/smp_lock.h>
 #include <linux/device.h>
+#ifdef CONFIG_GDB_CONSOLE
+#include <linux/gdb.h>
+#endif
 
 #include <asm/uaccess.h>
 #include <asm/system.h>
@@ -2190,6 +2193,13 @@ void tty_register_device(struct tty_driv
 	devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
 			"%s%d", driver->devfs_name, index + driver->name_base);
 
+	{
+		extern int kgdb_not_ready_yet;
+
+		if (kgdb_not_ready_yet)
+			return;
+	}
+
 	/* we don't care about the ptys */
 	/* how nice to hide this behind some crappy interface.. */
 	if (driver->type != TTY_DRIVER_TYPE_PTY) {
@@ -2415,6 +2425,9 @@ void __init console_init(void)
 		(*call)();
 		call++;
 	}
+#ifdef CONFIG_GDB_CONSOLE
+	gdb_console_init();
+#endif
 }
 
 #ifdef CONFIG_VT
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/drivers/serial/8250.c 200-kgdb/drivers/serial/8250.c
--- 140-objrmap/drivers/serial/8250.c	Wed Jul  2 21:59:11 2003
+++ 200-kgdb/drivers/serial/8250.c	Tue Sep  2 10:14:11 2003
@@ -2117,9 +2117,116 @@ void serial8250_resume_port(int line, u3
 	uart_resume_port(&serial8250_reg, &serial8250_ports[line].port, level);
 }
 
-static int __init serial8250_init(void)
+#ifdef CONFIG_X86_REMOTE_DEBUG
+/* 
+ *  Takes:
+ *	ttyS - integer specifying which serial port to use for debugging
+ *	baud - baud rate of specified serial port
+ *  Returns:
+ *	port for use by the gdb serial driver
+ */
+int gdb_serial_setup(int ttyS, int baud, int *port, int *irq)
+{
+        struct uart_8250_port *up;
+        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;
+                case 9600:
+                default:
+                        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
+         */
+
+        up =  &serial8250_ports[ttyS];
+//	ser->flags &= ~ASYNC_BOOT_AUTOCONF;
+        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_outp(up, UART_LCR, cval | UART_LCR_DLAB);       /* set DLAB */
+        serial_outp(up, UART_DLL, quot & 0xff);         /* LS of divisor */
+        serial_outp(up, UART_DLM, quot >> 8);           /* MS of divisor */
+        serial_outp(up, UART_LCR, cval);                /* reset DLAB */
+        serial_outp(up, UART_IER, UART_IER_RDI);        /* turn on interrupts*/
+        serial_outp(up, UART_MCR, UART_MCR_OUT2 | UART_MCR_DTR | UART_MCR_RTS);
+
+        /*
+         *      If we read 0xff from the LSR, there is no UART here.
+         */
+        if (serial_inp(up, UART_LSR) == 0xff)
+                return 1;
+	*port = up->port.iobase;
+	*irq = up->port.irq;
+//	serial8250_shutdown(&up->port);
+        return 0;
+}
+#endif
+
+int serial8250_init(void)
 {
 	int ret, i;
+	static int didit = 0;
+
+	if (didit++)
+		return 0;
 
 	printk(KERN_INFO "Serial: 8250/16550 driver $Revision: 1.90 $ "
 		"IRQ sharing %sabled\n", share_irqs ? "en" : "dis");
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/drivers/serial/core.c 200-kgdb/drivers/serial/core.c
--- 140-objrmap/drivers/serial/core.c	Tue Aug  5 20:01:53 2003
+++ 200-kgdb/drivers/serial/core.c	Tue Sep  2 10:14:11 2003
@@ -33,6 +33,10 @@
 #include <linux/device.h>
 #include <linux/serial.h> /* for serial_state and serial_icounter_struct */
 
+#ifdef CONFIG_X86_REMOTE_DEBUG
+#include <linux/gdb.h>
+#endif
+
 #include <asm/irq.h>
 #include <asm/uaccess.h>
 
@@ -1130,6 +1134,16 @@ uart_ioctl(struct tty_struct *tty, struc
 	 * protected against the tty being hung up.
 	 */
 	switch (cmd) {
+#ifdef CONFIG_X86_REMOTE_DEBUG
+	case TIOCGDB:
+		ret = -ENOTTY;
+		if (capable(CAP_SYS_ADMIN)) {
+			gdb_ttyS = MINOR(tty->device) & 0x03F;
+			gdb_baud = tty_get_baud_rate(tty);
+			ret = gdb_hook();
+		}
+		break;
+#endif
 	case TIOCSERGETLSR: /* Get line status register */
 		ret = uart_get_lsr_info(state, (unsigned int *)arg);
 		break;
@@ -1146,6 +1160,30 @@ uart_ioctl(struct tty_struct *tty, struc
  out:
 	return ret;
 }
+
+ /*
+ * ------------------------------------------------------------
+ * Serial GDB driver (most in gdbserial.c)
+ * ------------------------------------------------------------
+ */
+
+#ifdef CONFIG_X86_REMOTE_DEBUG
+#ifdef CONFIG_GDB_CONSOLE
+static struct console gdbcons = {
+	name:		"gdb",
+	write:		gdb_console_write,
+	flags:		CON_PRINTBUFFER | CON_ENABLED,
+	index:		-1,
+};
+#endif
+
+#ifdef CONFIG_GDB_CONSOLE
+void __init gdb_console_init(void)
+{
+	register_console(&gdbcons);
+}
+#endif
+#endif /* CONFIG_X86_REMOTE_DEBUG */
 
 static void uart_set_termios(struct tty_struct *tty, struct termios *old_termios)
 {
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/include/asm-i386/bug.h 200-kgdb/include/asm-i386/bug.h
--- 140-objrmap/include/asm-i386/bug.h	Sat Jun 14 18:37:35 2003
+++ 200-kgdb/include/asm-i386/bug.h	Tue Sep  2 10:14:11 2003
@@ -9,6 +9,11 @@
  * undefined" opcode for parsing in the trap handler.
  */
 
+#ifdef CONFIG_X86_REMOTE_DEBUG
+#define BUG() do {                                            \
+	asm ("int $0x3");                                       \
+} while (0)
+#else
 #if 1	/* Set to zero for a slightly smaller kernel */
 #define BUG()				\
  __asm__ __volatile__(	"ud2\n"		\
@@ -17,6 +22,7 @@
 			 : : "i" (__LINE__), "i" (__FILE__))
 #else
 #define BUG() __asm__ __volatile__("ud2\n")
+#endif
 #endif
 
 #define BUG_ON(condition) do { if (unlikely((condition)!=0)) BUG(); } while(0)
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/include/asm-i386/ioctls.h 200-kgdb/include/asm-i386/ioctls.h
--- 140-objrmap/include/asm-i386/ioctls.h	Tue Apr  8 14:38:20 2003
+++ 200-kgdb/include/asm-i386/ioctls.h	Tue Sep  2 10:14:11 2003
@@ -68,6 +68,7 @@
 #define TIOCGHAYESESP   0x545E  /* Get Hayes ESP configuration */
 #define TIOCSHAYESESP   0x545F  /* Set Hayes ESP configuration */
 #define FIOQSIZE	0x5460
+#define TIOCGDB         0x547F  /* enable GDB stub mode on this tty */
 
 /* Used for packet mode */
 #define TIOCPKT_DATA		 0
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/include/asm-i386/processor.h 200-kgdb/include/asm-i386/processor.h
--- 140-objrmap/include/asm-i386/processor.h	Tue Sep  2 10:08:30 2003
+++ 200-kgdb/include/asm-i386/processor.h	Tue Sep  2 10:15:14 2003
@@ -417,6 +417,9 @@ struct thread_struct {
 	unsigned int		saved_fs, saved_gs;
 /* IO permissions */
 	unsigned long	*io_bitmap_ptr;
+#ifdef CONFIG_X86_REMOTE_DEBUG
+	struct pt_regs *kgdbregs;
+#endif
 };
 
 #define INIT_THREAD  {							\
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/include/linux/gdb.h 200-kgdb/include/linux/gdb.h
--- 140-objrmap/include/linux/gdb.h	Wed Dec 31 16:00:00 1969
+++ 200-kgdb/include/linux/gdb.h	Tue Sep  2 10:14:11 2003
@@ -0,0 +1,67 @@
+#ifndef _GDB_H_
+#define _GDB_H_
+
+/*
+ * Copyright (C) 2001 Amit S. Kale
+ */
+
+/* gdb locks */
+#define KGDB_MAX_NO_CPUS NR_CPUS
+
+extern int gdb_enter;	/* 1 = enter debugger on boot */
+extern int gdb_ttyS;
+extern int gdb_baud;
+extern int gdb_initialized;
+
+extern int gdb_hook(void);
+extern void breakpoint(void);
+
+typedef int     gdb_debug_hook(int trapno,
+                               int signo,
+                               int err_code,
+                               struct pt_regs *regs);
+extern gdb_debug_hook  *linux_debug_hook;
+
+#ifdef CONFIG_SMP
+extern spinlock_t kgdb_spinlock;
+extern spinlock_t kgdb_nmispinlock;
+#else
+extern unsigned kgdb_spinlock;
+extern unsigned kgdb_nmispinlock;
+#endif
+
+extern volatile int kgdb_memerr_expected;
+
+struct console;
+void gdb_console_write(struct console *co, const char *s,
+				unsigned count);
+void gdb_console_init(void);
+
+extern volatile int procindebug[KGDB_MAX_NO_CPUS];
+
+#define KGDB_ASSERT(message, condition)	do {			\
+	if (!(condition)) {					\
+		printk("kgdb assertion failed: %s\n", message); \
+		asm ("int $0x3");				\
+	}							\
+} while (0)
+
+#ifdef CONFIG_KERNEL_ASSERTS
+#define KERNEL_ASSERT(message, condition) KGDB_ASSERT(message, condition)
+#else
+#define KERNEL_ASSERT(message, condition)
+#endif
+
+#define KA_VALID_ERRNO(errno) ((errno) > 0 && (errno) <= EMEDIUMTYPE)
+
+#define KA_VALID_PTR_ERR(ptr) KA_VALID_ERRNO(-PTR_ERR(ptr))
+
+#define KA_VALID_KPTR(ptr)  (!(ptr) ||	\
+	       ((void *)(ptr) >= (void *)PAGE_OFFSET &&  \
+	       (void *)(ptr) < ERR_PTR(-EMEDIUMTYPE)))
+
+#define KA_VALID_PTRORERR(errptr) (KA_VALID_KPTR(errptr) || KA_VALID_PTR_ERR(errptr))
+
+#define KA_HELD_GKL()	(current->lock_depth >= 0)
+
+#endif /* _GDB_H_ */
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/include/linux/sched.h 200-kgdb/include/linux/sched.h
--- 140-objrmap/include/linux/sched.h	Tue Sep  2 09:55:56 2003
+++ 200-kgdb/include/linux/sched.h	Tue Sep  2 10:14:11 2003
@@ -173,7 +173,9 @@ extern unsigned long cache_decay_ticks;
 
 #define	MAX_SCHEDULE_TIMEOUT	LONG_MAX
 extern signed long FASTCALL(schedule_timeout(signed long timeout));
-asmlinkage void schedule(void);
+asmlinkage void do_schedule(void);
+asmlinkage void kern_schedule(void);
+asmlinkage void kern_do_schedule(struct pt_regs);
 
 struct namespace;
 
@@ -718,6 +720,12 @@ static inline int thread_group_empty(tas
 		(thread_group_leader(p) && !thread_group_empty(p))
 
 extern void unhash_process(struct task_struct *p);
+
+#ifdef CONFIG_KGDB_THREAD
+#define schedule() kern_schedule()
+#else
+#define schedule() do_schedule()
+#endif
 
 /* Protects ->fs, ->files, ->mm, and synchronises with wait4().
  * Nests both inside and outside of read_lock(&tasklist_lock).
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/init/main.c 200-kgdb/init/main.c
--- 140-objrmap/init/main.c	Tue Sep  2 09:58:37 2003
+++ 200-kgdb/init/main.c	Tue Sep  2 10:14:11 2003
@@ -56,6 +56,10 @@
 #include <asm/smp.h>
 #endif
 
+#ifdef CONFIG_X86_REMOTE_DEBUG
+#include <linux/gdb.h>
+#endif
+
 /*
  * Versions of gcc older than that listed below may actually compile
  * and link okay, but the end product can have subtle run time bugs.
@@ -378,6 +382,7 @@ static void rest_init(void)
 /*
  *	Activate the first processor.
  */
+int kgdb_not_ready_yet;
 
 asmlinkage void __init start_kernel(void)
 {
@@ -464,6 +469,14 @@ asmlinkage void __init start_kernel(void
 	 *	make syscalls (and thus be locked).
 	 */
 	init_idle(current, smp_processor_id());
+
+#ifdef CONFIG_X86_REMOTE_DEBUG
+	if (gdb_enter) {
+		kgdb_not_ready_yet = 1;
+		gdb_hook();		/* right at boot time */
+		kgdb_not_ready_yet = 0;
+	}
+#endif
 
 	/* Do the rest non-__init'ed, we're now alive */
 	rest_init();
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/kernel/ksyms.c 200-kgdb/kernel/ksyms.c
--- 140-objrmap/kernel/ksyms.c	Tue Sep  2 09:55:57 2003
+++ 200-kgdb/kernel/ksyms.c	Tue Sep  2 10:14:11 2003
@@ -463,7 +463,10 @@ EXPORT_SYMBOL(sleep_on);
 EXPORT_SYMBOL(sleep_on_timeout);
 EXPORT_SYMBOL(interruptible_sleep_on);
 EXPORT_SYMBOL(interruptible_sleep_on_timeout);
-EXPORT_SYMBOL(schedule);
+EXPORT_SYMBOL(do_schedule);
+#ifdef CONFIG_KGDB_THREAD
+EXPORT_SYMBOL(kern_schedule);
+#endif
 #ifdef CONFIG_PREEMPT
 EXPORT_SYMBOL(preempt_schedule);
 #endif
diff -urpN -X /home/fletch/.diff.exclude 140-objrmap/kernel/sched.c 200-kgdb/kernel/sched.c
--- 140-objrmap/kernel/sched.c	Tue Sep  2 10:09:31 2003
+++ 200-kgdb/kernel/sched.c	Tue Sep  2 10:14:11 2003
@@ -1295,7 +1295,7 @@ void scheduling_functions_start_here(voi
 /*
  * schedule() is the main scheduler function.
  */
-asmlinkage void schedule(void)
+asmlinkage void do_schedule(void)
 {
 	task_t *prev, *next;
 	runqueue_t *rq;
@@ -1522,6 +1522,22 @@ void complete_all(struct completion *x)
 	__wake_up_common(&x->wait, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 0, 0);
 	spin_unlock_irqrestore(&x->wait.lock, flags);
 }
+
+asmlinkage void user_schedule(void)
+{
+#ifdef CONFIG_KGDB_THREAD
+	current->thread.kgdbregs = NULL;
+#endif
+	do_schedule();
+}
+
+#ifdef CONFIG_KGDB_THREAD
+asmlinkage void kern_do_schedule(struct pt_regs regs)
+{
+	current->thread.kgdbregs = &regs;
+	do_schedule();
+}
+#endif
 
 void wait_for_completion(struct completion *x)
 {