19144475043

Committed 06 Nov 2025 05:35PM UTC coverage: 36.62% (-1.5%) from 38.153%

Build # 19144475043

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #75 from zvonkok/address-soon-issues

refactor: address 'soon' issues from code analysis

Run Details

0 of 42 new or added lines in 5 files covered. (0.0%)

2 existing lines in 2 files now uncovered.

286 of 781 relevant lines covered (36.62%)

0.6 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/kmsg.rs

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) NVIDIA CORPORATION

use anyhow::{Context, Result};
use std::fs::{self, File, OpenOptions};
use std::io::{BufRead, BufReader};
use std::sync::mpsc;
use std::thread::{self, sleep, JoinHandle};
use std::time::Duration;

// Keep only poll interval constant (readability)
const POLL_INTERVAL: Duration = Duration::from_millis(100);

pub fn kernlog_setup() -> Result<()> {
    kernlog::init().context("kernel log init")?;
    log::set_max_level(log::LevelFilter::Off);
    // Write large buffer size to related kernel params
    for path in [
        "/proc/sys/net/core/rmem_default",
        "/proc/sys/net/core/wmem_default",
        "/proc/sys/net/core/rmem_max",
        "/proc/sys/net/core/wmem_max",
    ] {
        fs::write(path, b"16777216").with_context(|| format!("write {}", path))?;
    }
    Ok(())
}

pub fn kmsg() -> Result<File> {
    let path = if log_enabled!(log::Level::Debug) {
        "/dev/kmsg"
    } else {
        "/dev/null"
    };
    OpenOptions::new()
        .write(true)
        .open(path)
        .with_context(|| format!("open {}", path))
}

pub fn watch_for_pattern(
    pattern: &'static str,
    tx: mpsc::SyncSender<&'static str>,
) -> JoinHandle<()> {
    thread::spawn(move || {
        let file = match File::open("/dev/kmsg") {
            Ok(f) => f,
            Err(e) => {
                log::error!("open /dev/kmsg: {}", e);
                return;
            }
        };
        let mut reader = BufReader::new(file);
        let mut line = String::new();
        let mut last_seq = 0u64;
        loop {
            line.clear();
            match reader.read_line(&mut line) {
                Ok(0) => {
                    sleep(POLL_INTERVAL);
                    continue;
                }
                Ok(_) => {
                    if let Some(seq) = parse_kmsg_sequence(&line) {
                        if seq <= last_seq {
                            continue;
                        }
                        last_seq = seq;
                    }
                    if line.contains(pattern) && tx.send("hot-unplug").is_err() {
                        log::error!("send pattern notification failed");
                        break;
                    }
                }
                Err(e) => {
                    log::error!("read /dev/kmsg: {}", e);
                    sleep(POLL_INTERVAL);
                }
            }
        }
    })
}

fn parse_kmsg_sequence(line: &str) -> Option<u64> {
    line.split(',').nth(1)?.parse().ok()
}

1	// SPDX-License-Identifier: Apache-2.0
2	// Copyright (c) NVIDIA CORPORATION
3
4	use anyhow::{Context, Result};
5	use std::fs::{self, File, OpenOptions};
6	use std::io::{BufRead, BufReader};
7	use std::sync::mpsc;
8	use std::thread::{self, sleep, JoinHandle};
9	use std::time::Duration;
10
11	// Keep only poll interval constant (readability)
12	const POLL_INTERVAL: Duration = Duration::from_millis(100);
13
14	pub fn kernlog_setup() -> Result<()> {	×
15	kernlog::init().context("kernel log init")?;	×
16	log::set_max_level(log::LevelFilter::Off);	×
17	// Write large buffer size to related kernel params
18	for path in [	×
19	"/proc/sys/net/core/rmem_default",
20	"/proc/sys/net/core/wmem_default",
21	"/proc/sys/net/core/rmem_max",
22	"/proc/sys/net/core/wmem_max",
23	] {
24	fs::write(path, b"16777216").with_context(\|\| format!("write {}", path))?;	×
25	}
26	Ok(())	×
27	}
28
29	pub fn kmsg() -> Result<File> {	×
30	let path = if log_enabled!(log::Level::Debug) {	×
31	"/dev/kmsg"	×
32	} else {
33	"/dev/null"	×
34	};
35	OpenOptions::new()	×
36	.write(true)
37	.open(path)	×
38	.with_context(\|\| format!("open {}", path))	×
39	}
40
NEW 41	pub fn watch_for_pattern(	×
42	pattern: &'static str,
43	tx: mpsc::SyncSender<&'static str>,
44	) -> JoinHandle<()> {
45	thread::spawn(move \|\| {	×
46	let file = match File::open("/dev/kmsg") {	×
47	Ok(f) => f,	×
48	Err(e) => {	×
49	log::error!("open /dev/kmsg: {}", e);	×
50	return;
51	}
52	};
53	let mut reader = BufReader::new(file);	×
54	let mut line = String::new();	×
55	let mut last_seq = 0u64;	×
56	loop {
57	line.clear();	×
58	match reader.read_line(&mut line) {	×
59	Ok(0) => {
60	sleep(POLL_INTERVAL);	×
61	continue;
62	}
63	Ok(_) => {
64	if let Some(seq) = parse_kmsg_sequence(&line) {	×
65	if seq <= last_seq {	×
66	continue;
67	}
68	last_seq = seq;	×
69	}
70	if line.contains(pattern) && tx.send("hot-unplug").is_err() {	×
71	log::error!("send pattern notification failed");	×
72	break;
73	}
74	}
75	Err(e) => {	×
76	log::error!("read /dev/kmsg: {}", e);	×
77	sleep(POLL_INTERVAL);	×
78	}
79	}
80	}
81	})
82	}
83
84	fn parse_kmsg_sequence(line: &str) -> Option<u64> {	×
85	line.split(',').nth(1)?.parse().ok()	×
86	}

NVIDIA / nvrc / 19144475043

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous