#panic-handler #panic-impl #panic #persist

no-std panic-persist

Persist panic messages in the targets' RAM

3 unstable releases

0.3.0 Sep 17, 2021
0.2.1 Nov 28, 2019
0.2.0 Nov 25, 2019

#772 in Embedded development

50 downloads per month


99 lines


Writes panic messages to a section of RAM

This crate contains an implementation of panic_fmt that logs panic messages to a region of RAM defined by the user, so that these messages can be retrieved on next boot, and handled outside of panic context, by sending to a logging interface, writing to flash, etc.

After logging the message to RAM, the device will be soft-reset automatically.

Unlike other methods this allows to discover the panic reason post-mortem using normal program control flow.

Currently this crate was only tested on ARM Cortex-M architecture but should be easily portable to other platforms as required.



Add a section to your linker script

You will need to reserve a section of RAM to be used to persist messages. This section must be large enough to hold the 8 byte header, as well as any panic messages you would like to persist. If there is not suitable space in the section, the panic message will be truncated.

This section should be outside of any other sections, to prevent program initialization from zeroing or otherwise modifying these sections on boot.

memory.x file before modification:

  /* NOTE K = KiBi = 1024 bytes */
  FLASH : ORIGIN  = 0x00000000, LENGTH = 512K
  RAM : ORIGIN    = 0x20000000, LENGTH = 64K

memory.x file after modification to hold a 1K region:

  /* NOTE K = KiBi = 1024 bytes */
  FLASH : ORIGIN  = 0x00000000, LENGTH = 512K
  RAM : ORIGIN    = 0x20000000, LENGTH = 63K

_panic_dump_start = ORIGIN(PANDUMP);
_panic_dump_end   = ORIGIN(PANDUMP) + LENGTH(PANDUMP);

Program Usage Example


use panic_persist as _;

fn main() -> ! {
    // Normal board setup...

    // Check if there was a panic message, if so, send to UART
    if let Some(msg) = get_panic_message_bytes() {

    // ...


There are a few optional features, utf8 and custom-panic-handler.


This allows the panic message to be returned as a &str rather than &[u8], for easier printing. As this requires the ability to validate the UTF-8 string (to ensure it wasn't truncated mid-character), it may increase code size usage, and is by default off.


This disables the panic handler from this library so that any user can implement their own. To persist panic messages, the function report_panic_info is made available;

// My custom panic implementation
fn panic(info: &PanicInfo) -> ! {
    // ...
    // ...


This prints a smaller, line-number-only message, in order to reduce space needed when persisting panics, at a loss of some context.


This crate was inspired (and forked from) the panic-ramdump crate.


Licensed under either of

at your option.


Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.