Go语言底层真相速查表：C仅用于6类场景——信号转发、线程创建、TLS初始化、profiling钩子、errno映射、syscall桥接（精确到函数名）

第一章：Go语言底层用c吗

Go语言的运行时（runtime）和标准库核心部分确实大量使用C语言编写，但这种“用C”并非指Go源码直接编译为C，而是指其构建工具链与底层基础设施深度依赖C生态。具体而言，Go的启动代码（如runtime·rt0_go）、内存分配器（mheap）、调度器初始化、系统调用封装（syscall包底层）以及平台相关汇编桥接逻辑，均以.s（Plan 9汇编）或.c文件形式存在于src/runtime/目录中。

Go构建过程中的C参与环节

cmd/dist工具在首次构建Go编译器时，会调用宿主系统的C编译器（如gcc或clang）编译runtime/cgo和runtime/proc.c等C辅助模块；
cgo机制允许Go代码直接调用C函数，其生成的中间文件（.cgo1.go、.cgo2.c）由gcc或clang参与链接；
在Linux上执行go build -x可观察到实际调用链：gcc -I $GOROOT/include -D... runtime/cgo/cgo.c被显式编译。

验证C依赖的实操步骤

# 进入Go源码目录（需已克隆https://go.dev/src）
cd $GOROOT/src/runtime
# 查看C文件存在性
ls -l *.c | head -5
# 输出示例：
# -rw-r--r-- 1 user user  3248 Jan 10 10:23 atomic.c
# -rw-r--r-- 1 user user 11276 Jan 10 10:23 mem_linux.c

该命令列出runtime中真实存在的C源文件，证实其作为Go运行时基础组件的组成部分。

C与Go共存的边界设计

组件类型	语言实现	说明
GC核心算法	Go	标记-清扫逻辑主要用Go实现
系统调用封装	C + 汇编	`sys_linux_amd64.s`调用`libc`或直接`syscall`
信号处理	C	`signal_unix.c`处理`SIGSEGV`等异步事件

值得注意的是，自Go 1.20起，libgcc等外部C运行时依赖已被移除，Go运行时通过纯汇编+Go重写了大部分平台适配逻辑，大幅降低对宿主C库的耦合度。

第二章：信号转发机制与C代码介入点

2.1 signal.Notify背后的sigaction系统调用链（runtime/signal_unix.go → libc sigaction）

Go 的 signal.Notify 并非直接拦截信号，而是通过运行时层注册信号处理行为，最终委托给底层 sigaction(2) 系统调用。

Go 运行时信号注册入口

// runtime/signal_unix.go
func signal_enable(sig uint32) {
    var sa sigactiont
    sa.sa_flags = _SA_SIGINFO | _SA_RESTART
    sa.sa_mask = uint64(0) // block no additional signals during handler
    sa.sa_handler = uintptr(unsafe.Pointer(&sigtramp)) // Go's signal trampoline
    sigaction(sig, &sa, nil)
}

该函数构造 sigactiont 结构体，设置 _SA_SIGINFO 以支持带上下文的信号处理，并将 sigtramp（Go 信号跳板）设为处理函数地址；sigaction 是封装后的 libc 调用。

关键参数语义对照表

字段	含义	Go 中对应值
`sa_handler`	信号处理函数指针	`&sigtramp` 地址
`sa_flags`	行为标志（如 `_SA_SIGINFO`）	启用 `siginfo_t` 传递
`sa_mask`	临时屏蔽的信号掩码	空掩码（0）

系统调用链路

graph TD
    A[signal.Notify] --> B[runtime.signal_enable]
    B --> C[syscall.sigaction]
    C --> D[libc sigaction wrapper]
    D --> E[syscalls/syscall.S → kernel]

2.2 SIGPROF/SIGQUIT在goroutine抢占中的C层转发逻辑（runtime/os_linux.go → sigsend）

Go运行时通过SIGPROF（周期性）与SIGQUIT（手动触发）实现goroutine抢占，其信号处理路径需从内核态安全转入Go调度器。

信号注册与转发入口

Linux平台中，runtime/signal_unix.go调用sigprocmask屏蔽所有信号，再由sigtramp将SIGPROF/SIGQUIT重定向至sigsend函数：

