name: String,

func: Box<dyn Fn() -> Result<T, E>>,

passing: HashSet<TestEnvironment>,

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

f.debug_struct("ShadowTest")

.field("name", &self.name)

.field("passing", &self.passing)

.finish()

}

pub fn new(

name: &str,

func: impl Fn() -> Result<T, E> + 'static,

passing: HashSet<TestEnvironment>,

) -> Self {

Self {

name: name.to_string(),

func: Box::new(func),

passing,

}

}

pub fn run(&self) -> Result<T, E> {

(self.func)()

}

pub fn name(&self) -> &str {

&self.name

}

pub fn passing(&self, environment: TestEnvironment) -> bool {

self.passing.contains(&environment)

}

I: IntoIterator<Item = &'a ShadowTest<T, E>>,

E: 'a + std::fmt::Debug + std::fmt::Display,

let mut results = vec![];

for test in tests {

print!("Testing {}...", test.name());

std::io::stdout().flush().unwrap();

match test.run() {

Err(failure) => {

println!(" ✗ ({failure})");

if !summarize {

return Err(failure);

}

}

Ok(result) => {

results.push(result);

println!(" ✓");

}

}

}

Ok(results)

fn as_ptr(&self) -> *const T {

match self {

Some(v) => std::ptr::from_ref(v),

None => std::ptr::null(),

}

}

fn as_mut_ptr(&mut self) -> *mut T {

match self {

Some(v) => std::ptr::from_mut(v),

None => std::ptr::null_mut(),

}

}

if cond {

Ok(())

} else {

Err(message.to_string())

}

T: std::fmt::Debug + std::cmp::PartialEq,

if a == b {

Ok(())

} else {

Err(format!("{a:?} != {b:?} -- {message}"))

}

T: std::fmt::Debug + std::cmp::PartialEq,

if a != b {

Ok(())

} else {

Err(format!("{a:?} == {b:?} -- {message}"))

}

T: std::fmt::Debug + std::cmp::PartialOrd,

if a < b {

Ok(())

} else {

Err(format!("!({a:?} < {b:?}) -- {message}"))

}

T: std::fmt::Debug + std::cmp::PartialOrd,

if a > b {

Ok(())

} else {

Err(format!("!({a:?} > {b:?}) -- {message}"))

}

I: IntoIterator<Item = &'a libc::c_int>,

F: FnOnce() -> U,

let rv = f();

for fd in fds.into_iter() {

let rv_close = unsafe { libc::close(*fd) };

assert_eq!(rv_close, 0, "Could not close fd {fd}");

}

rv

let cstr;

unsafe {

let error_ptr = libc::strerror(errno);

cstr = std::ffi::CStr::from_ptr(error_ptr)

}

cstr.to_string_lossy().into_owned()

($f: expr) => {{

let result = $f;

let errno = test_utils::get_errno();

let errno_str =

linux_api::errno::Errno::from_u16(errno as u16).expect("errno is not valid");

assert!(

result,

"assertion failed: {} (errno: {})",

stringify!($f),

errno_str

);

errno

}};

($f: expr, $expected_errnos: expr $(,)?) => {

test_utils::check_system_call($f, $expected_errnos, line!());

};

f: F,

expected_errnos: &[libc::c_int],

line: u32,

) -> Result<J, String>

F: FnOnce() -> J,

J: std::cmp::Ord + std::convert::From<i8> + Copy + std::fmt::Display,

let rv = f();

let errno = get_errno();

if expected_errnos.is_empty() {

// if no error is expected (rv should be >= 0)

if rv < 0.into() {

return Err(format!(

"Expecting a non-negative return value, received {} \"{}\" [line {}]",

rv,

get_errno_message(errno),

line,

));

}

} else {

// if we expect the system call to return an error (rv should be -1)

if rv != (-1).into() {

return Err(format!(

"Expecting a return value of -1, received {rv} [line {line}]",

));

}

if !expected_errnos.contains(&errno) {

return Err(format!(

"Expecting errnos {:?}, received {} \"{}\" [line {}]",

expected_errnos,

errno,

get_errno_message(errno),

line,

));

}

}

Ok(rv)

() => (

std::collections::HashSet::new()

);

($($x:expr),+ $(,)?) => (

([$($x),+]).iter().cloned().collect::<std::collections::HashSet<_>>()

);

// There is the same function in the C tests common code

let Ok(ld_preload) = std::env::var("LD_PRELOAD") else {

return false;

};

ld_preload.contains("libshadow_injector.so")

let mut poll_fds = [nix::poll::PollFd::new(fd, PollFlags::POLLIN)];

let count = nix::poll::poll(&mut poll_fds, timeout_ms)?;

Ok(count > 0 && poll_fds[0].revents().unwrap().contains(PollFlags::POLLIN))

let mut poll_fds = [nix::poll::PollFd::new(fd, PollFlags::POLLOUT)];

let count = nix::poll::poll(&mut poll_fds, timeout_ms)?;

Ok(count > 0 && poll_fds[0].revents().unwrap().contains(PollFlags::POLLOUT))

let mut poll_fds = [nix::poll::PollFd::new(fd, PollFlags::all())];

let _count = nix::poll::poll(&mut poll_fds, timeout_ms)?;

Ok(poll_fds[0].revents().unwrap_or(PollFlags::empty()))

/// Creates an Interruptor that will send `signo` to the current thread

/// after `t` has elapsed (unless cancelled in the meantime).

