<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN" "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" []> <book id="kgdbOnLinux"> <bookinfo> <title>Using kgdb and the kgdb Internals</title> <authorgroup> <author> <firstname>Jason</firstname> <surname>Wessel</surname> <affiliation> <address> <email>jason.wessel@windriver.com</email> </address> </affiliation> </author> </authorgroup> <authorgroup> <author> <firstname>Tom</firstname> <surname>Rini</surname> <affiliation> <address> <email>trini@kernel.crashing.org</email> </address> </affiliation> </author> </authorgroup> <authorgroup> <author> <firstname>Amit S.</firstname> <surname>Kale</surname> <affiliation> <address> <email>amitkale@linsyssoft.com</email> </address> </affiliation> </author> </authorgroup> <copyright> <year>2008</year> <holder>Wind River Systems, Inc.</holder> </copyright> <copyright> <year>2004-2005</year> <holder>MontaVista Software, Inc.</holder> </copyright> <copyright> <year>2004</year> <holder>Amit S. Kale</holder> </copyright> <legalnotice> <para> This file is licensed under the terms of the GNU General Public License version 2. This program is licensed "as is" without any warranty of any kind, whether express or implied. </para> </legalnotice> </bookinfo> <toc></toc> <chapter id="Introduction"> <title>Introduction</title> <para> kgdb is a source level debugger for linux kernel. It is used along with gdb to debug a linux kernel. The expectation is that gdb can be used to "break in" to the kernel to inspect memory, variables and look through call stack information similar to what an application developer would use gdb for. It is possible to place breakpoints in kernel code and perform some limited execution stepping. </para> <para> Two machines are required for using kgdb. One of these machines is a development machine and the other is a test machine. The kernel to be debugged runs on the test machine. The development machine runs an instance of gdb against the vmlinux file which contains the symbols (not boot image such as bzImage, zImage, uImage...). In gdb the developer specifies the connection parameters and connects to kgdb. The type of connection a developer makes with gdb depends on the availability of kgdb I/O modules compiled as builtin's or kernel modules in the test machine's kernel. </para> </chapter> <chapter id="CompilingAKernel"> <title>Compiling a kernel</title> <para> To enable <symbol>CONFIG_KGDB</symbol> you should first turn on "Prompt for development and/or incomplete code/drivers" (CONFIG_EXPERIMENTAL) in "General setup", then under the "Kernel debugging" select "KGDB: kernel debugging with remote gdb". </para> <para> It is advised, but not required that you turn on the CONFIG_FRAME_POINTER kernel option. This option inserts code to into the compiled executable which saves the frame information in registers or on the stack at different points which will allow a debugger such as gdb to more accurately construct stack back traces while debugging the kernel. </para> <para> If the architecture that you are using supports the kernel option CONFIG_DEBUG_RODATA, you should consider turning it off. This option will prevent the use of software breakpoints because it marks certain regions of the kernel's memory space as read-only. If kgdb supports it for the architecture you are using, you can use hardware breakpoints if you desire to run with the CONFIG_DEBUG_RODATA option turned on, else you need to turn off this option. </para> <para> Next you should choose one of more I/O drivers to interconnect debugging host and debugged target. Early boot debugging requires a KGDB I/O driver that supports early debugging and the driver must be built into the kernel directly. Kgdb I/O driver configuration takes place via kernel or module parameters, see following chapter. </para> <para> The kgdb test compile options are described in the kgdb test suite chapter. </para> </chapter> <chapter id="EnableKGDB"> <title>Enable kgdb for debugging</title> <para> In order to use kgdb you must activate it by passing configuration information to one of the kgdb I/O drivers. If you do not pass any configuration information kgdb will not do anything at all. Kgdb will only actively hook up to the kernel trap hooks if a kgdb I/O driver is loaded and configured. If you unconfigure a kgdb I/O driver, kgdb will unregister all the kernel hook points. </para> <para> All drivers can be reconfigured at run time, if <symbol>CONFIG_SYSFS</symbol> and <symbol>CONFIG_MODULES</symbol> are enabled, by echo'ing a new config string to <constant>/sys/module/<driver>/parameter/<option></constant>. The driver can be unconfigured by passing an empty string. You cannot change the configuration while the debugger is attached. Make sure to detach the debugger with the <constant>detach</constant> command prior to trying unconfigure a kgdb I/O driver. </para> <sect1 id="kgdbwait"> <title>Kernel parameter: kgdbwait</title> <para> The Kernel command line option <constant>kgdbwait</constant> makes kgdb wait for a debugger connection during booting of a kernel. You can only use this option you compiled a kgdb I/O driver into the kernel and you specified the I/O driver configuration as a kernel command line option. The kgdbwait parameter should always follow the configuration parameter for the kgdb I/O driver in the kernel command line else the I/O driver will not be configured prior to asking the kernel to use it to wait. </para> <para> The kernel will stop and wait as early as the I/O driver and architecture will allow when you use this option. If you build the kgdb I/O driver as a kernel module kgdbwait will not do anything. </para> </sect1> <sect1 id="kgdboc"> <title>Kernel parameter: kgdboc</title> <para> The kgdboc driver was originally an abbreviation meant to stand for "kgdb over console". Kgdboc is designed to work with a single serial port. It was meant to cover the circumstance where you wanted to use a serial console as your primary console as well as using it to perform kernel debugging. Of course you can also use kgdboc without assigning a console to the same port. </para> <sect2 id="UsingKgdboc"> <title>Using kgdboc</title> <para> You can configure kgdboc via sysfs or a module or kernel boot line parameter depending on if you build with CONFIG_KGDBOC as a module or built-in. <orderedlist> <listitem><para>From the module load or build-in</para> <para><constant>kgdboc=<tty-device>,[baud]</constant></para> <para> The example here would be if your console port was typically ttyS0, you would use something like <constant>kgdboc=ttyS0,115200</constant> or on the ARM Versatile AB you would likely use <constant>kgdboc=ttyAMA0,115200</constant> </para> </listitem> <listitem><para>From sysfs</para> <para><constant>echo ttyS0 > /sys/module/kgdboc/parameters/kgdboc</constant></para> </listitem> </orderedlist> </para> <para> NOTE: Kgdboc does not support interrupting the target via the gdb remote protocol. You must manually send a sysrq-g unless you have a proxy that splits console output to a terminal problem and has a separate port for the debugger to connect to that sends the sysrq-g for you. </para> <para>When using kgdboc with no debugger proxy, you can end up connecting the debugger for one of two entry points. If an exception occurs after you have loaded kgdboc a message should print on the console stating it is waiting for the debugger. In case you disconnect your terminal program and then connect the debugger in its place. If you want to interrupt the target system and forcibly enter a debug session you have to issue a Sysrq sequence and then type the letter <constant>g</constant>. Then you disconnect the terminal session and connect gdb. Your options if you don't like this are to hack gdb to send the sysrq-g for you as well as on the initial connect, or to use a debugger proxy that allows an unmodified gdb to do the debugging. </para> </sect2> </sect1> <sect1 id="kgdbcon"> <title>Kernel parameter: kgdbcon</title> <para> Kgdb supports using the gdb serial protocol to send console messages to the debugger when the debugger is connected and running. There are two ways to activate this feature. <orderedlist> <listitem><para>Activate with the kernel command line option:</para> <para><constant>kgdbcon</constant></para> </listitem> <listitem><para>Use sysfs before configuring an io driver</para> <para> <constant>echo 1 > /sys/module/kgdb/parameters/kgdb_use_con</constant> </para> <para> NOTE: If you do this after you configure the kgdb I/O driver, the setting will not take effect until the next point the I/O is reconfigured. </para> </listitem> </orderedlist> </para> <para> IMPORTANT NOTE: Using this option with kgdb over the console (kgdboc) is not supported. </para> </sect1> </chapter> <chapter id="ConnectingGDB"> <title>Connecting gdb</title> <para> If you are using kgdboc, you need to have used kgdbwait as a boot argument, issued a sysrq-g, or the system you are going to debug has already taken an exception and is waiting for the debugger to attach before you can connect gdb. </para> <para> If you are not using different kgdb I/O driver other than kgdboc, you should be able to connect and the target will automatically respond. </para> <para> Example (using a serial port): </para> <programlisting> % gdb ./vmlinux (gdb) set remotebaud 115200 (gdb) target remote /dev/ttyS0 </programlisting> <para> Example (kgdb to a terminal server on tcp port 2012): </para> <programlisting> % gdb ./vmlinux (gdb) target remote 192.168.2.2:2012 </programlisting> <para> Once connected, you can debug a kernel the way you would debug an application program. </para> <para> If you are having problems connecting or something is going seriously wrong while debugging, it will most often be the case that you want to enable gdb to be verbose about its target communications. You do this prior to issuing the <constant>target remote</constant> command by typing in: <constant>set debug remote 1</constant> </para> </chapter> <chapter id="KGDBTestSuite"> <title>kgdb Test Suite</title> <para> When kgdb is enabled in the kernel config you can also elect to enable the config parameter KGDB_TESTS. Turning this on will enable a special kgdb I/O module which is designed to test the kgdb internal functions. </para> <para> The kgdb tests are mainly intended for developers to test the kgdb internals as well as a tool for developing a new kgdb architecture specific implementation. These tests are not really for end users of the Linux kernel. The primary source of documentation would be to look in the drivers/misc/kgdbts.c file. </para> <para> The kgdb test suite can also be configured at compile time to run the core set of tests by setting the kernel config parameter KGDB_TESTS_ON_BOOT. This particular option is aimed at automated regression testing and does not require modifying the kernel boot config arguments. If this is turned on, the kgdb test suite can be disabled by specifying "kgdbts=" as a kernel boot argument. </para> </chapter> <chapter id="CommonBackEndReq"> <title>KGDB Internals</title> <sect1 id="kgdbArchitecture"> <title>Architecture Specifics</title> <para> Kgdb is organized into three basic components: <orderedlist> <listitem><para>kgdb core</para> <para> The kgdb core is found in kernel/kgdb.c. It contains: <itemizedlist> <listitem><para>All the logic to implement the gdb serial protocol</para></listitem> <listitem><para>A generic OS exception handler which includes sync'ing the processors into a stopped state on an multi cpu system.</para></listitem> <listitem><para>The API to talk to the kgdb I/O drivers</para></listitem> <listitem><para>The API to make calls to the arch specific kgdb implementation</para></listitem> <listitem><para>The logic to perform safe memory reads and writes to memory while using the debugger</para></listitem> <listitem><para>A full implementation for software breakpoints unless overridden by the arch</para></listitem> </itemizedlist> </para> </listitem> <listitem><para>kgdb arch specific implementation</para> <para> This implementation is generally found in arch/*/kernel/kgdb.c. As an example, arch/x86/kernel/kgdb.c contains the specifics to implement HW breakpoint as well as the initialization to dynamically register and unregister for the trap handlers on this architecture. The arch specific portion implements: <itemizedlist> <listitem><para>contains an arch specific trap catcher which invokes kgdb_handle_exception() to start kgdb about doing its work</para></listitem> <listitem><para>translation to and from gdb specific packet format to pt_regs</para></listitem> <listitem><para>Registration and unregistration of architecture specific trap hooks</para></listitem> <listitem><para>Any special exception handling and cleanup</para></listitem> <listitem><para>NMI exception handling and cleanup</para></listitem> <listitem><para>(optional)HW breakpoints</para></listitem> </itemizedlist> </para> </listitem> <listitem><para>kgdb I/O driver</para> <para> Each kgdb I/O driver has to provide an implemenation for the following: <itemizedlist> <listitem><para>configuration via builtin or module</para></listitem> <listitem><para>dynamic configuration and kgdb hook registration calls</para></listitem> <listitem><para>read and write character interface</para></listitem> <listitem><para>A cleanup handler for unconfiguring from the kgdb core</para></listitem> <listitem><para>(optional) Early debug methodology</para></listitem> </itemizedlist> Any given kgdb I/O driver has to operate very closely with the hardware and must do it in such a way that does not enable interrupts or change other parts of the system context without completely restoring them. The kgdb core will repeatedly "poll" a kgdb I/O driver for characters when it needs input. The I/O driver is expected to return immediately if there is no data available. Doing so allows for the future possibility to touch watch dog hardware in such a way as to have a target system not reset when these are enabled. </para> </listitem> </orderedlist> </para> <para> If you are intent on adding kgdb architecture specific support for a new architecture, the architecture should define <constant>HAVE_ARCH_KGDB</constant> in the architecture specific Kconfig file. This will enable kgdb for the architecture, and at that point you must create an architecture specific kgdb implementation. </para> <para> There are a few flags which must be set on every architecture in their <asm/kgdb.h> file. These are: <itemizedlist> <listitem> <para> NUMREGBYTES: The size in bytes of all of the registers, so that we can ensure they will all fit into a packet. </para> <para> BUFMAX: The size in bytes of the buffer GDB will read into. This must be larger than NUMREGBYTES. </para> <para> CACHE_FLUSH_IS_SAFE: Set to 1 if it is always safe to call flush_cache_range or flush_icache_range. On some architectures, these functions may not be safe to call on SMP since we keep other CPUs in a holding pattern. </para> </listitem> </itemizedlist> </para> <para> There are also the following functions for the common backend, found in kernel/kgdb.c, that must be supplied by the architecture-specific backend unless marked as (optional), in which case a default function maybe used if the architecture does not need to provide a specific implementation. </para> <!-- include/linux/kgdb.h --> <refentry id="API-kgdb-skipexception"> <refentryinfo> <title>LINUX</title> <productname>Kernel Hackers Manual</productname> <date>June 2011</date> </refentryinfo> <refmeta> <refentrytitle><phrase>kgdb_skipexception</phrase></refentrytitle> <manvolnum>9</manvolnum> <refmiscinfo class="version">2.6.32</refmiscinfo> </refmeta> <refnamediv> <refname>kgdb_skipexception</refname> <refpurpose> (optional) exit kgdb_handle_exception early </refpurpose> </refnamediv> <refsynopsisdiv> <title>Synopsis</title> <funcsynopsis><funcprototype> <funcdef>int <function>kgdb_skipexception </function></funcdef> <paramdef>int <parameter>exception</parameter></paramdef> <paramdef>struct pt_regs * <parameter>regs</parameter></paramdef> </funcprototype></funcsynopsis> </refsynopsisdiv> <refsect1> <title>Arguments</title> <variablelist> <varlistentry> <term><parameter>exception</parameter></term> <listitem> <para> Exception vector number </para> </listitem> </varlistentry> <varlistentry> <term><parameter>regs</parameter></term> <listitem> <para> Current <structname>struct pt_regs</structname>. </para> </listitem> </varlistentry> </variablelist> </refsect1> <refsect1> <title>Description</title> <para> On some architectures it is required to skip a breakpoint exception when it occurs after a breakpoint has been removed. This can be implemented in the architecture specific portion of for kgdb. </para> </refsect1> </refentry> <refentry id="API-kgdb-post-primary-code"> <refentryinfo> <title>LINUX</title> <productname>Kernel Hackers Manual</productname> <date>June 2011</date> </refentryinfo> <refmeta> <refentrytitle><phrase>kgdb_post_primary_code</phrase></refentrytitle> <manvolnum>9</manvolnum> <refmiscinfo class="version">2.6.32</refmiscinfo> </refmeta> <refnamediv> <refname>kgdb_post_primary_code</refname> <refpurpose> (optional) Save error vector/code numbers. </refpurpose> </refnamediv> <refsynopsisdiv> <title>Synopsis</title> <funcsynopsis><funcprototype> <funcdef>void <function>kgdb_post_primary_code </function></funcdef> <paramdef>struct pt_regs * <parameter>regs</parameter></paramdef> <paramdef>int <parameter>e_vector</parameter></paramdef> <paramdef>int <parameter>err_code</parameter></paramdef> </funcprototype></funcsynopsis> </refsynopsisdiv> <refsect1> <title>Arguments</title> <variablelist> <varlistentry> <term><parameter>regs</parameter></term> <listitem> <para> Original pt_regs. </para> </listitem> </varlistentry> <varlistentry> <term><parameter>e_vector</parameter></term> <listitem> <para> Original error vector. </para> </listitem> </varlistentry> <varlistentry> <term><parameter>err_code</parameter></term> <listitem> <para> Original error code. </para> </listitem> </varlistentry> </variablelist> </refsect1> <refsect1> <title>Description</title> <para> This is usually needed on architectures which support SMP and KGDB. This function is called after all the secondary cpus have been put to a know spin state and the primary CPU has control over KGDB. </para> </refsect1> </refentry> <refentry id="API-kgdb-disable-hw-debug"> <refentryinfo> <title>LINUX</title> <productname>Kernel Hackers Manual</productname> <date>June 2011</date> </refentryinfo> <refmeta> <refentrytitle><phrase>kgdb_disable_hw_debug</phrase></refentrytitle> <manvolnum>9</manvolnum> <refmiscinfo class="version">2.6.32</refmiscinfo> </refmeta> <refnamediv> <refname>kgdb_disable_hw_debug</refname> <refpurpose> (optional) Disable hardware debugging hook </refpurpose> </refnamediv> <refsynopsisdiv> <title>Synopsis</title> <funcsynopsis><funcprototype> <funcdef>void <function>kgdb_disable_hw_debug </function></funcdef> <paramdef>struct pt_regs * <parameter>regs</parameter></paramdef> </funcprototype></funcsynopsis> </refsynopsisdiv> <refsect1> <title>Arguments</title> <variablelist> <varlistentry> <term><parameter>regs</parameter></term> <listitem> <para> Current <structname>struct pt_regs</structname>. </para> </listitem> </varlistentry> </variablelist> </refsect1> <refsect1> <title>Description</title> <para> This function will be called if the particular architecture must disable hardware debugging while it is processing gdb packets or handling exception. </para> </refsect1> </refentry> <refentry id="API-kgdb-breakpoint"> <refentryinfo> <title>LINUX</title> <productname>Kernel Hackers Manual</productname> <date>June 2011</date> </refentryinfo> <refmeta> <refentrytitle><phrase>kgdb_breakpoint</phrase></refentrytitle> <manvolnum>9</manvolnum> <refmiscinfo class="version">2.6.32</refmiscinfo> </refmeta> <refnamediv> <refname>kgdb_breakpoint</refname> <refpurpose> compiled in breakpoint </refpurpose> </refnamediv> <refsynopsisdiv> <title>Synopsis</title> <funcsynopsis><funcprototype> <funcdef>void <function>kgdb_breakpoint </function></funcdef> <paramdef> <parameter>void</parameter></paramdef> </funcprototype></funcsynopsis> </refsynopsisdiv> <refsect1> <title>Arguments</title> <variablelist> <varlistentry> <term><parameter>void</parameter></term> <listitem> <para> no arguments </para> </listitem> </varlistentry> </variablelist> </refsect1> <refsect1> <title>Description</title> <para> </para><para> This will be impelmented a static inline per architecture. This function is called by the kgdb core to execute an architecture specific trap to cause kgdb to enter the exception processing. </para> </refsect1> </refentry> <refentry id="API-kgdb-arch-init"> <refentryinfo> <title>LINUX</title> <productname>Kernel Hackers Manual</productname> <date>June 2011</date> </refentryinfo> <refmeta> <refentrytitle><phrase>kgdb_arch_init</phrase></refentrytitle> <manvolnum>9</manvolnum> <refmiscinfo class="version">2.6.32</refmiscinfo> </refmeta> <refnamediv> <refname>kgdb_arch_init</refname> <refpurpose> Perform any architecture specific initalization. </refpurpose> </refnamediv> <refsynopsisdiv> <title>Synopsis</title> <funcsynopsis><funcprototype> <funcdef>int <function>kgdb_arch_init </function></funcdef> <paramdef> <parameter>void</parameter></paramdef> </funcprototype></funcsynopsis> </refsynopsisdiv> <refsect1> <title>Arguments</title> <variablelist> <varlistentry> <term><parameter>void</parameter></term> <listitem> <para> no arguments </para> </listitem> </varlistentry> </variablelist> </refsect1> <refsect1> <title>Description</title> <para> </para><para> This function will handle the initalization of any architecture specific callbacks. </para> </refsect1> </refentry> <refentry id="API-kgdb-arch-exit"> <refentryinfo> <title>LINUX</title> <productname>Kernel Hackers Manual</productname> <date>June 2011</date> </refentryinfo> <refmeta> <refentrytitle><phrase>kgdb_arch_exit</phrase></refentrytitle> <manvolnum>9</manvolnum> <refmiscinfo class="version">2.6.32</refmiscinfo> </refmeta> <refnamediv> <refname>kgdb_arch_exit</refname> <refpurpose> Perform any architecture specific uninitalization. </refpurpose> </refnamediv> <refsynopsisdiv> <title>Synopsis</title> <funcsynopsis><funcprototype> <funcdef>void <function>kgdb_arch_exit </function></funcdef> <paramdef> <parameter>void</parameter></paramdef> </funcprototype></funcsynopsis> </refsynopsisdiv> <refsect1> <title>Arguments</title> <variablelist> <varlistentry> <term><parameter>void</parameter></term> <listitem> <para> no arguments </para> </listitem> </varlistentry> </variablelist> </refsect1> <refsect1> <title>Description</title> <para> </para><para> This function will handle the uninitalization of any architecture specific callbacks, for dynamic registration and unregistration. </para> </refsect1> </refentry> <refentry id="API-pt-regs-to-gdb-regs"> <refentryinfo> <title>LINUX</title> <productname>Kernel Hackers Manual</productname> <date>June 2011</date> </refentryinfo> <refmeta> <refentrytitle><phrase>pt_regs_to_gdb_regs</phrase></refentrytitle> <manvolnum>9</manvolnum> <refmiscinfo class="version">2.6.32</refmiscinfo> </refmeta> <refnamediv> <refname>pt_regs_to_gdb_regs</refname> <refpurpose> Convert ptrace regs to GDB regs </refpurpose> </refnamediv> <refsynopsisdiv> <title>Synopsis</title> <funcsynopsis><funcprototype> <funcdef>void <function>pt_regs_to_gdb_regs </function></funcdef> <paramdef>unsigned long * <parameter>gdb_regs</parameter></paramdef> <paramdef>struct pt_regs * <parameter>regs</parameter></paramdef> </funcprototype></funcsynopsis> </refsynopsisdiv> <refsect1> <title>Arguments</title> <variablelist> <varlistentry> <term><parameter>gdb_regs</parameter></term> <listitem> <para> A pointer to hold the registers in the order GDB wants. </para> </listitem> </varlistentry> <varlistentry> <term><parameter>regs</parameter></term> <listitem> <para> The <structname>struct pt_regs</structname> of the current process. </para> </listitem> </varlistentry> </variablelist> </refsect1> <refsect1> <title>Description</title> <para> Convert the pt_regs in <parameter>regs</parameter> into the format for registers that GDB expects, stored in <parameter>gdb_regs</parameter>. </para> </refsect1> </refentry> <refentry id="API-sleeping-thread-to-gdb-regs"> <refentryinfo> <title>LINUX</title> <productname>Kernel Hackers Manual</productname> <date>June 2011</date> </refentryinfo> <refmeta> <refentrytitle><phrase>sleeping_thread_to_gdb_regs</phrase></refentrytitle> <manvolnum>9</manvolnum> <refmiscinfo class="version">2.6.32</refmiscinfo> </refmeta> <refnamediv> <refname>sleeping_thread_to_gdb_regs</refname> <refpurpose> Convert ptrace regs to GDB regs </refpurpose> </refnamediv> <refsynopsisdiv> <title>Synopsis</title> <funcsynopsis><funcprototype> <funcdef>void <function>sleeping_thread_to_gdb_regs </function></funcdef> <paramdef>unsigned long * <parameter>gdb_regs</parameter></paramdef> <paramdef>struct task_struct * <parameter>p</parameter></paramdef> </funcprototype></funcsynopsis> </refsynopsisdiv> <refsect1> <title>Arguments</title> <variablelist> <varlistentry> <term><parameter>gdb_regs</parameter></term> <listitem> <para> A pointer to hold the registers in the order GDB wants. </para> </listitem> </varlistentry> <varlistentry> <term><parameter>p</parameter></term> <listitem> <para> The <structname>struct task_struct</structname> of the desired process. </para> </listitem> </varlistentry> </variablelist> </refsect1> <refsect1> <title>Description</title> <para> Convert the register values of the sleeping process in <parameter>p</parameter> to the format that GDB expects. This function is called when kgdb does not have access to the <structname>struct pt_regs</structname> and therefore it should fill the gdb registers <parameter>gdb_regs</parameter> with what has been saved in <structname>struct thread_struct</structname> thread field during switch_to. </para> </refsect1> </refentry> <refentry id="API-gdb-regs-to-pt-regs"> <refentryinfo> <title>LINUX</title> <productname>Kernel Hackers Manual</productname> <date>June 2011</date> </refentryinfo> <refmeta> <refentrytitle><phrase>gdb_regs_to_pt_regs</phrase></refentrytitle> <manvolnum>9</manvolnum> <refmiscinfo class="version">2.6.32</refmiscinfo> </refmeta> <refnamediv> <refname>gdb_regs_to_pt_regs</refname> <refpurpose> Convert GDB regs to ptrace regs. </refpurpose> </refnamediv> <refsynopsisdiv> <title>Synopsis</title> <funcsynopsis><funcprototype> <funcdef>void <function>gdb_regs_to_pt_regs </function></funcdef> <paramdef>unsigned long * <parameter>gdb_regs</parameter></paramdef> <paramdef>struct pt_regs * <parameter>regs</parameter></paramdef> </funcprototype></funcsynopsis> </refsynopsisdiv> <refsect1> <title>Arguments</title> <variablelist> <varlistentry> <term><parameter>gdb_regs</parameter></term> <listitem> <para> A pointer to hold the registers we've received from GDB. </para> </listitem> </varlistentry> <varlistentry> <term><parameter>regs</parameter></term> <listitem> <para> A pointer to a <structname>struct pt_regs</structname> to hold these values in. </para> </listitem> </varlistentry> </variablelist> </refsect1> <refsect1> <title>Description</title> <para> Convert the GDB regs in <parameter>gdb_regs</parameter> into the pt_regs, and store them in <parameter>regs</parameter>. </para> </refsect1> </refentry> <refentry id="API-kgdb-arch-handle-exception"> <refentryinfo> <title>LINUX</title> <productname>Kernel Hackers Manual</productname> <date>June 2011</date> </refentryinfo> <refmeta> <refentrytitle><phrase>kgdb_arch_handle_exception</phrase></refentrytitle> <manvolnum>9</manvolnum> <refmiscinfo class="version">2.6.32</refmiscinfo> </refmeta> <refnamediv> <refname>kgdb_arch_handle_exception</refname> <refpurpose> Handle architecture specific GDB packets. </refpurpose> </refnamediv> <refsynopsisdiv> <title>Synopsis</title> <funcsynopsis><funcprototype> <funcdef>int <function>kgdb_arch_handle_exception </function></funcdef> <paramdef>int <parameter>vector</parameter></paramdef> <paramdef>int <parameter>signo</parameter></paramdef> <paramdef>int <parameter>err_code</parameter></paramdef> <paramdef>char * <parameter>remcom_in_buffer</parameter></paramdef> <paramdef>char * <parameter>remcom_out_buffer</parameter></paramdef> <paramdef>struct pt_regs * <parameter>regs</parameter></paramdef> </funcprototype></funcsynopsis> </refsynopsisdiv> <refsect1> <title>Arguments</title> <variablelist> <varlistentry> <term><parameter>vector</parameter></term> <listitem> <para> The error vector of the exception that happened. </para> </listitem> </varlistentry> <varlistentry> <term><parameter>signo</parameter></term> <listitem> <para> The signal number of the exception that happened. </para> </listitem> </varlistentry> <varlistentry> <term><parameter>err_code</parameter></term> <listitem> <para> The error code of the exception that happened. </para> </listitem> </varlistentry> <varlistentry> <term><parameter>remcom_in_buffer</parameter></term> <listitem> <para> The buffer of the packet we have read. </para> </listitem> </varlistentry> <varlistentry> <term><parameter>remcom_out_buffer</parameter></term> <listitem> <para> The buffer of <constant>BUFMAX</constant> bytes to write a packet into. </para> </listitem> </varlistentry> <varlistentry> <term><parameter>regs</parameter></term> <listitem> <para> The <structname>struct pt_regs</structname> of the current process. </para> </listitem> </varlistentry> </variablelist> </refsect1> <refsect1> <title>Description</title> <para> This function MUST handle the 'c' and 's' command packets, as well packets to set / remove a hardware breakpoint, if used. If there are additional packets which the hardware needs to handle, they are handled here. The code should return -1 if it wants to process more packets, and a <constant>0</constant> or <constant>1</constant> if it wants to exit from the kgdb callback. </para> </refsect1> </refentry> <refentry id="API-kgdb-roundup-cpus"> <refentryinfo> <title>LINUX</title> <productname>Kernel Hackers Manual</productname> <date>June 2011</date> </refentryinfo> <refmeta> <refentrytitle><phrase>kgdb_roundup_cpus</phrase></refentrytitle> <manvolnum>9</manvolnum> <refmiscinfo class="version">2.6.32</refmiscinfo> </refmeta> <refnamediv> <refname>kgdb_roundup_cpus</refname> <refpurpose> Get other CPUs into a holding pattern </refpurpose> </refnamediv> <refsynopsisdiv> <title>Synopsis</title> <funcsynopsis><funcprototype> <funcdef>void <function>kgdb_roundup_cpus </function></funcdef> <paramdef>unsigned long <parameter>flags</parameter></paramdef> </funcprototype></funcsynopsis> </refsynopsisdiv> <refsect1> <title>Arguments</title> <variablelist> <varlistentry> <term><parameter>flags</parameter></term> <listitem> <para> Current IRQ state </para> </listitem> </varlistentry> </variablelist> </refsect1> <refsect1> <title>Description</title> <para> On SMP systems, we need to get the attention of the other CPUs and get them be in a known state. This should do what is needed to get the other CPUs to call <function>kgdb_wait</function>. Note that on some arches, the NMI approach is not used for rounding up all the CPUs. For example, in case of MIPS, <function>smp_call_function</function> is used to roundup CPUs. In this case, we have to make sure that interrupts are enabled before calling <function>smp_call_function</function>. The argument to this function is the flags that will be used when restoring the interrupts. There is <function>local_irq_save</function> call before <function>kgdb_roundup_cpus</function>. </para><para> On non-SMP systems, this is not called. </para> </refsect1> </refentry> <refentry id="API-struct-kgdb-arch"> <refentryinfo> <title>LINUX</title> <productname>Kernel Hackers Manual</productname> <date>June 2011</date> </refentryinfo> <refmeta> <refentrytitle><phrase>struct kgdb_arch</phrase></refentrytitle> <manvolnum>9</manvolnum> <refmiscinfo class="version">2.6.32</refmiscinfo> </refmeta> <refnamediv> <refname>struct kgdb_arch</refname> <refpurpose> Describe architecture specific values. </refpurpose> </refnamediv> <refsynopsisdiv> <title>Synopsis</title> <programlisting> struct kgdb_arch { unsigned char gdb_bpt_instr[BREAK_INSTR_SIZE]; unsigned long flags; int (* set_breakpoint) (unsigned long, char *); int (* remove_breakpoint) (unsigned long, char *); int (* set_hw_breakpoint) (unsigned long, int, enum kgdb_bptype); int (* remove_hw_breakpoint) (unsigned long, int, enum kgdb_bptype); void (* remove_all_hw_break) (void); void (* correct_hw_break) (void); }; </programlisting> </refsynopsisdiv> <refsect1> <title>Members</title> <variablelist> <varlistentry> <term>gdb_bpt_instr[BREAK_INSTR_SIZE]</term> <listitem><para> The instruction to trigger a breakpoint. </para></listitem> </varlistentry> <varlistentry> <term>flags</term> <listitem><para> Flags for the breakpoint, currently just <constant>KGDB_HW_BREAKPOINT</constant>. </para></listitem> </varlistentry> <varlistentry> <term>set_breakpoint</term> <listitem><para> Allow an architecture to specify how to set a software breakpoint. </para></listitem> </varlistentry> <varlistentry> <term>remove_breakpoint</term> <listitem><para> Allow an architecture to specify how to remove a software breakpoint. </para></listitem> </varlistentry> <varlistentry> <term>set_hw_breakpoint</term> <listitem><para> Allow an architecture to specify how to set a hardware breakpoint. </para></listitem> </varlistentry> <varlistentry> <term>remove_hw_breakpoint</term> <listitem><para> Allow an architecture to specify how to remove a hardware breakpoint. </para></listitem> </varlistentry> <varlistentry> <term>remove_all_hw_break</term> <listitem><para> Allow an architecture to specify how to remove all hardware breakpoints. </para></listitem> </varlistentry> <varlistentry> <term>correct_hw_break</term> <listitem><para> Allow an architecture to specify how to correct the hardware debug registers. </para></listitem> </varlistentry> </variablelist> </refsect1> </refentry> <refentry id="API-struct-kgdb-io"> <refentryinfo> <title>LINUX</title> <productname>Kernel Hackers Manual</productname> <date>June 2011</date> </refentryinfo> <refmeta> <refentrytitle><phrase>struct kgdb_io</phrase></refentrytitle> <manvolnum>9</manvolnum> <refmiscinfo class="version">2.6.32</refmiscinfo> </refmeta> <refnamediv> <refname>struct kgdb_io</refname> <refpurpose> Describe the interface for an I/O driver to talk with KGDB. </refpurpose> </refnamediv> <refsynopsisdiv> <title>Synopsis</title> <programlisting> struct kgdb_io { const char * name; int (* read_char) (void); void (* write_char) (u8); void (* flush) (void); int (* init) (void); void (* pre_exception) (void); void (* post_exception) (void); }; </programlisting> </refsynopsisdiv> <refsect1> <title>Members</title> <variablelist> <varlistentry> <term>name</term> <listitem><para> Name of the I/O driver. </para></listitem> </varlistentry> <varlistentry> <term>read_char</term> <listitem><para> Pointer to a function that will return one char. </para></listitem> </varlistentry> <varlistentry> <term>write_char</term> <listitem><para> Pointer to a function that will write one char. </para></listitem> </varlistentry> <varlistentry> <term>flush</term> <listitem><para> Pointer to a function that will flush any pending writes. </para></listitem> </varlistentry> <varlistentry> <term>init</term> <listitem><para> Pointer to a function that will initialize the device. </para></listitem> </varlistentry> <varlistentry> <term>pre_exception</term> <listitem><para> Pointer to a function that will do any prep work for the I/O driver. </para></listitem> </varlistentry> <varlistentry> <term>post_exception</term> <listitem><para> Pointer to a function that will do any cleanup work for the I/O driver. </para></listitem> </varlistentry> </variablelist> </refsect1> </refentry> </sect1> <sect1 id="kgdbocDesign"> <title>kgdboc internals</title> <para> The kgdboc driver is actually a very thin driver that relies on the underlying low level to the hardware driver having "polling hooks" which the to which the tty driver is attached. In the initial implementation of kgdboc it the serial_core was changed to expose a low level uart hook for doing polled mode reading and writing of a single character while in an atomic context. When kgdb makes an I/O request to the debugger, kgdboc invokes a call back in the serial core which in turn uses the call back in the uart driver. It is certainly possible to extend kgdboc to work with non-uart based consoles in the future. </para> <para> When using kgdboc with a uart, the uart driver must implement two callbacks in the <constant>struct uart_ops</constant>. Example from drivers/8250.c:<programlisting> #ifdef CONFIG_CONSOLE_POLL .poll_get_char = serial8250_get_poll_char, .poll_put_char = serial8250_put_poll_char, #endif </programlisting> Any implementation specifics around creating a polling driver use the <constant>#ifdef CONFIG_CONSOLE_POLL</constant>, as shown above. Keep in mind that polling hooks have to be implemented in such a way that they can be called from an atomic context and have to restore the state of the uart chip on return such that the system can return to normal when the debugger detaches. You need to be very careful with any kind of lock you consider, because failing here is most going to mean pressing the reset button. </para> </sect1> </chapter> <chapter id="credits"> <title>Credits</title> <para> The following people have contributed to this document: <orderedlist> <listitem><para>Amit Kale<email>amitkale@linsyssoft.com</email></para></listitem> <listitem><para>Tom Rini<email>trini@kernel.crashing.org</email></para></listitem> </orderedlist> In March 2008 this document was completely rewritten by: <itemizedlist> <listitem><para>Jason Wessel<email>jason.wessel@windriver.com</email></para></listitem> </itemizedlist> </para> </chapter> </book>