交易编码(新增) - 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 上验过框架契约, 不等于真链能上链;真链部署与调用仍未做。
1616 lines
63 KiB
Rust
1616 lines
63 KiB
Rust
//! [`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);
|
||
}
|
||
}
|