Struct Windows 

pub struct Windows<B> { /* private fields */ }

Implementations

impl<B: Backend> Windows<B>

pub fn create(backend: B, symbols: SymbolsIndexer) -> VmResult<Self>

pub fn nt_os_version(&self) -> VmResult<(u32, u32)>

Trait Implementations

impl<B: Backend> Buildable<B> for Windows<B>

fn quick_check(backend: &B) -> Option<OsBuilder>

fn build(backend: B, builder: OsBuilder) -> VmResult<Self>

impl<B: Backend> HasVcpus for Windows<B>

type Arch = <B as HasVcpus>::Arch

fn arch(&self) -> Self::Arch

fn vcpus_count(&self) -> usize

fn registers( &self, vcpu: VcpuId, ) -> VcpuResult<<Self::Arch as Architecture>::Registers>

fn special_registers( &self, vcpu: VcpuId, ) -> VcpuResult<<Self::Arch as Architecture>::SpecialRegisters>

fn other_registers( &self, vcpu: VcpuId, ) -> VcpuResult<<Self::Arch as Architecture>::OtherRegisters>

fn instruction_pointer(&self, vcpu: VcpuId) -> VcpuResult<VirtualAddress>

fn stack_pointer(&self, vcpu: VcpuId) -> VcpuResult<VirtualAddress>

fn base_pointer(&self, vcpu: VcpuId) -> VcpuResult<Option<VirtualAddress>>

fn pgd(&self, vcpu: VcpuId) -> VcpuResult<PhysicalAddress>

fn kernel_per_cpu(&self, vcpu: VcpuId) -> VcpuResult<Option<VirtualAddress>>

fn iter_vcpus(&self) -> VcpuIterator

impl<B: Backend> Os for Windows<B>

fn read_virtual_memory( &self, mmu_addr: PhysicalAddress, addr: VirtualAddress, buf: &mut [u8], ) -> VmResult<()>

fn try_read_virtual_memory( &self, mmu_addr: PhysicalAddress, addr: VirtualAddress, buf: &mut [u8], ) -> VmResult<()>

fn read_process_memory( &self, proc: Process, mmu_addr: PhysicalAddress, addr: VirtualAddress, buf: &mut [u8], ) -> VmResult<()>

fn try_read_process_memory( &self, proc: Process, mmu_addr: PhysicalAddress, addr: VirtualAddress, buf: &mut [u8], ) -> VmResult<()>

fn kernel_pgd(&self) -> PhysicalAddress

fn init_process(&self) -> VmResult<Process>

fn for_each_kernel_module( &self, f: &mut dyn FnMut(Module) -> VmResult<ControlFlow<()>>, ) -> VmResult<()>

fn current_thread(&self, vcpu: VcpuId) -> VmResult<Thread>

fn process_is_kernel(&self, _proc: Process) -> VmResult<bool>

fn process_id(&self, proc: Process) -> VmResult<u64>

fn process_name(&self, proc: Process) -> VmResult<String>

fn process_pgd(&self, proc: Process) -> VmResult<PhysicalAddress>

fn process_path(&self, proc: Process) -> VmResult<Option<String>>

fn process_parent(&self, proc: Process) -> VmResult<Process>

fn process_parent_id(&self, proc: Process) -> VmResult<u64>

fn process_for_each_child( &self, proc: Process, f: &mut dyn FnMut(Process) -> VmResult<ControlFlow<()>>, ) -> VmResult<()>

fn process_for_each_thread( &self, proc: Process, f: &mut dyn FnMut(Thread) -> VmResult<ControlFlow<()>>, ) -> VmResult<()>

fn for_each_process( &self, f: &mut dyn FnMut(Process) -> VmResult<ControlFlow<()>>, ) -> VmResult<()>

fn process_for_each_vma( &self, proc: Process, f: &mut dyn FnMut(Vma) -> VmResult<ControlFlow<()>>, ) -> VmResult<()>

