Go程序在Windows上正常，Linux下coredump？二手代码中syscall.Syscall误用、文件路径硬编码、信号处理差异的跨平台适配手册

第一章：Go程序跨平台异常的典型现象与诊断范式

Go语言标榜“一次编译，随处运行”，但在真实跨平台部署中，开发者常遭遇隐匿而顽固的异常——这些并非语法错误，而是由操作系统内核行为、文件系统语义、C标准库绑定差异及环境变量敏感性引发的运行时故障。

常见异常现象

文件路径分隔符与大小写敏感性：Windows使用\且不区分文件名大小写，Linux/macOS使用/且严格区分大小写。os.Open("config.JSON")在Windows可能成功，在Linux则返回no such file or directory。
行尾符差异导致配置解析失败：Windows生成的.env或YAML文件含CRLF（\r\n），某些Go解析库（如gopkg.in/yaml.v3）在Linux下可能将\r误认为键名一部分，引发yaml: unmarshal errors。
系统调用兼容性断裂：调用syscall.Kill()向进程发送信号时，syscall.SIGUSR1在Linux/macOS有效，但在Windows无对应实现，直接panic：signal: killed或operation not supported。
CGO依赖的动态链接失败：启用CGO_ENABLED=1编译的二进制在目标平台缺失libssl.so.1.1（Linux）或libcrypto.dylib（macOS），启动即报cannot open shared object file。

诊断核心范式

坚持「环境隔离验证」与「最小可复现单元」原则：

使用GOOS和GOARCH交叉编译后，必须在目标平台原生环境中运行，禁用Wine、WSL模拟层；

启用Go运行时调试标志：

# 捕获所有系统调用（Linux/macOS）
strace -f -e trace=open,openat,stat,readlink ./myapp 2>&1 | head -n 50
# Windows下启用ETW日志（PowerShell）
Start-Trace -Level 5 -Providers "Microsoft-Windows-DotNETRuntime,GoRuntime" -OutputFile go-trace.etl

在main()入口插入环境快照：

func main() {
   fmt.Printf("GOOS=%s, GOARCH=%s, GODEBUG=%s\n", runtime.GOOS, runtime.GOARCH, os.Getenv("GODEBUG"))
   fmt.Printf("PWD=%s, HOME=%s\n", os.Getenv("PWD"), os.Getenv("HOME"))
   // …其余逻辑
}

诊断维度	推荐工具/方法	关键观察点
文件系统行为	`strace` / `Procmon`（Windows）	`openat`返回值、路径字符串原始字节
环境变量继承	`env \| sort` + 对比构建/运行环境	`LD_LIBRARY_PATH`、`PATH`是否污染
CGO符号解析	`ldd ./binary`（Linux） / `otool -L`（macOS）	缺失的`.so`/`.dylib`名称与路径

第二章：syscall.Syscall误用的深层剖析与安全重构

2.1 系统调用ABI差异：Windows syscall vs Linux syscall语义解耦

Linux 与 Windows 的系统调用 ABI 在语义层彻底解耦：Linux 通过 syscall() 统一入口+编号跳转，而 Windows 依赖 ntdll.dll 中的 Nt* 函数封装，实际调用经由 mov eax, NtXxx + syscall 指令触发内核态切换。

调用约定对比

Linux：rax 存系统调用号，rdi, rsi, rdx, r10, r8, r9 传最多6个参数
Windows：rax 存系统调用号，但前4参数走 rcx, rdx, r8, r9，栈传其余参数（遵循 Microsoft x64 ABI）

典型调用示例

// Linux: write(1, "hi", 2)
syscall(SYS_write, 1, (long)"hi", 2);

SYS_write=1 是 ABI 稳定常量；参数顺序严格对应寄存器约定；无隐式错误包装，-1 返回值需配合 errno 解析。

// Windows: NtWriteFile（简化示意）
NtWriteFile(hFile, NULL, NULL, NULL, &io, buf, 2, NULL, NULL);

实际 NtWriteFile 是用户态 stub，内部将参数重排后触发 syscall；错误直接返回 NTSTATUS（如 0xC0000005），无需 errno 辅助。

维度	Linux	Windows
调用入口	`syscall` 指令直调	`Nt*` 函数间接封装
错误语义	`-1` + `errno`	`NTSTATUS` 码（如 `0x0` 成功）
参数传递	寄存器优先（6参数）	前4寄存器+栈扩展