// runtime/os_linux.go
func sigsend(sig uint32) {
    // 将信号转为runtime内部事件
    if sig == _SIGPROF || sig == _SIGQUIT {
        atomic.Store(&sighandled[sig], 1)
        // 唤醒m等待队列，触发mcall到sysmon或signal handling goroutine
        notewakeup(&sigNote)
    }
}

该函数不直接执行抢占，而是通过notewakeup唤醒阻塞在sigNote上的sysmon线程，由其调用doSigProc完成goroutine栈扫描与抢占标记。

关键信号语义对比

信号	触发源	抢占粒度	是否可被屏蔽
`SIGPROF`	`setitimer(ITIMER_PROF)`	约10ms周期	否（runtime强制接管）
`SIGQUIT`	`kill -QUIT <pid>`	即时、手动触发	否

graph TD
    A[内核发送SIGPROF/SIGQUIT] --> B[内核态信号递达]
    B --> C[go signal trampoline]
    C --> D[sigsend(sig)]
    D --> E[notewakeup&amp;sigNote]
    E --> F[sysmon goroutine]
    F --> G[scan all G stacks]
    G --> H[设置g.preempt = true]

2.3 Go runtime对SIGURG、SIGPIPE等特殊信号的屏蔽与重定向实现（runtime/cgocall.go + signal.c）

Go runtime为保障goroutine调度的确定性，主动屏蔽并重定向部分POSIX信号。核心逻辑分布在runtime/cgocall.go（CGO调用上下文隔离）与runtime/signal.c（底层信号处理注册）。

信号屏蔽策略

SIGURG：被sigfillset(&dontignore)显式加入忽略集，避免干扰网络goroutine的netpoll事件循环
SIGPIPE：默认忽略（SA_RESTART不适用），防止CGO调用中write系统调用意外终止程序

关键代码片段

// runtime/signal.c: sigtramp_go() 初始化阶段
sigfillset(&dontignore);
sigdelset(&dontignore, SIGTRAP);   // 保留调试信号
sigdelset(&dontignore, SIGPROF);   // 保留性能剖析
// ... 其余信号按需从dontignore中移除

该代码构建“不可忽略信号白名单”，其余信号（含SIGURG/SIGPIPE）由内核自动设为SIG_IGN。

信号	默认行为	Go runtime 处理方式	影响面
`SIGURG`	中断	强制忽略	`net.Conn`紧急数据
`SIGPIPE`	终止进程	忽略 + errno=EPIPE	CGO write调用

// runtime/cgocall.go: cgoCall 的信号上下文保存
func cgoCall(fn, arg, ret unsafe.Pointer) {
    // 保存当前信号掩码，恢复时仅还原用户态关注的信号
    sigprocmask(_SIG_SETMASK, &oldmask, nil)
}

此机制确保CGO调用期间，SIGURG/SIGPIPE不会穿透到Go调度器，维持M级线程的信号环境一致性。

2.4 信号处理函数注册时的C函数指针封装（runtime/signal_amd64.s → sigtramp）

在 Go 运行时中，sigtramp 是 AMD64 平台下信号传递的关键胶水代码，负责将内核触发的信号安全转交至 Go 的 sighandler。

sigtramp 的核心职责

保存完整寄存器上下文（含 RSP、RIP、RFLAGS 等）
切换至 g0 栈以避免用户栈损坏
调用 runtime.sigtrampgo（Go 封装层），传入 sig, info, ctxt 三参数

// runtime/signal_amd64.s 中关键片段
TEXT runtime·sigtramp(SB),NOSPLIT,$0
    // 保存寄存器到栈帧
    PUSHQ   %rax
    MOVQ    %rsp, %rdi      // ctxt = &ucontext
    MOVQ    $0, %rsi        // info = nil（由内核填充）
    CALL    runtime·sigtrampgo(SB)

参数说明：%rdi 指向 ucontext_t*（含所有寄存器快照）；%rsi 为 siginfo_t*；%rdx 是信号号。sigtrampgo 由此解包并分发至注册的 Go handler。

Go handler 注册流程

signal.Notify(c, os.Interrupt) → sigNotify → setHandler
最终调用 setitimer + rt_sigaction，其中 sa_handler 指向 sigtramp

组件	类型	作用
`sigtramp`	汇编桩函数	架构特定入口，保障 ABI 兼容性
`sigtrampgo`	Go 函数	解析上下文，调度 goroutine 执行 handler
`sighandler`	运行时逻辑	分发信号至 channel 或执行默认动作

