frysk - Execution Analysis And Debugging Technology

An overview of the frysk Execution Analysis Technology.

See:
Description

frysk Packages

frysk.bindir
frysk.config	This package exports interfaces describing the environment within-which frysk was configured to run.
frysk.core
frysk.debuginfo	This package implements frysk's low-level, or application binary interface, location expression model.
frysk.dom
frysk.dom.cparser
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.ftrace
frysk.gtk
frysk.gui
frysk.gui.common
frysk.gui.console
frysk.gui.dialogs
frysk.gui.disassembler
frysk.gui.druid
frysk.gui.memory
frysk.gui.monitor
frysk.gui.monitor.actions
frysk.gui.monitor.datamodels
frysk.gui.monitor.eventviewer
frysk.gui.monitor.filters
frysk.gui.monitor.observers
frysk.gui.prefs
frysk.gui.register
frysk.gui.sessions
frysk.gui.srcwin
frysk.gui.srcwin.prefs
frysk.gui.srcwin.tags
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.gui.test
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.junit
frysk.pkglibdir
frysk.proc	This package implements frysk's process model of the target system.
frysk.proc.dead
frysk.proc.dummy	This package implements a dummy process model that can be used to test code that does not require a running process.
frysk.proc.live	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.rt
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.sys.termios
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.util
frysk.value	This package implements frysk's low-level, or application binary interface, type model.
frysk.vtecli

Imported Packages

gnu.classpath.tools.getopt
inua.eio	Simplistic 64-bit version of java.nio.
inua.elf
inua.util
jline	The core JLine API.
junit.awtui
junit.extensions
junit.framework
junit.runner
junit.swingui
junit.textui

Native Bindings

lib.dwfl	This package implements wrappers around elfutils.
lib.stdcpp
lib.unwind

An overview of the frysk Execution Analysis Technology.

Overview

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 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:

• A shared-memory multi-processor executing machine instructions on a local machine.
• A multi-threaded program written in C and using POSIX threads.
• A distributed application, made up of a number of programs distributed across multiple machines.

Each level of abstraction (or model) being implemented using the layers below.

This can be depicted visually as:

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

Benefits:

• Segmentation of high-level from low-level issues.
• The implementation details of a layer are hidden (abstracted) from other layers.
• Many upper layers can share the services of a lower layer.

Dynamics:

• Requests percolate downward between layers.
• Notifications percolate upward between layers.
• Layers can improve performance by caching requests.

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:

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:

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.

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.

Clients

GUI

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:

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.

Eclipse

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).