[New Release] UDB and LiveRecorder 7.0 for C/C++

Our engineering team just released a major new version of UDB and LiveRecorder 7.0 for C/C++ with the cheesy codename of Pecorino*.

This release includes the following improvements for UDB and LiveRecorder for C/C++.

Improvements in UDB (relevant to all customers)

Bundled GDB distribution updated to version 13.2

GDB is the debugger frontend which communicates with the Undo Engine to enable time travel debugging

In release 7.0, the version of GDB that is bundled with UDB is updated from 10.2 to 13.2. The main benefit of GDB 13.2 for our customers is that multithreaded symbol loading is now enabled by default. A number of other improvements are listed at https://www.sourceware.org/gdb/news/.

Support for self-service hardware optimisations

Linux software applications can communicate with device hardware through ioctl system calls. These calls can change any part of the application’s memory – the effect is defined by the writer of the device driver. When the Undo Engine reaches an ioctl call, it falls back to a safe-but-slow code path which checks the whole application memory for changes. In this circumstance, UDB prints a message to the user indicating that improved performance may be achieved if the ioctl calls are “optimised”.

Previously, customers have asked us to optimise the handling of certain ioctl calls, but this has two drawbacks:

• customers must reveal certain information to us about the calls they require to be optimised;
• customers must wait for us to re-release our product with the relevant improvements.

Release 7.0 allows users to optimise ioctl calls without revealing any sensitive hardware information to us, by writing a JSON configuration file with definitions of the ioctl calls that are to be optimised. More information is available at https://docs.undo.io/SelfServiceConfiguration.html

Support for encrypted symbol files

In applications built with their debugging information in a separate file to the executable itself, symbol files must be loaded into UDB in order to allow line-by-line time travel debugging.

In release 7.0, UDB allows those symbol files to be encrypted. Symbol files can be encrypted using the symbol-enc utility present in the release and loaded using the symbol-file GDB command as is used for unencrypted symbols. See https://docs.undo.io/SymbolEncryption.html for more information.

Early-access support for ARM64

Since the initial releases of UDB and LiveRecorder, Undo has supported applications and hardware platforms built for the 64-bit and 32-bit x86 instruction set architectures.

Release 7.0 provides the first public early access release of Undo UDB and LiveRecorder for the 64-bit ARM architecture family (AArch64). This release allows the recording and replaying of native (compiled) Linux processes using the UDB time travel debugger and the LiveRecorder API and command-line tool on the Graviton2 CPU as used in AWS EC2.

A number of limitations are present in this release:

• Only 4 kB memory pages are supported.
• The optional Scalable Vector Extension to ARMv8.2 is not supported.
• Certain LiveRecorder features are not supported on ARM64, most notably Thread Fuzzing.
• LiveRecorder and UDB are known to work well on Ubuntu 20.04 but may not be stable on certain Linux distributions, including but not limited to Ubuntu 22.04, openSUSE Leap and Red Hat Enterprise Linux 8.
• Performance improvements implemented in LiveRecorder for x86 will be ported to LiveRecorder for ARM64 in forthcoming releases.

As part of this major improvement, Undo is now a member of the Arm Partner Ecosystem.

 

Improvements relevant to LiveRecorder customers

Persistent state between UDB sessions with loaded recordings

Over the course of a debugging session involving a loaded recording, a substantial amount of session state may be accumulated in the form of breakpoint and watchpoint settings, current time and thread information, the ugo undo / ugo redo stack, minimum / maximum time limits, the wall-clock timezone, and signal handling information.

In previous releases, only bookmarks were restored from the previous debugging session, and quitting UDB would cause the additional state listed above to be lost. In release 7.0, this state is now restored when loading a previously-loaded LiveRecorder recording.

Automatic recording of user-selected subprocesses in a process tree

In applications consisting of more than one software process, for example when a process of interest is started by a simple wrapper script, it can be desirable to record one or more intermediate processes in a process tree. In previous releases, it was necessary either to attach to the process of interest directly or to modify application wrapper scripts to invoke the  live-record tool.

In release 7.0, the live-record tool now provides a new parameter to the --record-on option which allows recording to start when execution reaches a specified function, or when the name of the program or any of its descendants matches a specified pattern. For more information, see https://docs.undo.io/UsingTheLiveRecorderTool.html.

Faster loading of recordings

In release 7.0, UDB uses multiple threads to unpack files when loading recordings saved by LiveRecorder 7.0. This can reduce the time to load recordings by up to 40%, when the recording contains many large files, and when reading from the disk is fast enough.

 

Privacy policy updates

The Undo privacy policy has been updated and UDB 7.0 collects usage statistics in line with the updated policy. UDB can now collect anonymized usage data and handle it separately from personally-identifiable data collected for licensing reasons. Users can control which usage statistics are shared with Undo via the set share-usage-statistics command. In the interest of transparency, all the collected information is documented in the docs.

 

Full release notes

Release notes in  the docs  include further details (e.g. including system requirements, deprecations)

*Pecorino

We ❤️ cheese, so we name all of our releases after some of them. What on earth is Pecorino cheese? Check out wikipedia to see if it might be for you. 🙂