pub fn new(t: Duration, signal: signal::Signal) -> Self {

let (sender, receiver) = mpsc::channel();

let tid = nix::unistd::gettid();

let handle = thread::spawn(move || {

if receiver.recv_timeout(t).is_ok() {

// Cancelled

return;

} // else Timed out.

unsafe { libc::syscall(libc::SYS_tkill, tid.as_raw(), signal as i32) };

});

Self {

cancellation_sender: sender,

handle: Some(handle),

}

}

/// Cancel the interruption.

pub fn cancel(&mut self) {

if let Some(handle) = self.handle.take() {

// Send a cancellation message. Ignore failure,

// which will happen if the thread has already exited,

// closing the receiver side of the channel.

self.cancellation_sender.send(()).ok();

handle.join().unwrap();

}

}

fn drop(&mut self) {

self.cancel();

}

unsafe {

nix::sys::signal::sigaction(

signal,

&nix::sys::signal::SigAction::new(

nop_sig_handler(),

nix::sys::signal::SaFlags::empty(),

nix::sys::signal::SigSet::empty(),

),

)?

};

Ok(())

F: FnOnce() -> anyhow::Result<()>,

let signo = signal::Signal::SIGUSR1;

install_nop_signal_handler(signo)?;

// Start a thread that will interrupt us after the timeout.

let interruptor = Interruptor::new(interrupt_timeout, signo);

// Run the function, which may be interrupted.

f()?;

// Cancel the interruptor, in case it hasn't already fired.

drop(interruptor);

Ok(())

($lhs:expr, $ord:tt, $rhs:expr) => {

let eval_lhs = $lhs;

let eval_rhs = $rhs;

anyhow::ensure!(eval_lhs $ord eval_rhs, "!({:?} {} {:?})", eval_lhs, stringify!($ord), eval_rhs);

};

// assume that if try_from() was successful, then a direct cast would also be

assert!(s.iter().all(|x| i8::try_from(*x).is_ok()));

unsafe { std::slice::from_raw_parts(s.as_ptr() as *const i8, s.len()) }

// assume that if try_from() was successful, then a direct cast would also be

assert!(s.iter().all(|x| u8::try_from(*x).is_ok()));

unsafe { std::slice::from_raw_parts(s.as_ptr() as *const u8, s.len()) }

fn from(val: libc::itimerval) -> Self {

Self {

interval: TimeVal::from(val.it_interval),

value: TimeVal::from(val.it_value),

}

}

let mut old_value: libc::itimerval = unsafe { std::mem::zeroed() };

if unsafe {

libc::syscall(

libc::SYS_getitimer,

which,

std::ptr::from_mut(&mut old_value),

)

} == -1

{

return Err(nix::errno::Errno::last());

}

Ok(old_value.into())

let mut old_value: libc::itimerval = unsafe { std::mem::zeroed() };

if unsafe { libc::syscall(libc::SYS_setitimer, which, new_value, &mut old_value) } == -1 {

return Err(nix::errno::Errno::last());

}

Ok(old_value.into())

I: IntoIterator<Item = &'a T>,

T: AsRef<[u8]> + 'a + ?Sized,

iov.into_iter()

.map(|x| std::io::IoSlice::new(x.as_ref()))

.collect()

I: IntoIterator<Item = &'a mut T>,

T: AsMut<[u8]> + 'a + ?Sized,

iov.into_iter()

.map(|x| std::io::IoSliceMut::new(x.as_mut()))

.collect()

First,

Second,

Third,

Fourth,

Fifth,

Sixth,

/// The fuzz value to pass as an argument to a syscall.

pub value: T,

/// The expected result for passing the arg value into the syscall. If we expect the value to

/// produce an error, the expected rv and/or errno are encoded in `FuzzerError`.

pub expected_result: FuzzResult,

/// Create a new `FuzzArg` without manually specifying the `FuzzArg` struct.

pub fn new(value: T, expected_result: FuzzResult) -> Self {

FuzzArg::<T> {

value,

expected_result,

}

}

/// Encodes the order in which Linux checks the syscall args.

pub order: FuzzOrder,

/// If `Some`, this return value is expected as a syscall result.

pub rv: Option<libc::c_int>,

/// If `Some`, this errno value is expected as a syscall result.

pub errno: Option<libc::c_int>,

/// Encode that a new syscall error with priority `order` should have occurred, optionally

/// causing return val `rv` and/or `errno` to be returned.

pub fn new(order: FuzzOrder, rv: Option<libc::c_int>, errno: Option<libc::c_int>) -> Self {

FuzzError { order, rv, errno }

}

expected_results: Vec<FuzzResult>,

expected_success_rv: libc::c_int,

actual_rv: libc::c_int,

actual_errno: libc::c_int,

) -> anyhow::Result<()> {

// We want to ensure we have the correct error for invalid values.

let mut expected_errors = filter_discard_valid(&expected_results);

// Check the error according to the ordering defined by the caller.

expected_errors.sort();

if let Some(error) = expected_errors.first() {

// The caller encoded that this should have been error.

if let Some(expected_rv) = error.rv {

// The caller wants to validate the return value.

ensure_ord!(expected_rv, ==, actual_rv);

}

if let Some(expected_errno) = error.errno {

// The caller wants to validate the errno.

ensure_ord!(expected_errno, ==, actual_errno);

}

} else {

// The caller encoded that the syscall should have returned success.

ensure_ord!(expected_success_rv, ==, actual_rv);

}

Ok(())

expected: Duration,

tolerance: Duration,

f: F,

) -> anyhow::Result<()>

F: FnOnce() -> Result<(), E>,

anyhow::Error: From<E>,

let before = SystemTime::now();

f()?;

let after = SystemTime::now();

let actual = after.duration_since(before)?;

let diff = time::duration_abs_diff(expected, actual);

ensure_ord!(diff, <=, tolerance);

Ok(())