最终答案以客人函数的结果正常返回。

为了实现这一点，我们引入了一个新的enum类型来表示我们希望宿主执行的操作，并在适当的时候产出它。

use lucet_runtime::lucet_hostcall;
use lucet_runtime::vmctx::Vmctx;

pub enum FactorialsK {
    Mult(u64, u64),
    Result(u64),
}

#[lucet_hostcall]
#[no_mangle]
pub fn hostcall_factorials(vmctx: &mut Vmctx, n: u64) -> u64 {
    fn fact(vmctx: &mut Vmctx, n: u64) -> u64 {
        let result = if n <= 1 {
            1
        } else {
            let n_rec = fact(vmctx, n - 1);
            // yield a request for the host to perform multiplication
            vmctx.yield_val_expecting_val(FactorialsK::Mult(n, n_rec))
            // once resumed, that yield evaluates to the multiplication result
        };
        // yield a result
        vmctx.yield_val(FactorialsK::Result(result));
        result
    }
    fact(vmctx, n)
}

因此，代码的宿主部分是一个解释器，它反复检查产出的值并执行相应的操作。当hostcall完成时，它以最终答案正常返回，因此我们退出循环当运行/恢复结果为Ok。

use lucet_runtime::{DlModule, Error, Limits, MmapRegion, Region};

let module = DlModule::load("factorials_guest.so").unwrap();
let region = MmapRegion::create(1, &Limits::default()).unwrap();
let mut inst = region.new_instance(module).unwrap();

let mut factorials = vec![];

let mut res = inst.run("run", &[]).unwrap();

while let Ok(val) = res.yielded_ref() {
    if let Some(k) = val.downcast_ref::<FactorialsK>() {
        match k {
            FactorialsK::Mult(n, n_rec) => {
                // guest wants us to multiply for it
                res = inst.resume_with_val(n * n_rec).unwrap();
            }
            FactorialsK::Result(n) => {
                // guest is returning an answer
                factorials.push(*n);
                res = inst.resume().unwrap();
            }
        }
    } else {
        panic!("didn't yield with expected type");
    }
}

// intermediate values are correct
assert_eq!(factorials.as_slice(), &[1, 2, 6, 24, 120]);
// final value is correct
assert_eq!(u64::from(res.unwrap_returned()), 120u64);

自定义信号处理程序

由于Lucet程序作为本地机器代码运行，因此在执行期间可能会出现如SIGSEGV和SIGFPE之类的信号。而不是让这些信号使整个进程崩溃，Lucet运行时安装了替代信号处理程序，以将影响限制在引发信号的实例上。

默认情况下，信号处理程序将实例状态设置为State::Fault，并从Instance::run()的调用中提前返回。但是，您可以通过为每个实例定义新的信号处理程序来实施自定义的错误恢复和日志记录行为。例如，以下信号处理程序在设置故障状态之前增加了一个之前看到的信号的计数器。

use lucet_runtime::{
    DlModule, Error, Instance, Limits, MmapRegion, Region, SignalBehavior, TrapCode,
};
use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};

static SIGNAL_COUNT: AtomicUsize = ATOMIC_USIZE_INIT;

fn signal_handler_count(
    _inst: &Instance,
    _trapcode: &Option<TrapCode>,
    _signum: libc::c_int,
    _siginfo_ptr: *const libc::siginfo_t,
    _ucontext_ptr: *const libc::c_void,
) -> SignalBehavior {
    SIGNAL_COUNT.fetch_add(1, Ordering::SeqCst);
    SignalBehavior::Default
}

let module = DlModule::load("/my/lucet/module.so").unwrap();
let region = MmapRegion::create(1, &Limits::default()).unwrap();
let mut inst = region.new_instance(module).unwrap();

// install the handler
inst.set_signal_handler(signal_handler_count);

match inst.run("raise_a_signal", &[]) {
    Err(Error::RuntimeFault(_)) => {
        println!("I've now handled {} signals!", SIGNAL_COUNT.load(Ordering::SeqCst));
    }
    res => panic!("unexpected result: {:?}", res),
}

在为Lucet运行时实现自定义信号处理程序时，通常关于信号安全的注意事项适用：请参阅signal-safety(7)。