20350393628

Committed 18 Dec 2025 08:28PM UTC coverage: 32.588% (-1.3%) from 33.871%

Build # 20350393628

Build Type

Pull #82

github

Committed by

web-flow

Commit Message

Merge 7e3fecea0 into 2f4720aec

Pull Request Pull Request #82: Cleanup and refactor of daemon.rs

Coverage Stats

10 of 49 new or added lines in 6 files covered. (20.41%)

102 of 313 relevant lines covered (32.59%)

0.61 hits per line

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

0.0

/src/daemon.rs

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

use anyhow::{anyhow, Context, Result};
use std::process::{Command, Stdio};

use crate::kmsg::kmsg;
use crate::nvrc::NVRC;
use std::fs;

pub fn foreground(command: &str, args: &[&str]) -> Result<()> {
    debug!("{} {}", command, args.join(" "));

    let kmsg_file = kmsg().context("Failed to open kmsg device")?;
    let output = Command::new(command)
        .stdout(Stdio::from(kmsg_file.try_clone().unwrap()))
        .stderr(Stdio::from(kmsg_file))
        .args(args)
        .output()
        .context(format!("failed to execute {command}"))?;

    if !output.status.success() {
        return Err(anyhow!("{} failed with status: {}", command, output.status,));
    }
    Ok(())
}

fn background(command: &str, args: &[&str]) -> Result<()> {
    debug!("{} {}", command, args.join(" "));
    let kmsg_file = kmsg().context("Failed to open kmsg device")?;
    let mut child = Command::new(command)
        .args(args)
        .stdout(Stdio::from(kmsg_file.try_clone().unwrap()))
        .stderr(Stdio::from(kmsg_file))
        .spawn()
        .with_context(|| format!("Failed to start {}", command))?;

    match child.try_wait() {
        Ok(Some(status)) => Err(anyhow!("{} exited with status: {}", command, status)),
        Ok(None) => Ok(()),
        Err(e) => Err(anyhow!("Error attempting to wait: {}", e)),
    }
}

impl NVRC {
    pub fn nvidia_persistenced(&self) -> Result<()> {
        const DIR: &str = "/var/run/nvidia-persistenced";
        fs::create_dir_all(DIR).with_context(|| format!("create_dir_all {}", DIR))?;

        // UVM persistence mode: enabled by default, only "off" disables it
        let uvm_enabled = self.uvm_persistence_mode.as_deref() != Some("off");

        let args: &[&str] = if uvm_enabled {
            &["--verbose", "--uvm-persistence-mode"]
        } else {
            &["--verbose"]
        };

        background("/bin/nvidia-persistenced", args)
    }

    pub fn nv_hostengine(&mut self) -> Result<()> {
        if !self.dcgm_enabled.unwrap_or(false) {
            return Ok(());
        }
        background(
            "/bin/nv-hostengine",
            &["--service-account", "nvidia-dcgm", "--home-dir", "/tmp"],
        )
    }

    pub fn dcgm_exporter(&mut self) -> Result<()> {
        if !self.dcgm_enabled.unwrap_or(false) {
            return Ok(());
        }
        background(
            "/bin/dcgm-exporter",
            &["-k", "-f", "/etc/dcgm-exporter/default-counters.csv"],
        )
    }

    pub fn nv_fabricmanager(&mut self) -> Result<()> {
        if !self.fabricmanager_enabled.unwrap_or(false) {
            return Ok(());
        }
        background(
            "/bin/nv-fabricmanager",
            &["-c", "/usr/share/nvidia/nvswitch/fabricmanager.cfg"],
        )
    }
}

1	// SPDX-License-Identifier: Apache-2.0
2	// Copyright (c) NVIDIA CORPORATION
3
4	use anyhow::{anyhow, Context, Result};
5	use std::process::{Command, Stdio};
6
7	use crate::kmsg::kmsg;
8	use crate::nvrc::NVRC;
9	use std::fs;
10
11	pub fn foreground(command: &str, args: &[&str]) -> Result<()> {	×
12	debug!("{} {}", command, args.join(" "));	×
13
14	let kmsg_file = kmsg().context("Failed to open kmsg device")?;	×
15	let output = Command::new(command)	×
16	.stdout(Stdio::from(kmsg_file.try_clone().unwrap()))	×
17	.stderr(Stdio::from(kmsg_file))	×
18	.args(args)	×
19	.output()
20	.context(format!("failed to execute {command}"))?;	×
21
22	if !output.status.success() {	×
23	return Err(anyhow!("{} failed with status: {}", command, output.status,));	×
24	}
25	Ok(())	×
26	}
27
28	fn background(command: &str, args: &[&str]) -> Result<()> {	×
29	debug!("{} {}", command, args.join(" "));	×
30	let kmsg_file = kmsg().context("Failed to open kmsg device")?;	×
31	let mut child = Command::new(command)	×
32	.args(args)	×
33	.stdout(Stdio::from(kmsg_file.try_clone().unwrap()))	×
34	.stderr(Stdio::from(kmsg_file))	×
35	.spawn()
36	.with_context(\|\| format!("Failed to start {}", command))?;	×
37
38	match child.try_wait() {	×
39	Ok(Some(status)) => Err(anyhow!("{} exited with status: {}", command, status)),	×
40	Ok(None) => Ok(()),	×
41	Err(e) => Err(anyhow!("Error attempting to wait: {}", e)),	×
42	}
43	}
44
45	impl NVRC {
NEW 46	pub fn nvidia_persistenced(&self) -> Result<()> {	×
47	const DIR: &str = "/var/run/nvidia-persistenced";
NEW 48	fs::create_dir_all(DIR).with_context(\|\| format!("create_dir_all {}", DIR))?;	×
49
50	// UVM persistence mode: enabled by default, only "off" disables it
NEW 51	let uvm_enabled = self.uvm_persistence_mode.as_deref() != Some("off");	×
52
NEW 53	let args: &[&str] = if uvm_enabled {	×
NEW 54	&["--verbose", "--uvm-persistence-mode"]	×
55	} else {
NEW 56	&["--verbose"]	×
57	};
58
NEW 59	background("/bin/nvidia-persistenced", args)	×
60	}
61
62	pub fn nv_hostengine(&mut self) -> Result<()> {	×
63	if !self.dcgm_enabled.unwrap_or(false) {	×
64	return Ok(());	×
65	}
66	background(
67	"/bin/nv-hostengine",
68	&["--service-account", "nvidia-dcgm", "--home-dir", "/tmp"],
69	)
70	}
71
72	pub fn dcgm_exporter(&mut self) -> Result<()> {	×
73	if !self.dcgm_enabled.unwrap_or(false) {	×
74	return Ok(());	×
75	}
76	background(
77	"/bin/dcgm-exporter",
78	&["-k", "-f", "/etc/dcgm-exporter/default-counters.csv"],
79	)
80	}
81
82	pub fn nv_fabricmanager(&mut self) -> Result<()> {	×
83	if !self.fabricmanager_enabled.unwrap_or(false) {	×
84	return Ok(());	×
85	}
86	background(
87	"/bin/nv-fabricmanager",
88	&["-c", "/usr/share/nvidia/nvswitch/fabricmanager.cfg"],
89	)
90	}
91	}

NVIDIA / nvrc / 20350393628

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