Enum KernelOpValue 

pub enum KernelOpValue {
    U32(u32),
    U64(u64),
    Bytes(Vec<u8>),
    OrU32(u32),
}

Wire-encoded crate::scenario::ops::KernelValue variant tag. Mirrors the four KernelValue enum variants 1:1.

Variants

U32(u32)

32-bit unsigned, little-endian on the wire and at the resolved PA. Atomic when the resolved host PA is 4-byte aligned (see GuestKernel::write_*_u32 doc).

U64(u64)

64-bit unsigned, little-endian. Atomic at 8-byte alignment.

Bytes(Vec<u8>)

Variable-length byte payload. Written non-atomically; the dispatcher emits a Release fence after the copy.

OrU32(u32)

32-bit unsigned read-modify-write OR mask. The cold-path dispatcher reads the live u32 at the resolved host PA, ORs the carried mask into it, and writes the new value back as two separate read_u32 / write_u32 calls — atomic by quiesce because the freeze rendezvous parks every guest vCPU before the RMW runs (no concurrent kernel writer can interleave). No compare_exchange loop in the cold path. Mirrors crate::scenario::ops::KernelValue::OrU32 — see that variant’s doc for the full atomicity, ordering, and width-correctness contract (the canonical SCX_RQ_CLK_VALID use case + the kernel/sched/sched.h:802 u32-width citation for the struct scx_rq.flags field that motivated keeping the variant u32 rather than u64). Hot-path support is a future variant — it would require AtomicU32::from_ptr

• cmpxchg + strict alignment rejection.

Trait Implementations

impl Clone for KernelOpValue

fn clone(&self) -> KernelOpValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KernelOpValue

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KernelOpValue

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&KernelValue> for KernelOpValue

fn from(value: &KernelValue) -> Self

1:1 mapping of every Op-side KernelValue variant to its wire-side peer. The Bytes arm clones the inner Vec<u8> so the source variant remains usable after dispatch (large payloads pay the clone cost — see crate::vmm::wire::KernelOpValue::Bytes for the wire representation).

impl From<&KernelValueWidth> for KernelOpValue

fn from(width: &KernelValueWidth) -> Self

Map a KernelValueWidth to a zero-filled crate::vmm::wire::KernelOpValue of the requested width for the read-entry’s value-hint slot. The wire payload’s value discriminant tells the host dispatcher which read family to invoke; the byte contents are written by the host before replying.

impl PartialEq for KernelOpValue

fn eq(&self, other: &KernelOpValue) -> 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 Serialize for KernelOpValue

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for KernelOpValue

impl StructuralPartialEq for KernelOpValue