graph TD
    A[用户代码] --> B{ABI 分支}
    B --> C[Linux: syscall(SYS_xxx, ...)]
    B --> D[Windows: NtXxx(...)]
    C --> E[内核 sys_call_table[rdi]]
    D --> F[ntdll stub → 重排参数 → syscall]

2.2 unsafe.Pointer与uintptr生命周期陷阱：Linux内核态参数传递失效复现与修复

失效场景复现

当 Go 程序通过 syscall.Syscall 向 Linux 内核传递用户态地址时，若将 unsafe.Pointer 转为 uintptr 后未及时固定对象，GC 可能移动内存并使 uintptr 指向非法地址：

buf := make([]byte, 64)
ptr := uintptr(unsafe.Pointer(&buf[0])) // ❌ 危险：buf 可能被 GC 移动
syscall.Syscall(SYS_IOCTL, fd, cmd, ptr) // 内核读取时 buf 已迁移

逻辑分析：uintptr 是纯数值，不携带指针语义，Go 编译器无法追踪其关联对象；buf 在栈上分配且无强引用，GC 可在 Syscall 执行前回收/重定位该内存块。

安全修复方案

使用 runtime.KeepAlive(buf) 延长生命周期
或改用 C.malloc + defer C.free 管理堆内存

方案	GC 安全性	内存归属	适用场景
`unsafe.Pointer` + `KeepAlive`	✅	Go runtime	短期调用、栈数据
`C.malloc` 分配	✅	C heap	长时 ioctl、跨 goroutine

graph TD
    A[Go 分配 buf] --> B[转 uintptr]
    B --> C{GC 是否已运行？}
    C -->|是| D[ptr 指向野地址 → 内核 panic]
    C -->|否| E[系统调用成功]

2.3 替代方案实践：使用x/sys/unix统一抽象层重构底层IO逻辑

传统 syscall 封装在跨平台时易引入条件编译分支，x/sys/unix 提供了 POSIX 兼容的统一接口层，显著降低 Linux/macOS/BSD 的 IO 逻辑维护成本。

核心优势对比

维度	原生 `syscall` 包	`x/sys/unix`
可移植性	需 `// +build linux,darwin`	单一 API，自动适配系统调用号
错误处理	手动检查 `errno`	返回 `error`，符合 Go 惯例
类型安全	`uintptr` 参数易出错	强类型参数（如 `SockaddrUnix`）

同步读写重构示例

// 使用 x/sys/unix 替代 raw syscall.Read/Write
fd := int(conn.(*net.UnixConn).FD())
n, err := unix.Write(fd, buf)
if err != nil {
    return 0, err // 自动映射 EAGAIN/EWOULDBLOCK → syscall.EAGAIN
}

unix.Write 内部调用 SYS_write 系统调用，并将 errno 转为标准 *os.SyscallError；fd 必须为有效文件描述符，buf 非空切片，返回实际写入字节数。

数据同步机制

自动处理 EINTR 重试（可禁用 via unix.SyscallNoError）
支持 unix.Sendfile 零拷贝传输（Linux ≥2.6.33 / FreeBSD）

graph TD
    A[Go 应用] --> B[x/sys/unix.Write]
    B --> C{OS 调用分发}
    C -->|Linux| D[sys_write]
    C -->|Darwin| E[write]
    C -->|FreeBSD| F[write]

2.4 cgo边界内存泄漏检测：基于pprof+asan的Linux下coredump根因定位流程

核心诊断链路

Go程序 → cgo调用C代码 → ASan拦截malloc/free → pprof聚合堆分配 → coredump符号回溯

关键启用步骤

编译时添加 -gcflags="-gcdebug=2" -ldflags="-linkmode external -extldflags '-fsanitize=address -fno-omit-frame-pointer'"
运行前设置 export ASAN_OPTIONS="abort_on_error=1:detect_leaks=1:handle_segv=1"

典型ASan报告片段

// 示例：C函数中越界写入触发ASan中断
void unsafe_copy(char *dst, const char *src) {
    strcpy(dst, src); // ❌ dst仅分配16字节，src超长
}

此代码触发ASan生成带栈帧的SIGABRT，pprof -http=:8080 http://localhost:6060/debug/pprof/heap可定位cgo调用点。