fn process_find_vma_by_address( &self, proc: Process, addr: VirtualAddress, ) -> VmResult<Option<Vma>>

fn process_for_each_module( &self, proc: Process, f: &mut dyn FnMut(Module) -> VmResult<ControlFlow<()>>, ) -> VmResult<()>

fn process_callstack_with_regs( &self, proc: Process, instruction_pointer: VirtualAddress, stack_pointer: VirtualAddress, base_pointer: Option<VirtualAddress>, f: &mut dyn FnMut(&StackFrame) -> VmResult<ControlFlow<()>>, ) -> VmResult<()>

fn thread_process(&self, thread: Thread) -> VmResult<Process>

fn thread_id(&self, thread: Thread) -> VmResult<u64>

fn thread_name(&self, thread: Thread) -> VmResult<Option<String>>

fn vma_path(&self, _vma: Vma) -> VmResult<Option<String>>

fn vma_start(&self, vma: Vma) -> VmResult<VirtualAddress>

fn vma_end(&self, vma: Vma) -> VmResult<VirtualAddress>

fn vma_flags(&self, vma: Vma) -> VmResult<VmaFlags>

fn module_span( &self, module: Module, proc: Process, ) -> VmResult<(VirtualAddress, VirtualAddress)>

fn module_name(&self, module: Module, proc: Process) -> VmResult<String>

fn module_path(&self, module: Module, proc: Process) -> VmResult<String>

fn module_symbols( &self, proc: Process, module: Module, ) -> VmResult<Option<&ModuleSymbols>>

fn read_kernel_memory( &self, addr: VirtualAddress, buf: &mut [u8], ) -> Result<(), VmError>

fn current_process(&self, vcpu: VcpuId) -> Result<Process, VmError>

fn find_process_by_name(&self, name: &str) -> Result<Option<Process>, VmError>

fn find_process_by_id(&self, pid: u64) -> Result<Option<Process>, VmError>

fn process_collect_children( &self, proc: Process, ) -> Result<Vec<Process>, VmError>

fn process_collect_threads(&self, proc: Process) -> Result<Vec<Thread>, VmError>

fn process_collect_modules(&self, proc: Process) -> Result<Vec<Module>, VmError>

fn collect_processes(&self) -> Result<Vec<Process>, VmError>

fn process_collect_vmas(&self, proc: Process) -> Result<Vec<Vma>, VmError>

fn process_callstack( &self, proc: Process, f: &mut dyn FnMut(&StackFrame) -> Result<ControlFlow<()>, VmError>, ) -> Result<(), VmError>

fn vma_contains(&self, vma: Vma, addr: VirtualAddress) -> Result<bool, VmError>

fn module_contains( &self, module: Module, proc: Process, addr: VirtualAddress, ) -> Result<bool, VmError>

fn find_module_by_address( &self, proc: Process, addr: VirtualAddress, ) -> Result<Option<Module>, VmError>

fn module_resolve_symbol_exact( &self, addr: VirtualAddress, proc: Process, module: Module, ) -> Result<Option<&str>, VmError>

fn module_resolve_symbol( &self, addr: VirtualAddress, proc: Process, module: Module, ) -> Result<Option<(&str, u64)>, VmError>

fn resolve_symbol_exact( &self, addr: VirtualAddress, proc: Process, ) -> Result<Option<&str>, VmError>

fn resolve_symbol( &self, addr: VirtualAddress, proc: Process, ) -> Result<Option<(&str, u64)>, VmError>

fn format_symbol( &self, proc: Process, addr: VirtualAddress, demangle: bool, ) -> Result<String, VmError>

fn format_symbol_with_module( &self, proc: Process, module: Module, addr: VirtualAddress, fun_start: Option<VirtualAddress>, demangle: bool, ) -> Result<String, VmError>

fn format_stackframe_symbol( &self, proc: Process, frame: &StackFrame, demangle: bool, ) -> Result<String, VmError>