sallyport 0.6.3

API for the Enarx hypervisor-microkernel boundary
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

// SPDX-License-Identifier: Apache-2.0

use super::super::types::Argv;
use super::Alloc;
use crate::guest::alloc::{Allocator, Collector};
use crate::item::gdbcall::Number;
use crate::Result;

/// Trait implemented by allocatable GDB calls, which are passed through directly to the host and do
/// not require custom handling logic.
///
/// # Example
/// ```rust
/// use sallyport::item::gdbcall::Number;
/// use sallyport::guest::call::types::Argv;
/// use sallyport::guest::gdbcall::PassthroughAlloc;
/// use sallyport::Result;
///
/// pub struct Read;
///
/// impl PassthroughAlloc for Read {
///     const NUM: Number = Number::Read;
///
///     type Argv = Argv<0>;
///     type Ret = u8;
///
///     fn stage(self) -> Self::Argv {
///         Argv([])
///     }
/// }
/// ```
pub trait PassthroughAlloc {
    /// GDB call number.
    ///
    /// For example, [`Number::Read`].
    const NUM: Number;

    /// The gdbcall argument vector.
    ///
    /// For example, [`call::types::Argv<0>`](crate::guest::call::types::Argv<0>).
    type Argv: Into<[usize; 4]>;

    /// Gdbcall return value.
    ///
    /// For example, `u8`.
    type Ret;

    /// Returns argument vector registers.
    fn stage(self) -> Self::Argv;
}

impl<'a, T: PassthroughAlloc> Alloc<'a> for T {
    const NUM: Number = T::NUM;

    type Argv = T::Argv;
    type Ret = T::Ret;

    type Staged = ();
    type Committed = ();
    type Collected = Result<T::Ret>;

    fn stage(self, _: &mut impl Allocator) -> Result<(Self::Argv, Self::Staged)> {
        Ok((T::stage(self), ()))
    }

    fn collect(_: Self::Committed, ret: Result<Self::Ret>, _: &impl Collector) -> Self::Collected {
        ret
    }
}

#[cfg_attr(feature = "doc", doc = "[`gdbstub::conn::Connection::flush`] call")]
#[repr(transparent)]
pub struct Flush;

impl PassthroughAlloc for Flush {
    const NUM: Number = Number::Flush;

    type Argv = Argv<0>;
    type Ret = ();

    fn stage(self) -> Self::Argv {
        Argv([])
    }
}

#[cfg_attr(
    feature = "doc",
    doc = "[`gdbstub::conn::Connection::on_session_start`] call"
)]
#[repr(transparent)]
pub struct OnSessionStart;

impl PassthroughAlloc for OnSessionStart {
    const NUM: Number = Number::OnSessionStart;

    type Argv = Argv<0>;
    type Ret = ();

    fn stage(self) -> Self::Argv {
        Argv([])
    }
}

#[cfg_attr(feature = "doc", doc = "[`gdbstub::conn::ConnectionExt::peek`] call")]
#[repr(transparent)]
pub struct Peek;

impl PassthroughAlloc for Peek {
    const NUM: Number = Number::Peek;

    type Argv = Argv<0>;
    type Ret = Option<u8>;

    fn stage(self) -> Self::Argv {
        Argv([])
    }
}

#[cfg_attr(feature = "doc", doc = "[`gdbstub::conn::ConnectionExt::read`] call")]
#[repr(transparent)]
pub struct Read;

impl PassthroughAlloc for Read {
    const NUM: Number = Number::Read;

    type Argv = Argv<0>;
    type Ret = u8;

    fn stage(self) -> Self::Argv {
        Argv([])
    }
}

#[cfg_attr(feature = "doc", doc = "[`gdbstub::conn::Connection::write`] call")]
#[repr(transparent)]
pub struct Write {
    pub byte: u8,
}

impl PassthroughAlloc for Write {
    const NUM: Number = Number::Write;

    type Argv = Argv<1>;
    type Ret = ();

    fn stage(self) -> Self::Argv {
        Argv([self.byte as _])
    }
}