graph TD
    KernelSignal --> sigtramp
    sigtramp --> sigtrampgo
    sigtrampgo --> sighandler
    sighandler --> NotifyChannel
    sighandler --> DefaultAction

2.5 实战：通过patch libc sigprocmask验证Go信号屏蔽行为的C依赖边界

Go 运行时在 runtime/signal_unix.go 中调用 sigprocmask 系统调用（经由 libc 封装）管理信号屏蔽字，但其行为受底层 C 库实现约束。

关键观察点

Go 不直接执行 syscalls，而是通过 libc 的 sigprocmask() 函数间接操作；
若 libc 实现存在缺陷（如忽略 SIG_BLOCK 参数），Go 的 runtime.LockOSThread() + signal.Ignore() 组合将失效。

patch libc 验证方案

// 替换 glibc 的 sigprocmask 实现（简化示意）
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset) {
    // 强制返回 0（成功），但跳过实际设置 → 模拟“假成功”
    return 0;  // 注意：真实 patch 需修改 .so 符号表或 LD_PRELOAD
}

该 patch 使 Go 调用 signal.Ignore(syscall.SIGUSR1) 后，SIGUSR1 仍可被 delivery，暴露 Go 对 libc 行为的隐式依赖。

验证结果对比表

场景	libc 正常	patched libc	Go 信号屏蔽效果
`signal.Ignore(SIGUSR1)`	✅ 屏蔽生效	❌ 仍可触发 handler	依赖 libc 实现正确性

信号流依赖链（mermaid）

graph TD
    A[Go signal.Ignore] --> B[runtime.sigprocmask]
    B --> C[libc sigprocmask]
    C --> D[内核 thread->blocked]
    D --> E[实际信号投递]

第三章：线程创建与OS线程生命周期管理

3.1 runtime.newosproc调用clone(2)的完整参数构造与栈分配（runtime/os_linux.go → clone() wrapper）

Go 运行时在 Linux 上创建新 OS 线程时，runtime.newosproc 最终调用封装后的 clone 系统调用。该调用需精确构造寄存器级参数，确保新线程从 mstart 入口安全执行。

栈布局与内存准备

新线程栈由 runtime.stackalloc 分配，大小为 8192 字节（最小栈）
栈底（高地址）存放 g0 的 gobuf 结构，用于保存初始上下文
栈顶（低地址）预留 sizeof(sigaltstack) + sizeof(mstart) 对齐空间

clone 参数详解（x86-64）

参数	值	说明
`flags`	`CLONE_VM \| CLONE_FS \| CLONE_FILES \| CLONE_SIGHAND \| CLONE_THREAD \| CLONE_SYSVSEM \| CLONE_SETTLS \| CLONE_PARENT_SETTID`	共享地址空间、文件系统、信号处理等，但独立 tid
`stack`	`stk + stksize`	指向栈顶（即新线程栈的最高有效地址）
`parent_tid`	`&m.tid`	写入子线程 TID 到 m.tid
`child_tid`	`&g.m.tls[0]`	用于 futex 清理
`tls`	`&g.m.tls`	设置线程局部存储基址

// runtime/os_linux.go（简化）
func newosproc(mp *m, stk unsafe.Pointer, stksize uintptr) {
    // 构造 tls 段：g.m.tls[0] = g; g.m.tls[1] = mp; ...
    tls := &mp.tls[0]
    cloneFlags := _CLONE_VM | _CLONE_FS | _CLONE_FILES | /* ... */ 
    ret := clone(cloneFlags, procfunc, stk, &mp.tid, tls)
}

procfunc 是汇编桩函数，负责设置 gs_base、加载 g0、跳转至 mstart。stk 必须对齐且足够容纳 gobuf 和中断帧——否则 clone 返回后立即触发栈溢出或寄存器污染。

graph TD
    A[newosproc] --> B[stackalloc 8KB]
    B --> C[setup g0.gobuf on stack top]
    C --> D[prepare tls array]
    D --> E[call clone syscall]
    E --> F[procfunc: set gs_base → mstart]

3.2 M结构体与pthread_create的映射关系及TLS寄存器初始化时机（runtime/os_linux.c → mstart0）

