#316

Build # #316

Build Type

push

Committed by

Commit Message

Update date

Run Details

3013 of 3812 relevant lines covered (79.04%)

181974.77 hits per line

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

38.64

/src/process_handling/linux.rs

use crate::config::types::Mode;
use crate::errors::*;
use crate::process_handling::execute_test;
use crate::ptrace_control::*;
use crate::Config;
use crate::TestBinary;
use crate::TestHandle;
use lazy_static::lazy_static;
use nix::sched::*;
use nix::sys::personality;
use nix::unistd::*;
use std::ffi::{CStr, CString};
use std::path::Path;
use tracing::{info, warn};

lazy_static! {
    static ref NUM_CPUS: usize = num_cpus::get();
}

/// Returns the coverage statistics for a test executable in the given workspace
pub fn get_test_coverage(
    test: &TestBinary,
    config: &Config,
    ignored: bool,
) -> Result<Option<TestHandle>, RunError> {
    if !test.path().exists() {
        warn!("Test at {} doesn't exist", test.path().display());
        return Ok(None);
    }

    // Solves CI issue when fixing #953 and #966 in PR #962
    let threads = if config.follow_exec { 1 } else { *NUM_CPUS };

    if let Err(e) = limit_affinity() {
        warn!("Failed to set processor affinity {}", e);
    }

    unsafe {
        match fork() {
            Ok(ForkResult::Parent { child }) => Ok(Some(TestHandle::Id(child))),
            Ok(ForkResult::Child) => {
                let bin_type = match config.command {
                    Mode::Test => "test",
                    Mode::Build => "binary",
                };
                info!("Launching {}", bin_type);
                execute_test(test, &[], ignored, config, Some(threads))?;
                Ok(None)
            }
            Err(err) => Err(RunError::TestCoverage(format!(
                "Failed to run test {}, Error: {}",
                test.path().display(),
                err
            ))),
        }
    }
}

fn disable_aslr() -> nix::Result<()> {
    let this = personality::get()?;
    personality::set(this | personality::Persona::ADDR_NO_RANDOMIZE).map(|_| ())
}

pub fn limit_affinity() -> nix::Result<()> {
    let this = Pid::this();
    // Get current affinity to be able to limit the cores to one of
    // those already in the affinity mask.
    let affinity = sched_getaffinity(this)?;
    let mut selected_cpu = 0;
    for i in 0..CpuSet::count() {
        if affinity.is_set(i)? {
            selected_cpu = i;
            break;
        }
    }
    let mut cpu_set = CpuSet::new();
    cpu_set.set(selected_cpu)?;
    sched_setaffinity(this, &cpu_set)
}

pub fn execute(
    test: &Path,
    argv: &[String],
    envar: &[(String, String)],
) -> Result<TestHandle, RunError> {
    let program = CString::new(test.display().to_string()).unwrap_or_default();
    disable_aslr().map_err(|e| RunError::TestRuntime(format!("ASLR disable failed: {e}")))?;

    request_trace().map_err(|e| RunError::Trace(e.to_string()))?;

    let envar = envar
        .iter()
        .map(|(k, v)| CString::new(format!("{k}={v}").as_str()).unwrap_or_default())
        .collect::<Vec<CString>>();

    let argv = argv
        .iter()
        .map(|x| CString::new(x.as_str()).unwrap_or_default())
        .collect::<Vec<CString>>();

    let arg_ref = argv.iter().map(AsRef::as_ref).collect::<Vec<&CStr>>();
    let env_ref = envar.iter().map(AsRef::as_ref).collect::<Vec<&CStr>>();
    execve(&program, &arg_ref, &env_ref).map_err(|_| RunError::Internal)?;

    unreachable!();
}

