Struct RegisterState 

pub struct RegisterState<T: RegisterStorage> {
    pub real_registers: T,
    pub orig_rax: u64,
}

The state of the task’s registers when the thread of execution entered the kernel. This is a thin wrapper around [zx::sys::zx_restricted_state_t].

Implements std::ops::Deref and std::ops::DerefMut as a way to get at the underlying [zx::sys::zx_restricted_state_t] that this type wraps.

Fields

real_registers: T

orig_rax: u64

A copy of the x64 rax register at the time of the syscall instruction. This is important to store, as the return value of a syscall overwrites rax, making it impossible to recover the original syscall number in the case of syscall restart and strace output.

Implementations

impl<T: RegisterStorage> RegisterState<T>

pub fn save_registers_for_restart(&mut self, syscall_number: u64)

Saves any register state required to restart syscall_number.

pub fn prepare_for_custom_restart(&mut self)

Custom restart, invoke restart_syscall instead of the original syscall.

pub fn restore_original_return_register(&mut self)

Restores rax to match its value before restarting.

pub fn instruction_pointer_register(&self) -> u64

Returns the register that indicates the single-machine-word return value from a function call.

pub fn set_instruction_pointer_register(&mut self, new_ip: u64)

Sets the register that indicates the single-machine-word return value from a function call.

pub fn rewind_syscall_instruction(&mut self)

Rewind the the register that indicates the instruction pointer by one syscall instruction.

pub fn return_register(&self) -> u64

Returns the register that indicates the single-machine-word return value from a function call.

pub fn set_return_register(&mut self, return_value: u64)

Sets the register that indicates the single-machine-word return value from a function call.

pub fn stack_pointer_register(&self) -> u64

Gets the register that indicates the current stack pointer.

pub fn set_stack_pointer_register(&mut self, sp: u64)

Sets the register that indicates the current stack pointer.

pub fn set_thread_pointer_register(&mut self, tp: u64)

Sets the register that indicates the TLS.

pub fn set_arg0_register(&mut self, rdi: u64)

Sets the register that indicates the first argument to a function.

pub fn set_arg1_register(&mut self, rsi: u64)

Sets the register that indicates the second argument to a function.

pub fn set_arg2_register(&mut self, rdx: u64)

Sets the register that indicates the third argument to a function.

pub fn syscall_register(&self) -> u64

Returns the register that contains the syscall number.

pub fn reset_flags(&mut self)

Resets the register that contains the application status flags.

pub fn apply_user_register( &mut self, offset: usize, f: &mut dyn FnMut(&mut u64), ) -> Result<(), Errno>

Executes the given predicate on the register.

pub fn load(&mut self, regs: zx_restricted_state_t)

pub fn sync_stack_ptr(&mut self)

Trait Implementations

impl<T: Clone + RegisterStorage> Clone for RegisterState<T>

fn clone(&self) -> RegisterState<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: RegisterStorage> Debug for RegisterState<T>

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

Formats the value using the given formatter.

impl<T: Default + RegisterStorage> Default for RegisterState<T>

fn default() -> RegisterState<T>

Returns the “default value” for a type.

impl<T: RegisterStorage> Deref for RegisterState<T>

type Target = zx_restricted_state_t

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: RegisterStorage> DerefMut for RegisterState<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl From<RegisterState<HeapRegs>> for RegisterState<RegisterStorageEnum>

fn from(regs: RegisterState<HeapRegs>) -> Self

Converts to this type from the input type.

impl From<RegisterState<RegisterStorageEnum>> for RegisterState<HeapRegs>

fn from(regs: RegisterState<RegisterStorageEnum>) -> Self

Converts to this type from the input type.

impl<T: PartialEq + RegisterStorage> PartialEq for RegisterState<T>

fn eq(&self, other: &RegisterState<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq + RegisterStorage> Eq for RegisterState<T>

impl<T: RegisterStorage> StructuralPartialEq for RegisterState<T>