工具协同关系

工具	职责	输出关键字段
ASan	捕获非法内存访问与泄漏	`heap-use-after-free`
pprof	可视化cgo调用栈深度	`runtime.cgocall`
addr2line	将coredump地址映射到.c行号	`gcc -g`编译必需

graph TD
    A[Go主程序] -->|cgo.Call| B[C函数入口]
    B --> C{ASan Hook malloc/free}
    C -->|异常触发| D[生成coredump+stderr]
    D --> E[pprof加载符号栈]
    E --> F[定位Go→C→C函数内具体行]

2.5 生产级加固：syscall封装层的平台感知断言与panic防护机制

在高可靠性系统中，裸syscall调用易因平台差异（如Linux vs FreeBSD ABI、内核版本特性）触发未定义行为。为此，我们构建了带平台指纹的断言层。

断言注入点设计

在SyscallGuard初始化时自动探测uname()返回的sysname与machine
所有敏感系统调用（mmap, clone, epoll_ctl）前插入platform_assert!()

运行时防护策略

// 平台感知panic拦截（非终止式）
fn safe_mmap(addr: *mut c_void, len: usize, prot: i32) -> Result<*mut c_void, Errno> {
    platform_assert!("mmap", "linux", "x86_64"); // 仅允许指定平台组合
    let ret = unsafe { libc::mmap(addr, len, prot, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0) };
    if ret == libc::MAP_FAILED {
        // 不直接panic，转为可追踪错误
        return Err(Errno::from_i32(errno::errno().0));
    }
    Ok(ret)
}

该函数在非授权平台（如freebsd/aarch64）下编译期禁用，并在运行时校验uname结果；失败时返回结构化错误而非panic!，避免服务级雪崩。

检查项	Linux x86_64	FreeBSD aarch64	Windows x64
`mmap`支持	✅	⚠️（需`MAP_ANON`）	❌（`VirtualAlloc`）
`clone`语义	✅	❌	❌

graph TD
    A[syscall入口] --> B{平台断言}
    B -->|通过| C[执行原生syscall]
    B -->|失败| D[记录trace_id]
    D --> E[返回Errno]

第三章：文件路径硬编码引发的平台兼容性断裂

3.1 路径分隔符与URI语义混淆：filepath.Join在Windows/Linux下的行为差异实测

filepath.Join 是 Go 标准库中用于拼接文件路径的函数，但其行为高度依赖运行时操作系统，易与 URI（如 http://host/path）中的 / 产生语义混淆。

行为差异实测对比

环境	输入 `filepath.Join("C:", "foo", "bar")`	输出
Windows	`"C:\\foo\\bar"`	使用反斜杠，保留盘符语义
Linux	`"C:/foo/bar"`	仅作字符串拼接，无盘符概念

关键代码验证

package main
import (
    "fmt"
    "path/filepath"
)
func main() {
    fmt.Println(filepath.Join("C:", "foo", "bar"))
    // Windows: "C:\foo\bar"；Linux: "C:/foo/bar"
}

该调用未触发路径规范化（如 .. 消解），且 C: 在 Linux 下被视作普通目录名——非跨平台等价操作。

混淆风险链路

graph TD
    A[用户输入“C:/data”] --> B{OS=Windows?}
    B -->|Yes| C[解析为本地盘符路径]
    B -->|No| D[解析为相对路径“C:/data”]
    C --> E[可能绕过URI校验逻辑]
    D --> E

3.2 隐式绝对路径构造：os.Open中相对路径解析在chroot与mount namespace下的失效分析

Go 标准库 os.Open("config.json") 在底层调用 openat(AT_FDCWD, "config.json", ...)，其路径解析依赖进程当前工作目录（CWD）——但 CWD 是进程级抽象，不受 chroot() 系统调用或 mount namespace 的 root 更改影响。

路径解析的双重失配

chroot() 仅修改 getcwd() 返回值与内核路径查找的 root，但 AT_FDCWD 仍指向原文件系统中的真实 CWD inode；
mount namespace 中 setns(..., CLONE_NEWNS) 切换后，/proc/self/cwd 符号链接目标已变更，但 openat(AT_FDCWD, ...) 仍基于调用时刻的 fd 路径解析上下文。

