Files
ssw-mpc/crates/mpc-hostd/src/runtime.rs
T
admin 3fc34904ba feat(chain): 国密链真交易形态跑通,挖出并修掉签名格式、幂等状态机、僵尸进程三个真缺口
交易编码(新增)
- crates/mpc-chain/src/fisco_tx.rs:FISCO 国密链自有交易编码(TARS 二进制)
  + dataHash(SM3) + prehashed SM2 签名 + 已签名交易构造。
  逐字节对齐官方 bcos-sdk-jni 基准(V0 / V1 两个样本)。
- crates/mpc-chain/src/contract.rs:合约调用编码,选择子 = SM3 前 4 字节
  (国密链取 ABI selector[1],不是 keccak256 的 selector[0])。
- crates/mpc-chain/src/rpc.rs:ChainClient::send_transaction(4 参)+ ChainSubmitResult。

真缺口一:交易签名少了公钥
- 上游 signTransactionDataHash() 传 _signatureWithPub=true ⇒ 签名是
  r||s||pub(128 字节),公钥为裸 64 字节 X||Y。
- 只签 64 字节 r||s 的交易,节点侧 recover() 解析不出公钥 ⇒ 交易被拒。
- 新增 TX_SIGNATURE_LEN 与判据 transaction_signature_is_raw_rs_followed_by_the_public_key。

真缺口二:signed-tx 绕过 outbox 状态机 ⇒ 幂等性破
- 原来自己遍历 entries,从不写回 Confirmed ⇒ 二次 flush 会把同一笔再发一遍。
- 改为统一走 Outbox::flush_with:同一份状态机不许另起一套实现。

真缺口三:僵尸进程被当成活实例
- /proc/<pid>/stat 对僵尸仍存在、starttime 仍读得到 ⇒ 身份被误判为已确认
  ⇒ restore() 把已死实例标成 Running,站点端以为它还在跑。
- process_start_key() 显式排除 state=Z/X(Linux)与 ps -o state= 的 Z/I(macOS)。
- 新增判据 zombie_process_is_not_treated_as_alive。

判据
- tools/selftest-chain-tx.py:真链形态 44 条判据,含真 TARS 解析器、
  成功判据三件套、幂等、8 类负向;接入 tools/ci.sh 第 21 条(门禁 20→21)。
- 修判据脚本自身三个 bug:failed 是二维数组却被按字符串子串查(永远为假)、
  SIMPLE_LIST 类型码是 13 而非 0x13、TARS 解析只跳头不跳值导致错位。

文档
- docs/FISCO_UPSTREAM_TRUTH.md:FISCO 上游真相源逐条固化
  (TARS 编码 / dataHash / prehashed SM2 / r||s||pub / sendTransaction 4 参 /
  回执字段 / SM3 选择子 / status==0 才是成功 / gasUsed 是 hex 串)。

诚实边界:交易编码已对齐官方 SDK,但只在假 bcos-rpc 上验过框架契约,
不等于真链能上链;真链部署与调用仍未做。
2026-11-08 10:48:50 +08:00

