use std::ffi::c_int;
use std::mem::size_of_val;
use std::sync::{Arc, Mutex};
use std::time::Duration;
use snare_interpose::NetResult as HostResult;
use snare_interpose::{Domain, Host, Layer};
use crate::HashMap;
use crate::clock::{Clock, ClockLayer};
use crate::scope::SimShared;
use crate::win_cpu::Topology;
use windows_sys::Win32::Foundation::{
CloseHandle, CompareObjectHandles, DUPLICATE_SAME_ACCESS, DuplicateHandle, ERROR_ACCESS_DENIED,
ERROR_CALL_NOT_IMPLEMENTED, ERROR_INVALID_HANDLE, ERROR_INVALID_PARAMETER,
ERROR_NO_SYSTEM_RESOURCES, ERROR_NOT_SUPPORTED, ERROR_PRIVILEGE_NOT_HELD,
ERROR_PROCESS_MODE_ALREADY_BACKGROUND, ERROR_PROCESS_MODE_NOT_BACKGROUND,
ERROR_THREAD_MODE_ALREADY_BACKGROUND, ERROR_THREAD_MODE_NOT_BACKGROUND, GetLastError, HANDLE,
SetLastError, UNICODE_STRING,
};
use windows_sys::Win32::System::LibraryLoader::{GetModuleHandleW, GetProcAddress};
use windows_sys::Win32::System::Memory::{
QUOTA_LIMITS_HARDWS_MAX_DISABLE, QUOTA_LIMITS_HARDWS_MAX_ENABLE,
QUOTA_LIMITS_HARDWS_MIN_DISABLE, QUOTA_LIMITS_HARDWS_MIN_ENABLE,
};
use windows_sys::Win32::System::Threading::{
ABOVE_NORMAL_PRIORITY_CLASS, ALL_PROCESSOR_GROUPS, BELOW_NORMAL_PRIORITY_CLASS,
GetCurrentProcess, GetCurrentProcessId, GetCurrentThread, GetCurrentThreadId,
GetProcessIdOfThread, GetThreadId, HIGH_PRIORITY_CLASS, IDLE_PRIORITY_CLASS,
NORMAL_PRIORITY_CLASS, PROCESS_MODE_BACKGROUND_BEGIN, PROCESS_MODE_BACKGROUND_END,
PROCESS_QUERY_INFORMATION, PROCESS_QUERY_LIMITED_INFORMATION, PROCESS_SET_INFORMATION,
PROCESS_SET_LIMITED_INFORMATION, PROCESS_SET_QUOTA, REALTIME_PRIORITY_CLASS,
THREAD_MODE_BACKGROUND_BEGIN, THREAD_MODE_BACKGROUND_END, THREAD_PRIORITY_NORMAL,
THREAD_QUERY_INFORMATION, THREAD_QUERY_LIMITED_INFORMATION, THREAD_SET_INFORMATION,
THREAD_SET_LIMITED_INFORMATION,
};
#[derive(Clone)]
struct ThreadState {
priority: i32,
affinity: Option<u64>,
background_priority: Option<i32>,
power_throttling: PowerThrottling,
cpu_sets: Vec<u32>,
}
impl Default for ThreadState {
fn default() -> Self {
ThreadState {
priority: THREAD_PRIORITY_NORMAL,
affinity: None,
background_priority: None,
power_throttling: PowerThrottling::default(),
cpu_sets: Vec::new(),
}
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct PowerThrottling {
pub control_mask: u32,
pub state_mask: u32,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MmcssTask {
pub thread_id: u32,
pub task: String,
pub index: u32,
pub priority: i32,
}
const MMCSS_TASKS: [&str; 8] = [
"Audio",
"Capture",
"DisplayPostProcessing",
"Distribution",
"Games",
"Playback",
"Pro Audio",
"Window Manager",
];
const ERROR_INVALID_TASK_NAME: u32 = 1550;
const ERROR_INVALID_TASK_INDEX: u32 = 1551;
const ERROR_THREAD_ALREADY_IN_TASK: u32 = 1552;
const ERROR_INVALID_CPU_SET: u32 = 813;
const ERROR_BAD_LENGTH: u32 = 24;
const ERROR_INSUFFICIENT_BUFFER: u32 = 122;
const PROCESS_POWER_THROTTLING: c_int = 4;
const THREAD_POWER_THROTTLING: c_int = 3;
const PROCESS_THROTTLING_BITS: u32 = 0b111;
const THREAD_THROTTLING_BITS: u32 = 0b1;
const THROTTLING_STATE_SIZE: u32 = 12;
const FIRST_CPU_SET: u32 = 0x100;
const CPU_SET_RECORD: usize = 32;
struct NativeHandle(usize);
impl Drop for NativeHandle {
fn drop(&mut self) {
snare_interpose::real(|| unsafe { CloseHandle(self.0 as HANDLE) });
}
}
pub(crate) struct PreservedLastError(u32);
impl PreservedLastError {
pub(crate) fn new() -> Self {
Self(unsafe { GetLastError() })
}
}
impl Drop for PreservedLastError {
fn drop(&mut self) {
unsafe { SetLastError(self.0) };
}
}
type QueryObject =
unsafe extern "system" fn(HANDLE, i32, *mut std::ffi::c_void, u32, *mut u32) -> i32;
type StatusError = unsafe extern "system" fn(i32) -> u32;
#[repr(C)]
#[derive(Default)]
struct HandleBasic {
_attributes: u32,
granted_access: u32,
_handle_count: u32,
_pointer_count: u32,
_reserved: [u32; 10],
}
fn handle_access(handle: u64, kind: &str) -> Result<u32, u32> {
let _error = PreservedLastError::new();
static APIS: std::sync::OnceLock<Option<(QueryObject, StatusError)>> =
std::sync::OnceLock::new();
let (query, error) = APIS
.get_or_init(|| unsafe {
let library = GetModuleHandleW(windows_sys::core::w!("ntdll.dll"));
let query = GetProcAddress(library, c"NtQueryObject".as_ptr().cast())?;
let error = GetProcAddress(library, c"RtlNtStatusToDosError".as_ptr().cast())?;
Some((
std::mem::transmute::<unsafe extern "system" fn() -> isize, QueryObject>(query),
std::mem::transmute::<unsafe extern "system" fn() -> isize, StatusError>(error),
))
})
.ok_or(ERROR_CALL_NOT_IMPLEMENTED)?;
let mut basic = HandleBasic::default();
let status = unsafe {
query(
handle as HANDLE,
0,
std::ptr::from_mut(&mut basic).cast(),
size_of_val(&basic) as u32,
std::ptr::null_mut(),
)
};
if status < 0 {
return Err(unsafe { error(status) });
}
let mut buffer = [0usize; 128];
let status = unsafe {
query(
handle as HANDLE,
2,
buffer.as_mut_ptr().cast(),
size_of_val(&buffer) as u32,
std::ptr::null_mut(),
)
};
if status < 0 {
return Err(unsafe { error(status) });
}
let name = unsafe { &*buffer.as_ptr().cast::<UNICODE_STRING>() };
let name = unsafe { std::slice::from_raw_parts(name.Buffer, usize::from(name.Length) / 2) };
if !name.iter().copied().eq(kind.encode_utf16()) {
return Err(ERROR_INVALID_HANDLE);
}
Ok(basic.granted_access)
}
fn require_access(handle: u64, kind: &str, requirements: &[u32]) -> Result<(), u32> {
let access = handle_access(handle, kind)?;
if requirements.iter().any(|mask| access & mask == 0) {
return Err(ERROR_ACCESS_DENIED);
}
Ok(())
}
fn current_process(handle: u64, access: u32) -> Result<(), u32> {
let _error = PreservedLastError::new();
require_access(handle, "Process", &[access])?;
if unsafe { CompareObjectHandles(handle as HANDLE, GetCurrentProcess()) } == 0 {
return Err(ERROR_NOT_SUPPORTED);
}
Ok(())
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct WorkingSet {
pub min: usize,
pub max: usize,
pub flags: u32,
}
impl WorkingSet {
const INITIAL: WorkingSet = WorkingSet {
min: 204_800,
max: 1_413_120,
flags: QUOTA_LIMITS_HARDWS_MIN_DISABLE | QUOTA_LIMITS_HARDWS_MAX_DISABLE,
};
}
const PAGE: usize = 4096;
const MIN_WORKING_SET_PAGES: usize = 20;
const PHYSICAL_MEMORY: usize = 16 << 30;
struct HostState {
system_affinity: u64,
process_affinity: u64,
threads_per_core: u32,
priority_class: u32,
process_background: bool,
threads: Vec<(NativeHandle, ThreadState)>,
time_periods: HashMap<u32, u64>,
working_set: WorkingSet,
mmcss: Vec<(u64, MmcssTask)>,
next_mmcss_handle: u64,
mmcss_indices: Vec<(u32, String)>,
process_power_throttling: PowerThrottling,
process_cpu_sets: Vec<u32>,
}
impl HostState {
fn thread_by_id(&self, id: u32) -> Option<&ThreadState> {
let _error = PreservedLastError::new();
self.threads
.iter()
.find(|(handle, _)| unsafe { GetThreadId(handle.0 as HANDLE) } == id)
.map(|(_, state)| state)
}
fn cpus(&self) -> u32 {
self.system_affinity.count_ones()
}
fn topology(&self) -> Topology {
Topology {
cpus: self.cpus(),
threads_per_core: self.threads_per_core,
}
}
fn resolve(&mut self, handle: u64) -> Result<usize, u32> {
let _error = PreservedLastError::new();
if let Some(key) = self.threads.iter().position(|(known, _)| unsafe {
CompareObjectHandles(handle as HANDLE, known.0 as HANDLE) != 0
}) {
return Ok(key);
}
let process = unsafe { GetCurrentProcess() };
let mut pid = unsafe { GetProcessIdOfThread(handle as HANDLE) };
if pid == 0 {
let mut query = std::ptr::null_mut();
if unsafe {
DuplicateHandle(
process,
handle as HANDLE,
process,
&mut query,
THREAD_QUERY_LIMITED_INFORMATION,
0,
0,
)
} == 0
{
return Err(ERROR_NOT_SUPPORTED);
}
let query = NativeHandle(query as usize);
pid = unsafe { GetProcessIdOfThread(query.0 as HANDLE) };
}
if pid != unsafe { GetCurrentProcessId() } {
return Err(ERROR_NOT_SUPPORTED);
}
let mut owned = std::ptr::null_mut();
if unsafe {
DuplicateHandle(
process,
handle as HANDLE,
process,
&mut owned,
0,
0,
DUPLICATE_SAME_ACCESS,
)
} == 0
{
return Err(unsafe { GetLastError() });
}
self.threads
.push((NativeHandle(owned as usize), ThreadState::default()));
Ok(self.threads.len() - 1)
}
}
const REALTIME_BASE: i32 = 24;
const NORMAL_BASE: i32 = 8;
fn realtime_priority(priority: i32) -> i32 {
match priority {
..=-15 => -15,
15.. => 15,
_ => priority.clamp(-8, 7),
}
}
pub struct WinHost {
state: Mutex<HostState>,
shared: std::sync::OnceLock<std::sync::Weak<SimShared>>,
adapters: crate::win_adapter::Adapters,
}
impl WinHost {
fn new(cpus: usize, threads_per_core: usize) -> Self {
let cpus = cpus.clamp(1, 64);
let topology = Topology {
cpus: cpus as u32,
threads_per_core: threads_per_core.clamp(1, cpus) as u32,
};
WinHost {
state: Mutex::new(HostState {
system_affinity: topology.mask(),
process_affinity: topology.mask(),
threads_per_core: topology.threads_per_core,
priority_class: NORMAL_PRIORITY_CLASS,
process_background: false,
threads: Vec::new(),
time_periods: HashMap::default(),
working_set: WorkingSet::INITIAL,
mmcss: Vec::new(),
next_mmcss_handle: 0x4d4d_0004,
mmcss_indices: Vec::new(),
process_power_throttling: PowerThrottling::default(),
process_cpu_sets: Vec::new(),
}),
shared: std::sync::OnceLock::new(),
adapters: crate::win_adapter::Adapters::default(),
}
}
}
impl Host for WinHost {
fn set_thread_priority(&self, thread: u64, priority: c_int) -> Option<HostResult> {
if let Err(error) = require_access(
thread,
"Thread",
&[THREAD_SET_INFORMATION | THREAD_SET_LIMITED_INFORMATION],
) {
return Some(HostResult::Err(error as c_int));
}
let mut state = self.state.lock().unwrap();
let background = matches!(
priority,
THREAD_MODE_BACKGROUND_BEGIN | THREAD_MODE_BACKGROUND_END
);
if background {
let _error = PreservedLastError::new();
if unsafe { CompareObjectHandles(thread as HANDLE, GetCurrentThread()) } == 0 {
return Some(HostResult::Err(ERROR_INVALID_PARAMETER as c_int));
}
}
let realtime = state.priority_class == REALTIME_PRIORITY_CLASS;
if !background
&& !matches!(priority, -16 | -15 | -2..=2 | 15 | 16)
&& !(realtime && (-16..=16).contains(&priority))
{
return Some(HostResult::Err(ERROR_INVALID_PARAMETER as c_int));
}
let key = match state.resolve(thread) {
Ok(key) => key,
Err(error) => return Some(HostResult::Err(error as c_int)),
};
let background_priority = match state.priority_class {
IDLE_PRIORITY_CLASS => 0,
BELOW_NORMAL_PRIORITY_CLASS => -2,
ABOVE_NORMAL_PRIORITY_CLASS => -6,
HIGH_PRIORITY_CLASS => -9,
REALTIME_PRIORITY_CLASS => -20,
_ => -4,
};
let process_background = state.process_background;
let thread = &mut state.threads[key].1;
match priority {
THREAD_MODE_BACKGROUND_BEGIN => {
if thread.background_priority.is_some() {
return Some(HostResult::Err(
ERROR_THREAD_MODE_ALREADY_BACKGROUND as c_int,
));
}
if process_background {
return Some(HostResult::Err(
ERROR_PROCESS_MODE_ALREADY_BACKGROUND as c_int,
));
}
thread.background_priority = Some(thread.priority);
thread.priority = background_priority;
}
THREAD_MODE_BACKGROUND_END => {
let Some(priority) = thread.background_priority.take() else {
return Some(HostResult::Err(ERROR_THREAD_MODE_NOT_BACKGROUND as c_int));
};
thread.priority = priority;
}
_ if realtime => thread.priority = realtime_priority(priority),
_ => thread.priority = priority.clamp(-15, 15),
}
Some(HostResult::Ok(1))
}
fn get_thread_priority(&self, thread: u64) -> Option<HostResult> {
if let Err(error) = require_access(
thread,
"Thread",
&[THREAD_QUERY_INFORMATION | THREAD_QUERY_LIMITED_INFORMATION],
) {
return Some(HostResult::Err(error as c_int));
}
let mut state = self.state.lock().unwrap();
let key = match state.resolve(thread) {
Ok(key) => key,
Err(error) => return Some(HostResult::Err(error as c_int)),
};
Some(HostResult::Ok(state.threads[key].1.priority as i64))
}
fn set_thread_affinity_mask(&self, thread: u64, mask: u64) -> Option<HostResult> {
if let Err(error) = require_access(
thread,
"Thread",
&[THREAD_QUERY_INFORMATION | THREAD_QUERY_LIMITED_INFORMATION],
) {
return Some(HostResult::Err(error as c_int));
}
let mut state = self.state.lock().unwrap();
let process_affinity = state.process_affinity;
if mask == 0 || mask & !process_affinity != 0 {
return Some(HostResult::Err(ERROR_INVALID_PARAMETER as c_int));
}
if let Err(error) = require_access(
thread,
"Thread",
&[THREAD_SET_INFORMATION | THREAD_SET_LIMITED_INFORMATION],
) {
return Some(HostResult::Err(error as c_int));
}
let key = match state.resolve(thread) {
Ok(key) => key,
Err(error) => return Some(HostResult::Err(error as c_int)),
};
let entry = &mut state.threads[key].1;
let previous = entry.affinity.unwrap_or(process_affinity);
entry.affinity = Some(mask);
Some(HostResult::Ok(previous as i64))
}
fn set_priority_class(&self, process: u64, class: u32) -> Option<HostResult> {
if matches!(
class,
PROCESS_MODE_BACKGROUND_BEGIN | PROCESS_MODE_BACKGROUND_END
) {
if let Err(error) = current_process(process, PROCESS_SET_INFORMATION) {
return Some(HostResult::Err(error as c_int));
}
let mut state = self.state.lock().unwrap();
if class == PROCESS_MODE_BACKGROUND_BEGIN {
if state.process_background {
return Some(HostResult::Err(
ERROR_PROCESS_MODE_ALREADY_BACKGROUND as c_int,
));
}
state.process_background = true;
if state.priority_class == REALTIME_PRIORITY_CLASS {
for (_, thread) in &mut state.threads {
if thread.background_priority.is_none()
&& (-8..=7).contains(&thread.priority)
{
thread.priority += REALTIME_BASE - NORMAL_BASE;
}
}
}
state.priority_class = NORMAL_PRIORITY_CLASS;
} else {
if !state.process_background {
return Some(HostResult::Err(ERROR_PROCESS_MODE_NOT_BACKGROUND as c_int));
}
state.process_background = false;
}
return Some(HostResult::Ok(1));
}
let Some(class) = [
IDLE_PRIORITY_CLASS,
BELOW_NORMAL_PRIORITY_CLASS,
NORMAL_PRIORITY_CLASS,
ABOVE_NORMAL_PRIORITY_CLASS,
HIGH_PRIORITY_CLASS,
REALTIME_PRIORITY_CLASS,
]
.into_iter()
.find(|flag| class & flag != 0) else {
return Some(HostResult::Err(ERROR_INVALID_PARAMETER as c_int));
};
if let Err(error) = current_process(process, PROCESS_SET_INFORMATION) {
return Some(HostResult::Err(error as c_int));
}
let sys_nice = self
.shared
.get()
.and_then(std::sync::Weak::upgrade)
.is_none_or(|shared| shared.sys.privileges().sys_nice);
let class = if class == REALTIME_PRIORITY_CLASS && !sys_nice {
HIGH_PRIORITY_CLASS
} else {
class
};
self.state.lock().unwrap().priority_class = class;
Some(HostResult::Ok(1))
}
fn set_working_set(
&self,
process: u64,
min: usize,
max: usize,
flags: u32,
) -> Option<HostResult> {
if let Err(error) = current_process(process, PROCESS_SET_QUOTA) {
return Some(HostResult::Err(error as c_int));
}
if min == usize::MAX && max == usize::MAX {
return Some(HostResult::Ok(1));
}
let fail = |e: u32| Some(HostResult::Err(e as c_int));
let both_min = QUOTA_LIMITS_HARDWS_MIN_ENABLE | QUOTA_LIMITS_HARDWS_MIN_DISABLE;
let both_max = QUOTA_LIMITS_HARDWS_MAX_ENABLE | QUOTA_LIMITS_HARDWS_MAX_DISABLE;
if flags & both_min == both_min || flags & both_max == both_max {
return fail(ERROR_INVALID_PARAMETER);
}
let min = (min / PAGE * PAGE).max(MIN_WORKING_SET_PAGES * PAGE);
let max = max / PAGE * PAGE;
if min > max {
return fail(ERROR_INVALID_PARAMETER);
}
if min > PHYSICAL_MEMORY / 8 * 7 {
return fail(ERROR_NO_SYSTEM_RESOURCES);
}
let ipc_lock = self
.shared
.get()
.and_then(std::sync::Weak::upgrade)
.is_none_or(|shared| shared.sys.privileges().ipc_lock);
let mut state = self.state.lock().unwrap();
let current = state.working_set;
if (min > current.min || max > current.max) && !ipc_lock {
return fail(ERROR_PRIVILEGE_NOT_HELD);
}
let mut kept = current.flags;
if flags & both_min != 0 {
kept = (kept & !both_min) | (flags & both_min);
}
if flags & both_max != 0 {
kept = (kept & !both_max) | (flags & both_max);
}
state.working_set = WorkingSet {
min,
max,
flags: kept,
};
Some(HostResult::Ok(1))
}
unsafe fn get_working_set(
&self,
process: u64,
min: *mut usize,
max: *mut usize,
flags: *mut u32,
) -> Option<HostResult> {
if let Err(error) = current_process(
process,
PROCESS_QUERY_INFORMATION | PROCESS_QUERY_LIMITED_INFORMATION,
) {
return Some(HostResult::Err(error as c_int));
}
let ws = self.state.lock().unwrap().working_set;
unsafe {
if !min.is_null() {
min.write_unaligned(ws.min);
}
if !max.is_null() {
max.write_unaligned(ws.max);
}
if !flags.is_null() {
flags.write_unaligned(ws.flags);
}
}
Some(HostResult::Ok(1))
}
unsafe fn device(&self, call: snare_interpose::DevCall<'_>) -> Option<HostResult> {
let shared = self.shared.get()?.upgrade()?;
unsafe { self.adapters.call(&shared, call) }
}
fn get_priority_class(&self, process: u64) -> Option<HostResult> {
if let Err(error) = current_process(
process,
PROCESS_QUERY_INFORMATION | PROCESS_QUERY_LIMITED_INFORMATION,
) {
return Some(HostResult::Err(error as c_int));
}
Some(HostResult::Ok(
self.state.lock().unwrap().priority_class as i64,
))
}
unsafe fn av_set_mm_thread_characteristics(
&self,
task: &[u16],
task_index: *mut u32,
) -> Option<HostResult> {
let name = String::from_utf16_lossy(task);
let key = name.to_lowercase();
if !MMCSS_TASKS.iter().any(|t| t.to_lowercase() == key) {
return Some(HostResult::Err(ERROR_INVALID_TASK_NAME as c_int));
}
if task_index.is_null() {
return Some(HostResult::Err(ERROR_INVALID_PARAMETER as c_int));
}
let mut state = self.state.lock().unwrap();
let requested = unsafe { task_index.read_unaligned() };
if requested != 0
&& !state
.mmcss_indices
.iter()
.any(|(index, task)| *index == requested && *task == key)
{
return Some(HostResult::Err(ERROR_INVALID_TASK_INDEX as c_int));
}
let thread_id = unsafe { GetCurrentThreadId() };
if state.mmcss.iter().any(|(_, t)| t.thread_id == thread_id) {
return Some(HostResult::Err(ERROR_THREAD_ALREADY_IN_TASK as c_int));
}
let index = if requested == 0 {
let index = state.mmcss_indices.len() as u32 + 1;
state.mmcss_indices.push((index, key));
index
} else {
requested
};
unsafe { task_index.write_unaligned(index) };
let handle = state.next_mmcss_handle;
state.next_mmcss_handle += 4;
state.mmcss.push((
handle,
MmcssTask {
thread_id,
task: name,
index,
priority: 0,
},
));
Some(HostResult::Ok(handle as i64))
}
fn av_set_mm_thread_priority(&self, task: u64, priority: c_int) -> Option<HostResult> {
let mut state = self.state.lock().unwrap();
let Some((_, registration)) = state.mmcss.iter_mut().find(|(h, _)| *h == task) else {
return Some(HostResult::Err(ERROR_INVALID_HANDLE as c_int));
};
if !(-2..=2).contains(&priority) {
return Some(HostResult::Err(ERROR_INVALID_PARAMETER as c_int));
}
registration.priority = priority;
Some(HostResult::Ok(1))
}
fn av_revert_mm_thread_characteristics(&self, task: u64) -> Option<HostResult> {
let mut state = self.state.lock().unwrap();
let Some(at) = state.mmcss.iter().position(|(h, _)| *h == task) else {
return Some(HostResult::Err(ERROR_INVALID_HANDLE as c_int));
};
state.mmcss.remove(at);
Some(HostResult::Ok(1))
}
unsafe fn set_process_information(
&self,
process: u64,
class: c_int,
info: *const u8,
size: u32,
) -> Option<HostResult> {
if class != PROCESS_POWER_THROTTLING {
return None;
}
if let Err(error) = current_process(process, PROCESS_SET_INFORMATION) {
return Some(HostResult::Err(error as c_int));
}
if size != THROTTLING_STATE_SIZE || info.is_null() {
return Some(HostResult::Err(ERROR_BAD_LENGTH as c_int));
}
let throttling = match unsafe { read_throttling(info, 1..=1, PROCESS_THROTTLING_BITS) } {
Ok(t) => t,
Err(error) => return Some(HostResult::Err(error as c_int)),
};
self.state.lock().unwrap().process_power_throttling = throttling;
Some(HostResult::Ok(1))
}
unsafe fn get_process_information(
&self,
process: u64,
class: c_int,
info: *mut u8,
size: u32,
) -> Option<HostResult> {
if class != PROCESS_POWER_THROTTLING {
return None;
}
if let Err(error) = current_process(
process,
PROCESS_QUERY_INFORMATION | PROCESS_QUERY_LIMITED_INFORMATION,
) {
return Some(HostResult::Err(error as c_int));
}
if size != THROTTLING_STATE_SIZE || info.is_null() {
return Some(HostResult::Err(ERROR_BAD_LENGTH as c_int));
}
let throttling = self.state.lock().unwrap().process_power_throttling;
Some(match unsafe { write_throttling(info, throttling) } {
Ok(()) => HostResult::Ok(1),
Err(error) => HostResult::Err(error as c_int),
})
}
unsafe fn set_thread_information(
&self,
thread: u64,
class: c_int,
info: *const u8,
size: u32,
) -> Option<HostResult> {
if class != THREAD_POWER_THROTTLING {
return None;
}
if let Err(error) = require_access(thread, "Thread", &[THREAD_SET_INFORMATION]) {
return Some(HostResult::Err(error as c_int));
}
if size < THROTTLING_STATE_SIZE || info.is_null() {
return Some(HostResult::Err(ERROR_INVALID_PARAMETER as c_int));
}
let throttling = match unsafe { read_throttling(info, 0..=1, THREAD_THROTTLING_BITS) } {
Ok(t) => t,
Err(error) => return Some(HostResult::Err(error as c_int)),
};
let mut state = self.state.lock().unwrap();
let key = match state.resolve(thread) {
Ok(key) => key,
Err(error) => return Some(HostResult::Err(error as c_int)),
};
state.threads[key].1.power_throttling = throttling;
Some(HostResult::Ok(1))
}
unsafe fn get_thread_information(
&self,
thread: u64,
class: c_int,
info: *mut u8,
size: u32,
) -> Option<HostResult> {
if class != THREAD_POWER_THROTTLING {
return None;
}
if let Err(error) = require_access(
thread,
"Thread",
&[THREAD_QUERY_INFORMATION | THREAD_QUERY_LIMITED_INFORMATION],
) {
return Some(HostResult::Err(error as c_int));
}
if size != THROTTLING_STATE_SIZE || info.is_null() {
return Some(HostResult::Err(ERROR_INVALID_PARAMETER as c_int));
}
let mut state = self.state.lock().unwrap();
let key = match state.resolve(thread) {
Ok(key) => key,
Err(error) => return Some(HostResult::Err(error as c_int)),
};
let throttling = state.threads[key].1.power_throttling;
Some(match unsafe { write_throttling(info, throttling) } {
Ok(()) => HostResult::Ok(1),
Err(error) => HostResult::Err(error as c_int),
})
}
unsafe fn system_cpu_set_information(
&self,
info: *mut u8,
len: u32,
returned: *mut u32,
_process: u64,
_flags: u32,
) -> Option<HostResult> {
let topology = self.state.lock().unwrap().topology();
let (cpus, threads_per_core) = (topology.cpus, topology.threads_per_core);
let need = cpus as usize * CPU_SET_RECORD;
if !returned.is_null() {
unsafe { returned.write_unaligned(need as u32) };
}
if info.is_null() || (len as usize) < need {
return Some(HostResult::Err(ERROR_INSUFFICIENT_BUFFER as c_int));
}
for cpu in 0..cpus {
let mut record = [0u8; CPU_SET_RECORD];
record[0..4].copy_from_slice(&(CPU_SET_RECORD as u32).to_ne_bytes());
record[8..12].copy_from_slice(&(FIRST_CPU_SET + cpu).to_ne_bytes());
record[14] = cpu as u8;
record[15] = (cpu - cpu % threads_per_core) as u8;
record[16] = topology.last_level_cache_index(cpu);
unsafe {
std::ptr::copy_nonoverlapping(
record.as_ptr(),
info.add(cpu as usize * CPU_SET_RECORD),
CPU_SET_RECORD,
)
};
}
Some(HostResult::Ok(1))
}
unsafe fn set_cpu_sets(
&self,
thread: bool,
handle: u64,
ids: *const u32,
count: u32,
) -> Option<HostResult> {
let access = if thread {
require_access(handle, "Thread", &[THREAD_SET_LIMITED_INFORMATION])
} else {
current_process(handle, PROCESS_SET_LIMITED_INFORMATION)
};
if let Err(error) = access {
return Some(HostResult::Err(error as c_int));
}
if ids.is_null() && count != 0 {
return Some(HostResult::Err(ERROR_INVALID_PARAMETER as c_int));
}
let requested = if count == 0 {
&[][..]
} else {
unsafe { std::slice::from_raw_parts(ids, count as usize) }
};
let mut state = self.state.lock().unwrap();
let sets = FIRST_CPU_SET..FIRST_CPU_SET + state.cpus();
if requested.iter().any(|id| !sets.contains(id)) {
return Some(HostResult::Err(ERROR_INVALID_CPU_SET as c_int));
}
let mut chosen = requested.to_vec();
chosen.sort_unstable();
chosen.dedup();
if thread {
let key = match state.resolve(handle) {
Ok(key) => key,
Err(error) => return Some(HostResult::Err(error as c_int)),
};
state.threads[key].1.cpu_sets = chosen;
} else {
state.process_cpu_sets = chosen;
}
Some(HostResult::Ok(1))
}
unsafe fn get_cpu_sets(
&self,
thread: bool,
handle: u64,
ids: *mut u32,
count: u32,
required: *mut u32,
) -> Option<HostResult> {
let access = if thread {
require_access(handle, "Thread", &[THREAD_QUERY_LIMITED_INFORMATION])
} else {
current_process(handle, PROCESS_QUERY_LIMITED_INFORMATION)
};
if let Err(error) = access {
return Some(HostResult::Err(error as c_int));
}
let mut state = self.state.lock().unwrap();
let chosen = if thread {
let key = match state.resolve(handle) {
Ok(key) => key,
Err(error) => return Some(HostResult::Err(error as c_int)),
};
state.threads[key].1.cpu_sets.clone()
} else {
state.process_cpu_sets.clone()
};
drop(state);
if !required.is_null() {
unsafe { required.write_unaligned(chosen.len() as u32) };
}
let fits = chosen.len().min(count as usize);
if !ids.is_null() {
unsafe { std::ptr::copy_nonoverlapping(chosen.as_ptr(), ids, fits) };
}
if fits < chosen.len() {
return Some(HostResult::Err(ERROR_INSUFFICIENT_BUFFER as c_int));
}
Some(HostResult::Ok(1))
}
unsafe fn system_info(&self, info: *mut u8) -> Option<HostResult> {
let topology = self.state.lock().unwrap().topology();
unsafe { topology.write_system_info(info) };
Some(HostResult::Ok(0))
}
fn processor_count(&self, _maximum: bool, group: u16) -> Option<HostResult> {
if group != 0 && group != ALL_PROCESSOR_GROUPS {
return Some(HostResult::Err(ERROR_INVALID_PARAMETER as c_int));
}
Some(HostResult::Ok(i64::from(self.state.lock().unwrap().cpus())))
}
fn processor_group_count(&self, _maximum: bool) -> Option<HostResult> {
Some(HostResult::Ok(1))
}
unsafe fn logical_processor_information(
&self,
relationship: Option<i32>,
info: *mut u8,
len: *mut u32,
) -> Option<HostResult> {
let topology = self.state.lock().unwrap().topology();
Some(
match unsafe { topology.logical_processor_information(relationship, info, len) } {
Ok(()) => HostResult::Ok(1),
Err(error) => HostResult::Err(error as c_int),
},
)
}
unsafe fn get_process_affinity_mask(
&self,
process: u64,
process_mask: *mut usize,
system_mask: *mut usize,
) -> Option<HostResult> {
if let Err(error) = current_process(
process,
PROCESS_QUERY_INFORMATION | PROCESS_QUERY_LIMITED_INFORMATION,
) {
return Some(HostResult::Err(error as c_int));
}
let state = self.state.lock().unwrap();
unsafe {
process_mask.write_unaligned(state.process_affinity as usize);
system_mask.write_unaligned(state.system_affinity as usize);
}
Some(HostResult::Ok(1))
}
fn set_process_affinity_mask(&self, process: u64, mask: u64) -> Option<HostResult> {
if let Err(error) = current_process(process, PROCESS_SET_INFORMATION) {
return Some(HostResult::Err(error as c_int));
}
let mut state = self.state.lock().unwrap();
if mask == 0 || mask & !state.system_affinity != 0 {
return Some(HostResult::Err(ERROR_INVALID_PARAMETER as c_int));
}
state.process_affinity = mask;
for (_, thread) in &mut state.threads {
thread.affinity = None;
}
Some(HostResult::Ok(1))
}
fn numa_highest_node(&self) -> Option<HostResult> {
Some(HostResult::Ok(0))
}
unsafe fn numa_node_processor_mask(&self, node: u16, affinity: *mut u8) -> Option<HostResult> {
if node != 0 {
return Some(HostResult::Err(ERROR_INVALID_PARAMETER as c_int));
}
let mut record = [0u8; 16];
record[..8].copy_from_slice(&self.state.lock().unwrap().system_affinity.to_ne_bytes());
unsafe { std::ptr::copy_nonoverlapping(record.as_ptr(), affinity, record.len()) };
Some(HostResult::Ok(1))
}
unsafe fn processor_power_information(
&self,
input: *const u8,
_input_len: u32,
output: *mut u8,
output_len: u32,
) -> Option<HostResult> {
let topology = self.state.lock().unwrap().topology();
let status = unsafe { topology.power_information(input, output, output_len) };
Some(HostResult::Ok(i64::from(status)))
}
fn time_period(&self, begin: bool, period: u32) -> Option<HostResult> {
const TIMERR_NOCANDO: i64 = 97;
if period == 0 {
return Some(HostResult::Ok(TIMERR_NOCANDO));
}
let mut state = self.state.lock().unwrap();
if begin {
*state.time_periods.entry(period).or_default() += 1;
} else {
let Some(count) = state.time_periods.get_mut(&period) else {
return Some(HostResult::Ok(TIMERR_NOCANDO));
};
*count -= 1;
if *count == 0 {
state.time_periods.remove(&period);
}
}
Some(HostResult::Ok(0))
}
}
unsafe fn read_throttling(
info: *const u8,
versions: std::ops::RangeInclusive<u32>,
valid: u32,
) -> Result<PowerThrottling, u32> {
let word = |at: usize| unsafe { info.add(at * 4).cast::<u32>().read_unaligned() };
let (version, control_mask, state_mask) = (word(0), word(1), word(2));
if !versions.contains(&version) || control_mask & !valid != 0 || state_mask & !control_mask != 0
{
return Err(ERROR_INVALID_PARAMETER);
}
Ok(PowerThrottling {
control_mask,
state_mask,
})
}
unsafe fn write_throttling(info: *mut u8, throttling: PowerThrottling) -> Result<(), u32> {
let words = info.cast::<u32>();
if unsafe { words.read_unaligned() } != 1 {
return Err(ERROR_INVALID_PARAMETER);
}
unsafe {
words.add(1).write_unaligned(throttling.control_mask);
words.add(2).write_unaligned(throttling.state_mask);
}
Ok(())
}
pub struct Sim {
domain: Domain,
shared: Arc<SimShared>,
_host: Arc<WinHost>,
_net: Arc<crate::win_net::WinNet>,
_forward: Option<crate::signals::forward::Registration>,
}
impl std::fmt::Debug for Sim {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Sim")
.field("id", &self.domain.id())
.finish_non_exhaustive()
}
}
impl Drop for Sim {
fn drop(&mut self) {
let locals = self.domain.take_locals();
if !locals.is_empty() {
self.run(move || drop(locals));
}
if let Some(capture) = self.shared.capture() {
capture.finish();
}
}
}
impl Default for Sim {
fn default() -> Self {
Self::new()
}
}
impl Sim {
pub fn new() -> Self {
Self::builder().build()
}
pub fn builder() -> SimBuilder {
SimBuilder::default()
}
pub fn run<R>(&self, f: impl FnOnce() -> R) -> R {
let _registries = crate::win_net::enter(self._net.registries());
self.domain.run(f)
}
#[track_caller]
pub fn pause_time(&self) {
self.time().pause();
}
#[track_caller]
pub fn resume_time(&self) {
self.time().resume();
}
#[track_caller]
pub fn advance_time(&self, by: Duration) {
self.time().advance(by);
}
#[track_caller]
pub fn set_time_rate(&self, rate: f64) {
self.time().set_rate(rate);
}
#[track_caller]
pub fn time_rate(&self) -> f64 {
self.time().rate()
}
#[track_caller]
pub fn set_time_value(&self, value: Duration) {
self.time().set_value(value);
}
#[track_caller]
pub fn time_value(&self) -> Duration {
self.time().value()
}
#[track_caller]
pub fn time(&self) -> crate::TimeHandle {
self.shared.time()
}
pub fn pcapng_path(&self) -> Option<&std::path::Path> {
self.shared.capture().map(|c| c.path())
}
pub fn recorded_events(&self) -> Vec<crate::RecordedEntry> {
self.shared.events.snapshot()
}
pub fn clear_recorded_events(&self) {
self.shared.events.clear();
}
pub fn socket_entry(&self, id: crate::SocketId) -> Option<crate::SocketEntry> {
self.shared.socket_entry(id)
}
pub fn socket_table(&self) -> Vec<crate::SocketEntry> {
self.shared.socket_table()
}
pub fn closed_sockets(&self) -> Vec<crate::SocketEntry> {
self.shared.closed_sockets()
}
pub fn inject_socket_drops(&self, id: crate::SocketId, n: u32) -> std::io::Result<()> {
self.shared.inject_socket_drops(id, n)
}
pub fn set_socket_device(&self, id: crate::SocketId, nic: Option<&str>) -> std::io::Result<()> {
self.shared.set_socket_device(id, nic)
}
pub fn proto_counters(&self) -> crate::ProtoCounters {
self.shared.proto_counters()
}
pub fn working_set(&self) -> WorkingSet {
self._host.state.lock().unwrap().working_set
}
pub fn time_periods(&self) -> Vec<(u32, u64)> {
let mut periods: Vec<_> = self
._host
.state
.lock()
.unwrap()
.time_periods
.iter()
.map(|(&period, &count)| (period, count))
.collect();
periods.sort_unstable();
periods
}
pub fn mmcss_tasks(&self) -> Vec<MmcssTask> {
let state = self._host.state.lock().unwrap();
state.mmcss.iter().map(|(_, task)| task.clone()).collect()
}
pub fn process_power_throttling(&self) -> PowerThrottling {
self._host.state.lock().unwrap().process_power_throttling
}
pub fn thread_power_throttling(&self, thread_id: u32) -> Option<PowerThrottling> {
let state = self._host.state.lock().unwrap();
state.thread_by_id(thread_id).map(|t| t.power_throttling)
}
pub fn process_default_cpu_sets(&self) -> Vec<u32> {
self._host.state.lock().unwrap().process_cpu_sets.clone()
}
pub fn thread_selected_cpu_sets(&self, thread_id: u32) -> Vec<u32> {
let state = self._host.state.lock().unwrap();
state
.thread_by_id(thread_id)
.map(|t| t.cpu_sets.clone())
.unwrap_or_default()
}
pub fn socket_cpu_affinity(&self, id: crate::SocketId) -> Option<u16> {
snare_interpose::real(|| self.shared.sockets.cpu_affinity(id))
}
pub fn set_adapter(&self, nic: &str, adapter: crate::Adapter) {
self._host.adapters.configure(&self.shared, nic, adapter);
}
pub fn adapter_value(
&self,
nic: &str,
key: crate::AdapterKey,
path: &str,
name: &str,
) -> Option<crate::RegValue> {
self._host
.adapters
.value(&self.shared, nic, key, path, name)
}
pub fn adapter_property(&self, nic: &str, keyword: &str) -> Option<String> {
match self.adapter_value(nic, crate::AdapterKey::Driver, "", keyword)? {
crate::RegValue::Sz(value) => Some(value),
_ => None,
}
}
pub fn adapter_restarts(&self, nic: &str) -> u32 {
self._host.adapters.restarts(nic)
}
pub fn privileges(&self) -> crate::Privileges {
self.shared.sys.privileges()
}
pub fn set_privileges(&self, change: impl FnOnce(&mut crate::Privileges)) {
self.shared.sys.set_privileges(change);
}
pub fn sys_limits(&self) -> crate::SysLimits {
self.shared.sys.limits()
}
pub fn set_sys_limits(&self, change: impl FnOnce(&mut crate::SysLimits)) {
self.shared.sys.set_limits(change);
}
pub fn add_nic(&self, spec: crate::NicSpec) -> std::io::Result<u32> {
self.shared.add_nic(spec)
}
pub fn remove_nic(&self, name: &str) -> std::io::Result<()> {
self.shared.remove_nic(name)
}
pub fn set_nic(
&self,
name: &str,
change: impl FnOnce(&mut crate::NicSpec),
) -> std::io::Result<()> {
self.shared.set_nic(name, change)
}
pub fn set_link(&self, name: &str, carrier: bool) -> std::io::Result<()> {
self.shared.set_link(name, carrier)
}
pub fn schedule_link(&self, name: &str, after: Duration, carrier: bool) -> std::io::Result<()> {
self.shared.schedule_link(name, after, carrier)
}
pub fn set_nic_policy(
&self,
name: &str,
change: impl FnOnce(&mut crate::NicPolicy),
) -> std::io::Result<()> {
self.shared.set_nic_policy(name, change)
}
pub fn set_nic_counters(
&self,
name: &str,
change: impl FnOnce(&mut crate::NicCounters),
) -> std::io::Result<()> {
self.shared.set_nic_counters(name, change)
}
pub fn nic(&self, name: &str) -> Option<crate::NicSnapshot> {
self.shared.nic(name)
}
pub fn nics(&self) -> Vec<crate::NicSnapshot> {
self.shared.nics()
}
pub fn nic_counters(&self, name: &str) -> Option<crate::NicCounters> {
self.shared.nic_counters(name)
}
pub fn add_route(&self, route: crate::Route) -> std::io::Result<()> {
self.shared.add_route(route)
}
pub fn remove_route(&self, dest: crate::IpNet) -> bool {
self.shared.remove_route(dest)
}
pub fn set_default_route(&self, nic: Option<&str>) -> std::io::Result<()> {
self.shared.set_default_route(nic)
}
pub fn routes(&self) -> Vec<crate::Route> {
self.shared.routes()
}
pub fn route_lookup(
&self,
src: Option<std::net::IpAddr>,
dst: std::net::IpAddr,
) -> std::io::Result<crate::RouteChoice> {
self.shared.route_lookup(src, dst)
}
pub fn busy(&self, label: &'static str) -> crate::sched::BusyLease {
crate::sched::BusyLease::take(self.domain.clone(), label)
}
pub fn held_leases(&self) -> Vec<crate::sched::LeaseInfo> {
self.domain.leases()
}
pub fn id(&self) -> crate::sched::SimId {
self.domain.id()
}
pub fn thread_census(&self) -> Option<crate::sched::ThreadCensus> {
snare_interpose::census(Some(&self.domain))
}
pub fn add_host(&self, name: &str, addrs: impl IntoIterator<Item = std::net::IpAddr>) {
self.shared.dns.add(name, addrs);
}
pub fn remove_host(&self, name: &str) {
self.shared.dns.remove(name);
}
pub fn set_dns_policy(&self, name: &str, change: impl FnOnce(&mut crate::DnsPolicy)) {
self.shared.dns.update_policy(name, change);
}
pub fn set_default_dns_policy(&self, change: impl FnOnce(&mut crate::DnsPolicy)) {
self.shared.dns.update_default_policy(change);
}
pub fn raise_signal(&self, signal: crate::Signal) -> crate::SignalDelivery {
self.signals().raise(signal)
}
pub fn raise_signal_after(
&self,
signal: crate::Signal,
delay: Duration,
) -> crate::PendingSignal {
self.signals().raise_after(signal, delay)
}
pub fn signals(&self) -> crate::SignalHandle {
crate::SignalHandle::new(self.shared.clone())
}
pub fn set_listener_behavior(
&self,
addr: impl std::net::ToSocketAddrs,
behavior: crate::ListenerBehavior,
) {
crate::faults::set_listener_behavior_on(&self.shared, addr, behavior);
}
pub fn raise_socket_error(&self, addr: impl std::net::ToSocketAddrs, error: std::io::Error) {
crate::faults::raise_socket_error_on(&self.shared, addr, error);
}
pub fn inject_icmp_port_unreachable(
&self,
to: impl std::net::ToSocketAddrs,
from: impl std::net::ToSocketAddrs,
) {
crate::faults::inject_icmp_on(&self.shared, to, from);
}
pub fn quiesce(
&self,
addr: impl std::net::ToSocketAddrs,
span: Duration,
direction: crate::Direction,
) {
crate::faults::quiesce_on(&self.shared, addr, span, direction);
}
pub fn set_tcp_policy(
&self,
addr: impl std::net::ToSocketAddrs,
change: impl FnOnce(&mut crate::TcpPolicy),
) {
crate::netpolicy::set_tcp_policy_on(&self.shared, addr, change);
}
pub fn set_udp_policy(
&self,
addr: impl std::net::ToSocketAddrs,
change: impl FnOnce(&mut crate::UdpPolicy),
) {
crate::netpolicy::set_udp_policy_on(&self.shared, addr, change);
}
pub fn executive(
&self,
cfg: crate::sched::ExecutiveConfig,
) -> Result<crate::sched::Executive, crate::sched::AttachError> {
crate::executive::attach_to(self.shared.clone(), self.domain.clone(), cfg)
}
}
#[derive(Default)]
pub struct SimBuilder {
cpus: Option<usize>,
threads_per_core: Option<usize>,
wall_clock: bool,
time_rate: Option<f64>,
fixed_epoch: bool,
seed: u64,
deterministic: bool,
quiet: bool,
nics: Vec<crate::NicSpec>,
routes: Vec<crate::Route>,
dns: crate::dns::DnsSetup,
forward_signals: bool,
privileges: Option<crate::Privileges>,
sys_limits: Option<crate::SysLimits>,
pcapng: Option<std::path::PathBuf>,
pcapng_wall_comment: bool,
stuck_after: Option<Duration>,
adapters: Vec<(String, crate::Adapter)>,
strict_sockopts: bool,
isolate_env: bool,
env: Vec<(String, String)>,
time_zone: Option<String>,
}
impl SimBuilder {
pub fn time_zone(mut self, name: impl Into<String>) -> Self {
self.time_zone = Some(name.into());
self
}
pub fn privileges(mut self, privileges: crate::Privileges) -> Self {
self.privileges = Some(privileges);
self
}
pub fn sys_limits(mut self, limits: crate::SysLimits) -> Self {
self.sys_limits = Some(limits);
self
}
pub fn nic(mut self, spec: crate::NicSpec) -> Self {
self.nics.push(spec);
self
}
pub fn adapter(mut self, nic: impl Into<String>, adapter: crate::Adapter) -> Self {
self.adapters.push((nic.into(), adapter));
self
}
pub fn route(mut self, route: crate::Route) -> Self {
self.routes.push(route);
self
}
pub fn env(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
self.isolate_env = true;
self.env.push((key.into(), value.into()));
self
}
pub fn isolate_env(mut self) -> Self {
self.isolate_env = true;
self
}
pub fn cpus(mut self, count: usize) -> Self {
self.cpus = Some(count);
self
}
pub fn threads_per_core(mut self, count: usize) -> Self {
self.threads_per_core = Some(count);
self
}
pub fn virtual_clock(mut self) -> Self {
self.wall_clock = false;
self
}
pub fn wall_clock(mut self) -> Self {
self.wall_clock = true;
self
}
#[track_caller]
pub fn time_rate(mut self, rate: f64) -> Self {
crate::clock::validate_rate(rate, false);
self.time_rate = Some(rate);
self
}
pub fn fixed_epoch(mut self) -> Self {
self.fixed_epoch = true;
self
}
pub fn deterministic(mut self) -> Self {
self.deterministic = true;
self.wall_clock = false;
self
}
pub fn seed(mut self, seed: u64) -> Self {
self.seed = seed;
self
}
pub fn record_events(mut self, on: bool) -> Self {
self.quiet = !on;
self
}
pub fn add_host(
mut self,
name: &str,
addrs: impl IntoIterator<Item = std::net::IpAddr>,
) -> Self {
self.dns.add_host(name, addrs);
self
}
pub fn forward_real_signals(mut self) -> Self {
self.forward_signals = true;
self
}
pub fn resolve_real(mut self, name: &str) -> Self {
self.dns.resolve_real(name);
self
}
pub fn real_dns(mut self) -> Self {
self.dns.real_dns();
self
}
pub fn pcapng(mut self, path: impl Into<std::path::PathBuf>) -> Self {
self.pcapng = Some(path.into());
self
}
pub fn pcapng_wall_comment(mut self, on: bool) -> Self {
self.pcapng_wall_comment = on;
self
}
pub fn strict_sockopts(mut self) -> Self {
self.strict_sockopts = true;
self
}
#[track_caller]
pub fn stuck_after(mut self, after: Duration) -> Self {
assert!(!after.is_zero(), "stuck_after must be longer than zero");
self.stuck_after = Some(after);
self
}
#[track_caller]
pub fn build(self) -> Sim {
self.dns.check(self.deterministic);
let clock = (!self.wall_clock || self.time_rate.is_some()).then(|| Arc::new(Clock::new(0)));
if let Some(clock) = &clock {
clock.set_discrete(true);
clock.set_deterministic(self.deterministic);
clock.begin(self.deterministic || self.fixed_epoch);
if let Some(rate) = self.time_rate {
clock.check_rate(rate);
clock.set_rate(rate);
}
}
let shared = SimShared::new(self.seed, clock.clone());
shared.events.set_enabled(!self.quiet);
shared
.strict_sockopts
.store(self.strict_sockopts, std::sync::atomic::Ordering::Relaxed);
crate::pcapng::attach(&shared, self.pcapng, self.pcapng_wall_comment);
shared.init_topology(Vec::new(), Vec::new(), self.nics, self.routes);
self.dns.apply(&shared);
if let Some(privileges) = self.privileges {
shared.sys.set_privileges(|p| *p = privileges);
}
if let Some(limits) = self.sys_limits {
shared.sys.set_limits(|l| *l = limits);
}
let host = Arc::new(WinHost::new(
self.cpus.unwrap_or(8),
self.threads_per_core.unwrap_or(1),
));
for (nic, adapter) in self.adapters {
host.adapters.configure(&shared, &nic, adapter);
}
let _ = host.shared.set(Arc::downgrade(&shared));
let net = Arc::new(crate::win_net::WinNet::new(shared.clone()));
let mut builder = Domain::builder()
.resolver(crate::dns::DnsSetup::resolver(&shared))
.signals(Arc::new(crate::signals::SimSignals(shared.clone())))
.layers([
Arc::new(crate::win_net::ScopeLayer(net.registries())) as Arc<dyn Layer>,
Arc::new(crate::random::RandomLayer::new(shared.seed)),
])
.net(net.clone())
.host(host.clone());
if let Some(clock) = clock {
builder = builder.layers([Arc::new(ClockLayer(clock)) as Arc<dyn Layer>]);
}
if self.deterministic {
builder = builder.deterministic();
}
if let Some(name) = &self.time_zone {
builder = builder.time_zone(name);
}
if let Some(after) = self.stuck_after {
builder = builder.stuck_after(after);
}
if self.isolate_env {
builder = builder.env(Arc::new(snare_interpose::WinEnv::new(self.env)));
}
let domain = builder.install();
let _ = shared.domain.set(domain.downgrade());
if let Some(clock) = &shared.clock {
clock.set_domain(&domain);
}
let forward = self
.forward_signals
.then(|| crate::signals::forward::register(shared.clone()));
Sim {
domain,
shared,
_host: host,
_net: net,
_forward: forward,
}
}
}