Structured binary data editor

[Jiri Svoboda]

Implement a tool to view and edit structured binary data, such as program memory structures (task memory, core file), file system structures, etc.

Details

The implementation should primarily consist of a versatile library that would provide:

• An API to dynamically (at run time) define and manipulate data structures (data schemas) comprising of typical basic and compound data types (integers, arrays, structs, unions, pointers)
• An API to enumerate the members of such data structures
• An API to compute field offsets (addresses)
• An API to read and write values of the members and traverse complex data structures using pointers (with custom pointer resolution routines)
• A parser which would provide a way to define the data structures (data schemas) in a textual representation (XML-based description, C-like type declaration or a DSL)
• A generator which would output the data structure definition in the textual representation which the library can parse again.
• Support for custom memory back-ends using code plug-ins (file, task memory [using udebug], block device)

The implementation should also contain readily available definitions for common data structures (either as code plug-ins or in the form of textural representation), e.g.:

• ubiquitous data structures (doubly-linked link lists, hash tables, etc.)
• ELF file format (with DWARF data)
• FAT file system structures
• ext2 file system structures

An interactive or command-based browser/editor should be provided on top of this library and data structure definitions. The library can be also integrated into other applications, such as the debugger.

What Gains and Benefits will this bring?

Easier debugging of file system drivers, easier debugging of running tasks and their live data, easier analysis of core dumps. The open design of the library/editor should make it great also for other future uses (analysis of application data files, etc.).

As the implementation of the library and to a major extend also the implementation of the end-user interactive editor can be done in standard-compliant C with little to no HelenOS-specific code, it can be also usable in other operating systems.

Difficulty

Medium

Required skills

A successful applicant will have good skills of programming in the C language and experience with designing reusable and extensible libraries with decent internal structure and public API. For the end-user interactive editor the ability to learn and use HelenOS-specific console manipulation routines is also expected.

Documentation

• Compact Type Format (compact kernel debugging information used by MDB for Solaris)
  • OpenSolaris headers: ​ctf.h, ​ctf_api.h
• ​DWARF debugging standard

Possible mentors

HelenOS Core Team, Martin Decky, Vojtech Horky

[Martin Decky]

Mostly merged into mainline and documented as Bithenge.