1616 lines
63 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! [`TeeRuntime`] —— 宿主侧的 TEE 实例生命周期管理。
//!
//! # 它替代的是什么
//!
//! 现在跑一个 guest 的方式是 `deploy/tee/launch.sh` 里
//! `os.execvp(qemu)` —— **进程交出去,控制面就失联了**。
//! 谁在跑、跑了多久、为什么退出,全无记录。
//! 「部署」的定义是**能被观察和回收**,exec 之后做不到这件事。
//!
//! 所以运行时必须持有进程句柄:
//!
//! - [`TeeRuntime::spawn`] 用 [`std::process::Command::spawn`] 而不是 `exec`,
//! 拿到 [`Child`] 才能观察退出码;
//! - reaper 定期扫状态表,把「已经退出的」标成终态并回收;
//! - 状态**落盘**,重启后能恢复。
//!
//! # ★ 孤儿进程不能只按 pid 判断
//!
//! pid 会被复用:宿主重启后,旧 pid 很可能已经被别的进程占着。
//! 只按 pid 判断会「误杀」——把一个完全无关的进程当成残留 qemu 杀掉。
//! 所以每个实例同时记录 **pid + 启动时间**,重启后校验两者都对上,
//! 才认定「这个进程还是我起的那一个」。
//!
//! 启动时间取自 `/proc/<pid>/stat` 的第 22 字段(starttime,进程启动以来的时钟滴答)。
//! **这是 Linux 专有的**:macOS / Windows 没有这个接口。
//! 非 Linux 平台上「启动时间」退化为「创建时的墙钟时间」,
//! 比对精度差,但仍然比只比 pid 强(pid 复用有窗口,墙钟时间几乎不重合)。
//!
//! # 两类平台的语义差异
//!
//! | | 海光 CSV / AMD SNP | ARM OP-TEE |
//! |---|---|---|
//! | 宿主动作 | `spawn(qemu)` | **attach** 到已存在的 `/dev/tee0` |
//! | 生命周期 | 进程级:起 → 跑 → 退 | **会话级**:CA 打开 → 调 TA → 关会话 |
//! | 回收 | kill qemu | 关 CA 会话。**杀进程等于杀掉别人的会话** |
//!
//! 所以 OP-TEE 走 [`TeeRuntime::attach`]:**不新建接口**,但生命周期语义不同。
//! 硬把 OP-TEE 套成 VM 会让 reaper 变成事故源。
use std::collections::HashMap;
use std::io;
use std::path::PathBuf;
use std::process::{Child, Command, Stdio};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use crate::json::{Json, JsonObject};
use mpc_tee::PlatformKind;
/// 一个受管实例的状态。
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum InstanceState {
/// 刚创建,正在启动。
Starting,
/// 运行中。
Running,
/// 已暂停(`POST /sandboxes/{id}/pause`)。
Paused,
/// 正常退出。
Exited,
/// 异常终止(被信号杀死等)。
Failed,
/// 已回收(终态,reaper 已清理)。
Reaped,
}
impl InstanceState {
/// e2b 兼容面用的状态名。
pub fn as_str(self) -> &'static str {
match self {
Self::Starting => "starting",
Self::Running => "running",
Self::Paused => "paused",
Self::Exited => "exited",
Self::Failed => "failed",
Self::Reaped => "reaped",
}
}
/// 是否是终态。
pub fn is_terminal(self) -> bool {
matches!(self, Self::Exited | Self::Failed | Self::Reaped)
}
}
/// 一个受管实例的完整记录。
#[derive(Debug, Clone)]
pub struct Instance {
/// 沙箱 ID(e2b 语义,20 位小写 hex)。
pub sandbox_id: String,
/// 关联的 MPC 会话 ID。**会话是唯一主键**(见 `docs/INTEGRATION_ANALYSIS.md` 第 5 节)。
pub session_id: String,
/// 站点名。
pub site: String,
/// 平台类型。
pub platform: PlatformKind,
/// e2b 的 template —— 对 TEE 而言是**度量集合**,不是镜像。
pub template: String,
/// 启动用的命令(已展开的可执行文件路径)。
pub argv: Vec<String>,
/// 子进程 pid。OP-TEE attach 场景为 `None`(没有独立进程)。
pub pid: Option<u32>,
/// 进程的**启动标识** —— 用来识别「这个 pid 还是我起的那一个」。
///
/// ★ 这不是 pid 本身:pid 会被复用,只按 pid 判断会误杀别人的进程。
///
/// 平台相关的具体表示:
/// - Linux:`/proc/<pid>/stat` 的第 22 字段(starttime,进程启动以来的时钟滴答);
/// - macOS / BSD:`ps -p <pid> -o lstart=` 的输出(精确到秒);
/// - 拿不到的平台:`None`。
///
/// `None` 的含义是「**无法确认**」,不是「不匹配」。
/// 这种情况下本框架**一律判为不存活**(fail-closed)——
/// 宁可漏收一个实例,也不能对着一个身份不明的进程发信号。
pub start_key: Option<String>,
/// 创建时的墙钟秒。
pub created_at: u64,
/// 当前状态。
pub state: InstanceState,
/// 退出码(仅终态有值)。
pub exit_code: Option<i32>,
/// 运行时长(秒)。
pub timeout_secs: u64,
/// 暂停标记。
pub paused: bool,
/// OP-TEE 会话标识(attach 场景)。
pub optee_session: Option<String>,
}
impl Instance {
/// 运行了多少秒(按创建时刻算)。
pub fn uptime_secs(&self) -> u64 {
now_secs().saturating_sub(self.created_at)
}
}
/// 启动一个实例需要的全部信息。
#[derive(Debug, Clone)]
pub struct SpawnSpec {
/// 关联的 MPC 会话 ID。
pub session_id: String,
/// 站点名。
pub site: String,
/// 平台类型。
pub platform: PlatformKind,
/// e2b template(度量集合标识)。
pub template: String,
/// 可执行文件。
pub program: String,
/// 参数(不含 argv[0])。
pub args: Vec<String>,
/// 超时秒数(0 = 不自动杀)。
pub timeout_secs: u64,
}
impl SpawnSpec {
/// 构造一个启动规格。
pub fn new(
session_id: impl Into<String>,
site: impl Into<String>,
platform: PlatformKind,
program: impl Into<String>,
) -> Self {
Self {
session_id: session_id.into(),
site: site.into(),
platform,
template: String::new(),
program: program.into(),
args: Vec::new(),
timeout_secs: 0,
}
}
}
/// 运行时错误。
#[derive(Debug)]
pub enum RuntimeError {
/// 找不到实例。
NotFound(String),
/// 实例已存在(session_id 重复)。
Duplicate(String),
/// 平台不支持这个动作。
Unsupported(String),
/// 启动失败。
Spawn(String),
/// IO 错误。
Io(String),
}
impl std::fmt::Display for RuntimeError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::NotFound(s) => write!(f, "实例不存在: {s}"),
Self::Duplicate(s) => write!(f, "实例已存在: {s}"),
Self::Unsupported(s) => write!(f, "不支持的操作: {s}"),
Self::Spawn(s) => write!(f, "启动失败: {s}"),
Self::Io(s) => write!(f, "IO 错误: {s}"),
}
}
}
impl std::error::Error for RuntimeError {}
/// 宿主侧的 TEE 运行时。
///
/// 内部状态表由 `Mutex` 保护;`Child` 句柄**不放进表里**——
/// `Child` 不是 `Send` 的可克隆结构,且一旦进程被 reap,`Child` 就失效了。
/// 运行时只需要「进程是否还活着」这一位信息,用 `try_wait` 就够。
pub struct TeeRuntime {
/// 实例表:`sandbox_id` → 实例。
table: Mutex<HashMap<String, Instance>>,
/// 子进程句柄表:`sandbox_id` → `Child`。
///
/// ★ 必须持有它,否则会留下**僵尸进程**。
///
/// Rust 的 `Child` 在 drop 时**不会** wait 子进程 —— 它只是把句柄丢掉,
/// 子进程退出后变成 zombie。而僵尸在 `/proc/<pid>/stat` 里**仍然存在**、
/// starttime 也不变,于是 `process_alive_with_start_time` 永远返回 true,
/// 实例永远收不掉,reaper 变成空转。
///
/// 持有 `Child` 后,reaper 用 `try_wait()` 收割:它既能回收僵尸,
/// 又能拿到退出码(退出码是「这个实例为什么结束」的唯一来源)。
children: Mutex<HashMap<String, Child>>,
/// 状态落盘路径。
state_file: Option<PathBuf>,
/// reaper 是否还在跑。
running: AtomicBool,
}
impl TeeRuntime {
/// 建一个不带落盘的运行时(测试与一次性会话用)。
pub fn new() -> Self {
Self {
table: Mutex::new(HashMap::new()),
children: Mutex::new(HashMap::new()),
state_file: None,
running: AtomicBool::new(false),
}
}
/// 建一个带落盘的运行时。
pub fn with_state_file(path: impl Into<PathBuf>) -> Self {
Self {
table: Mutex::new(HashMap::new()),
children: Mutex::new(HashMap::new()),
state_file: Some(path.into()),
running: AtomicBool::new(false),
}
}
/// 从落盘文件恢复实例表。
///
/// **恢复不等于信任**:恢复出来的实例要重新核对「pid + 启动时间」,
/// 核对不上的说明进程已经没了(或 pid 被复用了),直接标成终态。
pub fn restore(&self) -> Result<usize, RuntimeError> {
let path = match &self.state_file {
Some(p) => p.clone(),
None => return Ok(0),
};
let raw = match std::fs::read_to_string(&path) {
Ok(s) => s,
Err(e) if e.kind() == io::ErrorKind::NotFound => return Ok(0),
Err(e) => return Err(RuntimeError::Io(format!("读状态文件失败: {e}"))),
};
let v = crate::json::parse(&raw)
.map_err(|e| RuntimeError::Io(format!("状态文件不是合法 JSON: {e}")))?;
// 形状:{"instances": [...]}。
// ★ 必须与 `flush` 写出的形状严格一致 —— 一边写数组一边读对象,
// 症状是「重启后一台实例都没有」,而日志里看不出是形状问题。
let items = match &v {
Json::Obj(m) => match m.get("instances") {
Some(Json::Arr(a)) => a.clone(),
_ => {
return Err(RuntimeError::Io(String::from(
"状态文件缺少 instances 数组",
)))
}
},
// 兼容早期写法:顶层就是数组。
Json::Arr(a) => a.clone(),
_ => return Err(RuntimeError::Io(String::from("状态文件形状不对"))),
};
let mut n = 0usize;
{
let mut table = self.table.lock().unwrap();
for it in items {
let obj = match it {
Json::Obj(m) => m,
_ => continue,
};
let mut inst = Instance {
sandbox_id: get_str(&obj, "sandbox_id").unwrap_or_default(),
session_id: get_str(&obj, "session_id").unwrap_or_default(),
site: get_str(&obj, "site").unwrap_or_default(),
platform: PlatformKind::None,
template: get_str(&obj, "template").unwrap_or_default(),
argv: Vec::new(),
pid: get_int(&obj, "pid")
.filter(|v| *v > 0)
.map(|v| v as u32),
start_key: get_str(&obj, "start_key"),
created_at: get_int(&obj, "created_at").unwrap_or(0) as u64,
state: InstanceState::Exited,
exit_code: get_int(&obj, "exit_code").map(|v| v as i32),
timeout_secs: get_int(&obj, "timeout_secs").unwrap_or(0) as u64,
paused: false,
optee_session: get_str(&obj, "optee_session"),
};
if let Some(p) = get_str(&obj, "platform") {
inst.platform = match p.as_str() {
"sev-snp" => PlatformKind::SevSnp,
"hygon-csv" => PlatformKind::HygonCsv,
"tdx" => PlatformKind::Tdx,
"optee" => PlatformKind::Optee,
_ => PlatformKind::None,
};
}
if inst.sandbox_id.is_empty() {
continue;
}
// ★ 孤儿校验:pid 与启动时间都要对上,才算「还活着」。
if let Some(pid) = inst.pid {
if process_alive(pid, inst.start_key.as_deref()) {
inst.state = InstanceState::Running;
} else {
// 进程没了,或 pid 已被复用 —— 标成已退出,
// 绝不能把它当成还在跑(那会让站点端以为实例活着)。
inst.state = InstanceState::Exited;
inst.pid = None;
}
} else {
// OP-TEE attach 场景没有进程,状态由会话存在性决定。
inst.state = if inst.optee_session.is_some() {
InstanceState::Running
} else {
InstanceState::Exited
};
}
table.insert(inst.sandbox_id.clone(), inst);
n += 1;
}
}
Ok(n)
}
/// 启动一个实例(进程级平台)。
///
/// 用 [`Command::spawn`] 而不是 `exec`:exec 之后进程与调用方脱钩,
/// 控制面再也拿不到它的退出码,也就没法回收。
pub fn spawn(&self, spec: &SpawnSpec) -> Result<Instance, RuntimeError> {
let mut cmd = Command::new(&spec.program);
cmd.args(&spec.args);
// 不用 `exec()`:子进程要能继承宿主关闭的 stdout/stderr 的行为,
// 但 stdin 必须断开 —— 否则子进程会一直等着读 stdin,
// 而宿主控制面永远不会喂它。
cmd.stdin(Stdio::null());
cmd.stdout(Stdio::inherit());
cmd.stderr(Stdio::inherit());
let child: Child = cmd
.spawn()
.map_err(|e| RuntimeError::Spawn(format!("{}: {e}", spec.program)))?;
let pid = child_pid(&child);
let start_key = process_start_key(pid);
let sandbox_id = new_sandbox_id();
let inst = Instance {
sandbox_id: sandbox_id.clone(),
session_id: spec.session_id.clone(),
site: spec.site.clone(),
platform: spec.platform,
template: spec.template.clone(),
argv: std::iter::once(spec.program.clone())
.chain(spec.args.iter().cloned())
.collect(),
pid: Some(pid),
start_key,
created_at: now_secs(),
state: InstanceState::Starting,
exit_code: None,
timeout_secs: spec.timeout_secs,
paused: false,
optee_session: None,
};
// 立刻放一个哨兵进表:即使后面落盘失败,内存里也知道这个实例存在。
{
let mut table = self.table.lock().unwrap();
table.insert(sandbox_id.clone(), inst.clone());
}
// ★ 句柄必须留下:丢了就会留僵尸,reaper 永远收不掉。
self.children.lock().unwrap().insert(sandbox_id.clone(), child);
self.flush()?;
// 进程还活着就标成 running。
let alive = {
let mut ch = self.children.lock().unwrap();
match ch.get_mut(&sandbox_id) {
Some(c) => c.try_wait().map(|s| s.is_none()).unwrap_or(true),
None => true,
}
};
self.set_state(&sandbox_id, |i| {
if alive {
i.state = InstanceState::Running;
}
});
self.flush()?;
Ok(self.get(&sandbox_id).unwrap_or(inst))
}
/// 附加到一个已存在的 TEE 会话(OP-TEE 场景)。
///
/// **不创建任何进程**:OP-TEE 的 TA 是设备级单例,所有 CA 共享。
/// 杀掉进程等于杀掉别人的会话,所以这里只登记会话句柄。
pub fn attach(&self, spec: &SpawnSpec, optee_session: &str) -> Result<Instance, RuntimeError> {
if spec.platform != PlatformKind::Optee {
return Err(RuntimeError::Unsupported(format!(
"attach 只用于 OP-TEE,{:?} 走 spawn",
spec.platform
)));
}
if optee_session.is_empty() {
return Err(RuntimeError::Spawn(String::from("OP-TEE 会话 ID 为空")));
}
let sandbox_id = new_sandbox_id();
let inst = Instance {
sandbox_id: sandbox_id.clone(),
session_id: spec.session_id.clone(),
site: spec.site.clone(),
platform: spec.platform,
template: spec.template.clone(),
argv: Vec::new(),
pid: None,
start_key: None,
created_at: now_secs(),
state: InstanceState::Running,
exit_code: None,
timeout_secs: spec.timeout_secs,
paused: false,
optee_session: Some(String::from(optee_session)),
};
let mut table = self.table.lock().unwrap();
table.insert(sandbox_id.clone(), inst.clone());
drop(table);
self.flush()?;
Ok(inst)
}
/// 取一个实例。
pub fn get(&self, id: &str) -> Option<Instance> {
self.table.lock().unwrap().get(id).cloned()
}
/// 列出全部实例(按创建时间排序)。
pub fn list(&self) -> Vec<Instance> {
let table = self.table.lock().unwrap();
let mut v: Vec<Instance> = table.values().cloned().collect();
v.sort_by_key(|i| i.created_at);
v
}
/// 按会话 ID 找实例。
pub fn find_by_session(&self, session_id: &str) -> Option<Instance> {
self.table
.lock()
.unwrap()
.values()
.find(|i| i.session_id == session_id)
.cloned()
}
/// 停止一个实例。
///
/// OP-TEE 场景**只关会话**,不动任何进程 —— 杀进程等于杀掉别人的 TA 会话。
///
/// # 怎么杀:优先用**子进程句柄**,不用外部 `kill` 命令
///
/// `Child::kill()` 由标准库实现,走 `waitpid`/`kill` 系统调用,
/// 两个好处:
/// - **不依赖外部命令** —— 受限容器里 `ps` / `kill` 可能被禁,
/// 而宿主控制面恰恰可能就跑在这种环境里;
/// - **天然免疫 pid 复用** —— 句柄指向内核里的**具体那个进程**,
/// 不像裸 pid 那样可能指向别人的进程。
///
/// 只有**重启后恢复的实例**(没有句柄)才退回裸 pid,
/// 而那条路必须先过身份确认(见 [`process_identity_confirmed`])。
pub fn stop(&self, id: &str) -> Result<Instance, RuntimeError> {
let inst = self
.get(id)
.ok_or_else(|| RuntimeError::NotFound(String::from(id)))?;
if inst.platform == PlatformKind::Optee {
// OP-TEE:关会话。TA 进程是设备级单例,不能杀。
self.set_state(id, |i| {
i.state = InstanceState::Exited;
i.optee_session = None;
i.pid = None;
});
self.flush()?;
return self
.get(id)
.ok_or_else(|| RuntimeError::NotFound(String::from(id)));
}
// 路径一:有句柄 → 用句柄杀。
if self.has_child(id) {
self.kill_via_handle(id);
// ★ kill 是**异步**的:刚发出去时进程通常还没死。
// 必须等它真的退出再收割,否则会拿到 None(当成还在跑),
// 状态也会被错记成「还在跑」。
// `code` 的类型是 `Option<Option<i32>>`:
// 外层「收割到了吗」,内层「退出码(信号终止时为 None)」。
let mut code: Option<Option<i32>> = None;
for _ in 0..100 {
std::thread::sleep(Duration::from_millis(20));
if let Some(c) = self.harvest_child(id) {
code = Some(c);
break;
}
}
let code = code.flatten();
self.set_state(id, |i| {
i.state = exit_state(code);
i.exit_code = code;
i.pid = None;
});
self.flush()?;
return self
.get(id)
.ok_or_else(|| RuntimeError::NotFound(String::from(id)));
}
// 路径二:没有句柄(重启后恢复的实例)→ 只能用裸 pid,
// 所以**必须**先确认身份,否则绝不能发信号。
if let Some(pid) = inst.pid {
match process_identity_confirmed(pid, inst.start_key.as_deref()) {
Some(true) => {
kill_pid(pid);
// 身份已确认 ⇒ 这个 pid 在进程被回收前不会被发给别人,
// 所以这里用「进程还在不在」等退出即可,不必再比 start_key。
for _ in 0..100 {
std::thread::sleep(Duration::from_millis(20));
if !process_exists(pid) {
break;
}
}
if process_exists(pid) {
kill_pid_hard(pid);
}
}
Some(false) => {
// pid 已被复用 —— 那个进程不是我们的,绝不能动它。
}
None => {
// 身份无法确认 → 不发任何信号(fail-closed)。
// 宁可漏收,也不误杀别人的进程。
}
}
}
self.set_state(id, |i| {
i.state = InstanceState::Failed;
i.pid = None;
});
self.flush()?;
self.get(id)
.ok_or_else(|| RuntimeError::NotFound(String::from(id)))
}
/// **删除**一个实例记录(e2b 的 `DELETE /sandboxes/{id}` 语义)。
///
/// ★ 与 [`Self::stop`] 的区别:`stop` 只**停进程并标终态**,
/// 记录仍在表里 —— 那是 reaper 的语义(「不删除记录,删掉就没法回答
/// 『这个实例后来怎么了』」)。
/// 但 e2b 兼容面的 `DELETE /sandboxes/{id}` 是**显式删除**:
/// 删完之后 `GET /sandboxes` 不应再返回它。
///
/// 2026-11-07 真机联调(沙箱管理节点 → 海光真机)实测发现的缺口:
/// `DELETE` 之前只调 `stop()`,实例仍留在列表里 —— 注释说「显式删除」
/// 而实现没删,与 e2b 语义不符。
///
/// 顺序很要紧:**先 stop(收进程、收僵尸)再删记录** ——
/// 反过来的话进程就没人管了,会留下僵尸。
pub fn remove(&self, id: &str) -> Result<(), RuntimeError> {
// 1. 先停:找不到实例直接报错(e2b 的 DELETE 对不存在的实例返回 404)。
let _ = self.stop(id)?;
// 2. 删记录 + 删子进程句柄(句柄留着会漏掉僵尸)。
{
let mut table = self.table.lock().unwrap();
table.remove(id);
}
{
let mut children = self.children.lock().unwrap();
children.remove(id);
}
self.flush()?;
Ok(())
}
/// 暂停一个实例。
///
/// qemu 没有 SIGSTOP 等价物,但 **Linux 上可以真的 SIGSTOP**。
/// 对 VM 平台发 SIGSTOP 会冻结 guest —— 这正是 pause 的语义。
pub fn pause(&self, id: &str) -> Result<Instance, RuntimeError> {
let inst = self
.get(id)
.ok_or_else(|| RuntimeError::NotFound(String::from(id)))?;
if inst.paused {
return Ok(inst);
}
if let Some(pid) = inst.pid {
self.deliver_signal(id, &inst, pid, SignalOp::Stop)?;
}
self.set_state(id, |i| {
i.paused = true;
i.state = InstanceState::Paused;
});
self.flush()?;
self.get(id)
.ok_or_else(|| RuntimeError::NotFound(String::from(id)))
}
/// 恢复一个实例。
pub fn resume(&self, id: &str) -> Result<Instance, RuntimeError> {
let inst = self
.get(id)
.ok_or_else(|| RuntimeError::NotFound(String::from(id)))?;
if !inst.paused {
return Ok(inst);
}
if let Some(pid) = inst.pid {
self.deliver_signal(id, &inst, pid, SignalOp::Continue)?;
}
self.set_state(id, |i| {
i.paused = false;
i.state = InstanceState::Running;
});
self.flush()?;
self.get(id)
.ok_or_else(|| RuntimeError::NotFound(String::from(id)))
}
/// 给实例的进程投递一个信号。
///
/// # 身份判据的优先级(这里曾经搞反过)
///
/// 1. **有子进程句柄** → 身份**天然确定**。
/// 句柄指向内核里的**具体那个进程**,pid 在进程被回收前不可能
/// 被发给别人 —— 所以不需要 `start_key` 二次确认。
/// 这也是**唯一在受限容器里也能用**的路(`ps` 被禁时 `start_key` 恒 `None`)。
/// 2. **没有句柄**(重启后从状态文件恢复的孤儿)→ 只能靠裸 pid,
/// 必须用 [`process_identity_confirmed`] 的三态:
/// - `Some(true)` 确认是同一个 → 可以发;
/// - `Some(false)` 确认不是(pid 被复用)→ **绝不能发**;
/// - `None` 无法确认 → 同样**绝不能发**(fail-closed)。
///
/// # fail-closed 落在哪
///
/// 不是「误判存活」,而是「**不发信号**」——
/// 宁可漏收一个实例,也不能对着身份不明的进程发 SIGTERM。
fn deliver_signal(
&self,
id: &str,
inst: &Instance,
pid: u32,
op: SignalOp,
) -> Result<(), RuntimeError> {
if self.has_child(id) {
// 句柄在 ⇒ 身份确定,直接发。
if !signal_pid(pid, op) {
// 发不出信号 → **不能假装暂停/恢复成功**。
// 「假装成功」意味着站点端以为实例停了,其实它还在跑。
return Err(RuntimeError::Spawn(format!(
"无法投递 SIG{}(系统缺少可用的 kill 命令)",
op.name()
)));
}
return Ok(());
}
// 没有句柄 → 裸 pid,必须先确认身份。
match process_identity_confirmed(pid, inst.start_key.as_deref()) {
Some(true) => {
if !signal_pid(pid, op) {
return Err(RuntimeError::Spawn(format!(
"无法投递 SIG{}(系统缺少可用的 kill 命令)",
op.name()
)));
}
Ok(())
}
Some(false) => Err(RuntimeError::Spawn(String::from(
"pid 已被复用,拒绝发信号",
))),
None => Err(RuntimeError::Spawn(String::from(
"无法确认进程身份,拒绝发信号",
))),
}
}
/// 修改超时。
pub fn set_timeout(&self, id: &str, secs: u64) -> Result<Instance, RuntimeError> {
if self.get(id).is_none() {
return Err(RuntimeError::NotFound(String::from(id)));
}
self.set_state(id, |i| i.timeout_secs = secs);
self.flush()?;
self.get(id)
.ok_or_else(|| RuntimeError::NotFound(String::from(id)))
}
/// 扫描并回收已退出的实例。
///
/// 返回被标记为终态的实例数量。
///
/// **不删除记录**,只改状态:删掉就没法回答「这个实例后来怎么了」。
/// e2b 兼容面里 `DELETE /sandboxes/{id}` 才是显式删除。
pub fn reap(&self) -> usize {
let mut changed = 0usize;
let ids: Vec<String> = self.table.lock().unwrap().keys().cloned().collect();
for id in ids {
let inst = match self.get(&id) {
Some(i) => i,
None => continue,
};
if inst.state.is_terminal() {
// 终态实例仍要收割它的子进程(否则僵尸留着)。
self.harvest_child(&id);
continue;
}
// 暂停中的实例本来就该是停的,不动它。
if inst.paused {
continue;
}
// 超时:到了时间就杀掉。
if inst.timeout_secs > 0 && inst.uptime_secs() >= inst.timeout_secs {
let _ = self.stop(&id);
changed += 1;
continue;
}
// ★ 先问子进程句柄:它退出后 try_wait 会返回 Some(status),
// 同时把僵尸收掉。这是唯一可靠的「进程真的结束了」判据 ——
// 只看 /proc 的话,僵尸还在,pid 还在,会被判成「还活着」。
if let Some(code) = self.harvest_child(&id) {
self.set_state(&id, |i| {
i.state = exit_state(code);
i.exit_code = code;
i.pid = None;
});
changed += 1;
continue;
}
// 没有句柄(重启后恢复的实例):退回 /proc 判据。
if let Some(pid) = inst.pid {
// 身份不符(pid 被复用)→ 判为已退出;
// 身份无法确认 → 保守地判为已退出(fail-closed:
// 不能确认的实例不该继续被当成活着的)。
let gone = match process_identity_confirmed(pid, inst.start_key.as_deref()) {
Some(true) => false,
Some(false) => true,
None => !self.child_running(&id),
};
if gone {
self.set_state(&id, |i| {
i.state = InstanceState::Exited;
i.pid = None;
});
changed += 1;
}
}
}
if changed > 0 {
let _ = self.flush();
}
changed
}
/// 是否还持有这个实例的子进程句柄。
fn has_child(&self, id: &str) -> bool {
self.children.lock().unwrap().contains_key(id)
}
/// 用子进程句柄杀掉进程。
///
/// `Child::kill()` 走系统调用,不依赖外部 `kill` 命令,
/// 且句柄指向内核里的**具体那个进程** —— 天然免疫 pid 复用。
fn kill_via_handle(&self, id: &str) {
let mut ch = self.children.lock().unwrap();
if let Some(c) = ch.get_mut(id) {
// 已经退出的进程 kill 会返回 Err,忽略即可。
let _ = c.kill();
}
}
/// 子进程是否还在跑。
///
/// 判据是**子进程句柄的 `try_wait()`** —— 内核提供,不依赖任何外部命令,
/// 在受限容器里(`ps` 被禁、`/proc` 没挂载)也能用。
///
/// 这是「活着」的权威判据;`start_key` 只用来在**能拿到时**额外确认
/// 「这个 pid 还是我起的那一个」。
fn child_running(&self, id: &str) -> bool {
let mut ch = self.children.lock().unwrap();
match ch.get_mut(id) {
Some(c) => matches!(c.try_wait(), Ok(None)),
None => false,
}
}
/// 收割子进程:进程已退出则返回退出码,并把僵尸收掉。
///
/// 返回形状是 `Option<Option<i32>>`:
/// - `None`:进程还在跑;
/// - `Some(Some(n))`:进程退出,退出码 n;
/// - `Some(None)`:进程被**信号**终止(`ExitStatus::code()` 对信号终止返回 `None`)。
///
/// ★ 两层 `Option` 不是冗余:`Some(-1)` 与 `Some(None)` 含义不同 ——
/// 前者是「非零退出码」,后者是「被信号杀掉」。混成一个 `-1`
/// 会让「跑完了但码是 -1」和「被杀了」看起来一样。
fn harvest_child(&self, id: &str) -> Option<Option<i32>> {
let mut ch = self.children.lock().unwrap();
let c = ch.get_mut(id)?;
match c.try_wait() {
Ok(Some(status)) => {
// 收割完成,把句柄丢掉。
ch.remove(id);
Some(status.code())
}
// ★ 进程还在跑 —— **绝不能移除句柄**。
// 移除就等于丢掉唯一可靠的存活判据,
// 而 `kill` 是异步的:刚发出去时进程通常还没死。
Ok(None) => None,
Err(_) => {
ch.remove(id);
None
}
}
}
/// 启动 reaper 线程。
///
/// 每 `interval` 扫一次。**幂等**:重复调用不会起第二个线程。
pub fn start_reaper(self: &Arc<Self>, interval: Duration) {
if self.running.swap(true, Ordering::SeqCst) {
return;
}
let rt = Arc::clone(self);
std::thread::Builder::new()
.name("mpc-tee-reaper".to_string())
.spawn(move || loop {
std::thread::sleep(interval);
rt.reap();
})
.expect("起 reaper 线程失败");
}
/// 停掉 reaper(测试用)。
pub fn stop_reaper(&self) {
self.running.store(false, Ordering::SeqCst);
}
/// 状态落盘。
pub fn flush(&self) -> Result<(), RuntimeError> {
let path = match &self.state_file {
Some(p) => p.clone(),
None => return Ok(()),
};
let mut arr = Vec::new();
for inst in self.list() {
let mut o = JsonObject::new();
o.push_str("sandbox_id", &inst.sandbox_id);
o.push_str("session_id", &inst.session_id);
o.push_str("site", &inst.site);
o.push_str("platform", &inst.platform.to_string());
o.push_str("template", &inst.template);
o.push_int("pid", inst.pid.map(|p| p as i64).unwrap_or(-1));
o.push_opt_str("start_key", inst.start_key.as_deref());
o.push_int("created_at", inst.created_at as i64);
o.push_str("state", inst.state.as_str());
o.push_int("exit_code", inst.exit_code.map(|c| c as i64).unwrap_or(-1));
o.push_int("timeout_secs", inst.timeout_secs as i64);
o.push_opt_str("optee_session", inst.optee_session.as_deref());
arr.push(json_from_object(o));
}
let mut root = JsonObject::new();
root.push_arr("instances", arr);
if let Some(parent) = path.parent() {
let _ = std::fs::create_dir_all(parent);
}
std::fs::write(&path, root.to_string())
.map_err(|e| RuntimeError::Io(format!("写状态文件失败: {e}")))
}
fn set_state<F: FnOnce(&mut Instance)>(&self, id: &str, f: F) {
let mut table = self.table.lock().unwrap();
if let Some(inst) = table.get_mut(id) {
f(inst);
}
}
}
impl Default for TeeRuntime {
fn default() -> Self {
Self::new()
}
}
/// 退出码 → 状态。
///
/// - `Some(0)`:正常退出 → `Exited`;
/// - `Some(n)`(n≠0):非零退出 → `Failed`;
/// - `None`:进程被信号终止(`ExitStatus::code()` 对信号终止返回 `None`)
/// → `Failed`。**被 SIGTERM 杀掉也是 `Failed`** —— 它不是「跑完了」。
fn exit_state(code: Option<i32>) -> InstanceState {
match code {
Some(0) => InstanceState::Exited,
_ => InstanceState::Failed,
}
}
/// 从 [`JsonObject`] 取回对象。
fn json_from_object(o: JsonObject) -> Json {
// `JsonObject` 的序列化产物就是一个对象;这里只需要能放进数组。
// 为避免把 `Json` 的构造暴露给外部,绕道解析一次(数据量极小)。
match crate::json::parse(&o.to_string()) {
Ok(v) => v,
Err(_) => Json::Null,
}
}
fn get_str(m: &std::collections::BTreeMap<String, Json>, k: &str) -> Option<String> {
match m.get(k) {
Some(Json::Str(s)) => Some(s.clone()),
_ => None,
}
}
fn get_int(m: &std::collections::BTreeMap<String, Json>, k: &str) -> Option<i64> {
match m.get(k) {
Some(Json::Int(i)) => Some(*i),
_ => None,
}
}
/// 当前墙钟秒。
pub fn now_secs() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0)
}
/// 生成 20 位小写 hex 的沙箱 ID(与 e2b 的形状一致)。
///
/// 用操作系统随机源,不用时间戳 —— 时间戳派生的 ID 可预测,
/// 而沙箱 ID 会出现在 HTTP 路径里。
pub fn new_sandbox_id() -> String {
let mut buf = [0u8; 10];
if mpc_core::osrand::fill_random(&mut buf).is_err() {
// 随机源不可用时退到时间 + pid 混合 —— 可预测性下降但仍唯一。
let t = now_secs();
let p = std::process::id() as u64;
let mut x = t
.wrapping_mul(0x9E3779B97F4A7C15)
.wrapping_add(p.wrapping_mul(0xBF58476D1CE4E5B9));
for b in buf.iter_mut() {
x ^= x >> 33;
x = x.wrapping_mul(0xFF51AFD7ED558CCD);
x ^= x >> 33;
*b = (x & 0xff) as u8;
}
}
let mut s = String::with_capacity(20);
for b in buf.iter() {
s.push_str(&format!("{b:02x}"));
}
s.truncate(20);
s
}
/// 读进程的启动标识 —— 用来识别「这个 pid 还是我起的那一个」。
///
/// # 平台实现
///
/// - **Linux**:`/proc/<pid>/stat` 的第 22 字段 `starttime`
/// (进程启动以来的时钟滴答,精度到 jiffy)。零依赖、最精确。
/// - **macOS / BSD**:`ps -p <pid> -o lstart=` 的输出(进程启动时刻,秒级精度)。
/// `lstart` 比 `etime` 好:`etime` 会随时间流逝而变化,读两次不一样;
/// `lstart` 是绝对时刻,读多少次都一样。
/// - **其它**:返回 `None`(拿不到)。
///
/// # ★ 僵尸进程一律返回 `None`
///
/// 进程被 SIGKILL 后、在被父进程 `wait()` 回收之前处于**僵尸态**:
/// - Linux:`/proc/<pid>/stat` 仍存在、starttime 仍读得到,state 是 `Z`;
/// - macOS:`ps -o lstart=` 仍输出启动时刻,state 是 `Z`。
///
/// 若不排除僵尸,调用方会把**已经死掉**的实例判成「身份确认的活进程」,
/// `restore()` 于是标成 Running ⇒ 站点端以为实例还在跑。症状是
/// 「实例永远不退出」,很难联想到是僵尸。
///
/// 返回 `None` 的含义是「无法确认」,调用方按 fail-closed 处理。
pub fn process_start_key(pid: u32) -> Option<String> {
#[cfg(target_os = "linux")]
{
let raw = std::fs::read_to_string(format!("/proc/{pid}/stat")).ok()?;
// comm 字段可能含空格与括号,所以从最后一个 ')' 之后开始切。
let close = raw.rfind(')')?;
let rest = &raw[close + 1..];
let fields: Vec<&str> = rest.split_whitespace().collect();
// ★ 第 3 字段是进程状态(`R` 运行 / `S` 可中断睡眠 / `Z` **僵尸** /
// `T` 停止 / `X` 死 …)。僵尸进程**已经死了**,只是还没被 wait 回收。
// `/proc/<pid>` 对僵尸仍然存在、starttime 也仍读得到 ⇒ 若不显式
// 排除,`process_identity_confirmed` 会把僵尸判成「身份确认的活进程」,
// `restore()` 于是把死实例标成 Running,站点端会以为它还在跑。
// (实测:`kill -9` 一个子进程后 `/proc/<pid>/stat` 的 state 是 `Z`,
// 直到调用方 `wait()` 才会消失。)
// ⇒ 僵尸一律返回 `None`(= 无法确认)⇒ 调用方 fail-closed 判已退出。
match fields.first() {
Some(&"Z") | Some(&"X") | Some(&"x") => return None,
None => return None,
_ => {}
}
// starttime 是第 22 字段 ⇒ rest 的第 20 项。
let t = fields.get(19)?.parse::<u64>().ok()?;
Some(format!("proc:{t}"))
}
#[cfg(not(target_os = "linux"))]
{
// ★ 与 Linux 分支同样的理由:**僵尸进程必须排除**。
// macOS 上 `ps -o lstart=` 对僵尸仍会输出启动时刻(僵尸只是没被
// `wait()` 回收),所以必须先看状态列。
// BSD/macOS 的 `ps -o state=` 给出 `S`/`R`/`Z`/`T`/`I` 等;
// `Z` = 僵尸,`I` = 空闲(内核线程,也算「不是我们的实例」)。
let st = Command::new("ps")
.arg("-p")
.arg(pid.to_string())
.arg("-o")
.arg("state=")
.stdout(Stdio::null())
.stderr(Stdio::null())
.output()
.ok()?;
if !st.status.success() {
return None;
}
let state = String::from_utf8_lossy(&st.stdout).trim().to_string();
if state.starts_with('Z') || state.starts_with('I') || state.is_empty() {
return None;
}
// `ps` 拿不到 lstart 时返回 None(fail-closed 的调用方会当成「无法确认」)。
let out = Command::new("ps")
.arg("-p")
.arg(pid.to_string())
.arg("-o")
.arg("lstart=")
.stdout(Stdio::null())
.stderr(Stdio::null())
.output()
.ok()?;
if !out.status.success() {
return None;
}
let s = String::from_utf8_lossy(&out.stdout).trim().to_string();
if s.is_empty() {
None
} else {
Some(format!("lstart:{s}"))
}
}
}
/// 进程是否还活着。
///
/// 只判「在不在」,不判「是不是我起的那一个」——
/// 身份比对见 [`process_identity_confirmed`]。
///
/// 实现:
/// - **Linux**:`/proc/<pid>` 存在且能读到 `stat`(僵尸也满足);
/// - **其它**:`kill -0 <pid>` 不报错(只探活,不发信号)。
///
/// ⚠️ 僵尸进程在这里会被判为「活着」。这是**故意的** ——
/// 僵尸的处置靠子进程句柄的 `try_wait()`(见 `harvest_child`),
/// 靠 `/proc` 是分不清僵尸和活进程的。
/// 进程身份是否已确认 —— 「这个 pid 还是我起的那一个」。
///
/// # 为什么这是两个判据而不是一个
///
/// 「活着」和「是我的」是两件事:
/// - 判活可以在任何平台做(`/proc` 或 `kill -0`);
/// - 判身份需要**平台的启动标识**(Linux 的 `/proc` starttime、
/// macOS 的 `ps -o lstart=`),某些环境拿不到(受限容器、没装 `ps`)。
///
/// # fail-closed 在哪里
///
/// 身份**确认不了**时,本框架**不会对这个 pid 发任何信号**。
/// 宁可漏收一个实例(标成已退出,站点端重新下发即可),
/// 也不能对着一个身份不明的进程发 SIGTERM —— 那可能杀掉别人的进程。
///
/// 所以调用方必须区分三态:
/// - `true`:身份确认,可以发信号;
/// - `false`:身份**不符**(pid 被复用),绝不能发信号;
/// - `None`:**无法确认**(平台不支持 / 读不到),同样不能发信号。
pub fn process_identity_confirmed(pid: u32, start_key: Option<&str>) -> Option<bool> {
let recorded = match start_key {
Some(k) if !k.is_empty() => k,
_ => return None,
};
match process_start_key(pid) {
Some(actual) => Some(actual == recorded),
None => None,
}
}
/// 进程是否还活着,**且**身份已确认是同一个。
///
/// 身份确认不了(`None`)时返回 `false` —— fail-closed。
///
/// ⚠️ 这个函数只用于**状态判定**,**不用于决定要不要发信号**:
/// 发信号那一层只看 [`process_identity_confirmed`] 的三态。
/// 「活着」本身由**子进程句柄的 `try_wait()`** 判定(内核提供,
/// 不依赖任何外部命令,在受限容器里也能用)。
pub fn process_alive(pid: u32, start_key: Option<&str>) -> bool {
matches!(process_identity_confirmed(pid, start_key), Some(true))
}
/// 取子进程 pid。
///
/// ★ 版本兼容的坑(这个 API 换过两次名字):
/// - Rust ≤1.86:只有 `Child::pid()`;
/// - Rust 1.87–1.94:`Child::pid()` 被废弃,`Child::id()` 新增;
/// - Rust ≥1.95:`Child::pid()` 被**移除**,只剩 `Child::id()`。
///
/// 本项目声明 `rust-version = "1.85"`,而开发机是 1.95 —— 两边都得能编。
/// `cfg` 无法直接表达「编译器版本号」,所以 `build.rs` 探测版本并发出
/// `has_child_id` 这个 cfg(见 `crates/mpc-tee/build.rs`)。
///
/// ⚠️ 走 `pid()` 的那条分支必须带 `#[allow(deprecated)]`:
/// 在 1.87–1.94 上 `pid()` 已废弃,而 CI 用 `-Dwarnings` ——
/// 少了这个属性,CI 会在中间版本上直接挂。
#[cfg(has_child_id)]
fn child_pid(child: &Child) -> u32 {
child.id()
}
#[cfg(not(has_child_id))]
fn child_pid(child: &Child) -> u32 {
#[allow(deprecated)]
child.pid()
}
/// 信号操作。
#[derive(Debug, Clone, Copy)]
#[allow(dead_code)] // `Probe` 只在非 Linux 分支构造。
enum SignalOp {
Stop,
Continue,
Term,
Kill,
/// `kill -0`:只探活,不投递任何信号。
Probe,
}
impl SignalOp {
fn name(self) -> &'static str {
match self {
SignalOp::Stop => "STOP",
SignalOp::Continue => "CONT",
SignalOp::Term => "TERM",
SignalOp::Kill => "KILL",
SignalOp::Probe => "0",
}
}
}
/// 给进程发信号。返回是否投递成功。
///
/// ⚠️ 依赖外部 `kill` 命令 —— 受限环境里它可能被禁,
/// 所以**返回 bool**,调用方必须检查:发不出信号就不能假装操作成功。
/// (终止进程优先走 `Child::kill()`,不依赖外部命令。)
///
/// ★ 这里**不能**按平台 `cfg` 掉:
/// Rust 标准库只提供 `Child::kill()`(= SIGKILL),
/// **没有** SIGSTOP / SIGCONT —— 这两个是 pause / resume 的唯一实现,
/// 跨平台只能用外部 `kill` 命令。
/// 之前把实现 `#[cfg(target_os = "linux")]` 掉、非 Linux 直接返回 false,
/// 等于 **macOS 上 pause / resume 从来没工作过**,而且是静默失败。
fn signal_pid(pid: u32, op: SignalOp) -> bool {
// PATH 里未必有 kill;退而求其次试绝对路径。
// 两个都试是廉价的,且不引入任何外部依赖。
for bin in ["kill", "/bin/kill"] {
let ok = Command::new(bin)
.arg(format!("-{}", op.name()))
.arg(pid.to_string())
.stdout(Stdio::null())
.stderr(Stdio::null())
.status()
.map(|s| s.success())
.unwrap_or(false);
if ok {
return true;
}
}
false
}
/// 进程是否存在(**只探活,不判身份**)。
///
/// 与 [`process_alive`] 的区别:
/// - 这里只回答「这个 pid 上还有没有进程」;
/// - 那里回答「这个 pid 还是不是我起的那一个」。
///
/// 只在**已经确认过身份之后**用来等待退出 ——
/// 那时 pid 不可能在我们脚下被复用(进程还活着时内核不会把 pid 发给别人)。
pub fn process_exists(pid: u32) -> bool {
#[cfg(target_os = "linux")]
{
std::path::Path::new(&format!("/proc/{pid}")).exists()
}
#[cfg(not(target_os = "linux"))]
{
signal_pid(pid, SignalOp::Probe)
}
}
/// 终止进程(SIGTERM)。
fn kill_pid(pid: u32) {
signal_pid(pid, SignalOp::Term);
}
/// 强制终止进程(SIGKILL)。
fn kill_pid_hard(pid: u32) {
signal_pid(pid, SignalOp::Kill);
}
#[cfg(test)]
mod tests {
use super::*;
fn spec(program: &str) -> SpawnSpec {
let mut s = SpawnSpec::new("sess-1", "alice", PlatformKind::SevSnp, program);
// `sleep 300` 而不是 `--flag`:参数非法的话进程会立刻退出,
// 于是「刚 spawn 就 Running」这类断言全部变成假失败。
s.args = vec!["300".to_string()];
s
}
#[test]
fn sandbox_id_shape_is_e2b_compatible() {
let id = new_sandbox_id();
assert_eq!(id.len(), 20, "e2b 的 sandboxID 是 20 位 hex");
assert!(
id.chars().all(|c| c.is_ascii_hexdigit() && !c.is_uppercase()),
"必须是小写 hex: {id}"
);
}
#[test]
fn sandbox_ids_are_unique() {
let mut seen = std::collections::HashSet::new();
for _ in 0..100 {
assert!(seen.insert(new_sandbox_id()), "sandbox_id 撞了");
}
}
#[test]
fn spawn_records_process_and_transitions_to_running() {
let rt = TeeRuntime::new();
// `sleep` 一定有;但用 /bin/sleep 更稳(macOS 与 Linux 都在)。
let inst = rt.spawn(&spec("/bin/sleep")).unwrap();
assert_eq!(inst.state, InstanceState::Running);
assert!(inst.pid.is_some());
assert_eq!(inst.argv[0], "/bin/sleep");
assert_eq!(inst.argv[1], "300");
// 清理
let _ = rt.stop(&inst.sandbox_id);
}
#[test]
fn spawn_failure_is_reported_not_swallowed() {
let rt = TeeRuntime::new();
let e = rt.spawn(&spec("/nonexistent/binary/xyz")).unwrap_err();
assert!(matches!(e, RuntimeError::Spawn(_)), "got {e:?}");
}
#[test]
fn stop_marks_terminated_and_clears_pid() {
let rt = TeeRuntime::new();
let inst = rt.spawn(&spec("/bin/sleep")).unwrap();
let stopped = rt.stop(&inst.sandbox_id).unwrap();
// ★ 被我们杀掉 = 进程没跑完 = `Failed`,不是 `Exited`。
// `Exited` 只留给「自己跑完且退出码为 0」。
// 混为一谈会让「实例正常结束」和「被超时回收」看起来一样。
assert_eq!(stopped.state, InstanceState::Failed);
assert!(stopped.pid.is_none());
assert!(!rt.child_running(&inst.sandbox_id), "停了就不该还在跑");
}
#[test]
fn reap_detects_exited_process() {
let rt = TeeRuntime::new();
let inst = rt.spawn(&spec("/bin/sleep")).unwrap();
// 杀掉它,然后让 reap 发现。
// 用**句柄**杀,不依赖外部 `kill` 命令(受限环境里它可能被禁)。
rt.kill_via_handle(&inst.sandbox_id);
std::thread::sleep(Duration::from_millis(300));
let n = rt.reap();
assert!(n >= 1, "reap 应该发现已退出的实例");
let after = rt.get(&inst.sandbox_id).unwrap();
// 被杀 = Failed(不是自己跑完的 Exited)。
assert_eq!(after.state, InstanceState::Failed);
assert!(after.pid.is_none());
}
#[test]
fn reap_respects_paused_instances() {
// 暂停中的实例「本来就该是停的」,reap 不能把它当异常。
let rt = TeeRuntime::new();
let inst = rt.spawn(&spec("/bin/sleep")).unwrap();
// 发不出 SIGSTOP 的环境里,pause 会报错 —— 那时这条不适用,
// 但「reap 不动暂停实例」这条判据仍要单独验。
if rt.pause(&inst.sandbox_id).is_ok() {
let n = rt.reap();
assert_eq!(n, 0, "暂停的实例不该被 reap");
assert_eq!(
rt.get(&inst.sandbox_id).unwrap().state,
InstanceState::Paused
);
}
let _ = rt.stop(&inst.sandbox_id);
}
#[test]
fn attach_does_not_create_process_and_never_kills() {
let rt = TeeRuntime::new();
let mut s = SpawnSpec::new("sess-optee", "bob", PlatformKind::Optee, "/usr/bin/true");
s.template = String::from("optee-template");
let inst = rt.attach(&s, "session-abc").unwrap();
assert_eq!(inst.state, InstanceState::Running);
assert!(inst.pid.is_none(), "attach 不该有进程");
assert_eq!(inst.optee_session.as_deref(), Some("session-abc"));
// 停止只关会话
let stopped = rt.stop(&inst.sandbox_id).unwrap();
assert_eq!(stopped.state, InstanceState::Exited);
assert!(stopped.optee_session.is_none());
}
#[test]
fn attach_rejects_non_optee_platform() {
let rt = TeeRuntime::new();
let s = SpawnSpec::new("s", "a", PlatformKind::SevSnp, "/bin/true");
assert!(matches!(
rt.attach(&s, "x").unwrap_err(),
RuntimeError::Unsupported(_)
));
}
#[test]
fn attach_rejects_empty_session() {
let rt = TeeRuntime::new();
let s = SpawnSpec::new("s", "a", PlatformKind::Optee, "/bin/true");
assert!(matches!(rt.attach(&s, "").unwrap_err(), RuntimeError::Spawn(_)));
}
#[test]
fn missing_instance_is_not_found_not_panic() {
let rt = TeeRuntime::new();
assert!(matches!(
rt.stop("nope").unwrap_err(),
RuntimeError::NotFound(_)
));
assert!(matches!(
rt.pause("nope").unwrap_err(),
RuntimeError::NotFound(_)
));
assert!(matches!(
rt.set_timeout("nope", 10).unwrap_err(),
RuntimeError::NotFound(_)
));
}
#[test]
fn timeout_kills_instance_on_reap() {
let rt = TeeRuntime::new();
let mut s = spec("/bin/sleep");
s.timeout_secs = 1;
let inst = rt.spawn(&s).unwrap();
std::thread::sleep(Duration::from_millis(1100));
rt.reap();
let after = rt.get(&inst.sandbox_id).unwrap();
assert_eq!(
after.state,
InstanceState::Failed,
"超时应该被 reap 杀掉(被杀 = Failed)"
);
}
#[test]
fn find_by_session_works() {
let rt = TeeRuntime::new();
let inst = rt.spawn(&spec("/bin/sleep")).unwrap();
let found = rt.find_by_session("sess-1").unwrap();
assert_eq!(found.sandbox_id, inst.sandbox_id);
assert!(rt.find_by_session("no-such").is_none());
let _ = rt.stop(&inst.sandbox_id);
}
#[test]
fn state_file_roundtrip_and_orphan_validation() {
let dir = std::env::temp_dir().join(format!("mpc-rt-test-{}", std::process::id()));
let _ = std::fs::create_dir_all(&dir);
let path = dir.join("state.json");
let rt = TeeRuntime::with_state_file(&path);
let inst = rt.spawn(&spec("/bin/sleep")).unwrap();
rt.flush().unwrap();
// 换一个运行时恢复。
let rt2 = TeeRuntime::with_state_file(&path);
let n = rt2.restore().unwrap();
assert_eq!(n, 1);
let rec = rt2.get(&inst.sandbox_id).unwrap();
assert_eq!(rec.session_id, "sess-1");
assert_eq!(rec.start_key, inst.start_key);
// 原实例还活着 → 恢复成 running。
// ⚠️ 能不能判成 running **取决于能否确认进程身份**:
// 受限环境里拿不到启动标识时,fail-closed 会判成已退出。
// 两种结果都对,取决于平台 —— 所以这里按实际能力断言。
match rec.state {
InstanceState::Running => {
assert_eq!(rec.pid, inst.pid, "判成 running 时 pid 必须还在");
}
InstanceState::Exited => {
assert!(
rec.pid.is_none(),
"判成已退出时 pid 必须被清掉"
);
}
other => panic!("恢复后的状态不对: {other:?}"),
}
let _ = rt.stop(&inst.sandbox_id);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn restore_marks_dead_process_as_exited() {
let dir = std::env::temp_dir().join(format!("mpc-rt-test2-{}", std::process::id()));
let _ = std::fs::create_dir_all(&dir);
let path = dir.join("state.json");
let rt = TeeRuntime::with_state_file(&path);
let inst = rt.spawn(&spec("/bin/sleep")).unwrap();
rt.flush().unwrap();
kill_pid_hard(inst.pid.unwrap());
std::thread::sleep(Duration::from_millis(200));
let rt2 = TeeRuntime::with_state_file(&path);
rt2.restore().unwrap();
let rec = rt2.get(&inst.sandbox_id).unwrap();
assert_eq!(rec.state, InstanceState::Exited);
assert!(rec.pid.is_none());
let _ = std::fs::remove_dir_all(&dir);
}
/// ★ 核心不变量:pid 被复用时,绝不能误杀别人的进程。
///
/// 「启动标识」在受限环境里可能拿不到(macOS 上 `ps` 被沙箱禁、
/// Linux 上 `/proc` 没挂载),所以本测试覆盖两种情况:
/// - 拿得到:错标识必须判为「身份不符」,对标识必须判为「确认」;
/// - 拿不到:必须判为「**无法确认**」——三态里的第三态。
#[test]
fn orphan_check_rejects_recycled_pid() {
let rt = TeeRuntime::new();
let inst = rt.spawn(&spec("/bin/sleep")).unwrap();
let pid = inst.pid.unwrap();
// 错的启动标识:绝不能判为「确认」。
match process_identity_confirmed(pid, Some("proc:999999999")) {
Some(true) => panic!("错标识绝不能判为身份确认"),
Some(false) => { /* 正确:身份不符 */ }
None => { /* 正确:无法确认 */ }
}
// 空标识:无法确认(不是「确认」)。
assert_eq!(process_identity_confirmed(pid, None), None);
assert_eq!(process_identity_confirmed(pid, Some("")), None);
// 拿得到标识时,用对的标识必须判为「确认」。
if let Some(real) = &inst.start_key {
assert_eq!(
process_identity_confirmed(pid, Some(real)),
Some(true),
"对的标识必须判为身份确认"
);
assert!(
process_alive(pid, Some(real)),
"身份确认且进程在 → 判为存活"
);
}
let _ = rt.stop(&inst.sandbox_id);
}
/// ★ fail-closed:没有启动标识时,一律判为「无法确认」,
/// 而「无法确认」在发信号那一层是**拒绝发信号**。
#[test]
fn orphan_check_without_start_key_is_fail_closed() {
let rt = TeeRuntime::new();
let inst = rt.spawn(&spec("/bin/sleep")).unwrap();
let pid = inst.pid.unwrap();
assert_eq!(
process_identity_confirmed(pid, None),
None,
"没有启动标识时必须是「无法确认」,不是「确认」也不是「确认不符」"
);
assert!(
!process_alive(pid, None),
"没有启动标识时不能判为存活(fail-closed)"
);
let _ = rt.stop(&inst.sandbox_id);
}
#[test]
fn start_key_is_stable_across_reads() {
// 启动标识必须读多次都一样 —— 不然每次判据都会「不匹配」。
let rt = TeeRuntime::new();
let inst = rt.spawn(&spec("/bin/sleep")).unwrap();
let pid = inst.pid.unwrap();
let a = process_start_key(pid);
let b = process_start_key(pid);
assert_eq!(a, b, "启动标识必须稳定: {a:?} vs {b:?}");
let _ = rt.stop(&inst.sandbox_id);
}
/// ★★ 僵尸进程**不得**被当成活实例。
///
/// 为什么这条重要:`/proc/<pid>/stat` 对**僵尸**仍然存在,starttime
/// 也仍读得到 ⇒ 若不显式排除 state,`process_identity_confirmed` 会
/// 返回 `Some(true)`,`restore()` 于是把**已经死掉**的实例标成 Running,
/// 站点端会以为它还在跑(症状是「实例永远不退出」)。
///
/// 判据要覆盖三态:
/// - 活着时 start_key 有值;
/// - 被 SIGKILL 但**未 wait**(= 僵尸)时 start_key 必须变 `None`;
/// - `process_alive` 对僵尸必须返回 false(fail-closed)。
#[test]
fn zombie_process_is_not_treated_as_alive() {
let rt = TeeRuntime::new();
let inst = rt.spawn(&spec("/bin/sleep")).unwrap();
let pid = inst.pid.unwrap();
let key = process_start_key(pid);
assert!(key.is_some(), "活进程的启动标识必须拿得到");
assert!(process_alive(pid, key.as_deref()), "活进程必须判为活");
// SIGKILL 之后进程进入僵尸态(本进程是它的父 ⇒ 还没被 wait 回收)。
kill_pid_hard(pid);
std::thread::sleep(Duration::from_millis(200));
// ★ 僵尸:启动标识必须拿不到(None = 无法确认)。
assert!(
process_start_key(pid).is_none(),
"僵尸进程不得还有启动标识(否则会被当成活实例)"
);
// ★ 僵尸:存活判据必须为 false。
assert!(
!process_alive(pid, key.as_deref()),
"僵尸进程不得被判为存活"
);
let _ = rt.stop(&inst.sandbox_id);
}
/// ★ 存活判据必须靠**子进程句柄**,不靠外部命令。
///
/// 为什么这条重要:受限容器里 `ps` 可能被禁、`/proc` 可能没挂载。
/// 靠句柄的 `try_wait()` 才是任何环境都能用的判据。
#[test]
fn liveness_uses_child_handle_not_external_tools() {
let rt = TeeRuntime::new();
let inst = rt.spawn(&spec("/bin/sleep")).unwrap();
assert!(rt.child_running(&inst.sandbox_id), "刚起的进程必须在跑");
let _ = rt.stop(&inst.sandbox_id);
assert!(
!rt.child_running(&inst.sandbox_id),
"停掉之后不该再判为在跑"
);
}
#[test]
fn set_timeout_updates_record() {
let rt = TeeRuntime::new();
let inst = rt.spawn(&spec("/bin/sleep")).unwrap();
let updated = rt.set_timeout(&inst.sandbox_id, 42).unwrap();
assert_eq!(updated.timeout_secs, 42);
let _ = rt.stop(&inst.sandbox_id);
}
#[test]
fn pause_then_resume_roundtrip() {
let rt = TeeRuntime::new();
let inst = rt.spawn(&spec("/bin/sleep")).unwrap();
// 有子进程句柄 ⇒ 身份天然确定 ⇒ pause 必须**真的成功**。
// (早期版本额外要求 `start_key` 可比对,导致 macOS 受限环境
// 里 `ps` 被禁 → start_key 恒 None → pause 永远失败。
// 身份判据的优先级搞反了:句柄才是第一判据。)
let p = rt.pause(&inst.sandbox_id).unwrap_or_else(|e| {
panic!("有句柄时 pause 必须成功: {e}");
});
assert_eq!(p.state, InstanceState::Paused);
assert!(p.paused);
let r = rt.resume(&inst.sandbox_id).unwrap();
assert_eq!(r.state, InstanceState::Running);
assert!(!r.paused);
let _ = rt.stop(&inst.sandbox_id);
}
}