// 示例：chroot 后 os.Open("etc/passwd") 实际访问宿主 /home/chroot/etc/passwd
f, err := os.Open("etc/passwd") // 相对路径 → 解析为 CWD + "etc/passwd"
if err != nil {
    log.Fatal(err) // 可能因越界访问被 SELinux 或 open_by_handle_at 拒绝
}

逻辑分析：os.Open 不感知 chroot，其 syscall.Openat(AT_FDCWD, ...) 使用的是 execve 时继承的、未被 chroot 重绑定的原始 CWD 文件描述符。参数 AT_FDCWD 是常量 -100，表示“使用当前进程 CWD”，而该 CWD 的 dentry 在 chroot 后未更新。

失效场景对比

环境	`os.Open("a.txt")` 解析路径	是否受 chroot 影响	是否受 mount ns 影响
普通进程	`/home/user/a.txt`	否	否
`chroot /mnt` 后	`/home/user/a.txt`（非 `/mnt/a.txt`）	是（但解析不变）	否
新 mount ns + bind mount	取决于 CWD 所在挂载点是否随 ns 迁移	否（CWD fd 不迁移）	是（若 CWD 被 unmounted）

graph TD
    A[os.Open\&quot;foo.txt\&quot;] --> B[syscall.Openat AT_FDCWD]
    B --> C{CWD fd 来源}
    C --> D[execve 时继承的目录 fd]
    C --> E[chroot 不修改此 fd]
    C --> F[mount ns 切换不重置此 fd]
    D --> G[真实 inode，可能越出 jail]

3.3 可移植路径策略：基于runtime.GOOS的路径规范化中间件设计与单元测试覆盖

路径歧义的根源

不同操作系统对路径分隔符（/ vs \）、根路径（/ vs C:\）及大小写敏感性处理迥异，直接拼接字符串易致跨平台失效。

中间件核心逻辑

func NormalizePath(path string) string {
    switch runtime.GOOS {
    case "windows":
        return filepath.FromSlash(path) // 将 / 转为 \
    case "darwin", "linux":
        return filepath.ToSlash(path)   // 统一为 /
    default:
        return path
    }
}

filepath.FromSlash() 在 Windows 上将正斜杠转为反斜杠并处理驱动器前缀；ToSlash() 则强制归一化为 POSIX 风格。二者均尊重 filepath.Clean() 的语义，不改变路径逻辑结构。

单元测试覆盖要点

OS 环境	输入路径	期望输出	覆盖维度
windows	`"a/b/c"`	`"a\b\c"`	分隔符转换
linux	`"C:/tmp/file"`	`"C:/tmp/file"`	非Windows不干预

graph TD
    A[原始路径] --> B{runtime.GOOS}
    B -->|windows| C[FromSlash]
    B -->|linux/darwin| D[ToSlash]
    C --> E[标准化路径]
    D --> E

第四章：信号处理机制的跨平台鸿沟与收敛实践

4.1 SIGPIPE、SIGCHLD等信号默认行为对比：Linux默认终止 vs Windows模拟缺失

信号语义鸿沟的根源

POSIX 定义了 SIGPIPE（写已关闭管道）和 SIGCHLD（子进程状态改变）等信号，Linux 内核对其赋予明确默认动作：SIGPIPE → 终止进程；SIGCHLD → 忽略（不终止，但可被 wait() 捕获）。Windows 无原生信号机制，其 CRT（如 MSVCRT）仅对极少数信号（如 SIGINT）做有限模拟，SIGPIPE 和 SIGCHLD 完全未实现。

行为差异对照表

信号	Linux 默认动作	Windows CRT 行为	可移植性影响
`SIGPIPE`	`terminate`	未定义（`raise(SIGPIPE)` 通常触发 `abort()` 或静默忽略）	`write()` 到断开 socket/pipe 不触发预期终止
`SIGCHLD`	`ignore`	无对应信号，`CreateProcess` + `WaitForSingleObject` 替代	`fork()`/`wait()` 模式无法直接移植

典型陷阱代码示例

#include <unistd.h>
#include <signal.h>
#include <stdio.h>

int main() {
    signal(SIGPIPE, SIG_DFL); // 显式设为默认：Linux 终止，Windows 无效
    write(1, "hello", 5);     // 若 stdout 被重定向至已关闭管道，Linux crash，Windows 可能返回 -1 且 errno=EBADF
    return 0;
}

