#dmesg #syslog #klogctl #printk

bin+lib rmesg

This is a fully Rust-based implementation of the popular dmesg Linux utility, giving programmatic access to the kernel log buffer

28 releases (stable)

new 1.0.21 Sep 25, 2023
1.0.20 Apr 29, 2022
1.0.19 Mar 3, 2022
1.0.18 Dec 23, 2021
0.5.0 Apr 30, 2020

#63 in Operating systems

Download history 3850/week @ 2023-06-06 2635/week @ 2023-06-13 3989/week @ 2023-06-20 3052/week @ 2023-06-27 5095/week @ 2023-07-04 3681/week @ 2023-07-11 6125/week @ 2023-07-18 3891/week @ 2023-07-25 6575/week @ 2023-08-01 5532/week @ 2023-08-08 5759/week @ 2023-08-15 4424/week @ 2023-08-22 5817/week @ 2023-08-29 4305/week @ 2023-09-05 4967/week @ 2023-09-12 3363/week @ 2023-09-19

19,394 downloads per month


1.5K SLoC

Build Status


A 'dmesg' implementation in Rust

As a crate: https://crates.io/crates/rmesg

As a command-line utility

Obtain the latest release binary

wget https://github.com/archisgore/rmesg/releases/latest/download/rmesg
chmod a+x ./rmesg
mv ./rmesg /usr/local/bin

Cargo Install

cargo install rmesg


rmesg: A 'dmesg' port onto Rust 1.0.0
Archis Gore <me@archisgore.com>
Reads (and prints) the kernel log buffer. Does not support all dmesg options (yet).

    rmesg [FLAGS] [OPTIONS]

    -c               Clear ring buffer after printing (only when using klogctl)
    -f               When specified, follows logs (like tail -f)
    -h, --help       Prints help information
    -r               Print raw data as it came from the source backend.
    -V, --version    Prints version information

    -b <backend>        Select backend from where to read the logs. klog is the syslog/klogctl system call through libc.
                        kmsg is the /dev/kmsg file. [possible values: klogctl, devkmsg]

As a Crate

The real value of this crate is programmatic access to kernel buffer from Rust programs, allowing a dmesg that can be consumed programmatically.

The complete API can be found in the main.rs file which uses the sync/async versions of the APIs, both single-shot and iterative.

Depend on the rmesg crate

Include it in Cargo.toml:

rmesg = "1.0.0"

Suppots two features:

  • async - Exposes asynchronous Stream API
  • sync - Exposes synchronous Iterator API

Reading the buffer single-shot (non-blocking)

NOTE: Reading single-shot is the same interface for sync or async

    use rmesg;

    // Read all logs as one big string with line-breaks
    let raw = rmesg::logs_raw(opts.backend, opts.clear).unwrap();
    print!("{}", raw)

    // Read logs as a Vec of Entry'ies (`Vec<Entry>`)
    // and can be processed entry-by-entry
    let entries = rmesg::log_entries(opts.backend, opts.clear).unwrap();
    for entry in entries {
        println!("{}", entry)

Indefinitely iterating

With feature sync (i.e. synchronous), provides an Iterator over Result<Entry, RMesgError>.

    use rmesg;

    let entries = rmesg::logs_iter(opts.backend, opts.clear, opts.raw)?;
    for maybe_entry in entries {
        let entry = maybe_entry?;
        println!("{}", entry);

With feature async (i.e. asynchronous), provides a Stream over Result<Entry, RMesgError>.

    use rmesg;

    // given that it's a stream over Result's, use the conveniences provided to us
    use futures_util::stream::TryStreamExt;

    let mut entries = rmesg::logs_stream(opts.backend, opts.clear, opts.raw).await?;

    while let Some(entry) = entries.try_next().await? {
        println!("{}", entry);


~193K SLoC