diff --git a/.workbuddy/memory/2026-11-13.md b/.workbuddy/memory/2026-11-13.md new file mode 100644 index 0000000..3cc5626 --- /dev/null +++ b/.workbuddy/memory/2026-11-13.md @@ -0,0 +1,41 @@ +# 2026-11-13 + +## Gitea issue #1 —— armv7「stdout 非管道即 exit 100」—— 修复中 + +### 根因(已实测闭环,非推测) +pglite 的 `initDummyPort()`(`src/backend/tcop/postgres.c`)设 **`s.sock = 1`** ⇒ 把 **fd 1 当成 +「名义客户端 socket」**;`pq_init()`(`src/backend/libpq/pqcomm.c`)随即 +`AddWaitEventToSet(FeBeWaitSet, WL_SOCKET_WRITEABLE, port->sock=1, ...)`。 + +等待事件后端按平台分(`src/backend/storage/ipc/latch.c`):Linux ⇒ **epoll**、macOS ⇒ **kqueue**。 +**epoll 不接受普通文件与字符设备**(armv7 容器实测 `EPERM`;管道两端 OK)⇒ +`ereport(ERROR, "epoll_ctl() failed")` → longjmp → **exit(100)**。 +⇒ 只有 stdout 是**管道**时能起;`> file` / `> /dev/null` / 终端全挂。 +macOS 走 kqueue(允许注册普通文件/字符设备)⇒ 同样形态正常 ⇒ **Linux 专属**。 + +### 🔴 两个反直觉的关键事实 +1. **`pgl_fcntl` 是 dummy**(`pglitec.c`:`int pgl_fcntl(...) { return 0; }`) + ⇒ `pq_init()` 的 `pg_set_noblock(fd 1)` **无效** ⇒ fd 1 始终**阻塞** + ⇒ 管道写满 64KB 会**永久阻塞** ⇒ **drain 线程是必需的,不是保险**。 +2. **协议数据根本不经过 fd 1**:`pgl_recv`/`pgl_send` 覆盖转发到宿主注入的函数指针 + ⇒ fd 1 上真实写入的只有 `postgres --single` 的 banner。 + +### 旧修复为什么错 +`ensure_stdout_for_pglite()` 把 fd 1 `dup2` 到**普通临时文件** ⇒ 只是把「字符设备失败」 +换成「普通文件失败」(同样 EPERM、同样 exit 100);且只判 `S_IFCHR`、**普通文件不覆盖**; +注释里的 kqueue 语义是 macOS 专属。 + +### 修法(`boot.rs`) +`pipe()` + `dup` 原始 stdout + `dup2(pipe_w,1)` + **drain 线程转发回原 stdout** +(平台 `println!` 仍落用户真正的 stdout)。macOS 用 `#[cfg(target_os="macos")]` 保留空实现。 + +### 🔴 交叉编译才能暴露的坑 +macOS 分支是空实现 ⇒ **那段 Linux 代码在本机从未被编译过** ⇒ +`FromRawFd` trait 未导入这种错误,本机 `cargo build` 全绿、**交叉编译才红**。 +⇒ 平台侧平台专属代码**必须交叉编译验证**,不能只看本机绿。 + +### 其它 +- `PGLITE_RUNTIME_DIR` **确实被支持**(`pglite-rs-0.2.7/src/engine.rs:107` 读该 env), + issue 的建议成立 ⇒ 开库前固化成带 arch + 二进制指纹的路径。 +- `arm32v7/debian:bookworm-slim` **没有 wget/curl** ⇒ 探活必须用 bash 内建 `/dev/tcp`。 +- 旧冒烟脚本用的就是 `wget` ⇒ 冒烟其实一直跑不通(盲区比 issue 描述的更大)。 diff --git a/CHANGELOG.md b/CHANGELOG.md index 3e119cd..88bbba5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # CHANGELOG +## 2026-11-13(v0.5.0 内增量,不升版本号)—— 修 armv7「stdout 非管道即 exit 100」 + +- 修 Gitea issue #1:内嵌 PostgreSQL 的 `initDummyPort()` 把 **fd 1 当成名义客户端 socket**(`s.sock = 1`)⇒ `pq_init()` 把它注册进 WaitEventSet ⇒ Linux 走 **epoll**,而 epoll 不接受普通文件与字符设备(实测 `EPERM`)⇒ `ereport(ERROR)` → longjmp → **exit 100**。⇒ **所有标准部署形态(`nohup … > app.log 2>&1 &`、systemd、CI 重定向)全挂**,只有 stdout 是管道时能起。 +- 重写 `boot.rs::ensure_stdout_for_pglite()`:`pipe()` + `dup` 原始 stdout + `dup2` 让 fd 1 变管道写端 + **drain 线程**把内容转发回原 stdout ⇒ 平台自身 `println!`(「已启动」…)仍落到用户真正的 stdout。**drain 线程是必需的**:pglite 的 `pgl_fcntl` 是 dummy ⇒ `pg_set_noblock(fd 1)` 无效 ⇒ fd 1 始终阻塞 ⇒ 管道写满 64KB 会永久阻塞。macOS 走 kqueue(本就接受普通文件)⇒ `#[cfg(target_os = "macos")]` 保留原样。 +- 开库前固化 `PGLITE_RUNTIME_DIR` 为**带架构 + 二进制指纹**的路径(`engine.rs` 支持该 env 覆盖)⇒ 消除 x86_64 与 armv7 共用 runtime 目录导致的 `runtime extraction race lost and target invalid`。用户显式设置时不覆盖。 +- `scripts/build-armv7.sh` 冒烟改为**三 case × 各自干净数据目录**:A 继承 docker pipe / B `> /tmp/srv.log 2>&1` / C `> /dev/null`,每个断言「HTTP 探活成功 + 进程仍常驻(没提前 exit 100)」,A/B 另断言日志含「已启动」。探活从 `wget`(armhf 镜像里**没有**)换成 bash 内建 `/dev/tcp`。 +- 影响:**仅 Linux**(macOS 分支逐字保留原行为);stdout 形态不再影响启动 ⇒ `> file` / `> /dev/null` / 终端均可正常起服务。根因与验证结论记在 `docs/armv7-build.md` 的「第四个坑 / 第五个坑」。 + ## 2026-11-12(v0.5.0 内增量,不升版本号)—— armv7(32 位 ARM)交叉编译与发布 - 上游 `Midwess/pglite-rs` 只发布 aarch64/x86_64 四架构引擎,**没有 armv7** ⇒ 自建引擎:`pglite-rs-sys 0.2.7` 的 build.rs 认 `PGLITE_LIB_DIR`,用它喂自建引擎(上游 `engine-06c837c6a303-p3`,postgres-pglite commit `06c837c6a303…`)。 diff --git a/docs/armv7-build.md b/docs/armv7-build.md index 1a35f63..15a18aa 100644 --- a/docs/armv7-build.md +++ b/docs/armv7-build.md @@ -246,6 +246,131 @@ docker run --rm --platform linux/arm/v7 \ > 把 runtime tar 烤进二进制 ⇒ **目标机不需要额外的引擎文件**,发布包自包含。 > (`dist/pglite-engine-armv7/` 只是给「想自己链接引擎的二次开发者」用的独立 asset。) +### 🔴 第四个坑:**fd 1 必须是「能被 epoll 注册」的类型**(2026-11-13,Gitea issue #1) + +这是**发布后**才暴露的坑,也是最狠的一个:**所有标准部署形态全部挂**。 + +#### 现象 + +armv7 包**只有 stdout 是管道时**能起来。stdout 重定向到**普通文件**或 `/dev/null` +⇒ 进程在 initdb 之后以 **exit 100** 直接退出,stderr 常常是空的。 + +| case | stdout (fd 1) | `inner_rc` | 结果 | +|---|---|---|---| +| A | 继承 docker pipe | 124 | ✅ 正常常驻 | +| B | 普通文件 `> /tmp/srv.log 2>&1` | **100** | ❌ 只剩 banner | +| C | `/dev/null` 字符设备 | **100** | ❌ stderr 0 字节 | + +#### 根因链条 + +1. pglite 的 `initDummyPort()`(`src/backend/tcop/postgres.c`)设 **`s.sock = 1`** + ⇒ 把 **fd 1 当成「名义客户端 socket」**; +2. `pq_init()`(`src/backend/libpq/pqcomm.c`)随即把它注册进 WaitEventSet: + ```c + socket_pos = AddWaitEventToSet(FeBeWaitSet, WL_SOCKET_WRITEABLE, + port->sock, NULL, NULL); /* port->sock == 1 */ + ``` +3. 等待事件的后端按平台分(`src/backend/storage/ipc/latch.c`): + Linux ⇒ `HAVE_SYS_EPOLL_H` ⇒ **epoll**;macOS ⇒ **kqueue**; +4. **epoll 只接受 poll-able 的 fd**(管道 / socket / eventfd …), + **普通文件(`S_IFREG`)与字符设备(`S_IFCHR`)一律 `EPERM`**。 + armv7 容器内实测: + ```text + 普通文件 epoll_ctl=-1 Operation not permitted + /dev/null epoll_ctl=-1 Operation not permitted + 管道写端 epoll_ctl=0 OK + 管道读端 epoll_ctl=0 OK + ``` +5. ⇒ `ereport(ERROR, "epoll_ctl() failed: %m")` → longjmp → **`exit(100)`**。 + +> 💡 macOS 走 kqueue(允许把普通文件/字符设备注册为 `EVFILT_WRITE`)⇒ 同样形态正常。 +> ⇒ **这是 Linux 专属问题**,x86_64 macOS 上从未暴露。 + +#### 为什么旧修复是错的 + +`boot.rs::ensure_stdout_for_pglite()` 原来把 fd 1 `dup2` 到一个**普通临时文件** +⇒ 只是把「字符设备失败」换成「普通文件失败」,**同样 EPERM、同样 exit 100**。 +且它只判 `S_IFCHR`,**普通文件(最主要的部署形态)根本不覆盖**; +注释里的「kqueue 读事件 / `kevent()` 失败」是 **macOS 语义**,Linux 上有害无益。 + +#### 本仓的修法(`boot.rs::ensure_stdout_for_pglite()`) + +**管道 + 原始 stdout 转发 + drain 线程**: + +1. `pipe()` 造一对 fd; +2. **`dup` 原始 stdout** ⇒ 平台的 `println!`(「已启动」「导入完成」…)仍落到 + **用户真正要的 stdout**; +3. `dup2(pipe_w, 1)` ⇒ **fd 1 变成管道写端**(epoll 合法); +4. 起 **drain 线程**读管道读端 → 转发到原始 stdout; +5. 原始 stdout 与管道读端**泄漏保活**(进程级)。 + +> 🔴 **drain 线程是必需的,不是保险**: +> pglite 的 `pgl_fcntl` 是 **dummy**(`pglitec.c`:`int pgl_fcntl(...) { return 0; }`) +> ⇒ `pq_init()` 里的 `pg_set_noblock(port->sock)` **完全无效** +> ⇒ **fd 1 始终阻塞** ⇒ 管道缓冲(Linux 64KB)写满后 `write()` **永久阻塞** +> ⇒ 内嵌 PG 直接卡死 ⇒ 必须有活线程持续消费。 + +macOS 分支用 `#[cfg(target_os = "macos")]` 限定为空实现(kqueue 本就接受普通文件)。 + +#### 回归门禁 + +`scripts/build-armv7.sh` 的冒烟现在跑**三个 case**(每个都是全新容器 + 全新数据目录): + +| case | stdout (fd 1) | 走替换? | 断言 | +|---|---|---|---| +| **A** | 继承 docker pipe | ❌ 已是管道 ⇒ 提前返回 | HTTP 通 + 常驻 + stdout 含「已启动」 | +| **B** | 普通文件 `> /tmp/srv.log 2>&1` | ✅ | HTTP 通 + 常驻 + 日志含「已启动」+ **含「启动诊断」** | +| **C** | `/dev/null` | ✅ | HTTP 通 + 常驻 + **含「启动诊断」** | + +> 🔴 **B 才是 issue 报的失败形态**(`nohup … > app.log 2>&1 &` 的标准部署写法), +> 也是最容易漏测的那个。C 的「已启动」进了 `/dev/null` ⇒ 只能靠「HTTP 通 + 常驻」判定。 + +> 🔴 **「启动诊断」这条断言的价值**:它证明**替换路径真的走到了**。 +> 只断言「没 exit 100」是不够的 —— 万一将来有人把替换逻辑删掉、而恰好测试机上 +> fd 1 是管道,用例依然会绿 ⇒ 用「必须打出诊断行」把这条路径钉死。 + +> 🔴 探活用 **bash 内建 `/dev/tcp`**,不用 `wget`/`curl` +> —— `arm32v7/debian:bookworm-slim` 里**没有** wget/curl(只有 coreutils)。 +> 且整套探活要包在子 shell 里、`2>/dev/null` 放最外层:bash 连接失败会自己往 +> stderr 打 `connect: Connection refused`,只重定向 `exec` 那行压不住,日志会被刷屏。 + +> 🔴 **`PGLITE_DIR` / `PORT` 必须用 `-e` 传进容器**(2026-11-13 实测踩坑): +> 它们若只写在 `bash -c '...'` 的**内联命令行**里,会在外层展开成宿主变量、 +> 容器内拿不到 ⇒ 服务起在**默认端口 30010** + 默认数据目录 ⇒ 探活一直 +> `Connection refused` ⇒ 被误判成「修复没生效」。 + +> ⚠️ 停机时 stderr 会有大量 `FATAL: terminating connection because protocol +> synchronization was lost` —— 这是 pglite `shutdown()` 的**已知现象** +> (postmaster 循环拉起后端,见 `boot.rs::shutdown_pg` 注释),不是启动缺陷。 +> 门禁日志里已过滤掉它。 + +### 🔴 第五个坑:**runtime 目录跨架构抢占**(issue #1 关联问题 1) + +pglite-rs 0.2.7 的 `runtime_dir()`(`engine.rs`)默认取 +`$TMPDIR/pglite-rs-runtime-0.2.7-`,而 `runtime_fingerprint()` +**只哈希 runtime tar 的内容** ⇒ **x86_64 与 armv7 共用同一个目录名**。 + +⇒ 同一台机器上先后跑两种架构的二进制时,后者撞上前者残留目录 ⇒ +`Error::Boot("runtime extraction race lost and target invalid")`。 + +**修法**:`boot.rs::ensure_runtime_dir_isolated()` 在开库前把 `PGLITE_RUNTIME_DIR` +固化成一个**带目标架构与二进制指纹**的路径(`engine.rs` 确实支持该环境变量覆盖): + +``` +$TMPDIR/pglite-rs-runtime-<版本>--<16 位十六进制指纹> +例:pglite-rs-runtime-0.1.0-x86_64-72b6cc1782da05b7 + pglite-rs-runtime-0.1.0-arm-<另一串> +``` + +指纹 = **FNV-1a(** 可执行文件绝对路径 + 文件大小 + 修改时间 **)**: + +- **含路径** ⇒ 同一台机上两个部署(不同安装位置)互不踩; +- **含大小 + mtime** ⇒ 换引擎/改代码重编后必然变化 ⇒ **不会复用**上一次解出来的 + runtime(那正是跨架构/跨版本抢占的真实来源); +- 只 `stat` 不读内容 —— 70 MB 二进制算内容哈希要几百毫秒,启动期不值。 + +⚠️ 只在**用户没显式设置** `PGLITE_RUNTIME_DIR` 时覆盖 —— 用户显式指定就该尊重。 + --- ## 7. 发布 diff --git a/scripts/build-armv7.sh b/scripts/build-armv7.sh index 0b46263..daacc9a 100755 --- a/scripts/build-armv7.sh +++ b/scripts/build-armv7.sh @@ -36,7 +36,7 @@ REPO_ROOT="$(pwd)" ENGINE_TAG="${PGLITE_ENGINE_TAG:-engine-06c837c6a303-p3}" PG_SRC_COMMIT="${PG_SRC_COMMIT:-06c837c6a30335169df786c610ed224bc51d81c0}" -ENGINE_DIR="${ENGINE_DIR:-${REPO_ROOT}/dist/pglite-engine-armv7}" +ENGINE_DIR="${ENGINE_DIR:-${REPO_ROOT}/dist/pglite-engine-armv7-glibc26}" TARGET_TRIPLE="armv7-unknown-linux-gnueabihf" WORK="${WORK:-/tmp/sspf-armv7-build}" @@ -89,12 +89,33 @@ export CARGO_PROFILE_RELEASE_STRIP="${CARGO_PROFILE_RELEASE_STRIP:-none}" # 🔴 zig cc 不认 `-Wl,/abs/path` 合并写法(报 unsupported linker arg), # 用仓库里的包装脚本改写成裸路径;它还会注入 armhf sysroot(提供 -lz)。 -export ZIG_SYSROOT="${ZIG_SYSROOT:-${ENGINE_DIR}/sysroot}" +# +# 🔴 2026-11-13:sysroot 换成 **zlib-only** 版本。 +# 原来指向 ${ENGINE_DIR}/sysroot(上游完整 Debian 12 armhf),它的 +# libc.so.6 是 **glibc 2.36** ⇒ `-L` 把链接器引到 2.36 ⇒ 产物又绑 +# GLIBC_2.34+ ⇒ 海光(2.28)/ZYNQ(2.26) 都跑不了。 +# 现在用 ssw-tds-test/build/sysroot-armhf(只含 libz.so.1 + zlib.h, +# libz 的 GLIBC 需求仅 2.4)。 +export ZIG_SYSROOT="${ZIG_SYSROOT:-${REPO_ROOT}/../ssw-tds-test/build/sysroot-armhf}" + +# 🔴 glibc 兼容 shim 注入目录(explicit_bzero / getrandom,glibc 2.25 才有) +# ⚠️ 这两个 shim **不能**放进 libpglite.a:rustc 在 --whole-archive 场景会 +# 重打包归档,对这类只被 undefined 引用的成员处理不确定(时有时无)。 +export ZIG_COMPAT_DIR="${ZIG_COMPAT_DIR:-${ENGINE_DIR}/compat}" + export CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER="${REPO_ROOT}/scripts/zig-cc-armv7.sh" +# 🔴🔴🔴 **必须绕过 sccache**(2026-11-13 定位): +# rustc 把 `-L native=<引擎目录>` 里的 `libpglite.a` **bundle 进 rlib**, +# 而 rustc 指纹**不含 native 静态库内容哈希** ⇒ 换引擎后 sccache 仍命中旧缓存 +# ⇒ 返回内嵌**旧引擎**的 rlib ⇒ 链接期 `undefined symbol: fcntl64`。 +# `cargo clean` 清不掉 sccache 缓存 ⇒ 只能绕开 wrapper。 +export RUSTC_WRAPPER="${RUSTC_WRAPPER-}" + echo " 引擎目录(PGLITE_LIB_DIR): ${ENGINE_DIR}" echo " 链接器(zig cc): ${CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER}" echo " sysroot: ${ZIG_SYSROOT}" +echo " compat: ${ZIG_COMPAT_DIR}" echo " strip: ${CARGO_PROFILE_RELEASE_STRIP}(交叉构建必须 none,见脚本注释)" cargo build --release --target "${TARGET_TRIPLE}" -p sspf-admin @@ -103,28 +124,188 @@ BIN="target/${TARGET_TRIPLE}/release/sspf-admin" file "${BIN}" # ── 3. 冒烟:在 arm/v7 容器里真跑一下 ───────────────────────── -echo "==> [3/3] arm/v7 容器冒烟(起服务 → 探活 → 停)" +# +# 🔴🔴 **三个 case,覆盖 stdout 的三种形态**(2026-11-13,Gitea issue #1): +# +# 内嵌 PostgreSQL 把 **fd 1 当成「名义客户端 socket」**(`initDummyPort()` 设 +# `s.sock = 1`)⇒ `pq_init()` 把它注册进 WaitEventSet ⇒ Linux 走 **epoll**, +# 而 **epoll 不接受普通文件与字符设备**(实测 EPERM)⇒ `ereport(ERROR)` +# ⇒ longjmp ⇒ **exit 100**。 +# +# ⇒ 只有「fd 1 是管道」才能启动。 +# ⇒ 旧冒烟**只测了管道形态**(docker 继承的 pipe)却**没有断言**, +# 而文档里记录的验证命令也没有重定向 ⇒ 验收链有盲区: +# 最常见的部署形态(`nohup … > app.log 2>&1 &`)从来没被测过。 +# +# 三个 case(每个都是**全新容器 + 全新数据目录**,串行,避免互相干扰): +# A. stdout 继承 docker pipe(= 现状,issue 里的成功形态) +# B. stdout → 普通文件 `> /tmp/srv.log 2>&1`(= **最常见的部署形态**,旧盲区) +# C. stdout → /dev/null(字符设备) +# +# 断言(每个 case 都要过): +# · HTTP 探活成功(`/api/oauth/CurrentUser` 有响应) +# · 进程**仍存活**(没有提前 exit 100) +# · A/B 还要日志里出现「已启动」 +# (C 的 stdout 进了 /dev/null ⇒ 拿不到,这正是 C 的形态本身) +echo "==> [3/3] arm/v7 容器冒烟(stdout 三形态 × 干净数据目录)" SMOKE_DIR="${WORK}/smoke" -DATA_DIR="${WORK}/pgdata" -mkdir -p "${SMOKE_DIR}" "${DATA_DIR}" +rm -rf "${SMOKE_DIR}" +mkdir -p "${SMOKE_DIR}" cp "${BIN}" "${SMOKE_DIR}/sspf-admin" # 🔴 用 arm32v7/debian:bookworm-slim(armhf 基础镜像)而不是 debian:bookworm-slim: # 后者是 amd64 镜像,--platform linux/arm/v7 拉下来还得 qemu 转译,白白慢。 -docker run --rm --platform linux/arm/v7 \ - -v "${SMOKE_DIR}:/app:ro" -v "${DATA_DIR}:/data" \ - arm32v7/debian:bookworm-slim sh -c ' - cd /tmp && PGLITE_DIR=/data/pg PORT=30077 /app/sspf-admin > /tmp/srv.log 2>&1 & - PID=$! - for i in $(seq 1 90); do - if wget -q -O /dev/null http://127.0.0.1:30077/api/oauth/CurrentUser 2>/dev/null; then - echo "HTTP-OK"; break +SMOKE_IMAGE="${SMOKE_IMAGE:-arm32v7/debian:bookworm-slim}" +# 🔴 armv7 上 initdb + schema + 14k 条示例数据导入实测 40~150s ⇒ 轮询窗口给到 240s。 +SMOKE_TRIES="${SMOKE_TRIES:-120}" +# 🔴🔴 **端口与数据目录必须用 `-e` 传进容器**(2026-11-13 实测踩坑): +# 旧脚本把它们写在 `sh -c '... PGLITE_DIR=… PORT=… …'` 的**内联命令行**里; +# 改成 `bash -c` 后若只靠内联,就会在**外层**展开成宿主机 shell 的变量, +# 容器内拿不到 ⇒ 服务起在**默认端口 30010** + **默认数据目录**(cwd 下的 +# `src/backend/data/lite.pg`)⇒ 探活一直 Connection refused ⇒ 误判成「启动失败」。 +# ⇒ 显式 `-e` 传参,容器内用 `$PORT` / `$PGLITE_DIR` 引用。 +SMOKE_PORT="${SMOKE_PORT:-30077}" + +# 跑一个 case,输出到文件并回显。 +run_smoke_case() { + local name="$1" + local data_dir="${WORK}/smoke-${name}" + local out="${WORK}/smoke-${name}.out" + rm -rf "${data_dir}" + mkdir -p "${data_dir}" + # 🔴 `bash` 而不是 `sh`:探活用 bash 的 `/dev/tcp`(dash 不支持)。 + # 镜像里也**没有 wget/curl**(bookworm-slim 只有 coreutils)⇒ 只能用 /dev/tcp。 + docker run --rm --platform linux/arm/v7 \ + -v "${SMOKE_DIR}:/app:ro" -v "${data_dir}:/data" \ + -e SMOKE_CASE="${name}" -e SMOKE_TRIES="${SMOKE_TRIES}" \ + -e SMOKE_PORT="${SMOKE_PORT}" -e PORT="${SMOKE_PORT}" -e PGLITE_DIR="/data/pg" \ + "${SMOKE_IMAGE}" bash -c ' + cd /tmp + # ── 三种 stdout 形态 ─────────────────────────────────── + case "$SMOKE_CASE" in + A) /app/sspf-admin 2>/tmp/srv.log & ;; # stdout 继承 docker pipe + B) /app/sspf-admin > /tmp/srv.log 2>&1 & ;; # stdout → 普通文件 + C) /app/sspf-admin > /dev/null 2>/tmp/srv.log & ;; # stdout → /dev/null + esac + PID=$! + + # ── 探活:bash 内建 /dev/tcp,发一个真实 HTTP 请求 ───── + # 🔴 整套塞进子 shell 且把 `2>/dev/null` 放在**最外层**:bash 对 + # `/dev/tcp` 连接失败时会自己往 stderr 打 "connect: Connection refused", + # 若只把重定向写在 exec 那一行,错误消息会在重定向生效**之前**就冒出 + # ⇒ 日志被几百行噪声淹没。 + probe() { + ( + exec 3<>/dev/tcp/127.0.0.1/"$SMOKE_PORT" || exit 1 + printf "GET /api/oauth/CurrentUser HTTP/1.0\r\nHost: 127.0.0.1\r\n\r\n" >&3 || exit 1 + read -r -t 5 line <&3 || exit 1 + case "$line" in HTTP/*) exit 0 ;; *) exit 1 ;; esac + ) 2>/dev/null + } + + OK=0 + for i in $(seq 1 "$SMOKE_TRIES"); do + if probe; then OK=1; break; fi + kill -0 "$PID" 2>/dev/null || break + sleep 2 + done + echo "CASE_HTTP_OK=$OK" + + if kill -0 "$PID" 2>/dev/null; then + echo "CASE_ALIVE=1" + kill "$PID" 2>/dev/null + wait "$PID" 2>/dev/null + else + echo "CASE_ALIVE=0" + wait "$PID" 2>/dev/null + echo "CASE_EXIT=$?" fi - kill -0 $PID 2>/dev/null || break - sleep 2 - done - head -30 /tmp/srv.log - kill $PID 2>/dev/null - ' 2>&1 | tail -30 + + # 日志全文里的关键标记(不靠 tail 截断,避免把「已启动」截掉) + if [ -f /tmp/srv.log ]; then + echo "CASE_LOG_BYTES=$(wc -c < /tmp/srv.log)" + # 🔴 `grep -c` 在「0 个匹配」时**退出码非 0**,直接 `$(… || echo 0)` 会把 + # 输出变成 "0\n0" ⇒ 用 `|| true` 兜住退出码,保留 grep 自己打的那个 0。 + echo "CASE_LOG_MARKER=$(grep -c "已启动" /tmp/srv.log 2>/dev/null || true)" + # 🔴 「启动诊断」= fd 1 替换路径**确实执行过**(B/C 必须有,A 必然没有) + echo "CASE_DIAG=$(grep -c "启动诊断" /tmp/srv.log 2>/dev/null || true)" + else + echo "CASE_LOG_BYTES=0" + echo "CASE_LOG_MARKER=0" + echo "CASE_DIAG=0" + fi + echo "---- srv.log(去噪后,最多 20 行)----" + grep -v "protocol synchronization was lost" /tmp/srv.log 2>/dev/null | tail -20 || true + echo "---- end ----" + ' > "${out}" 2>&1 || true + cat "${out}" +} + +# 断言一个 case 的结果。 +# +# $1 = case 名;$2 = 「已启动」标记从哪找: +# host ⇒ 宿主机侧的 `${out}`(case A 的 stdout 直接进 docker pipe) +# srvlog ⇒ 容器内 `/tmp/srv.log`(case B 的 stdout 就写在这里) +# none ⇒ 不查(case C 的 stdout 进了 /dev/null,本来就拿不到) +# $3 = 是否要求「启动诊断」出现(= fd 1 被替换过) +assert_smoke_case() { + local name="$1" marker_src="$2" need_diag="$3" + local out="${WORK}/smoke-${name}.out" + local fail=0 + + if ! grep -q "CASE_HTTP_OK=1" "${out}"; then + echo " ❌ ${name}: HTTP 探活失败(服务没起来)"; fail=1 + fi + if ! grep -q "CASE_ALIVE=1" "${out}"; then + echo " ❌ ${name}: 进程未常驻(提前退出 ⇒ 很可能又是 exit 100)"; fail=1 + grep -m1 "CASE_EXIT=" "${out}" || true + fi + + case "${marker_src}" in + host) + grep -q "已启动" "${out}" || { echo " ❌ ${name}: stdout 里没有「已启动」"; fail=1; } + ;; + srvlog) + grep -q "CASE_LOG_MARKER=1" "${out}" || { echo " ❌ ${name}: 日志里没有「已启动」"; fail=1; } + ;; + esac + + if [[ "${need_diag}" == "1" ]]; then + grep -q "CASE_DIAG=1" "${out}" \ + || { echo " ❌ ${name}: 没有「启动诊断」⇒ fd 1 替换路径没走到(修复可能没生效)"; fail=1; } + fi + + if [[ "${fail}" == "0" ]]; then + echo " ✅ ${name}: 通过" + return 0 + fi + return 1 +} + +SMOKE_FAILED=0 + +# 🔴 用例分工(关键:**B 才是 issue 报的失败形态**) +# A stdout 是管道 ⇒ `already_ok` 提前返回 ⇒ **不走替换**、无诊断、无 drain 线程; +# 标记只能从 docker 捕获的 stdout 里找。 +# B stdout 是普通文件 ⇒ **必须走替换** ⇒ 必须有诊断、必须有「已启动」。 +# C stdout 是 /dev/null ⇒ 也走替换 ⇒ 必须有诊断;「已启动」进 /dev/null,查不到。 +echo "--- case A: stdout 继承 docker pipe(不走替换)---" +run_smoke_case A +assert_smoke_case A host 0 || SMOKE_FAILED=1 + +echo "--- case B: stdout → 普通文件(> /tmp/srv.log 2>&1,issue 的失败形态)---" +run_smoke_case B +assert_smoke_case B srvlog 1 || SMOKE_FAILED=1 + +echo "--- case C: stdout → /dev/null(字符设备)---" +run_smoke_case C +assert_smoke_case C none 1 || SMOKE_FAILED=1 + +if [[ "${SMOKE_FAILED}" != "0" ]]; then + echo "" >&2 + echo "!! armv7 冒烟失败(stdout 三形态未全部通过)" >&2 + echo " 详见 ${WORK}/smoke-{A,B,C}.out" >&2 + exit 1 +fi echo "" echo "✅ armv7 产物: ${BIN}" diff --git a/src/backend/src/boot.rs b/src/backend/src/boot.rs index 7270ace..c6393ec 100644 --- a/src/backend/src/boot.rs +++ b/src/backend/src/boot.rs @@ -334,7 +334,10 @@ pub fn whitelist_self_check_platform() -> Result<(), String> { /// 开库:`PGLITE_DIR=memory://` ⇒ 临时库(进程退出即销毁);否则磁盘目录。 pub async fn open_db(config: &Config) -> Result { #[cfg(unix)] - ensure_stdout_for_pglite(); + { + ensure_stdout_for_pglite(); + ensure_runtime_dir_isolated(); + } if config.pg_is_temp() { Db::open_temp().await } else { @@ -342,38 +345,282 @@ pub async fn open_db(config: &Config) -> Result file` / `| pipe` / 终端场景完全不动, -/// 也不影响 MCP 协议通道(协议走 `dup` 出来的独立 fd)。 -#[cfg(unix)] +/// ## 根因(Gitea issue #1,armv7 部署全挂) +/// +/// pglite 的 `initDummyPort()`(`src/backend/tcop/postgres.c`)设 **`s.sock = 1`** —— +/// 把 **fd 1 当成「名义客户端 socket」**;`pq_init()` 随即把它注册进 WaitEventSet: +/// +/// ```c +/// socket_pos = AddWaitEventToSet(FeBeWaitSet, WL_SOCKET_WRITEABLE, +/// port->sock, NULL, NULL); /* port->sock == 1 */ +/// ``` +/// +/// 等待事件的后端按平台分(`src/backend/storage/ipc/latch.c`): +/// Linux ⇒ `HAVE_SYS_EPOLL_H` ⇒ **epoll**;macOS ⇒ **kqueue**。 +/// +/// 而 **epoll 只接受 poll-able 的 fd**:管道 / socket / eventfd …… +/// **普通文件(`S_IFREG`)与字符设备(`S_IFCHR`)一律 `EPERM`**。 +/// 实测(armv7 容器内): +/// +/// ```text +/// 普通文件 epoll_ctl=-1 Operation not permitted +/// /dev/null epoll_ctl=-1 Operation not permitted +/// 管道写端 epoll_ctl=0 OK +/// 管道读端 epoll_ctl=0 OK +/// ``` +/// +/// ⇒ fd 1 是普通文件或 `/dev/null` 时,`epoll_ctl` 报 `EPERM` ⇒ +/// `ereport(ERROR, "epoll_ctl() failed: %m")` ⇒ longjmp ⇒ **`exit(100)`**。 +/// macOS 走 kqueue(允许把普通文件/字符设备注册为 `EVFILT_WRITE`)⇒ 同样形态正常。 +/// +/// ## 为什么不能「换成普通文件」 +/// +/// 旧实现(`ensure_stdout_for_pglite`)把 fd 1 `dup2` 到一个**普通临时文件** —— +/// 那只是把「字符设备失败」换成「普通文件失败」,**同样 EPERM、同样 exit 100**。 +/// +/// ## 本实现(管道 + 原始 stdout 转发 + drain) +/// +/// 1. `pipe()` 造一对 fd; +/// 2. **`dup` 原始 stdout 到一个新 fd**(`orig_stdout`)—— 平台的 `println!` +/// (「已启动」「导入完成」…)必须继续落到**用户真正要的 stdout**; +/// 3. `dup2(pipe_w, 1)` ⇒ **fd 1 变成管道写端**(epoll 合法); +/// 4. 起一个 **drain 线程**读管道读端,把内容**转发到 `orig_stdout`**; +/// 5. 原始 stdout 与管道读端都**泄漏保活**(进程级,不随作用域结束而关闭)。 +/// +/// ## 为什么 drain 线程是必需的(不是「保险」) +/// +/// pglite 的 `pgl_fcntl` 是 **dummy**(`pglite/src/pglitec/pglitec.c`: +/// `int pgl_fcntl(int __fd, int __cmd, ...) { return 0; }`)⇒ +/// `pq_init()` 里的 `pg_set_noblock(port->sock)` **完全无效** ⇒ +/// **fd 1 始终是阻塞模式** ⇒ 管道缓冲(Linux 默认 64KB)写满后 +/// `write()` 会**永久阻塞** ⇒ 内嵌 PG 直接卡死。 +/// ⇒ 必须有活线程持续消费。 +/// +/// ## 为什么 macOS 不需要动 +/// +/// kqueue 允许注册普通文件/字符设备 ⇒ 原来的 fd 1 在 macOS 上本就可用。 +/// ⇒ 只在 **非 macOS** 上做替换(`#[cfg(not(target_os = "macos"))]`), +/// 避免在能跑的地方引入无谓的线程与转发延迟。 +#[cfg(all(unix, not(target_os = "macos")))] fn ensure_stdout_for_pglite() { - use std::os::unix::io::AsRawFd; + // ① unsafe 只覆盖「判定 + 造管道 + dup + dup2」这一段系统调用; + // 线程的启动与运行放在安全区(闭包体内不再有 unsafe)。 + let Some((pipe_r, orig_stdout, orig_kind)) = redirect_stdout_to_pipe() else { + return; + }; + + // ② drain 线程:读管道 ⇒ 转发到原始 stdout。 + // 🔴 两个裸 fd 交给 `File` 独占(它们没有其它所有者)⇒ 各关一次、不 double-close。 + // 🔴 线程 detach(不 join)⇒ 随进程退出而终止。 + use std::os::fd::FromRawFd; + // SAFETY: 两个 fd 都是 `redirect_stdout_to_pipe` 新建、且未交给任何其它所有者。 + let (src, dst) = unsafe { + ( + std::fs::File::from_raw_fd(pipe_r), + std::fs::File::from_raw_fd(orig_stdout), + ) + }; + + if let Err(e) = std::thread::Builder::new() + .name("ssw-pglite-stdout".to_string()) + .spawn(move || drain_stdout(src, dst)) + { + // 🔴 线程起不来的后果要说清:fd 1 已是管道写端但无人消费 + // ⇒ 内嵌 PG 写满 64KB 后会**永久阻塞**。 + eprintln!( + "[启动诊断] 无法启动 stdout 转发线程(fd 1 已是管道写端但无人消费,写满 64KB 会阻塞):{e}" + ); + return; + } + + eprintln!( + "[启动诊断] fd 1 原为 {orig_kind},已替换为管道写端(内嵌 PG 要求 fd 1 可被 epoll 注册);\ + 平台自身的输出由转发线程写回原 stdout。" + ); +} + +/// 把管道内容持续转发到原始 stdout(drain)。 +/// +/// 读到 `EOF`(写端全部关闭)或原始 stdout 不可写时退出 —— 后者意味着用户 +/// 把日志端关掉了,继续转发只会反复失败。 +#[cfg(all(unix, not(target_os = "macos")))] +fn drain_stdout(mut src: std::fs::File, mut dst: std::fs::File) { + use std::io::{Read, Write}; + + let mut buf = [0u8; 8192]; + loop { + match src.read(&mut buf) { + Ok(0) => break, // 写端全关 ⇒ 正常收尾 + Ok(n) => { + if dst.write_all(&buf[..n]).is_err() { + break; // 原始 stdout 不可写(用户关掉了)⇒ 停止转发 + } + let _ = dst.flush(); + } + Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue, + Err(_) => break, + } + } +} + +/// 判定并执行「把 fd 1 换成管道写端」,返回 `(管道读端, 原始 stdout 副本, fd 1 原类型)`。 +/// +/// 返回 `None` 的三种情况(都已尽力回滚 + 打诊断): +/// ① fd 1 已是管道/套接字(无需替换);② 造管道失败;③ dup / dup2 失败。 +/// +/// # Safety 说明 +/// +/// 函数内部全是 fd 级系统调用。任一步失败都**显式关闭已拿到的 fd**,不留半改状态。 +#[cfg(all(unix, not(target_os = "macos")))] +fn redirect_stdout_to_pipe() -> Option<(std::os::fd::RawFd, std::os::fd::RawFd, &'static str)> { + use std::os::fd::RawFd; + + // SAFETY: 见函数文档;所有失败路径都回滚。 + unsafe { + // ① fd 1 是不是已经「可被 epoll 接受」的类型?只对**管道/套接字**放行。 + // (终端是 S_IFCHR ⇒ 在 Linux 上同样 EPERM ⇒ 必须换。) + let mut st: libc::stat = std::mem::zeroed(); + let kind = if libc::fstat(libc::STDOUT_FILENO, &mut st) == 0 { + st.st_mode & libc::S_IFMT + } else { + 0 + }; + if kind == libc::S_IFIFO || kind == libc::S_IFSOCK { + return None; + } + + let orig_kind = describe_fd(libc::STDOUT_FILENO); + + // ② 造管道。 + let mut fds: [libc::c_int; 2] = [0; 2]; + if libc::pipe(fds.as_mut_ptr()) != 0 { + eprintln!( + "[启动诊断] 无法创建管道(fd 1 将在 epoll 上失败,内嵌 PG 可能以 exit 100 退出):{}", + std::io::Error::last_os_error() + ); + return None; + } + let (pipe_r, pipe_w): (RawFd, RawFd) = (fds[0], fds[1]); + + // ③ 原始 stdout 另存一份(平台的 println! 之后由 drain 线程转发过去)。 + let orig_stdout = libc::dup(libc::STDOUT_FILENO); + if orig_stdout < 0 { + eprintln!( + "[启动诊断] 无法复制原始 stdout(fd 1 将在 epoll 上失败,内嵌 PG 可能以 exit 100 退出):{}", + std::io::Error::last_os_error() + ); + libc::close(pipe_r); + libc::close(pipe_w); + return None; + } + + // ④ fd 1 ⇒ 管道写端。 + if libc::dup2(pipe_w, libc::STDOUT_FILENO) < 0 { + eprintln!( + "[启动诊断] 无法把 fd 1 指向管道(内嵌 PG 可能以 exit 100 退出):{}", + std::io::Error::last_os_error() + ); + libc::close(orig_stdout); + libc::close(pipe_r); + libc::close(pipe_w); + return None; + } + // dup2 之后 pipe_w 与 fd 1 指向同一管道 ⇒ 写端保持打开即可。 + libc::close(pipe_w); + + Some((pipe_r, orig_stdout, orig_kind)) + } +} + +/// macOS 走 kqueue(允许注册普通文件/字符设备)⇒ 原样保留 fd 1,不做任何替换。 +#[cfg(all(unix, target_os = "macos"))] +fn ensure_stdout_for_pglite() { + // 空实现:kqueue 对普通文件与字符设备都返回成功 ⇒ fd 1 无需是管道。 +} + +/// 描述 fd 的类型(用于启动诊断日志)。 +#[cfg(all(unix, not(target_os = "macos")))] +fn describe_fd(fd: libc::c_int) -> &'static str { + // SAFETY: `fstat` 只写 `st`;`libc::stat` 是 POD,zeroed 合法。 unsafe { let mut st: libc::stat = std::mem::zeroed(); - let bad = libc::fstat(libc::STDOUT_FILENO, &mut st) != 0 - || (st.st_mode & libc::S_IFMT) == libc::S_IFCHR; - if !bad { - return; + if libc::fstat(fd, &mut st) != 0 { + return "不可用(fstat 失败)"; } - // 开一个普通临时文件当作 stdout 落点(append,内容无人在意)。 - let tmp = std::env::temp_dir() - .join(format!("ssw-pglite-stdout-{}.log", std::process::id())); - match std::fs::OpenOptions::new().create(true).append(true).open(&tmp) { - Ok(f) => { - // 泄漏 fd 以保证 fd 1 在整个进程生命周期内有效(指向普通文件)。 - let _ = libc::dup2(f.as_raw_fd(), libc::STDOUT_FILENO); - std::mem::forget(f); - } - Err(_) => { - // 兜底:连临时文件都开不了,至少把 fd 1 指向 fd 2(通常仍非字符设备)。 - let _ = libc::dup2(libc::STDERR_FILENO, libc::STDOUT_FILENO); + match st.st_mode & libc::S_IFMT { + libc::S_IFIFO => "管道", + libc::S_IFREG => "普通文件", + libc::S_IFCHR => "字符设备(含终端)", + libc::S_IFSOCK => "套接字", + _ => "其它类型", + } + } +} + +/// 🔴 **把 pglite 的 runtime 目录按架构隔离**(Gitea issue #1 关联问题 1)。 +/// +/// pglite-rs 0.2.7 的 `runtime_dir()`(`engine.rs`)默认取 +/// `$TMPDIR/pglite-rs-runtime-0.2.7-`,而 `runtime_fingerprint()` +/// **只哈希 runtime tar 的内容** ⇒ **x86_64 与 armv7 共用同一个目录名**。 +/// ⇒ 在同一台机器上先后跑两种架构的二进制时,后者会撞上前者残留的目录 ⇒ +/// `Error::Boot("runtime extraction race lost and target invalid")`。 +/// +/// `engine.rs` **确实支持** `PGLITE_RUNTIME_DIR` 环境变量覆盖 ⇒ +/// 这里在开库前把它固化成一个**带目标架构与二进制指纹**的路径: +/// 不同架构、不同构建物 ⇒ 各自独立,互不抢占。 +/// +/// ⚠️ 只在**用户没显式设置**时覆盖 —— 用户显式指定了路径就该尊重它。 +#[cfg(unix)] +fn ensure_runtime_dir_isolated() { + if std::env::var_os("PGLITE_RUNTIME_DIR").is_some() { + return; // 用户显式指定 ⇒ 尊重 + } + let dir = runtime_dir_for_this_binary(); + // 🔴 **必须用 `set_var` 而不是 `std::env::set_var` 的不安全变体**: + // Rust 2024 起 `set_var` 是 unsafe;本仓 edition 2021 ⇒ 走 `std::env::set_var` + // 仍安全,但为兼容后续升级,这里显式标注调用点。 + unsafe { std::env::set_var("PGLITE_RUNTIME_DIR", &dir) }; +} + +/// 构造「带架构 + 二进制指纹」的 runtime 目录名。 +/// +/// 🔴 **指纹必须含架构**:pglite 的 runtime tar 里 `bin/postgres` / `bin/initdb` +/// 是**可执行文件**(目标架构的 ELF)⇒ 同一 tar 在 x86_64 与 armv7 上 +/// **内容不同** ⇒ 但 pglite 的 `runtime_fingerprint()` 只哈希 tar ⇒ 撞名。 +/// 这里额外把**当前二进制的架构**与**自身路径/长度**掺进去,够用且零成本。 +#[cfg(unix)] +fn runtime_dir_for_this_binary() -> PathBuf { + let arch = std::env::consts::ARCH; + let mut hash: u64 = 0xcbf29ce484222325; // FNV-1a 偏移基 + let mut mix = |bytes: &[u8]| { + for &b in bytes { + hash ^= u64::from(b); + hash = hash.wrapping_mul(0x100000001b3); + } + }; + + // ① 可执行文件路径(不同安装位置 ⇒ 不同目录,避免两个部署互相踩)。 + let exe = std::env::current_exe().unwrap_or_default(); + mix(exe.to_string_lossy().as_bytes()); + + // ② 二进制自身的**大小 + 修改时间** —— 这是「构建指纹」的实质: + // 换了引擎 / 改了代码重新编译 ⇒ 两者必有一变 ⇒ 目录名跟着变 + // ⇒ 不会复用上一次构建解出来的 runtime(那正是跨架构/跨版本抢占的来源)。 + // ⚠️ 只 stat 不读内容:70 MB 的二进制算哈希要几百毫秒,不值。 + if let Ok(md) = std::fs::metadata(&exe) { + mix(&md.len().to_le_bytes()); + if let Ok(t) = md.modified() { + if let Ok(d) = t.duration_since(std::time::UNIX_EPOCH) { + mix(&d.as_secs().to_le_bytes()); + mix(&d.subsec_nanos().to_le_bytes()); } } } + + let build = env!("CARGO_PKG_VERSION"); + std::env::temp_dir().join(format!("pglite-rs-runtime-{build}-{arch}-{hash:016x}")) } /// 🔴 **优雅关闭嵌入式 PostgreSQL**(起服务与跑种子共用同一条路径)。