逻辑分析：signal(SIGPIPE, SIG_DFL) 在 Linux 触发进程终止；Windows 下该调用成功但无实际效果。write() 返回值与 errno 成为唯一可靠判断依据，而非信号交付。

跨平台健壮性策略

始终检查 write()/send() 返回值与 errno == EPIPE
使用 sigaction() 替代 signal()（更可移植）
SIGCHLD 场景改用 waitpid(-1, &status, WNOHANG) 轮询或 I/O 多路复用通知

4.2 os/signal.Notify的goroutine泄漏：Linux下未阻塞signal channel导致的coredump复现链

根本诱因：非缓冲channel + 无消费导致goroutine永久阻塞

os/signal.Notify 将信号转发至 channel，若该 channel 未被接收（如 select {} 前未启动消费 goroutine），发送方将永远阻塞在 runtime.gopark。

func main() {
    sigs := make(chan os.Signal, 1) // 缓冲大小为1 → 安全
    // sigs := make(chan os.Signal)   // ❌ 无缓冲 → 危险！
    signal.Notify(sigs, syscall.SIGTERM)
    // 忘记 <-sigs 或 select { case <-sigs: }
    time.Sleep(time.Second)
} // main exit → runtime aborts blocked signal sender → coredump

逻辑分析：os/signal 内部通过 sigsend 向用户 channel 发送信号；当 channel 无缓冲且无 receiver 时，goroutine 永久休眠于 chan send。Linux kernel 在进程退出时强制终止所有 goroutine，触发 SIGABRT 引发 coredump。

复现关键路径

阶段	行为	结果
初始化	`Notify(c, SIGTERM)`	注册信号处理器
发送	`kill -TERM $pid`	内核投递 → runtime 尝试写入 `c`
阻塞	`c` 无 receiver 且无缓冲	goroutine stuck in `chan send`
退出	`main` 返回	runtime 强制 kill → `abort()` → coredump

graph TD
    A[收到SIGTERM] --> B{signal.sendLoop尝试写入sigs}
    B --> C{sigs有receiver?}
    C -- 否 --> D[goroutine park forever]
    C -- 是 --> E[正常接收并退出]
    D --> F[main exit → runtime.abort]

4.3 平台自适应信号拦截器：基于build tag的信号注册路由与优雅退出状态机实现

信号处理需兼顾跨平台差异：Linux 支持 SIGUSR1/2，Windows 仅支持 CTRL_C_EVENT 和 CTRL_BREAK_EVENT。通过 //go:build tag 实现编译期路由：

// signal_linux.go
//go:build linux
package signal

import "os/signal"

func RegisterOsSignals() <-chan os.Signal {
    return signal.Notify(make(chan os.Signal, 1), os.Interrupt, syscall.SIGTERM, syscall.SIGUSR1)
}

逻辑分析：//go:build linux 触发条件编译；os.Signal 通道缓冲为1，避免阻塞；SIGUSR1 用于热重载，仅 Linux 有效。

// signal_windows.go
//go:build windows
package signal

import "os"

func RegisterOsSignals() <-chan os.Signal {
    return signal.Notify(make(chan os.Signal, 1), os.Interrupt)
}

参数说明：Windows 不支持 syscall 级信号，os.Interrupt 映射为 CTRL_C_EVENT；通道容量仍设为1，保障退出事件不丢失。

优雅退出状态机

状态	触发条件	动作
Idle	进程启动	初始化资源
ShutdownInit	收到首个信号	停止新请求，启动超时计时
GracefulWait	正在等待活跃连接关闭	检查连接数、健康度
Terminated	超时或所有连接已释放	强制释放资源并退出

graph TD
    A[Idle] -->|SIGTERM/SIGINT| B[ShutdownInit]
    B --> C[GracefulWait]
    C -->|timeout| D[Terminated]
    C -->|all connections closed| D

4.4 测试验证闭环：利用testcontainers构建双平台信号压力测试环境

为真实模拟跨平台（Kafka + Redis）信号协同场景，采用 Testcontainers 启动轻量级、可编程的双引擎容器集群。

容器编排核心配置

public class DualPlatformTestEnvironment {
    public static final KafkaContainer kafka = new KafkaContainer(DockerImageName.parse("confluentinc/cp-kafka:7.5.0"));
    public static final GenericContainer<?> redis = new GenericContainer<>("redis:7.2-alpine")
        .withExposedPorts(6379)
        .withCommand("redis-server --appendonly yes");
}

