vmi-utils 0.5.1

Utilities for VMI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use super::arch::GpRegistersAdapter;

/// A response from the bridge.
///
/// Carries up to four architecture-mapped values and an optional typed
/// result. The values are written back into guest registers by
/// [`write_to`](Self::write_to); the result signals handler completion.
///
/// # Architecture-specific
///
/// - **AMD64**: value1-value4 map to `RAX`, `RBX`, `RCX`, `RDX`.
#[derive(Debug)]
pub struct BridgeResponse<T = ()> {
    value1: Option<u64>,
    value2: Option<u64>,
    value3: Option<u64>,
    value4: Option<u64>,
    result: Option<T>,
}

impl<T> Default for BridgeResponse<T> {
    fn default() -> Self {
        Self {
            value1: None,
            value2: None,
            value3: None,
            value4: None,
            result: None,
        }
    }
}

impl<T> BridgeResponse<T> {
    /// Creates a new response with the first value set.
    pub fn new(value1: u64) -> Self {
        Self {
            value1: Some(value1),
            value2: None,
            value3: None,
            value4: None,
            result: None,
        }
    }

    /// Returns the first value of the response.
    pub fn value1(&self) -> Option<u64> {
        self.value1
    }

    /// Returns the second value of the response.
    pub fn value2(&self) -> Option<u64> {
        self.value2
    }

    /// Returns the third value of the response.
    pub fn value3(&self) -> Option<u64> {
        self.value3
    }

    /// Returns the fourth value of the response.
    pub fn value4(&self) -> Option<u64> {
        self.value4
    }

    /// Returns a reference to the result of the response.
    pub fn result(&self) -> Option<&T> {
        self.result.as_ref()
    }

    /// Consumes the response and returns the result, if present.
    ///
    /// A `Some` value indicates that the handler has finished and the
    /// bridge dispatch loop should terminate.
    pub fn into_result(self) -> Option<T> {
        self.result
    }

    /// Sets the first value of the response.
    pub fn with_value1(self, value1: u64) -> Self {
        Self {
            value1: Some(value1),
            ..self
        }
    }

    /// Sets the second value of the response.
    pub fn with_value2(self, value2: u64) -> Self {
        Self {
            value2: Some(value2),
            ..self
        }
    }

    /// Sets the third value of the response.
    pub fn with_value3(self, value3: u64) -> Self {
        Self {
            value3: Some(value3),
            ..self
        }
    }

    /// Sets the fourth value of the response.
    pub fn with_value4(self, value4: u64) -> Self {
        Self {
            value4: Some(value4),
            ..self
        }
    }

    /// Sets the completion result of the response.
    ///
    /// When present, signals that the handler has finished processing
    /// and the bridge dispatch loop should terminate.
    pub fn with_result(self, result: T) -> Self {
        Self {
            result: Some(result),
            ..self
        }
    }

    /// Writes the response values into the given general-purpose registers.
    ///
    /// `None` values leave the corresponding register unchanged.
    pub fn write_to(&self, registers: &mut impl GpRegistersAdapter) {
        registers.write_response(self.value1, self.value2, self.value3, self.value4);
    }
}