Zentropix Launches First-Ever “In-the-Kernel” Symbolic Debugger at LinuxWorld

The Zentropix Remote Run-time Debugger (R2D2) has just been
dramatically extended to encompass applications running in kernel
space, as well as user space. This capability has not existed for
any Unix application until now. This is an extremely significant
event for developers for whom run-time performance is

The new version of the debugger affords the developer
non-intrusive symbolic access to parameters within real-time
threads and processes, while they are actually executing within the
kernel. It is undergoing beta testing and should be available for
general distribution in April.

The R2D2 Debugger is available at no charge for personal and
academic use, and $199 per seat license for commercial

For kernel based applications, such as device drivers, a
run-time debugger has not been available at all until now. As any
programmer is aware, code development within the kernel space is a
dangerous endeavor which can only too easily lead to a system
lock-up. One of the major benefits of the Zentropix System Builder,
which is scheduled for release in Q3 ’99, is to allow code to be
developed and debugged in the protected environment of user space
and then pushed down into kernel space once it is error free. For
examining such code once it is running in kernel space, the new
R2D2 kernel debugger becomes invaluable, allowing the developer to

  • navigate the data structures
  • access memory locations using the symbolic references used in
    the source code
  • examine data values in specific memory locations
  • change the data value in specific memory locations
  • conduct post run analysis (planned)
  • log specified events and code sequences for static post run
    analysis (planned)

Conventional software debugging tools require the developer to
place the control of the software under the debugger, rather than
the native execution environment. Typically, the normal interrupt
process is usurped and the software execution is controlled by the
debugger. The developer examines the software via insertion of
break-points, or by single-stepping through the code.

For many applications this is sufficient. But, where dynamic
interactions during the run-time may be significant, this procedure
has limitations. Since the code is not running in its intended
execution environment, dynamic effects and behavior of the code
interaction with other processes is not accurately represented.

For example, if the application code was intended to control a
servo motor, the developer would not be able to investigate the
behavior of the code and the variables while the program was
actually controlling the servo motor. The Zentropix non-intrusive
run-time debugger allows the developer to observe servo motor
behavior while adjusting the servo-loop feedback parameters.

For more information, visit the Zentropix website at http://www.zentropix.com/.