Go运行时通过mstart0启动M（machine）线程，该函数在runtime/os_linux.c中定义，是pthread_create创建的POSIX线程入口。

TLS寄存器初始化时机

mstart0执行前，Linux内核已为新线程分配栈并设置FS/GS寄存器指向线程局部存储（TLS）基址；Go运行时在mstart0首行即调用getg()，依赖此已就绪的TLS寄存器读取当前G指针。

// runtime/os_linux.c
void mstart0(void) {
    // 此刻FS寄存器已由pthread_setup()配置完毕，指向本线程TLS块
    g *gp = getg();  // 从TLS偏移_GS获取g结构体地址
    ...
}

getg()宏展开为(*g**)(uintptr(unsafe.Pointer(&gs)) + G_PTR_OFFSET)，其中gs是编译器注入的TLS符号，G_PTR_OFFSET为TLS内g指针的固定偏移（通常为0）。

M与pthread的一一映射

pthread_t	对应M字段	初始化来源
线程ID（TID）	`m->id`	`gettid()`系统调用
栈基址	`m->stack.hi`	`pthread_attr_getstack()`或默认分配
TLS基址	`m->tls[0]`	`arch_prctl(ARCH_SET_FS, ...)`

graph TD
    A[pthread_create] --> B[内核创建线程<br>设置FS寄存器]
    B --> C[mstart0入口]
    C --> D[getg()读取TLS中g指针]
    D --> E[绑定M与G，进入调度循环]

3.3 线程退出时的pthread_exit与runtime.mexit协同机制（runtime/asm_amd64.s → exit thread）

Go 运行时在线程退出路径中需兼顾 POSIX 兼容性与调度器感知能力。当 goroutine 所在 M（OS 线程）因空闲或系统调用返回而终止时，runtime.mexit 在 runtime/asm_amd64.s 中被调用：

// runtime/asm_amd64.s
TEXT runtime·mexit(SB), NOSPLIT, $0
    MOVQ m_cache+0(FP), AX     // 获取当前 m 结构指针
    CALL runtime·dropm(SB)     // 解绑 m 与 p，归还调度资源
    MOVQ $0, AX
    CALL runtime·pthread_exit(SB)  // 调用 libc pthread_exit，触发线程销毁

该汇编序列确保：

dropm 完成 m→p 解耦与栈清理；
pthread_exit 触发内核线程回收，并执行注册的线程局部存储（TLS）析构函数。

协同关键点

pthread_exit 不返回，避免栈重入风险；
Go 运行时通过 atfork 钩子拦截 fork，但不拦截 pthread_exit，依赖其标准语义完成资源释放。

阶段	主体	职责
用户态清理	`runtime.dropm`	解绑调度器、释放 m 缓存、通知 gc
内核态终结	`pthread_exit`	销毁线程、触发 TLS dtors、回收 kernel TID

graph TD
    A[goroutine 完成/阻塞超时] --> B[runtime.mexit 被调用]
    B --> C[dropm：解绑 m-p，清理本地缓存]
    C --> D[pthread_exit：进入 libc 终止流程]
    D --> E[内核回收线程资源 + TLS 析构]

第四章：TLS初始化与profiling钩子的C级支撑

4.1 _cgo_init中tls_get_addr调用与Glibc TLS模型适配（runtime/cgo/cgo.c → cgo_init）

Go 运行时通过 _cgo_init 初始化 C 语言运行环境，其中关键一步是适配 Glibc 的线程局部存储（TLS）模型。

TLS 初始化的桥梁作用

_cgo_init 在首次调用时传入 __tls_get_addr 符号地址，该函数由 Glibc 提供，用于解析动态 TLS 偏移量：

void _cgo_init(GoThreadStart* ts, void* tls, int64_t tls_size) {
    // tls 指向当前线程的 TLS 段起始地址
    // __tls_get_addr 是 Glibc 实现的 TLS 地址解析器
    __cgo_tls_get_addr = (__typeof__(__tls_get_addr))tls_get_addr_sym;
}

此处 tls_get_addr_sym 来自链接时解析的 __tls_get_addr@GLIBC_2.2.5 符号，确保 Go 协程能正确访问 __thread 变量。

Glibc TLS 模型兼容要点

支持 initial-exec 和 local-exec 模式
依赖 .tdata/.tbss 段布局与 __libc_setup_tls 协同
Go runtime 不接管 TLS 内存分配，仅复用 Glibc 的 __libc_pthread_init 流程

