[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*.
Improvements in UDB (relevant to all customers)
Bundled GDB distribution updated to version 13.2
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
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.
Full release notes
Release notes in the docs include further details (e.g. including system requirements, deprecations)
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. 🙂