Go cgo调用栈穿越源码追踪：从_cgo_call到goroutine状态机切换，含5道C回调中panic崩溃习题core dump解析

第一章：Go cgo调用栈穿越的底层机制全景

Go 语言通过 cgo 实现与 C 代码的互操作，其核心挑战在于跨越两种运行时环境——Go 的协作式调度栈（goroutine stack）与 C 的系统级调用栈。这种“调用栈穿越”并非简单的函数跳转，而是一套由编译器、运行时和链接器协同保障的上下文切换协议。

栈模型的根本差异

Go 使用可增长的分段栈（segmented stack），每个 goroutine 拥有独立、动态伸缩的栈空间，受 Go 调度器管理；C 则依赖操作系统分配的固定大小栈（通常 2MB+），由 CPU 的 rsp/rbp 寄存器直接维护。cgo 调用发生时，运行时必须在进入 C 函数前完成栈指针切换，并在返回 Go 代码时安全恢复 goroutine 栈上下文。

运行时的关键介入点

当执行 C.some_c_func() 时，Go 编译器生成的汇编桩（stub）会触发以下流程：

• 调用 runtime.cgocall，保存当前 goroutine 的寄存器状态（包括 rsp, rbp, rax 等）到 g 结构体中；
• 将控制权移交至 C 栈，此时 rsp 指向 OS 分配的 C 栈；
• C 函数返回后，runtime.cgocall 执行栈回切，恢复 goroutine 栈指针与寄存器，并检查是否需重新调度（如被抢占或发生 GC）。

实际验证方法

可通过以下命令观察 cgo 调用的汇编桩生成：

# 编译含 cgo 的源码并导出汇编
GOOS=linux GOARCH=amd64 go tool compile -S main.go | grep -A10 "C\.printf"

输出中可见 CALL runtime.cgocall(SB) 及后续寄存器压栈指令（如 MOVQ R12, (SP)），印证运行时对调用上下文的显式接管。

关键环节	Go 侧动作	C 侧约束
栈切换时机	进入 cgo 函数前	不得递归调用 Go 函数
寄存器保护范围	R12–R15、X15–X17、所有浮点寄存器	遵守 System V ABI 调用约定
GC 安全性	C 栈不扫描，避免悬垂指针	C 代码不可持有未 pinned 的 Go 指针

此机制使 cgo 成为零拷贝跨语言调用的基石，但也要求开发者严格遵循内存生命周期契约。

第二章：_cgo_call入口与C函数调用链深度剖析

2.1 _cgo_call汇编层实现与寄存器上下文保存机制

_cgo_call 是 Go 运行时中桥接 Go 栈与 C 栈的关键汇编入口，位于 runtime/cgo/asm_amd64.s。其核心职责是在调用 C 函数前完整保存 Go 协程的寄存器上下文，避免 C 代码破坏 Go 的调度状态。

寄存器保存策略

• x86-64 下需保存所有 callee-saved 寄存器（rbp, rbx, r12–r15）
• rax, rcx, rdx, rsi, rdi, r8–r11, r14, r15 等按调用约定分类处理
• SP 偏移量动态计算，适配不同栈帧布局

关键汇编片段（amd64）

_cgo_call:
    // 保存 Go 协程关键寄存器到栈
    pushq %rbp
    pushq %rbx
    pushq %r12
    pushq %r13
    pushq %r14
    pushq %r15
    // 调用 C 函数（%rax 指向 cgoCallInfo）
    callq *0x8(%rax)
    // 恢复寄存器
    popq %r15
    popq %r14
    popq %r13
    popq %r12
    popq %rbx
    popq %rbp
    ret

逻辑说明：该段汇编在调用 C 函数前后对 callee-saved 寄存器执行对称压栈/出栈。%rax 指向运行时构造的 cgoCallInfo 结构，其中含 C 函数指针与参数数组；所有保存操作均基于当前 goroutine 的栈顶（SP），确保 goroutine 切换安全。

寄存器	保存时机	用途
rbp	入口立即	栈帧基准，调试关键
rbx	入口立即	Go 运行时长期持有
r12-r15	入口立即	callee-saved，C 可修改

graph TD
    A[Go 协程进入 _cgo_call] --> B[压栈 rbp/rbx/r12-r15]
    B --> C[跳转至 C 函数]
    C --> D[C 执行完毕，返回]
    D --> E[弹栈恢复寄存器]
    E --> F[继续 Go 代码执行]

