Documentation/DocBook/kgdb.tmpl

   1 <?xml version="1.0" encoding="UTF-8"?>
   2 <!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
   3         "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" []>
   4
   5 <book id="kgdbOnLinux">
   6  <bookinfo>
   7   <title>Using kgdb and the kgdb Internals</title>
   8
   9   <authorgroup>
  10    <author>
  11     <firstname>Jason</firstname>
  12     <surname>Wessel</surname>
  13     <affiliation>
  14      <address>
  15       <email>jason.wessel@windriver.com</email>
  16      </address>
  17     </affiliation>
  18    </author>
  19   </authorgroup>
  20
  21   <authorgroup>
  22    <author>
  23     <firstname>Tom</firstname>
  24     <surname>Rini</surname>
  25     <affiliation>
  26      <address>
  27       <email>trini@kernel.crashing.org</email>
  28      </address>
  29     </affiliation>
  30    </author>
  31   </authorgroup>
  32
  33   <authorgroup>
  34    <author>
  35     <firstname>Amit S.</firstname>
  36     <surname>Kale</surname>
  37     <affiliation>
  38      <address>
  39       <email>amitkale@linsyssoft.com</email>
  40      </address>
  41     </affiliation>
  42    </author>
  43   </authorgroup>
  44
  45   <copyright>
  46    <year>2008</year>
  47    <holder>Wind River Systems, Inc.</holder>
  48   </copyright>
  49   <copyright>
  50    <year>2004-2005</year>
  51    <holder>MontaVista Software, Inc.</holder>
  52   </copyright>
  53   <copyright>
  54    <year>2004</year>
  55    <holder>Amit S. Kale</holder>
  56   </copyright>
  57
  58   <legalnotice>
  59    <para>
  60    This file is licensed under the terms of the GNU General Public License
  61    version 2. This program is licensed "as is" without any warranty of any
  62    kind, whether express or implied.
  63    </para>
  64
  65   </legalnotice>
  66  </bookinfo>
  67
  68 <toc></toc>
  69   <chapter id="Introduction">
  70     <title>Introduction</title>
  71     <para>
  72     kgdb is a source level debugger for linux kernel. It is used along
  73     with gdb to debug a linux kernel.  The expectation is that gdb can
  74     be used to "break in" to the kernel to inspect memory, variables
  75     and look through call stack information similar to what an
  76     application developer would use gdb for.  It is possible to place
  77     breakpoints in kernel code and perform some limited execution
  78     stepping.
  79     </para>
  80     <para>
  81     Two machines are required for using kgdb. One of these machines is a
  82     development machine and the other is a test machine.  The kernel
  83     to be debugged runs on the test machine. The development machine
  84     runs an instance of gdb against the vmlinux file which contains
  85     the symbols (not boot image such as bzImage, zImage, uImage...).
  86     In gdb the developer specifies the connection parameters and
  87     connects to kgdb.  The type of connection a developer makes with
  88     gdb depends on the availability of kgdb I/O modules compiled as
  89     builtin's or kernel modules in the test machine's kernel.
  90     </para>
  91   </chapter>
  92   <chapter id="CompilingAKernel">
  93     <title>Compiling a kernel</title>
  94     <para>
  95     To enable <symbol>CONFIG_KGDB</symbol> you should first turn on
  96     "Prompt for development and/or incomplete code/drivers"
  97     (CONFIG_EXPERIMENTAL) in  "General setup", then under the
  98     "Kernel debugging" select "KGDB: kernel debugging with remote gdb".
  99     </para>
 100     <para>
 101     Next you should choose one of more I/O drivers to interconnect debugging
 102     host and debugged target.  Early boot debugging requires a KGDB
 103     I/O driver that supports early debugging and the driver must be
 104     built into the kernel directly. Kgdb I/O driver configuration
 105     takes place via kernel or module parameters, see following
 106     chapter.
 107     </para>
 108     <para>
 109     The kgdb test compile options are described in the kgdb test suite chapter.
 110     </para>
 111
 112   </chapter>
 113   <chapter id="EnableKGDB">
 114    <title>Enable kgdb for debugging</title>
 115    <para>
 116    In order to use kgdb you must activate it by passing configuration
 117    information to one of the kgdb I/O drivers.  If you do not pass any
 118    configuration information kgdb will not do anything at all.  Kgdb
 119    will only actively hook up to the kernel trap hooks if a kgdb I/O
 120    driver is loaded and configured.  If you unconfigure a kgdb I/O
 121    driver, kgdb will unregister all the kernel hook points.
 122    </para>
 123    <para>
 124    All drivers can be reconfigured at run time, if
 125    <symbol>CONFIG_SYSFS</symbol> and <symbol>CONFIG_MODULES</symbol>
 126    are enabled, by echo'ing a new config string to
 127    <constant>/sys/module/&lt;driver&gt;/parameter/&lt;option&gt;</constant>.
 128    The driver can be unconfigured by passing an empty string.  You cannot
 129    change the configuration while the debugger is attached.  Make sure
 130    to detach the debugger with the <constant>detach</constant> command
 131    prior to trying unconfigure a kgdb I/O driver.
 132    </para>
 133    <sect1 id="kgdbwait">
 134    <title>Kernel parameter: kgdbwait</title>
 135    <para>
 136    The Kernel command line option <constant>kgdbwait</constant> makes
 137    kgdb wait for a debugger connection during booting of a kernel.  You
 138    can only use this option you compiled a kgdb I/O driver into the
 139    kernel and you specified the I/O driver configuration as a kernel
 140    command line option.  The kgdbwait parameter should always follow the
 141    configuration parameter for the kgdb I/O driver in the kernel
 142    command line else the I/O driver will not be configured prior to
 143    asking the kernel to use it to wait.
 144    </para>
 145    <para>
 146    The kernel will stop and wait as early as the I/O driver and
 147    architecture will allow when you use this option.  If you build the
 148    kgdb I/O driver as a kernel module kgdbwait will not do anything.
 149    </para>
 150    </sect1>
 151   <sect1 id="kgdboc">
 152   <title>Kernel parameter: kgdboc</title>
 153   <para>
 154   The kgdboc driver was originally an abbreviation meant to stand for
 155   "kgdb over console".  Kgdboc is designed to work with a single
 156   serial port. It was meant to cover the circumstance
 157   where you wanted to use a serial console as your primary console as
 158   well as using it to perform kernel debugging.  Of course you can
 159   also use kgdboc without assigning a console to the same port.
 160   </para>
 161   <sect2 id="UsingKgdboc">
 162   <title>Using kgdboc</title>
 163   <para>
 164   You can configure kgdboc via sysfs or a module or kernel boot line
 165   parameter depending on if you build with CONFIG_KGDBOC as a module
 166   or built-in.
 167   <orderedlist>
 168   <listitem><para>From the module load or build-in</para>
 169   <para><constant>kgdboc=&lt;tty-device&gt;,[baud]</constant></para>
 170   <para>
 171   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>
 172   </para>
 173   </listitem>
 174   <listitem><para>From sysfs</para>
 175   <para><constant>echo ttyS0 &gt; /sys/module/kgdboc/parameters/kgdboc</constant></para>
 176   </listitem>
 177   </orderedlist>
 178   </para>
 179   <para>
 180   NOTE: Kgdboc does not support interrupting the target via the
 181   gdb remote protocol.  You must manually send a sysrq-g unless you
 182   have a proxy that splits console output to a terminal problem and
 183   has a separate port for the debugger to connect to that sends the
 184   sysrq-g for you.
 185   </para>
 186   <para>When using kgdboc with no debugger proxy, you can end up
 187   connecting the debugger for one of two entry points.  If an
 188   exception occurs after you have loaded kgdboc a message should print
 189   on the console stating it is waiting for the debugger.  In case you
 190   disconnect your terminal program and then connect the debugger in
 191   its place.  If you want to interrupt the target system and forcibly
 192   enter a debug session you have to issue a Sysrq sequence and then
 193   type the letter <constant>g</constant>.  Then you disconnect the
 194   terminal session and connect gdb.  Your options if you don't like
 195   this are to hack gdb to send the sysrq-g for you as well as on the
 196   initial connect, or to use a debugger proxy that allows an
 197   unmodified gdb to do the debugging.
 198   </para>
 199   </sect2>
 200   </sect1>
 201   <sect1 id="kgdbcon">
 202   <title>Kernel parameter: kgdbcon</title>
 203   <para>
 204   Kgdb supports using the gdb serial protocol to send console messages
 205   to the debugger when the debugger is connected and running.  There
 206   are two ways to activate this feature.
 207   <orderedlist>
 208   <listitem><para>Activate with the kernel command line option:</para>
 209   <para><constant>kgdbcon</constant></para>
 210   </listitem>
 211   <listitem><para>Use sysfs before configuring an io driver</para>
 212   <para>
 213   <constant>echo 1 &gt; /sys/module/kgdb/parameters/kgdb_use_con</constant>
 214   </para>
 215   <para>
 216   NOTE: If you do this after you configure the kgdb I/O driver, the
 217   setting will not take effect until the next point the I/O is
 218   reconfigured.
 219   </para>
 220   </listitem>
 221   </orderedlist>
 222   </para>
 223   <para>
 224   IMPORTANT NOTE: Using this option with kgdb over the console
 225   (kgdboc) is not supported.
 226   </para>
 227   </sect1>
 228   </chapter>
 229   <chapter id="ConnectingGDB">
 230   <title>Connecting gdb</title>
 231     <para>
 232     If you are using kgdboc, you need to have used kgdbwait as a boot
 233     argument, issued a sysrq-g, or the system you are going to debug
 234     has already taken an exception and is waiting for the debugger to
 235     attach before you can connect gdb.
 236     </para>
 237     <para>
 238     If you are not using different kgdb I/O driver other than kgdboc,
 239     you should be able to connect and the target will automatically
 240     respond.
 241     </para>
 242     <para>
 243     Example (using a serial port):
 244     </para>
 245     <programlisting>
 246     % gdb ./vmlinux
 247     (gdb) set remotebaud 115200
 248     (gdb) target remote /dev/ttyS0
 249     </programlisting>
 250     <para>
 251     Example (kgdb to a terminal server on tcp port 2012):
 252     </para>
 253     <programlisting>
 254     % gdb ./vmlinux
 255     (gdb) target remote 192.168.2.2:2012
 256     </programlisting>
 257     <para>
 258     Once connected, you can debug a kernel the way you would debug an
 259     application program.
 260     </para>
 261     <para>
 262     If you are having problems connecting or something is going
 263     seriously wrong while debugging, it will most often be the case
 264     that you want to enable gdb to be verbose about its target
 265     communications.  You do this prior to issuing the <constant>target
 266     remote</constant> command by typing in: <constant>set remote debug 1</constant>
 267     </para>
 268   </chapter>
 269   <chapter id="KGDBTestSuite">
 270     <title>kgdb Test Suite</title>
 271     <para>
 272     When kgdb is enabled in the kernel config you can also elect to
 273     enable the config parameter KGDB_TESTS.  Turning this on will
 274     enable a special kgdb I/O module which is designed to test the
 275     kgdb internal functions.
 276     </para>
 277     <para>
 278     The kgdb tests are mainly intended for developers to test the kgdb
 279     internals as well as a tool for developing a new kgdb architecture
 280     specific implementation.  These tests are not really for end users
 281     of the Linux kernel.  The primary source of documentation would be
 282     to look in the drivers/misc/kgdbts.c file.
 283     </para>
 284     <para>
 285     The kgdb test suite can also be configured at compile time to run
 286     the core set of tests by setting the kernel config parameter
 287     KGDB_TESTS_ON_BOOT.  This particular option is aimed at automated
 288     regression testing and does not require modifying the kernel boot
 289     config arguments.  If this is turned on, the kgdb test suite can
 290     be disabled by specifying "kgdbts=" as a kernel boot argument.
 291     </para>
 292   </chapter>
 293   <chapter id="CommonBackEndReq">
 294   <title>KGDB Internals</title>
 295   <sect1 id="kgdbArchitecture">
 296     <title>Architecture Specifics</title>
 297       <para>
 298       Kgdb is organized into three basic components:
 299       <orderedlist>
 300       <listitem><para>kgdb core</para>
 301       <para>
 302       The kgdb core is found in kernel/kgdb.c.  It contains:
 303       <itemizedlist>
 304       <listitem><para>All the logic to implement the gdb serial protocol</para></listitem>
 305       <listitem><para>A generic OS exception handler which includes sync'ing the processors into a stopped state on an multi cpu system.</para></listitem>
 306       <listitem><para>The API to talk to the kgdb I/O drivers</para></listitem>
 307       <listitem><para>The API to make calls to the arch specific kgdb implementation</para></listitem>
 308       <listitem><para>The logic to perform safe memory reads and writes to memory while using the debugger</para></listitem>
 309       <listitem><para>A full implementation for software breakpoints unless overridden by the arch</para></listitem>
 310       </itemizedlist>
 311       </para>
 312       </listitem>
 313       <listitem><para>kgdb arch specific implementation</para>
 314       <para>
 315       This implementation is generally found in arch/*/kernel/kgdb.c.
 316       As an example, arch/x86/kernel/kgdb.c contains the specifics to
 317       implement HW breakpoint as well as the initialization to
 318       dynamically register and unregister for the trap handlers on
 319       this architecture.  The arch specific portion implements:
 320       <itemizedlist>
 321       <listitem><para>contains an arch specific trap catcher which
 322       invokes kgdb_handle_exception() to start kgdb about doing its
 323       work</para></listitem>
 324       <listitem><para>translation to and from gdb specific packet format to pt_regs</para></listitem>
 325       <listitem><para>Registration and unregistration of architecture specific trap hooks</para></listitem>
 326       <listitem><para>Any special exception handling and cleanup</para></listitem>
 327       <listitem><para>NMI exception handling and cleanup</para></listitem>
 328       <listitem><para>(optional)HW breakpoints</para></listitem>
 329       </itemizedlist>
 330       </para>
 331       </listitem>
 332       <listitem><para>kgdb I/O driver</para>
 333       <para>
 334       Each kgdb I/O driver has to provide an implemenation for the following:
 335       <itemizedlist>
 336       <listitem><para>configuration via builtin or module</para></listitem>
 337       <listitem><para>dynamic configuration and kgdb hook registration calls</para></listitem>
 338       <listitem><para>read and write character interface</para></listitem>
 339       <listitem><para>A cleanup handler for unconfiguring from the kgdb core</para></listitem>
 340       <listitem><para>(optional) Early debug methodology</para></listitem>
 341       </itemizedlist>
 342       Any given kgdb I/O driver has to operate very closely with the
 343       hardware and must do it in such a way that does not enable
 344       interrupts or change other parts of the system context without
 345       completely restoring them. The kgdb core will repeatedly "poll"
 346       a kgdb I/O driver for characters when it needs input.  The I/O
 347       driver is expected to return immediately if there is no data
 348       available.  Doing so allows for the future possibility to touch
 349       watch dog hardware in such a way as to have a target system not
 350       reset when these are enabled.
 351       </para>
 352       </listitem>
 353       </orderedlist>
 354       </para>
 355       <para>
 356       If you are intent on adding kgdb architecture specific support
 357       for a new architecture, the architecture should define
 358       <constant>HAVE_ARCH_KGDB</constant> in the architecture specific
 359       Kconfig file.  This will enable kgdb for the architecture, and
 360       at that point you must create an architecture specific kgdb
 361       implementation.
 362       </para>
 363       <para>
 364       There are a few flags which must be set on every architecture in
 365       their &lt;asm/kgdb.h&gt; file.  These are:
 366       <itemizedlist>
 367         <listitem>
 368           <para>
 369           NUMREGBYTES: The size in bytes of all of the registers, so
 370           that we can ensure they will all fit into a packet.
 371           </para>
 372           <para>
 373           BUFMAX: The size in bytes of the buffer GDB will read into.
 374           This must be larger than NUMREGBYTES.
 375           </para>
 376           <para>
 377           CACHE_FLUSH_IS_SAFE: Set to 1 if it is always safe to call
 378           flush_cache_range or flush_icache_range.  On some architectures,
 379           these functions may not be safe to call on SMP since we keep other
 380           CPUs in a holding pattern.
 381           </para>
 382         </listitem>
 383       </itemizedlist>
 384       </para>
 385       <para>
 386       There are also the following functions for the common backend,
 387       found in kernel/kgdb.c, that must be supplied by the
 388       architecture-specific backend unless marked as (optional), in
 389       which case a default function maybe used if the architecture
 390       does not need to provide a specific implementation.
 391       </para>
 392 !Iinclude/linux/kgdb.h
 393   </sect1>
 394   <sect1 id="kgdbocDesign">
 395   <title>kgdboc internals</title>
 396   <para>
 397   The kgdboc driver is actually a very thin driver that relies on the
 398   underlying low level to the hardware driver having "polling hooks"
 399   which the to which the tty driver is attached.  In the initial
 400   implementation of kgdboc it the serial_core was changed to expose a
 401   low level uart hook for doing polled mode reading and writing of a
 402   single character while in an atomic context.  When kgdb makes an I/O
 403   request to the debugger, kgdboc invokes a call back in the serial
 404   core which in turn uses the call back in the uart driver.  It is
 405   certainly possible to extend kgdboc to work with non-uart based
 406   consoles in the future.
 407   </para>
 408   <para>
 409   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>
 410 #ifdef CONFIG_CONSOLE_POLL
 411         .poll_get_char = serial8250_get_poll_char,
 412         .poll_put_char = serial8250_put_poll_char,
 413 #endif
 414   </programlisting>
 415   Any implementation specifics around creating a polling driver use the
 416   <constant>#ifdef CONFIG_CONSOLE_POLL</constant>, as shown above.
 417   Keep in mind that polling hooks have to be implemented in such a way
 418   that they can be called from an atomic context and have to restore
 419   the state of the uart chip on return such that the system can return
 420   to normal when the debugger detaches.  You need to be very careful
 421   with any kind of lock you consider, because failing here is most
 422   going to mean pressing the reset button.
 423   </para>
 424   </sect1>
 425   </chapter>
 426   <chapter id="credits">
 427      <title>Credits</title>
 428         <para>
 429                 The following people have contributed to this document:
 430                 <orderedlist>
 431                         <listitem><para>Amit Kale<email>amitkale@linsyssoft.com</email></para></listitem>
 432                         <listitem><para>Tom Rini<email>trini@kernel.crashing.org</email></para></listitem>
 433                 </orderedlist>
 434                 In March 2008 this document was completely rewritten by:
 435                 <itemizedlist>
 436                 <listitem><para>Jason Wessel<email>jason.wessel@windriver.com</email></para></listitem>
 437                 </itemizedlist>
 438         </para>
 439   </chapter>
 440 </book>
 441