kh_runtime/syscall/
common.rs1use crate::trap::TrapOutcome;
7
8pub const EPERM: i64 = 1;
10pub const ENOENT: i64 = 2;
11pub const EBADF: i64 = 9;
12pub const EFAULT: i64 = 14;
13pub const EEXIST: i64 = 17;
14pub const EINVAL: i64 = 22;
15pub const ENOSYS: i64 = 78;
16pub const ENOMEM: i64 = 12;
17
18#[derive(Debug, Clone, Copy)]
20pub struct SyscallArgs {
21 pub pc: u64,
23 pub number: u32,
25 pub x0: u64,
28 pub x1: u64,
29 pub x2: u64,
30 pub x3: u64,
31 pub x4: u64,
32 pub x5: u64,
33 pub x6: u64,
34}
35
36#[derive(Debug, Clone)]
38pub struct SyscallResult {
39 pub name: &'static str,
41 pub outcome: TrapOutcome,
43 pub retval: Option<u64>,
45 pub error: bool,
47}
48
49impl SyscallResult {
50 #[must_use]
52 pub const fn ok(name: &'static str, value: u64) -> Self {
53 Self {
54 name,
55 outcome: TrapOutcome::Continue,
56 retval: Some(value),
57 error: false,
58 }
59 }
60
61 #[must_use]
63 pub const fn err(name: &'static str, errno: i64) -> Self {
64 Self {
65 name,
66 outcome: TrapOutcome::Continue,
67 retval: Some(errno.unsigned_abs()),
68 error: true,
69 }
70 }
71
72 #[must_use]
74 pub const fn exit(code: i32) -> Self {
75 Self {
76 name: "exit",
77 outcome: TrapOutcome::Exit { code },
78 retval: None,
79 error: false,
80 }
81 }
82
83 #[must_use]
85 pub const fn thread_exit(name: &'static str) -> Self {
86 Self {
87 name,
88 outcome: TrapOutcome::ThreadExit,
89 retval: None,
90 error: false,
91 }
92 }
93}
94
95#[must_use]
97pub(crate) fn exit_status(x0: u64) -> i32 {
98 i32::try_from(x0 & 0xFF).unwrap_or(0)
99}
100
101#[must_use]
103pub(crate) fn reg_as_i32(x: u64) -> i32 {
104 let lo = u32::try_from(x & 0xFFFF_FFFF).unwrap_or(0);
105 i32::from_ne_bytes(lo.to_ne_bytes())
106}
107
108#[must_use]
110pub(crate) fn reg_as_i64(x: u64) -> i64 {
111 i64::from_ne_bytes(x.to_ne_bytes())
112}
113
114#[must_use]
116pub(crate) fn guest_ptr(addr: u64) -> *const u8 {
117 let u = usize::try_from(addr).unwrap_or(0);
118 std::ptr::with_exposed_provenance(u)
119}
120
121#[must_use]
123pub(crate) fn guest_ptr_mut(addr: u64) -> *mut u8 {
124 let u = usize::try_from(addr).unwrap_or(0);
125 std::ptr::with_exposed_provenance_mut(u)
126}
127
128#[must_use]
133#[allow(unsafe_code)]
134pub(crate) fn guest_slice<'a>(addr: u64, len: usize) -> &'a [u8] {
135 if len == 0 {
136 return &[];
137 }
138 unsafe { std::slice::from_raw_parts(guest_ptr(addr), len) }
140}
141
142#[must_use]
147#[allow(unsafe_code)]
148pub(crate) fn guest_slice_mut<'a>(addr: u64, len: usize) -> &'a mut [u8] {
149 if len == 0 {
150 return &mut [];
151 }
152 unsafe { std::slice::from_raw_parts_mut(guest_ptr_mut(addr), len) }
154}
155
156pub(crate) fn guest_write(addr: u64, data: &[u8]) {
161 guest_slice_mut(addr, data.len()).copy_from_slice(data);
162}
163
164#[must_use]
166pub(crate) fn guest_read_u32(addr: u64) -> u32 {
167 let mut le = [0_u8; 4];
168 le.copy_from_slice(guest_slice(addr, 4));
169 u32::from_le_bytes(le)
170}
171
172pub(crate) fn guest_write_u32(addr: u64, value: u32) {
174 guest_write(addr, &value.to_le_bytes());
175}
176
177#[must_use]
179pub(crate) fn guest_read_u64(addr: u64) -> u64 {
180 let mut le = [0_u8; 8];
181 le.copy_from_slice(guest_slice(addr, 8));
182 u64::from_le_bytes(le)
183}
184
185#[must_use]
187pub(crate) fn guest_read_i32(addr: u64) -> i32 {
188 i32::from_ne_bytes(guest_read_u32(addr).to_ne_bytes())
189}