2.2 C函数调用时GMP调度器感知与栈帧切换路径追踪

GMP（Goroutine Multiplexing Platform）调度器在C函数调用边界需精确识别控制流转移，避免goroutine挂起时误留C栈上下文。

调度器感知触发点

当runtime.cgocall进入C代码前，调度器通过g.m.curg = nil解绑M与G，并标记_Gsyscall状态；返回时检查g.status == _Gwaiting决定是否重调度。

栈帧切换关键路径

// runtime/asm_amd64.s 中的 cgocall_trampoline
CALL runtime·entersyscall(SB)   // 通知调度器：即将进入C世界
CALL (AX)                        // 实际C函数调用
CALL runtime·exitsyscall(SB)     // 恢复G绑定，检查抢占信号

entersyscall禁用抢占并保存G的SP/PC至g.sched；exitsyscall尝试原子恢复，失败则触发mcall切换至调度循环。

阶段	栈指针来源	调度器可见性
进入C前	Go栈 SP	✅ 可扫描
C执行中	C栈 SP	❌ 不可扫描
返回Go后	Go栈 SP	✅ 可调度

graph TD
    A[Go函数调用C] --> B[entersyscall：解绑G/M]
    B --> C[C函数执行]
    C --> D[exitsyscall：尝试恢复G]
    D -->|成功| E[继续执行Go栈]
    D -->|失败| F[mcall→schedule]

2.3 cgo call wrapper生成原理与gccgo/clang兼容性差异实践

cgo在构建时自动生成_cgo_callers和_cgo_gotypes等wrapper函数，用于桥接Go运行时与C ABI。其核心依赖cgo -godefs阶段对//export注释的扫描与AST解析。

Wrapper生成关键流程

// 示例：Go导出函数经cgo处理后生成的wrapper骨架
void ·MyCFunction(void* p) {
    struct { int x; } *a = (struct { int x; }*)p;
    MyCFunction_c(a->x); // 实际C调用
}

此wrapper由cmd/cgo动态生成，·前缀标识Go符号，参数通过指针统一传递以规避栈布局差异；MyCFunction_c为真实C函数，由链接器解析。

gccgo vs clang兼容性差异

特性	gccgo	clang (via cgo + system clang)
调用约定推断	严格遵循__attribute__((cdecl))	依赖目标平台ABI，默认sysv64
_cgo_init初始化	内置libgo运行时钩子	依赖libgcc或compiler-rt