1	use crate::config::types::Mode;
2	use crate::errors::*;
3	use crate::process_handling::execute_test;
4	use crate::ptrace_control::*;
5	use crate::Config;
6	use crate::TestBinary;
7	use crate::TestHandle;
8	use lazy_static::lazy_static;
9	use nix::sched::*;
10	use nix::sys::personality;
11	use nix::unistd::*;
12	use std::ffi::{CStr, CString};
13	use std::path::Path;
14	use tracing::{info, warn};
15
16	lazy_static! {
17	static ref NUM_CPUS: usize = num_cpus::get();
18	}
19
20	/// Returns the coverage statistics for a test executable in the given workspace
21	pub fn get_test_coverage(	168✔
22	test: &TestBinary,
23	config: &Config,
24	ignored: bool,
25	) -> Result<Option<TestHandle>, RunError> {
26	if !test.path().exists() {	168✔
27	warn!("Test at {} doesn't exist", test.path().display());	×
28	return Ok(None);	×
29	}
30
31	// Solves CI issue when fixing #953 and #966 in PR #962
32	let threads = if config.follow_exec { 1 } else { *NUM_CPUS };	504✔
33
34	if let Err(e) = limit_affinity() {	168✔
35	warn!("Failed to set processor affinity {}", e);	×
36	}
37
38	unsafe {
39	match fork() {	168✔
40	Ok(ForkResult::Parent { child }) => Ok(Some(TestHandle::Id(child))),	168✔
41	Ok(ForkResult::Child) => {
42	let bin_type = match config.command {	×
43	Mode::Test => "test",	×
44	Mode::Build => "binary",	×
45	};
46	info!("Launching {}", bin_type);	×
47	execute_test(test, &[], ignored, config, Some(threads))?;	×
48	Ok(None)	×
49	}
50	Err(err) => Err(RunError::TestCoverage(format!(	×
51	"Failed to run test {}, Error: {}",	×
52	test.path().display(),	×
53	err	×
54	))),
55	}
56	}
57	}
58
59	fn disable_aslr() -> nix::Result<()> {	×
60	let this = personality::get()?;	×
61	personality::set(this \| personality::Persona::ADDR_NO_RANDOMIZE).map(\|_\| ())	×
62	}
63
64	pub fn limit_affinity() -> nix::Result<()> {	168✔
65	let this = Pid::this();	168✔
66	// Get current affinity to be able to limit the cores to one of
67	// those already in the affinity mask.
68	let affinity = sched_getaffinity(this)?;	336✔
69	let mut selected_cpu = 0;	168✔
70	for i in 0..CpuSet::count() {	336✔
71	if affinity.is_set(i)? {	168✔
72	selected_cpu = i;	168✔
73	break;	168✔
74	}
75	}
76	let mut cpu_set = CpuSet::new();	168✔
77	cpu_set.set(selected_cpu)?;	168✔
78	sched_setaffinity(this, &cpu_set)	168✔
79	}
80
81	pub fn execute(	×
82	test: &Path,
83	argv: &[String],
84	envar: &[(String, String)],
85	) -> Result<TestHandle, RunError> {
86	let program = CString::new(test.display().to_string()).unwrap_or_default();	×
87	disable_aslr().map_err(\|e\| RunError::TestRuntime(format!("ASLR disable failed: {e}")))?;	×
88
89	request_trace().map_err(\|e\| RunError::Trace(e.to_string()))?;	×
90
91	let envar = envar	×
92	.iter()
93	.map(\|(k, v)\| CString::new(format!("{k}={v}").as_str()).unwrap_or_default())	×
94	.collect::<Vec<CString>>();
95
96	let argv = argv	×
97	.iter()
98	.map(\|x\| CString::new(x.as_str()).unwrap_or_default())	×
99	.collect::<Vec<CString>>();
100
101	let arg_ref = argv.iter().map(AsRef::as_ref).collect::<Vec<&CStr>>();	×
102	let env_ref = envar.iter().map(AsRef::as_ref).collect::<Vec<&CStr>>();	×
103	execve(&program, &arg_ref, &env_ref).map_err(\|_\| RunError::Internal)?;	×
104
105	unreachable!();
106	}

xd009642 / tarpaulin / #316

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