frysk - Execution Analysis And Debugging Technology

An overview of the frysk Execution Analysis Technology.


frysk Packages
frysk.config This package exports interfaces describing the environment within-which frysk was configured to run.
frysk.debuginfo This package implements frysk's low-level, or application binary interface, location expression model.
frysk.dwfl This package provides Dwfl objects for FRYSK's process model.
frysk.event Description of the FRYSK Event Loop.
frysk.expr This package implements frysk's expression handling.
frysk.expunit This package implements a simplistic version of expect that is suitable for use within the JUnit test framework.
frysk.gui.terminal This package supplies a wrapper for the Gnome Terminal object used by the Frysk Debug Window when it activates processes that require a terminal to interact with.
frysk.hpd This package implements a command line interpreter modeled after the High Performance Debugger Forum's interface.
frysk.isa This package provides an ISA (instruction set architecture) model of each architecture supported by frysk.
frysk.isa.banks A bank or block of data broken into into named locations.
frysk.isa.corefiles This package implements frysk's core-file generator code.
frysk.isa.registers This package implements frysk's Register abstraction.
frysk.isa.signals This package implements a representation of target signals.
frysk.isa.syscalls This package implements frysk's system-call database.
frysk.isa.watchpoints This package implements Frysk's Low level Watchpoint abstraction.
frysk.proc This package implements frysk's process model of the target system.
frysk.proc.dummy This package implements a dummy process model that can be used to test code that does not require a running process. This is a frysk implementation package that provides the implementation of frysk.proc for ptrace based (GNU/Linux) systems.
frysk.rsl This package provides a basic logger mechanism.
frysk.scopes Overview
frysk.solib This package provides mechanisms for constructing and tracking link-map and memory-maps from the link-map table found in a processes memory.
frysk.stack This package implements frysk's low-level, or application binary interface, stack model.
frysk.stepping This package implements frysk's stepping infrastructure.
frysk.symtab This package implements frysk's low-level, object, symbol table.
frysk.sys This package exports interfaces to the underlying native linux system.
frysk.sys.proc This package exports interfaces to the /proc pseudo file system.
frysk.sys.ptrace This package exports access to the PTRACE system.
frysk.sysroot This package implements frysk's sysroot support for handling a special system directory heirarchy.
frysk.testbed This package exports methods that can be used when testing.
frysk.value This package implements frysk's low-level, or application binary interface, type model.


Imported Packages  
inua.eio Simplistic 64-bit version of java.nio.
jline The core JLine API.


Native Bindings
lib.dwfl This package implements wrappers around elfutils.


An overview of the frysk Execution Analysis Technology.


At a high level, frysk's architecture can be viewed as a collection of clients that interact with frysk's core. frysk's core providing clients with alternate models of the system.

Frysk Interfaces

frysk then uses the target system's kernel interfaces to maintain its internal models.

Each of the components that make up frysk are discussed below.

frysk's Core

A Layered Architecture

An application running on a linux system can modeled at several different levels, each level providing a different of abstraction. For instance a distributed application, consisting of multiple processes and threads, running across multiple physical machines can be viewed, or modeled, as:
Each level of abstraction (or model) being implemented using the layers below.

This can be depicted visually as:

Layed Architecture

This structure is characterized as The Layered Architecture, and key benefits and characteristics of this architecture include:



In addition, a layered architecture, permits the distribution of components across a network. For instance, in the case of a cluster, and dependent on the performance requirements, one or more components may be local or remote:

Distributed Linux Process Layer

For further discussion of layered architectures, see Layered Architecture.

Kernel Interface

At the lowest level, is frysk's interface to underlying operating system (or kernel). The interface is implemented using frysk.sys, kernel level events as they arrive, being managed using frysk.event (frysk's event loop).

For instance, when implementing single-step, the kernel will generate stop events as illustrated by:

Single-step Requests and Notifications

For further information, see frysk.sys, and frysk.event.

Process Model

The Linux Process Layer abstracts the Kernel Layer, multi-processor machine in more exacting details. This abstraction models individual registers, the program-counter, and hardware breakpoints and watchpoints. It also implements more complex operations such as step-out-of-range (implemented using lower-level primitives).

See frysk.proc, for more information.

Language Model

The language model provides a source-language view of the running application. The model includes abstractions for high-level language concepts such as thread, frame and variable.

High level language support is implemented within this layer.

 Source Level Components

See frysk.lang, for more information.

Application Model

For an application distributed across multiple nodes of a cluster, there is an additional Cluster Layer, providing an overriding model of the system being debugged.

Command Line Interpreter

Built into frysk is a command line interpreter based on the specification published by the High Performance Debugger Forum.

Additional interpreters (such as adb), and scripting languages (such as scheme and Python) may be added at some stage in the future.

See frysk.cli.hpd for more information in frysk's existing interpreter.



See frysk.gui for a more detailed description of frysk's graphical interface.

Command Line Utilities

Frysk includes a number of command line utilities, at present they include: frysk.bin.ftrace to trace the system calls of running processes, frysk.bin.fstack to print the current stack of a running process. These utilities are implemented by directly interacting with frysk's process model:

 Debug Utilities

In the future, a stand-alone command-line tool, that provides a wrapper around frysk's built in High Performance Debugger Interpreter, or more traditional debugger interface (such as adb) may be added. For the moment, that interface is only available via the GUI.


There are many ways that Eclipse can exploit frysk. For instance, by using libgcj_db library, along with knowledge of the internals of a Java Virtual Machine (JVM) running within a process, an abstract model of a Java Virtual Machine can then be constructed. That model being exported to Eclipse using the Java Debug Wire Protocol (JDWP).

A Java Debug Wire Protocol Application Model