graph TD
    A[Go源码含//export] --> B[cgo预处理器扫描]
    B --> C{生成wrapper C文件}
    C --> D[gccgo: 调用libgo abi适配层]
    C --> E[clang: 直接emit LLVM IR via cc1]

2.4 Go runtime对_cgo_call的信号拦截与sigaltstack协同分析

Go runtime 在调用 C 函数（_cgo_call）时，需确保 Go 的抢占式调度与 C 代码的信号安全性兼容。核心机制在于：当线程进入 C 调用前，runtime 临时禁用其 goroutine 抢占，并注册专用信号栈（via sigaltstack），使关键信号（如 SIGPROF、SIGURG）能安全投递至独立栈空间，避免破坏 C 函数的栈帧。

信号栈切换关键逻辑

// runtime/cgo/asm_amd64.s 中片段（简化）
call    sigaltstack
// 参数：&ss（新栈结构体），&old_ss（保存旧栈）
// ss.ss_sp = g->m->signal_stack
// ss.ss_size = _STKSZ（通常 32KB）
// ss.ss_flags = SS_DISABLE → 后续启用时清除

该调用将线程信号处理栈切换至 runtime 预分配的 m->signal_stack，隔离 C 栈与信号处理上下文。

协同流程概览

graph TD
    A[goroutine 调用 C 函数] --> B[进入 _cgo_call]
    B --> C[runtime 切换 sigaltstack]
    C --> D[阻塞非异步信号，允许 SIGPROF/SIGURG]
    D --> E[信号触发时在 signal_stack 上执行 handler]
    E --> F[handler 完成后恢复 C 执行]

信号类型	是否投递至 signal_stack	说明
SIGPROF	✅	支持 CPU profiling
SIGURG	✅	用于 netpoll 紧急事件
SIGSEGV	❌（默认不拦截）	由 C 运行时或内核处理

2.5 手动注入_cgo_call断点并使用dlv+gdb双调试器联动验证

在混合 Go/C 场景中，_cgo_call 是 runtime 调度 CGO 调用的关键汇编入口。手动在其符号处设断可精准捕获跨语言调用上下文。

准备调试环境

• 启动 dlv exec --headless --api-version=2 --accept-multiclient ./myapp
• 另起终端连接 dlv connect :2345，同时用 gdb ./myapp 加载符号

注入断点（需 root 或 ptrace 权限）

# 在 dlv 中执行
(dlv) regs pc
(dlv) break *0x$(readelf -s ./myapp | awk '/_cgo_call/{print "0x"$3}')

此命令通过 readelf 解析符号表获取 _cgo_call 的绝对地址，并在该地址设置硬件断点；regs pc 用于校验当前执行流状态，避免地址偏移失效。

双调试器协同验证流程

graph TD
    A[dlv 控制 Go 协程调度] --> B[命中 _cgo_call 断点]
    B --> C[gdb 读取 %rsp/%rdi 等寄存器]
    C --> D[交叉比对 cgo call frame 与 Go stack]

调试器	主要职责	关键命令
dlv	Go 运行时栈、goroutine 状态	goroutines, stack
gdb	原生寄存器、C 帧、内存布局	info registers, x/10x $rsp

第三章：goroutine状态机在cgo调用中的迁移逻辑

3.1 G状态（Gwaiting→Gsyscall→Grunnable）转换条件与runtime源码印证

Goroutine 状态跃迁并非由调度器单向驱动，而是与系统调用生命周期深度耦合。

系统调用触发状态切换

当 G 进入阻塞式系统调用（如 read、accept），runtime 自动将其从 Gwaiting → Gsyscall：

// src/runtime/proc.go:enterSyscall
func entersyscall() {
    _g_ := getg()
    _g_.m.locks++ // 禁止抢占
    _g_.m.syscalltime = cputicks()
    _g_.m.syscallpc = getcallerpc()
    _g_.m.oldmask = _g_.sigmask
    _g_.m.p.ptr().m = _g_.m // 关联 P
    _g_.atomicstatus = _Gsyscall // 关键：原子更新状态
}

atomicstatus = _Gsyscall 是状态变更的唯一可信依据，确保 GC 和调度器可见性。

返回用户态前的就绪准备

系统调用返回后，若无抢占或锁竞争，立即转为 Grunnable 并尝试唤醒：

// src/runtime/proc.go:exitsyscall
func exitsyscall() {
    _g_ := getg()
    if atomic.Cas(&_g_.atomicstatus, _Gsyscall, _Grunnable) {
        handoffp(releasep()) // 将 P 归还或移交
    }
}

触发条件	源码位置	状态变更
进入阻塞 syscal	entersyscall()	Gwaiting → Gsyscall
成功退出 syscal	exitsyscall()	Gsyscall → Grunnable
调用被抢占/挂起	exitsyscallfast()	保持 Gsyscall

graph TD
    A[Gwaiting] -->|enterSyscall| B[Gsyscall]
    B -->|exitsyscall success| C[Grunnable]
    B -->|preempted| D[Gwaiting]

3.2 netpoller阻塞场景下cgo调用引发的G自旋与抢占失效实测

当 netpoller 进入阻塞等待（如 epoll_wait）时，若此时有 goroutine 执行长时间 cgo 调用（如 C.sleep(5)），该 M 将脱离 Go 调度器管控，导致绑定的 G 持续自旋且无法被抢占。

复现关键代码

// main.go
func blockInCgo() {
    C.usleep(C.useconds_t(5 * 1000000)) // 阻塞 5s，不交还 M
}

此调用使 M 进入系统调用态，g.status 保持 _Grunning，而 runtime 无法插入 preemptoff 或触发 sysmon 抢占，导致该 G 占用 M 长达 5 秒，阻塞其他 G 运行。

抢占失效链路

graph TD
    A[sysmon 检测 G 运行超 10ms] --> B{G 是否在 cgo 中？}
    B -->|是| C[跳过抢占标记]
    B -->|否| D[设置 g.preempt = true]

观测指标对比

场景	G 抢占延迟	M 可复用性	netpoller 响应
纯 Go 循环	≤ 10ms	高	正常
cgo 长阻塞调用	≥ 5s	丧失	暂停监听

3.3 cgo调用期间P绑定策略变更与mcache释放时机源码级定位

cgo调用时，Go运行时需确保G不被抢占并维持栈一致性，触发entersyscall路径，此时G与P解绑（g.p = nil），P进入_Psyscall状态。

P状态切换关键路径

// src/runtime/proc.go:entersyscall
func entersyscall() {
    gp := getg()
    mp := gp.m
    pp := mp.p.ptr()
    pp.status = _Psyscall      // 标记P为系统调用中
    mp.oldp.set(pp)           // 保存原P供后续恢复
    mp.p = 0                  // 解绑P，避免GC扫描该P的mcache
}

逻辑分析：mp.p = 0使当前M脱离P，阻止调度器将其他G调度至此P；pp.status = _Psyscall通知调度器该P不可用于常规G调度。

mcache释放时机

• exitsyscall中若无法立即重获P，则调用mcache_ReleaseAll清空本地缓存；
• 释放发生在handoffp或stopm流程中，确保内存分配器状态一致性。

事件	P状态	mcache是否释放
entersyscall	_Psyscall	否
exitsyscall失败	_Pidle	是（延迟至handoffp）
成功re-acquire P	_Prunning	否

第四章：C回调中panic崩溃的五类core dump模式解析

4.1 C函数内直接调用panic()导致的非法栈回溯与runtime.throw调用链断裂

Go 运行时要求 panic() 必须由 Go 函数发起，以确保 runtime.g 上下文、defer 链及 goroutine 栈帧结构完整。C 函数（如通过 //export 暴露或 CGO 调用）中直接调用 panic() 会绕过 runtime.gopanic 的初始化逻辑。

栈帧缺失引发的回溯失败

// bad_c_code.c
#include <runtime.h>
void c_broken_panic() {
    panic("from C"); // ❌ 触发未初始化的 runtime.panicwrap
}

该调用跳过 runtime.gopanic 入口，导致 g._panic 链为空、pcsp 表不可查，runtime.stack() 回溯时触发 throw("invalid stack trace")。

runtime.throw 调用链断裂表现

现象	原因
fatal error: invalid stack trace	runtime.gentraceback 无法定位 valid SP/PC
SIGABRT 而非 SIGGO	throw 降级为 abort()，跳过 runtime.fatalpanic

graph TD
    CFunc[c_broken_panic] --> PanicC[panic@C]
    PanicC --> Abort[abort()] 
    Abort --> OS[OS SIGABRT]
    subgraph MissingGoRuntimeContext
        PanicC -.-> g_panic[no g._panic link]
        PanicC -.-> defer[no defer chain]
    end

4.2 Go闭包传入C后被多次调用引发的stack growth异常与stack overflow core复现

Go闭包携带堆上捕获变量（如大slice、map）跨CGO边界传入C函数时，若C侧反复回调该闭包（如事件循环、定时器触发），会持续在goroutine栈上分配新帧，而Go runtime无法及时回收已退出的闭包调用栈帧——因C持有Go函数指针且无GC可见引用链。

栈增长不可控的关键路径

• C代码中 cgo_func_ptr() 被循环调用 ≥ 1000 次
• 每次调用触发 runtime.newstack 扩容（默认4KB→8KB→16KB…）
• 达到 runtime._StackGuard 硬上限（通常2GB）前即触发 fatal error: stack overflow

复现场景最小化代码

// c_callback.c
#include <stdio.h>
extern void go_callback(void);
void trigger_loop(int n) {
    for (int i = 0; i < n; i++) {
        go_callback(); // 每次都压入新goroutine栈帧
    }
}

// main.go
/*
#cgo LDFLAGS: -L. -lcallback
#include "c_callback.h"
*/
import "C"
import "unsafe"

func main() {
    cb := func() { 
        var buf [8192]byte // 强制栈分配8KB
        _ = buf
    }
    // ⚠️ 错误：直接将闭包转C函数指针，无生命周期管理
    C.trigger_loop(2000)
}

逻辑分析：cb 闭包含栈变量 buf，每次 go_callback() 调用均在当前 goroutine 栈上新建作用域并分配 buf。C 侧无栈帧释放机制，导致线性栈膨胀。参数 n=2000 在典型64位环境约消耗 2000×8KB ≈ 16MB，叠加栈管理开销快速触达 runtime.stackCacheSize 阈值，触发 throw("stack overflow") 并生成 core。

风险因子	默认值	触发阈值
初始栈大小	2KB	—
栈扩容步长	×2	≥12次扩容后超限
runtime._StackGuard	~1GB	OS级保护中断

graph TD
    A[C trigger_loop] --> B[go_callback call]
    B --> C[alloc [8192]byte on stack]
    C --> D{stack usage > guard?}
    D -->|Yes| E[fatal: stack overflow]
    D -->|No| B

4.3 C线程非goroutine关联环境下runtime.gp访问空指针的core dump逆向还原

当C线程（如通过 pthread_create 启动）直接调用 Go 导出函数但未绑定 goroutine 时，getg() 返回的 runtime.gp 为 nil，后续若误用 gp->m 或 gp->sched 将触发空指针解引用。

关键汇编线索

mov rax, qword ptr [rbp-0x8]   # gp 加载到 rax
test rax, rax                  # 检查是否为零
je 0x4d2a1f                    # 若为零则跳转至 panic path
mov rcx, qword ptr [rax+0x8]   # gp->m —— 此处崩溃：rax=0 → 访问 0x8

常见触发路径

• C线程未调用 runtime.cgocall 或 goexit 上下文初始化
• 直接调用 exported func 且内部访问 G 相关字段（如 G.stack.hi）
• 使用 //export 函数中调用 runtime.Gosched() 等需 gp 非空的运行时函数

还原核心步骤

步骤	工具/方法	说明
1. 定位崩溃点	gdb -c core + info registers	确认 rax=0 及指令地址
2. 回溯调用链	bt full	查看是否来自 CGO 边界且无 mstart 初始化
3. 验证 gp 状态	p *(struct G*)$rax	gdb 中对空指针解引用会报错，佐证为空

graph TD
    A[C线程启动] --> B[调用 export 函数]
    B --> C{runtime.getg() == nil?}
    C -->|是| D[gp->m 访问 → SIGSEGV]
    C -->|否| E[正常调度]

4.4 CGO_CFLAGS未启用-fno-omit-frame-pointer导致unwind失败的gdb frame分析实战

当 Go 程序通过 CGO 调用 C 函数，且 CGO_CFLAGS 未显式包含 -fno-omit-frame-pointer 时，GCC 默认启用帧指针优化（-fomit-frame-pointer），导致栈回溯信息丢失。

gdb 中观察到的异常现象

(gdb) bt
#0  0x00007ffff7bc9d10 in ?? ()
#1  0x00000000004b2a3c in runtime.asmcgocall () at /usr/local/go/src/runtime/asm_amd64.s:685
#2  0x00000000004b2a3c in runtime.asmcgocall () at /usr/local/go/src/runtime/asm_amd64.s:685
#3  0x0000000000000000 in ?? ()

此处 ?? 表明 DWARF unwind 无法解析 C 帧：-fomit-frame-pointer 破坏了 .eh_frame 与实际栈布局的一致性，gdb 依赖帧指针或 .eh_frame 进行栈展开，二者皆失效。

关键修复方式

• ✅ 正确设置：CGO_CFLAGS="-fno-omit-frame-pointer -g"
• ❌ 遗漏后果：C 帧不可见、panic traceback 截断、pprof CPU profile 丢失调用链

编译标志	是否保留 frame pointer	gdb bt 可见 C 帧	.eh_frame 完整性
-fomit-frame-pointer (默认)	否	❌	⚠️ 不可靠
-fno-omit-frame-pointer	是	✅	✅

graph TD
    A[Go 调用 C 函数] --> B[编译时未加 -fno-omit-frame-pointer]
    B --> C[栈帧无稳定 rbp 链]
    C --> D[gdb unwind 失败 → ??]
    D --> E[添加 -fno-omit-frame-pointer]
    E --> F[恢复 rbp 链 + .eh_frame 一致性]

第五章：cgo安全边界设计与生产环境规避指南

cgo调用链中的内存泄漏陷阱

在某金融风控服务中，Go 代码通过 cgo 调用 C 实现的布隆过滤器（bloom_filter_t*），但未对 bloom_destroy() 的调用时机做严格管控。当 Go GC 触发时，C 对象仍被 *C.bloom_filter_t 指针持有，而 finalizer 未注册或注册失败（因对象逃逸至 goroutine 共享栈），导致每秒 12MB 内存持续增长。修复方案采用显式资源管理模式：

type BloomFilter struct {
    cPtr *C.bloom_filter_t
}
func NewBloomFilter(size int) *BloomFilter {
    bf := &BloomFilter{cPtr: C.bloom_create(C.size_t(size))}
    runtime.SetFinalizer(bf, func(b *BloomFilter) { C.bloom_destroy(b.cPtr) })
    return bf
}

Go 与 C 线程模型冲突的真实案例

Kubernetes 节点代理组件集成 OpenSSL 的 SSL_read()，在高并发场景下偶发 SIGSEGV。根因是：Go runtime 启动的 M-P-G 模型中，CGO 调用可能跨 OS 线程迁移，而 OpenSSL 的 SSL_CTX 不是线程安全的，且未启用 CRYPTO_set_locking_callback。解决方案强制绑定：

/*
#cgo LDFLAGS: -lssl -lcrypto
#include <openssl/ssl.h>
#include <pthread.h>
static pthread_mutex_t *ssl_locks;
static void ssl_locking_callback(int mode, int type, const char *file, int line) {
    if (mode & CRYPTO_LOCK) pthread_mutex_lock(&ssl_locks[type]);
    else pthread_mutex_unlock(&ssl_locks[type]);
}
*/
import "C"

生产环境禁用 cgo 的决策矩阵

场景	是否允许 cgo	强制约束	替代方案
容器镜像构建（alpine）	❌ 禁止	CGO_ENABLED=0 构建失败即阻断CI	使用 pure-Go TLS 库（crypto/tls）
高频信号处理（如 sigaction）	✅ 允许	必须使用 // #cgo !windows LDFLAGS: -rtlib=compiler-rt 链接 sanitizer	无（系统调用不可替代）
日志模块调用 syslog(3)	⚠️ 有条件允许	必须封装为独立 syslog.Writer 并设置 C.CString 生命周期 ≤ 单次 Write	使用 UDP 写入 rsyslog

C 字符串生命周期的三重校验机制

某日志网关因 C.CString(os.Getenv("SERVICE_NAME")) 被缓存为全局变量，在环境变量变更后仍输出旧值。建立如下校验流程：

flowchart LR
    A[Go 字符串传入] --> B{是否需长期持有？}
    B -->|否| C[使用 C.CString + defer C.free]
    B -->|是| D[复制到 C.malloc 分配的 buffer]
    D --> E[绑定到结构体并注册 finalizer]
    E --> F[finalizer 中调用 C.free]

静态链接与符号污染防控

在嵌入式边缘设备部署中，多个 Go 模块均依赖不同版本的 libz.so，导致 zlibVersion() 符号冲突。最终采用全静态链接策略：

# 编译脚本片段
export CGO_LDFLAGS="-static-libgcc -static-libstdc++ -Wl,-Bstatic -lz -Wl,-Bdynamic"
go build -ldflags "-extldflags '-static'" -o agent .

同时在 build.go 中添加符号隔离注释：

//go:cgo_import_dynamic zlibVersion my_zlibVersion "libz.so.1"
//go:cgo_import_static my_zlibVersion

生产发布前的 cgo 安全扫描清单

• [x] 所有 C.free 调用均匹配 C.CString / C.CBytes 分配源
• [x] C.* 类型指针未作为结构体字段暴露给非 cgo 包
• [x] runtime.LockOSThread() 仅用于必须绑定线程的 C 函数，且成对出现
• [x] //export 函数签名全部使用 C 兼容类型（无 Go slice/map/channel）
• [x] CI 流程中启用 -gcflags="-d=checkptr" 和 CGO_CFLAGS="-fsanitize=address"

跨平台 ABI 兼容性验证实践

针对 ARM64 与 x86_64 混合集群，编写 ABI 对齐测试用例：验证 C.struct_stat.st_size 在 Go syscall.Stat_t 中偏移量一致性。使用 unsafe.Offsetof 生成校验表，并在启动时执行断言：

const expectedStSizeOffset = 48 // x86_64
if unsafe.Offsetof(syscall.Stat_t{}.Size) != expectedStSizeOffset {
    log.Fatal("ABI mismatch: st_size offset differs from expected")
}