Enum Op 

pub enum Op {
    Branch,
    Rdtsc,
    Cpuid,
    Syscall(Sysno, SyscallPhase),
    OtherInstructions,
    SignalReceived(SigWrapper),
}

NOTE [Event Semantics]

The observable operations that happen on a guest thread.

Each Op event has a beginning and an end, containing an interval of zero or more instructions inbetween. Each beginning and end point in time can be thought of as an imaginary marker between two instructions. Start/end RIP values, if present in the containing SchedEvent, correspond to those beginning/end points and always point to the next instruction to execute.

If we speak of an event as an instantaneous thing, we’re usually thinking of it as its end marker. Which is as follows for each:

• Branches: after the branch instruction has retired
• Syscall prehooks: just before the syscall instruction, after whatever came before
• Syscall posthooks: just after the syscall instruction completes
• Rdtsc/Cpuid: just after the designated instruction
• OtherInstructions: just after the region of zero or more branch-free, non-interceptable instructions.
• SignalReceived: just after the last regular, pre-signal guest instruction, and just before the first instruction of the signal handler.

If we view each event as a series of instructions contained between its start/end markers, then the pattern of instructions for each would be as follows. Here we use simple regular expressions with “B” standing for branch instructions, “S” for syscall instructions, “R” for RDTSC, “C” for CPUID, and “O” for all other instructions.

• Branch “O*B”
• Syscall prehook: “”
• Syscall posthook: “S”
• Rdtsc: “R”
• Cpuid: “C”
• OtherInstructions: “O*”
• SignalReceived: “”

A few observations about the above:

• Some events always correspond to zero instructions.
• OtherInstructions are omnipresent “dark matter” that we cannot intercept or count, so are implicitly present between other events.
• Therefore the OtherInstructions event itself is only interesting insofar as it signals the absence of other events.
• Branches include an implicit prefix of OtherInstructions. This is because for a branch count greater than 1 to make sense, we need to include the full between-branches O’s: “..BOB..”. We could change this design by going to either extreme. (1) removing implicit O’s and changing the count mechanism to allow repetition of entire sequences “(OB)^3” instead of “B^3”. Or (2), including implicit O’s in all event types, and not recording them explicitly.

Variants

Branch

A single retired conditional branch, corresponding to one increment of the RCB counter.

Rdtsc

A nondeterministic rdtsc instruction.

Cpuid

A nondeterministic cpuid instruction.

Syscall(Sysno, SyscallPhase)

A system call performed by the thread. The bool is set to true when this is a syscall PREHOOKh event, which is recorded BEFORE the syscall instruction executes, rather than after.

OtherInstructions

An unknown number of other instructions that occured BETWEEN hermit-interceptable events. The only way to preempt in between these is expensive single-stepping.

SignalReceived(SigWrapper)

The point a signal handler is received, just after whatever regular user instruction preceeded it, and just before the first instruction of the signal handler.

Trait Implementations

impl Clone for Op

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Op

impl Debug for Op

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Op

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Op

impl Hash for Op

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Op

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Op

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Op