组件	作用	依赖关系
`__tls_get_addr`	解析 TLS 变量运行时地址	必须在 libc.so 中符号可见
`_cgo_init`	注册 TLS 解析器入口	调用前需完成 `pthread_key_create` 初始化

graph TD
    A[_cgo_init] --> B[获取__tls_get_addr地址]
    B --> C[保存为全局函数指针]
    C --> D[后续cgo调用时解析TLS偏移]

4.2 runtime/pprof.startCPUProfile触发setitimer的C封装（runtime/pprof/pprof.go → setitimer syscall wrapper）

startCPUProfile 在 Go 运行时中通过 sysCall 调用底层 C 函数 setitimer，实现纳秒级定时中断：

// runtime/pprof/pprof.go（简化）
func startCPUProfile(w io.Writer) error {
    // ...
    setcpuprofilerate(100 * 1000) // 100μs interval → ~10kHz
    return nil
}

该调用最终经 runtime.setcpuprofilerate → runtime·setitimer（汇编/CGO桥接）进入系统调用。

关键参数映射

Go 参数（μs）	itimerval.it_value.tv_usec	作用
100_000	100000	首次触发延迟
100_000	100000	周期性间隔

流程示意

graph TD
    A[startCPUProfile] --> B[setcpuprofilerate]
    B --> C[runtime·setitimer]
    C --> D[syscall setitimer ITIMER_PROF]
    D --> E[内核定时器触发 SIGPROF]

此封装屏蔽了平台差异，确保 SIGPROF 按需投递至 M 线程以采样 goroutine 栈。

4.3 trace.Start启用时对perf_event_open的C层封装与errno转换（runtime/trace/trace.go → perf_event_open.c）

当 runtime/trace 启用时，Go 运行时通过 CGO 调用 perf_event_open.c 中的封装函数，将 Linux perf_event_open(2) 系统调用抽象为安全、可重入的 C 接口。

封装核心逻辑

// perf_event_open.c
int go_perf_event_open(struct perf_event_attr *attr, pid_t pid, int cpu,
                       int group_fd, unsigned long flags) {
    int ret = syscall(__NR_perf_event_open, attr, pid, cpu, group_fd, flags);
    if (ret == -1) {
        return -errno; // 统一返回负errno，避免Go侧误判为成功fd
    }
    return ret;
}

该函数屏蔽了 errno 的全局副作用，直接返回 -errno，使 Go 层可通过 syscall.Errno(-ret) 精确还原错误类型（如 EPERM、EINVAL）。

errno 转换规则

Go 错误检查方式	对应 C 返回值	常见场景
`err != nil`	`ret < 0`	权限不足或参数非法
`errors.Is(err, unix.EPERM)`	`ret == -1` + `errno == EPERM`	未启用 `CAP_SYS_ADMIN`

数据同步机制

所有 perf event fd 在 trace.enable() 中批量创建并注册到 runtime.tracePerfEvents
内核 ring buffer 通过 mmap() 映射至用户态，由 trace.(*EventReader).read() 定期轮询解析

4.4 实战：在musl libc环境下禁用C TLS初始化导致panic的复现与定位

复现环境构建

使用 Alpine Linux（基于 musl）容器，编译时添加 -fno-tls-model 和 -D_GNU_SOURCE 并链接 --nostdlib：

// tls_panic.c
#include <stdio.h>
__thread int x = 42;  // 触发TLS初始化路径
int main() { printf("%d\n", x); }  // musl 在 _start 后隐式调用 __libc_start_main → __init_tls

编译命令：gcc -static -fno-tls-model=initial-exec tls_panic.c -o tls_panic
关键点：musl 的 _dlstart_c 依赖 .tdata/.tbss 段完成 TLS 初始化；禁用后 __tls_get_addr 调用空指针跳转，触发 SIGSEGV → panic。

核心调用链

graph TD
A[_start] --> B[__libc_start_main]
B --> C[__init_tls]
C --> D[__setup_tls]
D --> E[访问 .tdata/.tbss]
E -->|缺失| F[NULL dereference → panic]

定位关键线索

strace -e trace=brk,mmap,arch_prctl ./tls_panic 显示无 arch_prctl(ARCH_SET_FS) 调用
readelf -S tls_panic | grep -E '\.(tdata|tbss)' 验证段存在但未被 musl runtime 映射