逻辑分析：KafkaContainer 自动注入 ZooKeeper 并暴露 9093（内部）与 29092（外部）端口；Redis 容器启用 AOF 持久化确保信号状态可追溯。withCommand 显式控制启动参数，避免默认配置导致的序列化不一致。

压力测试信号流

graph TD
    A[JUnit5 Test] --> B[Producer 发送 10k 信号]
    B --> C{Kafka Topic}
    C --> D[Consumer 拉取并写入 Redis]
    D --> E[Redis Lua 脚本原子校验]
    E --> F[断言信号吞吐与一致性]

关键指标对比

维度	Kafka 单独压测	双平台串联压测
P99 延迟	42ms	89ms
信号丢失率	0%	0.003%
容器启动耗时	1.2s	2.7s

第五章：二手Go代码现代化改造的方法论与工程落地 checklist

改造前的代码健康度快照

在启动改造前，必须对存量代码进行基线扫描。我们曾对某电商订单服务（Go 1.13 编写的 8 万行代码库）执行以下诊断：go vet -all 暴露 47 处未处理错误；staticcheck 发现 129 个 SA1019（已弃用 API 调用），集中在 gopkg.in/yaml.v2 和 github.com/gorilla/mux v1.x；gocyclo 显示 14 个函数圈复杂度 ≥ 25。这些数据直接决定改造优先级——高风险项（如 panic 泛滥、全局变量滥用）必须首期处理。

构建可验证的渐进式迁移路径

拒绝“重写式”重构。采用接口抽象 + 适配器模式实现平滑过渡。例如将旧版 Redis 客户端 github.com/garyburd/redigo/redis 替换为 github.com/redis/go-redis/v9 时，先定义统一缓存接口：

type Cache interface {
    Set(ctx context.Context, key string, value interface{}, ttl time.Duration) error
    Get(ctx context.Context, key string) (string, error)
}

再编写双写适配器，在灰度环境中并行调用新旧客户端，比对结果一致性，日志中记录偏差率。当连续 24 小时偏差率

工程落地 checklist

检查项	验证方式	自动化脚本
所有 HTTP handler 使用 context.Context 传递超时	`grep -r "http.HandleFunc" . \\| grep -v "context"`	`./scripts/check-context.sh`
错误处理符合 Go 1.13+ 错误链规范	`grep -r "fmt.Errorf(" . \\| grep -E "(%w\\|%v)"`	`golangci-lint run --enable=err113`
测试覆盖率 ≥ 75%（关键模块 ≥ 85%）	`go test -coverprofile=c.out && go tool cover -func=c.out`	CI 中强制拦截低于阈值的 PR

依赖治理的三阶段策略

第一阶段锁定主版本：将 go.mod 中所有 require 行替换为 // +replace 注释标记待升级项；第二阶段执行 go get -u=patch 自动修复安全漏洞；第三阶段使用 go list -m all 生成依赖图谱，用 Mermaid 可视化循环依赖：

graph LR
    A[order-service] --> B[auth-lib v1.2]
    B --> C[log-core v0.9]
    C --> A
    D[metrics-exporter] --> B

定位到 log-core v0.9 引入的隐式循环后，推动其发布 v1.0 并移除 replace。

生产环境熔断与回滚机制

在 API 网关层注入 X-Go-Migration: v2 请求头，Kubernetes Ingress 根据该 header 将 5% 流量路由至新版本 Deployment。Prometheus 监控关键指标：http_request_duration_seconds_bucket{le="0.2",handler="OrderCreate"} - 新旧版本 P95 延迟差值 > 50ms 时自动触发 Helm rollback。同时保留旧版 Docker 镜像 SHA256 哈希至rollback-manifest.yaml`，确保 30 秒内完成全量回退。

团队协作的契约保障

要求所有改造 PR 必须附带 migration-plan.md，明确标注：① 影响的微服务边界（通过 go list -f '{{.Deps}}' ./service/order 提取）；② 数据库 schema 变更是否需 pt-online-schema-change；③ 对接方 SDK 版本兼容性矩阵。SRE 团队每日扫描该文件，阻断未声明跨服务影响的合并请求。