20321016685

Committed 17 Dec 2025 11:52PM UTC coverage: 34.332% (+0.5%) from 33.871%

Build # 20321016685

Build Type

Pull #82

github

Committed by

web-flow

Commit Message

Merge 3da25841a into 2f4720aec

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

Run Details

0 of 34 new or added lines in 3 files covered. (0.0%)

45 existing lines in 4 files now uncovered.

126 of 367 relevant lines covered (34.33%)

0.64 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 nix::sys::stat::Mode;
use nix::unistd::{chown, mkdir};
use std::path::Path;
use std::process::{Command, Stdio};

use crate::kmsg::kmsg;
use crate::nvrc::NVRC;

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(&mut self) -> Result<()> {
        let uvm_flag = match self.uvm_persistence_mode.as_deref() {
            Some("off") => None,
            Some("on") | None => Some("--uvm-persistence-mode"),
            Some(other) => {
                warn!(
                    "Unknown UVM persistence mode '{}', defaulting to 'on'",
                    other
                );
                Some("--uvm-persistence-mode")
            }
        };

        const DIR: &str = "/var/run/nvidia-persistenced"; // scoped constant for readability
        if !Path::new(DIR).exists() {
            mkdir(DIR, Mode::S_IRWXU).with_context(|| format!("Failed to create dir {}", DIR))?;
        }
        chown(
            DIR,
            Some(self.identity.user_id),
            Some(self.identity.group_id),
        )
        .with_context(|| format!("Failed to chown {}", DIR))?;

        let mut args: Vec<&str> = vec!["--verbose"];
        if let Some(f) = uvm_flag {
            args.push(f);
        }

        /*  TODO: nvidia-persistenced will not start with -u or -g flag in both modes

            let user = self.identity.user_name.clone();
            let group = self.identity.group_name.clone();

            args.extend_from_slice(&["-u", &user.to_owned(), "-g", &group.to_owned()]);
            background("/bin/nvidia-persistenced", &args)

        */

        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 nix::sys::stat::Mode;
6	use nix::unistd::{chown, mkdir};
7	use std::path::Path;
8	use std::process::{Command, Stdio};
9
10	use crate::kmsg::kmsg;
11	use crate::nvrc::NVRC;
12
UNCOV 13	pub fn foreground(command: &str, args: &[&str]) -> Result<()> {	×
14	debug!("{} {}", command, args.join(" "));	×
15
16	let kmsg_file = kmsg().context("Failed to open kmsg device")?;	×
17	let output = Command::new(command)	×
18	.stdout(Stdio::from(kmsg_file.try_clone().unwrap()))	×
UNCOV 19	.stderr(Stdio::from(kmsg_file))	×
20	.args(args)	×
21	.output()
22	.context(format!("failed to execute {command}"))?;	×
23
UNCOV 24	if !output.status.success() {	×
25	return Err(anyhow!("{} failed with status: {}", command, output.status,));	×
26	}
UNCOV 27	Ok(())	×
28	}
29
30	fn background(command: &str, args: &[&str]) -> Result<()> {	×
31	debug!("{} {}", command, args.join(" "));	×
32	let kmsg_file = kmsg().context("Failed to open kmsg device")?;	×
33	let mut child = Command::new(command)	×
34	.args(args)	×
UNCOV 35	.stdout(Stdio::from(kmsg_file.try_clone().unwrap()))	×
36	.stderr(Stdio::from(kmsg_file))	×
37	.spawn()
38	.with_context(\|\| format!("Failed to start {}", command))?;	×
39
40	match child.try_wait() {	×
41	Ok(Some(status)) => Err(anyhow!("{} exited with status: {}", command, status)),	×
UNCOV 42	Ok(None) => Ok(()),	×
UNCOV 43	Err(e) => Err(anyhow!("Error attempting to wait: {}", e)),	×
44	}
45	}
46
47	impl NVRC {
48	pub fn nvidia_persistenced(&mut self) -> Result<()> {	×
UNCOV 49	let uvm_flag = match self.uvm_persistence_mode.as_deref() {	×
50	Some("off") => None,	×
51	Some("on") \| None => Some("--uvm-persistence-mode"),	×
UNCOV 52	Some(other) => {	×
53	warn!(	×
54	"Unknown UVM persistence mode '{}', defaulting to 'on'",
55	other
56	);
57	Some("--uvm-persistence-mode")	×
58	}
59	};
60
61	const DIR: &str = "/var/run/nvidia-persistenced"; // scoped constant for readability
62	if !Path::new(DIR).exists() {	×
63	mkdir(DIR, Mode::S_IRWXU).with_context(\|\| format!("Failed to create dir {}", DIR))?;	×
64	}
65	chown(
66	DIR,
UNCOV 67	Some(self.identity.user_id),	×
UNCOV 68	Some(self.identity.group_id),	×
69	)
UNCOV 70	.with_context(\|\| format!("Failed to chown {}", DIR))?;	×
71
72	let mut args: Vec<&str> = vec!["--verbose"];	×
73	if let Some(f) = uvm_flag {	×
74	args.push(f);	×
75	}
76
77	/* TODO: nvidia-persistenced will not start with -u or -g flag in both modes
78
79	let user = self.identity.user_name.clone();
80	let group = self.identity.group_name.clone();
81
82	args.extend_from_slice(&["-u", &user.to_owned(), "-g", &group.to_owned()]);
83	background("/bin/nvidia-persistenced", &args)
84
85	*/
86
UNCOV 87	background("/bin/nvidia-persistenced", &args)	×
88	}
89
UNCOV 90	pub fn nv_hostengine(&mut self) -> Result<()> {	×
UNCOV 91	if !self.dcgm_enabled.unwrap_or(false) {	×
UNCOV 92	return Ok(());	×
93	}
94	background(
95	"/bin/nv-hostengine",
96	&["--service-account", "nvidia-dcgm", "--home-dir", "/tmp"],
97	)
98	}
99
UNCOV 100	pub fn dcgm_exporter(&mut self) -> Result<()> {	×
UNCOV 101	if !self.dcgm_enabled.unwrap_or(false) {	×
UNCOV 102	return Ok(());	×
103	}
104	background(
105	"/bin/dcgm-exporter",
106	&["-k", "-f", "/etc/dcgm-exporter/default-counters.csv"],
107	)
108	}
109
UNCOV 110	pub fn nv_fabricmanager(&mut self) -> Result<()> {	×
UNCOV 111	if !self.fabricmanager_enabled.unwrap_or(false) {	×
UNCOV 112	return Ok(());	×
113	}
114	background(
115	"/bin/nv-fabricmanager",
116	&["-c", "/usr/share/nvidia/nvswitch/fabricmanager.cfg"],
117	)
118	}
119	}

NVIDIA / nvrc / 20321016685

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