Skip to content

Commit ce40760

Browse files
danbugsdanbugs
committed
[host/*] change API usage (MemoryRegions, MemMgrWrapper, etc.) across codebase
- temporarily comment out a lot of code (e.g., host/testing/mod.rs). - temporarily unuse seccomp stuff. - start using new mgr API and common API. - pending removal of writting host detail functions to memory. - change hv_handler to use new mgr API to get guest_function_dispatch_ptr. - remove layout/memory_region from mod.rs. - change RawPtr API (should probably be re-evaluated). Signed-off-by: danbugs <[email protected]>
1 parent 578d30c commit ce40760

22 files changed

+2012
-2038
lines changed

‎src/hyperlight_host/src/error.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,7 @@ use thiserror::Error;
4141

4242
#[cfg(target_os = "windows")]
4343
use crate::hypervisor::wrappers::HandleWrapper;
44-
use crate::mem::memory_region::MemoryRegionFlags;
44+
use crate::sandbox::sandbox_builder::MemoryRegionFlags;
4545
use crate::mem::ptr::RawPtr;
4646

4747
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]

‎src/hyperlight_host/src/func/call_ctx.rs

Lines changed: 167 additions & 161 deletions
Original file line numberDiff line numberDiff line change
@@ -72,7 +72,13 @@ impl MultiUseGuestCallContext {
7272
// !Send (and !Sync), we also don't need to worry about
7373
// synchronization
7474

75-
call_function_on_guest(&mut self.sbox, func_name, func_ret_type, args)
75+
call_function_on_guest(
76+
&mut self.sbox.hv_handler,
77+
&mut self.sbox.mem_mgr,
78+
func_name,
79+
func_ret_type,
80+
args,
81+
)
7682
}
7783

7884
/// Close out the context and get back the internally-stored
@@ -93,168 +99,168 @@ impl MultiUseGuestCallContext {
9399
/// and is not intended to be called publicly. It allows the state of the guest to be altered
94100
/// during the evolution of one sandbox state to another, enabling the new state created
95101
/// to be captured and stored in the Sandboxes state stack.
96-
///
97102
pub(crate) fn finish_no_reset(self) -> MultiUseSandbox {
98103
self.sbox
99104
}
100105
}
101106

102-
#[cfg(test)]
103-
mod tests {
104-
use std::sync::mpsc::sync_channel;
105-
use std::thread::{self, JoinHandle};
106-
107-
use hyperlight_common::flatbuffer_wrappers::function_types::{
108-
ParameterValue, ReturnType, ReturnValue,
109-
};
110-
use hyperlight_testing::simple_guest_as_string;
111-
112-
use crate::sandbox_state::sandbox::EvolvableSandbox;
113-
use crate::sandbox_state::transition::Noop;
114-
use crate::{GuestBinary, HyperlightError, MultiUseSandbox, Result, UninitializedSandbox};
115-
116-
fn new_uninit() -> Result<UninitializedSandbox> {
117-
let path = simple_guest_as_string().map_err(|e| {
118-
HyperlightError::Error(format!("failed to get simple guest path ({e:?})"))
119-
})?;
120-
UninitializedSandbox::new(GuestBinary::FilePath(path), None, None, None)
121-
}
122-
123-
/// Test to create a `MultiUseSandbox`, then call several guest functions
124-
/// on it across different threads.
125-
///
126-
/// This test works by passing messages between threads using Rust's
127-
/// [mpsc crate](https://doc.rust-lang.org/std/sync/mpsc). Details of this
128-
/// interaction are as follows.
129-
///
130-
/// One thread acts as the receiver (AKA: consumer) and owns the
131-
/// `MultiUseSandbox`. This receiver fields requests from N senders
132-
/// (AKA: producers) to make batches of calls.
133-
///
134-
/// Upon receipt of a message to execute a batch, a new
135-
/// `MultiUseGuestCallContext` is created in the receiver thread from the
136-
/// existing `MultiUseSandbox`, and the batch is executed.
137-
///
138-
/// After the batch is complete, the `MultiUseGuestCallContext` is done
139-
/// and it is converted back to the underlying `MultiUseSandbox`
140-
#[test]
141-
fn test_multi_call_multi_thread() {
142-
let (snd, recv) = sync_channel::<Vec<TestFuncCall>>(0);
143-
144-
// create new receiver thread and on it, begin listening for
145-
// requests to execute batches of calls
146-
let recv_hdl = thread::spawn(move || {
147-
let mut sbox: MultiUseSandbox = new_uninit().unwrap().evolve(Noop::default()).unwrap();
148-
while let Ok(calls) = recv.recv() {
149-
let mut ctx = sbox.new_call_context();
150-
for call in calls {
151-
let res = ctx
152-
.call(call.func_name.as_str(), call.ret_type, call.params)
153-
.unwrap();
154-
assert_eq!(call.expected_ret, res);
155-
}
156-
sbox = ctx.finish().unwrap();
157-
}
158-
});
159-
160-
// create new sender threads
161-
let send_handles: Vec<JoinHandle<()>> = (0..10)
162-
.map(|i| {
163-
let sender = snd.clone();
164-
thread::spawn(move || {
165-
let calls: Vec<TestFuncCall> = vec![
166-
TestFuncCall {
167-
func_name: "Echo".to_string(),
168-
ret_type: ReturnType::String,
169-
params: Some(vec![ParameterValue::String(
170-
format!("Hello {}", i).to_string(),
171-
)]),
172-
expected_ret: ReturnValue::String(format!("Hello {}", i).to_string()),
173-
},
174-
TestFuncCall {
175-
func_name: "CallMalloc".to_string(),
176-
ret_type: ReturnType::Int,
177-
params: Some(vec![ParameterValue::Int(i + 2)]),
178-
expected_ret: ReturnValue::Int(i + 2),
179-
},
180-
];
181-
sender.send(calls).unwrap();
182-
})
183-
})
184-
.collect();
185-
186-
for hdl in send_handles {
187-
hdl.join().unwrap();
188-
}
189-
// after all sender threads are done, drop the sender itself
190-
// so the receiver thread can exit. then, ensure the receiver
191-
// thread has exited.
192-
drop(snd);
193-
recv_hdl.join().unwrap();
194-
}
195-
196-
pub struct TestSandbox {
197-
sandbox: MultiUseSandbox,
198-
}
199-
200-
impl TestSandbox {
201-
pub fn new() -> Self {
202-
let sbox: MultiUseSandbox = new_uninit().unwrap().evolve(Noop::default()).unwrap();
203-
Self { sandbox: sbox }
204-
}
205-
pub fn call_add_to_static_multiple_times(mut self, i: i32) -> Result<TestSandbox> {
206-
let mut ctx = self.sandbox.new_call_context();
207-
let mut sum: i32 = 0;
208-
for n in 0..i {
209-
let result = ctx.call(
210-
"AddToStatic",
211-
ReturnType::Int,
212-
Some(vec![ParameterValue::Int(n)]),
213-
);
214-
sum += n;
215-
println!("{:?}", result);
216-
let result = result.unwrap();
217-
assert_eq!(result, ReturnValue::Int(sum));
218-
}
219-
let result = ctx.finish();
220-
assert!(result.is_ok());
221-
self.sandbox = result.unwrap();
222-
Ok(self)
223-
}
224-
225-
pub fn call_add_to_static(mut self, i: i32) -> Result<()> {
226-
for n in 0..i {
227-
let result = self.sandbox.call_guest_function_by_name(
228-
"AddToStatic",
229-
ReturnType::Int,
230-
Some(vec![ParameterValue::Int(n)]),
231-
);
232-
println!("{:?}", result);
233-
let result = result.unwrap();
234-
assert_eq!(result, ReturnValue::Int(n));
235-
}
236-
Ok(())
237-
}
238-
}
239-
240-
#[test]
241-
fn ensure_multiusesandbox_multi_calls_dont_reset_state() {
242-
let sandbox = TestSandbox::new();
243-
let result = sandbox.call_add_to_static_multiple_times(5);
244-
assert!(result.is_ok());
245-
}
246-
247-
#[test]
248-
fn ensure_multiusesandbox_single_calls_do_reset_state() {
249-
let sandbox = TestSandbox::new();
250-
let result = sandbox.call_add_to_static(5);
251-
assert!(result.is_ok());
252-
}
253-
254-
struct TestFuncCall {
255-
func_name: String,
256-
ret_type: ReturnType,
257-
params: Option<Vec<ParameterValue>>,
258-
expected_ret: ReturnValue,
259-
}
260-
}
107+
// TODO(danbugs:297): bring back
108+
// #[cfg(test)]
109+
// mod tests {
110+
// use std::sync::mpsc::sync_channel;
111+
// use std::thread::{self, JoinHandle};
112+
//
113+
// use hyperlight_common::flatbuffer_wrappers::function_types::{
114+
// ParameterValue, ReturnType, ReturnValue,
115+
// };
116+
// use hyperlight_testing::simple_guest_as_string;
117+
//
118+
// use crate::sandbox_state::sandbox::EvolvableSandbox;
119+
// use crate::sandbox_state::transition::Noop;
120+
// use crate::{GuestBinary, HyperlightError, MultiUseSandbox, Result, UninitializedSandbox};
121+
//
122+
// fn new_uninit() -> Result<UninitializedSandbox> {
123+
// let path = simple_guest_as_string().map_err(|e| {
124+
// HyperlightError::Error(format!("failed to get simple guest path ({e:?})"))
125+
// })?;
126+
// UninitializedSandbox::new(GuestBinary::FilePath(path), None, None, None)
127+
// }
128+
//
129+
// /// Test to create a `MultiUseSandbox`, then call several guest functions
130+
// /// on it across different threads.
131+
// ///
132+
// /// This test works by passing messages between threads using Rust's
133+
// /// [mpsc crate](https://doc.rust-lang.org/std/sync/mpsc). Details of this
134+
// /// interaction are as follows.
135+
// ///
136+
// /// One thread acts as the receiver (AKA: consumer) and owns the
137+
// /// `MultiUseSandbox`. This receiver fields requests from N senders
138+
// /// (AKA: producers) to make batches of calls.
139+
// ///
140+
// /// Upon receipt of a message to execute a batch, a new
141+
// /// `MultiUseGuestCallContext` is created in the receiver thread from the
142+
// /// existing `MultiUseSandbox`, and the batch is executed.
143+
// ///
144+
// /// After the batch is complete, the `MultiUseGuestCallContext` is done
145+
// /// and it is converted back to the underlying `MultiUseSandbox`
146+
// #[test]
147+
// fn test_multi_call_multi_thread() {
148+
// let (snd, recv) = sync_channel::<Vec<TestFuncCall>>(0);
149+
//
150+
// // create new receiver thread and on it, begin listening for
151+
// // requests to execute batches of calls
152+
// let recv_hdl = thread::spawn(move || {
153+
// let mut sbox: MultiUseSandbox = new_uninit().unwrap().evolve(Noop::default()).unwrap();
154+
// while let Ok(calls) = recv.recv() {
155+
// let mut ctx = sbox.new_call_context();
156+
// for call in calls {
157+
// let res = ctx
158+
// .call(call.func_name.as_str(), call.ret_type, call.params)
159+
// .unwrap();
160+
// assert_eq!(call.expected_ret, res);
161+
// }
162+
// sbox = ctx.finish().unwrap();
163+
// }
164+
// });
165+
//
166+
// // create new sender threads
167+
// let send_handles: Vec<JoinHandle<()>> = (0..10)
168+
// .map(|i| {
169+
// let sender = snd.clone();
170+
// thread::spawn(move || {
171+
// let calls: Vec<TestFuncCall> = vec![
172+
// TestFuncCall {
173+
// func_name: "Echo".to_string(),
174+
// ret_type: ReturnType::String,
175+
// params: Some(vec![ParameterValue::String(
176+
// format!("Hello {}", i).to_string(),
177+
// )]),
178+
// expected_ret: ReturnValue::String(format!("Hello {}", i).to_string()),
179+
// },
180+
// TestFuncCall {
181+
// func_name: "CallMalloc".to_string(),
182+
// ret_type: ReturnType::Int,
183+
// params: Some(vec![ParameterValue::Int(i + 2)]),
184+
// expected_ret: ReturnValue::Int(i + 2),
185+
// },
186+
// ];
187+
// sender.send(calls).unwrap();
188+
// })
189+
// })
190+
// .collect();
191+
//
192+
// for hdl in send_handles {
193+
// hdl.join().unwrap();
194+
// }
195+
// // after all sender threads are done, drop the sender itself
196+
// // so the receiver thread can exit. then, ensure the receiver
197+
// // thread has exited.
198+
// drop(snd);
199+
// recv_hdl.join().unwrap();
200+
// }
201+
//
202+
// pub struct TestSandbox {
203+
// sandbox: MultiUseSandbox,
204+
// }
205+
//
206+
// impl TestSandbox {
207+
// pub fn new() -> Self {
208+
// let sbox: MultiUseSandbox = new_uninit().unwrap().evolve(Noop::default()).unwrap();
209+
// Self { sandbox: sbox }
210+
// }
211+
// pub fn call_add_to_static_multiple_times(mut self, i: i32) -> Result<TestSandbox> {
212+
// let mut ctx = self.sandbox.new_call_context();
213+
// let mut sum: i32 = 0;
214+
// for n in 0..i {
215+
// let result = ctx.call(
216+
// "AddToStatic",
217+
// ReturnType::Int,
218+
// Some(vec![ParameterValue::Int(n)]),
219+
// );
220+
// sum += n;
221+
// println!("{:?}", result);
222+
// let result = result.unwrap();
223+
// assert_eq!(result, ReturnValue::Int(sum));
224+
// }
225+
// let result = ctx.finish();
226+
// assert!(result.is_ok());
227+
// self.sandbox = result.unwrap();
228+
// Ok(self)
229+
// }
230+
//
231+
// pub fn call_add_to_static(mut self, i: i32) -> Result<()> {
232+
// for n in 0..i {
233+
// let result = self.sandbox.call_guest_function_by_name(
234+
// "AddToStatic",
235+
// ReturnType::Int,
236+
// Some(vec![ParameterValue::Int(n)]),
237+
// );
238+
// println!("{:?}", result);
239+
// let result = result.unwrap();
240+
// assert_eq!(result, ReturnValue::Int(n));
241+
// }
242+
// Ok(())
243+
// }
244+
// }
245+
//
246+
// #[test]
247+
// fn ensure_multiusesandbox_multi_calls_dont_reset_state() {
248+
// let sandbox = TestSandbox::new();
249+
// let result = sandbox.call_add_to_static_multiple_times(5);
250+
// assert!(result.is_ok());
251+
// }
252+
//
253+
// #[test]
254+
// fn ensure_multiusesandbox_single_calls_do_reset_state() {
255+
// let sandbox = TestSandbox::new();
256+
// let result = sandbox.call_add_to_static(5);
257+
// assert!(result.is_ok());
258+
// }
259+
//
260+
// struct TestFuncCall {
261+
// func_name: String,
262+
// ret_type: ReturnType,
263+
// params: Option<Vec<ParameterValue>>,
264+
// expected_ret: ReturnValue,
265+
// }
266+
// }

0 commit comments

Comments
 (0)