现象	原因
`Illegal instruction`	TLS ABI hook 未注册
`Segmentation fault`	`__tls_get_addr` 返回 NULL

第五章：errno映射与syscall桥接的不可替代性

系统调用失败时的错误溯源困境

在嵌入式Linux驱动开发中，某厂商定制的SPI控制器驱动频繁返回 -1，但 perror("ioctl") 仅显示 Operation not permitted。实际调试发现，硬件寄存器超时标志位被置位，内核态 spi_sync() 返回 -ETIMEDOUT（值为110），而用户空间 ioctl() 调用因未正确传递 errno 导致被截断为 -EPERM（值为1）。该问题持续3周未定位，根源在于驱动中遗漏了 copy_to_user() 后对 current->thread.errno 的显式设置。

errno值域冲突的硬性约束

不同架构对 errno 的定义存在本质差异：

架构	`ERESTARTSYS` 值	`EUCLEAN` 值	冲突风险
x86_64	512	117	无重叠
ARM64	512	117	无重叠
RISC-V	512	117	与 `ENOTEMPTY`（117）冲突

当跨架构移植eBPF程序时，若直接将内核 errno 值写入用户空间缓冲区而不经 uapi/asm-generic/errno.h 映射层，会导致ARM64平台下 EUCLEAN 被误判为 ENOTEMPTY，触发文件系统级误删逻辑。

syscall桥接在容器逃逸防御中的实战价值

Kata Containers的轻量级VM隔离依赖于精确的系统调用拦截。其 kata-agent 在处理 openat(AT_FDCWD, "/proc/self/status", ...) 时，需将宿主机内核返回的 -ENOENT（2）转换为沙箱内核可识别的 -2，同时确保 strace -e trace=openat 显示的错误码与glibc解析结果一致。该过程必须通过 arch/x86/entry/syscall_table.c 中的桥接函数完成，绕过此层会导致OCI运行时无法区分“路径不存在”与“权限不足”。

// kata-agent中关键桥接代码（简化）
long kata_syscall_bridge(long syscall_nr, unsigned long args[6]) {
    long ret = orig_syscall(syscall_nr, args);
    if (ret < 0) {
        // 必须调用arch-specific errno translator
        ret = arch_errno_translate(current->thread.errno);
        current->thread.errno = 0; // 清除原始状态
    }
    return ret;
}

用户态库与内核态错误码的语义鸿沟

glibc 2.35中 connect() 函数在检测到 AF_UNIX 地址长度异常时，会主动设置 errno = EINVAL（22），而内核 net/unix/af_unix.c 实际返回 -EINVAL（-22）。当应用使用musl libc（不兼容glibc errno缓存机制）且未启用__errno_location()符号重绑定时，strerror(errno) 将返回空字符串——因为musl期望直接读取TLS段中的errno变量，而非glibc的__libc_errno别名。

flowchart LR
    A[用户调用 connect] --> B{glibc拦截}
    B -->|地址校验失败| C[设置 errno=22]
    B -->|转发syscall| D[内核返回 -22]
    D --> E[arch/x86/kernel/signal.c<br>do_syscall_64]
    E --> F[调用 errno_fixup<br>将-22转为22]
    F --> G[写入RAX寄存器]

安卓Binder驱动的errno透传链路

Android 13的binder_ioctl()在处理BINDER_WRITE_READ时，若binder_thread_read()返回-EAGAIN（11），必须经由binder_error_return()函数封装为BR_FAILED_REPLY协议包，并在用户态libbinder中通过IPCThreadState::executeCommand()解析为-EAGAIN。任何跳过binder_error_return()的快速路径优化都会导致Java层TransactionTooLargeException被误报为DeadObjectException。

错误码映射表的ABI稳定性要求

Linux内核文档明确要求：include/uapi/asm-generic/errno-base.h 中的前133个错误码（EAGAIN至EHWPOISON）必须保持跨版本二进制兼容。2023年某云厂商在内核补丁中将EMSGSIZE从90改为89，导致其自研RDMA用户态库的ibv_post_send()调用永久失败——因为该库的.rodata段硬编码了EMSGSIZE=90，而glibc 2.34的sysdeps/unix/sysv/linux/errlist.c仍按旧值索引。