Go调试器高级技法：清华调试实验室逆向GDB+Delve的8个隐藏命令，支持goroutine级断点注入

第一章：Go调试器高级技法导论

Go 调试器（dlv）不仅是基础断点工具，更是深入理解运行时行为、内存布局与并发语义的精密探针。掌握其高级能力，意味着能精准定位竞态、内存泄漏、GC 异常及 goroutine 死锁等生产级疑难问题。

调试会话启动策略

推荐始终使用 dlv debug 启动调试会话，并启用符号优化支持：

# 编译时保留完整调试信息（禁用内联和优化，便于源码级追踪）
go build -gcflags="all=-N -l" -o myapp .

# 启动调试器，监听本地端口并自动附加至进程
dlv debug --headless --listen :2345 --api-version 2 --accept-multiclient

注：-N -l 参数禁用编译器优化与函数内联，确保变量可观察、行号精确；--headless 模式适用于远程调试或 IDE 集成。

动态断点与条件表达式

dlv 支持在运行中设置条件断点，例如仅当某 channel 缓冲区满时触发：

(dlv) break main.processRequest
Breakpoint 1 set at 0x49a8f0 for main.processRequest() ./main.go:42

(dlv) condition 1 len(*ch) == cap(*ch)  # ch 为 *chan int 类型变量

条件表达式支持 Go 语法子集，可访问局部变量、字段、函数调用（无副作用），但不可修改状态。

Goroutine 级别观测矩阵

观测维度	命令示例	说明
当前活跃 goroutine	goroutines	列出所有 goroutine ID 及状态
切换至指定协程	goroutine 123 switch	在堆栈、变量上下文中切换上下文
查看阻塞原因	goroutine 123 stack	显示该 goroutine 的完整调用链
检查等待的 channel	goroutine 123 print <-ch	输出 channel 当前接收者/发送者

内存快照与变量深度检查

对复杂结构体启用递归展开（默认仅 1 层）：

(dlv) config show
...
[config] max-variable-recurse = 1  # 修改为 3 可展开嵌套 map/slice/struct

(dlv) config set max-variable-recurse 3
(dlv) print user.Profile.Address.Street
"123 Gopher Lane"

调试器会实时解析运行时类型信息，无需源码注解即可识别 interface{} 底层值。

第二章：GDB深度逆向与Go运行时交互

2.1 GDB插件机制与Go运行时符号解析

GDB通过Python插件接口扩展调试能力，Go运行时符号（如runtime.g, runtime.m, runtime.p）在编译时被剥离或重命名，需动态还原。

Go符号加载关键步骤

• 启动时加载$GOROOT/src/runtime/runtime-gdb.py
• 解析.gopclntab段定位函数元数据
• 利用go:linkname标记恢复内部符号可见性

符号解析核心代码示例

# runtime-gdb.py 片段：注册Go协程命令
class GoroutinesCommand(gdb.Command):
    def __init__(self):
        super(GoroutinesCommand, self).__init__("info goroutines", gdb.COMMAND_DATA)
    def invoke(self, arg, from_tty):
        # 获取当前G结构体地址：$runtime·g0 + offset_g
        g0 = gdb.parse_and_eval("$runtime·g0")
        # offset_g 来自 DWARF debug info 或硬编码偏移（Go 1.21+ 使用 DWARF）
        current_g = g0.cast(gdb.lookup_type("struct g").pointer()).dereference()

此代码通过GDB Python API获取当前goroutine结构体；$runtime·g0是编译器注入的全局g指针符号；cast()完成类型安全转换，避免内存越界读取。

符号类型	是否默认可见	解析方式
main.main	是	ELF symbol table
runtime.g	否	.gopclntab + DWARF
runtime·findrunnable	否	go:linkname 重绑定

graph TD
    A[GDB启动] --> B[加载runtime-gdb.py]
    B --> C[扫描.gopclntab获取函数入口]
    C --> D[解析DWARF获取g/m/p布局]
    D --> E[构建goroutine列表]

2.2 手动注入goroutine级断点的汇编级实践

Go 运行时将 goroutine 调度与 g 结构体强绑定，手动断点需精准作用于目标 g 的执行上下文。

核心原理

• 断点须插入 g.stack.lo → g.stack.hi 范围内的活跃栈帧
• 利用 GOARCH=amd64 下的 INT3（0xCC）字节覆写指令流
• 需同步暂停目标 g 所在 M，并保存/恢复 rip 和寄存器状态

注入步骤（以调试器视角）

1. 通过 runtime.allgs 获取目标 g* 地址
2. 解析 g.sched.pc 得到待中断的汇编地址
3. 使用 mmap 或 mprotect 临时解除页面写保护
4. 原子写入 0xCC 并刷新指令缓存（CLFLUSH）

// 示例：在 runtime.mcall 前插入断点（偏移 +0x17）
movq    0x10(%rsp), %rax   // 原指令（保存 g）
int3                       // 注入断点（单字节）
movq    %rax, 0x10(%rsp)   // 恢复指令（断点命中后由调试器替换）

逻辑分析：int3 触发 SIGTRAP，内核将控制权移交调试器；此时 g.sched.pc 已回退至断点地址，需在 g.sched.pc += 1 后单步跳过，避免重复触发。参数 %rax 为临时寄存器，确保断点前后寄存器状态一致。

操作阶段	关键校验点	失败后果
地址定位	g.status == _Grunning	误停休眠 goroutine
写保护	mprotect(addr, 1, PROT_READ\|PROT_WRITE)	SIGSEGV 崩溃
恢复执行	g.sched.pc++ 后 g.status = _Grunnable	断点永久挂起

2.3 利用GDB Python API实现goroutine状态快照捕获

Go 程序在调试时，runtime.g 和 runtime.g0 链表隐式维护所有 goroutine 状态。GDB Python API 可直接遍历该链表，无需依赖 dlv 或符号重载。

核心数据结构映射

• g.status: 表示运行状态（如 _Grunnable=2, _Grunning=3）
• g.stackguard0: 指向栈底，辅助判断栈使用情况
• g.sched.pc: 下一条待执行指令地址，定位协程挂起点

快照采集脚本示例

import gdb

class GoroutineSnapshot(gdb.Command):
    def __init__(self):
        super().__init__("go-snapshot", gdb.COMMAND_DATA)

    def invoke(self, arg, from_tty):
        g_list = gdb.parse_and_eval("runtime.allgs")
        # 获取 allgs 数组长度（Go 1.21+ 使用 slice，需解析 len）
        length = int(g_list["len"])
        print(f"Found {length} goroutines")
        for i in range(length):
            g = g_list["array"][i]
            status = int(g["status"])
            pc = int(g["sched"]["pc"])
            print(f"G{int(g['goid']):<4} | status={status:<2} | PC=0x{pc:x}")

GoroutineSnapshot()

逻辑分析：gdb.parse_and_eval("runtime.allgs") 直接读取 Go 运行时全局变量；g["sched"]["pc"] 提取调度上下文中的程序计数器，反映 goroutine 最近挂起位置；g["goid"] 是唯一协程 ID，用于跨快照比对。

状态码语义对照表

状态值	含义	是否活跃
1	_Gidle	否
2	_Grunnable	是（就绪）
3	_Grunning	是（执行中）
4	_Gsyscall	是（系统调用中）

执行流程示意

graph TD
    A[启动GDB并加载Go二进制] --> B[注册Python命令 go-snapshot]
    B --> C[读取 runtime.allgs slice]
    C --> D[遍历每个 g 结构体]
    D --> E[提取 goid/status/pc/stack]
    E --> F[格式化输出至控制台]

2.4 反向追踪GC触发点：从runtime.mcall到g0栈切换

Go 的 GC 触发常隐匿于系统调用栈深处。当 Goroutine 主动让出或被抢占时，runtime.mcall 成为关键跳板。

mcall 的核心作用

它将当前 G 的用户栈切换至 M 的 g0 栈，实现无栈寄存器保存的快速上下文迁移：

// src/runtime/asm_amd64.s
TEXT runtime·mcall(SB), NOSPLIT, $0-0
    MOVQ SP, g_m(g)(R15)   // 保存当前G的SP到g.m.g0.sp
    MOVQ g0, R14           // 切换至g0
    MOVQ g_m(R14), R13     // 获取M
    MOVQ g0_m_g0(R13), R15 // 加载g0.g
    MOVQ R14, g_m_g0(R13)  // 将当前G设为g0.m.curg
    JMP  runtime·mstart(SB) // 进入调度循环（可能触发GC）

逻辑分析：mcall 不修改 PC，仅切换栈指针与当前 G 关联；参数隐含在寄存器 R15（指向当前 g）中，全程避免函数调用开销。

g0 栈的关键角色

栈类型	用途	是否可被 GC 扫描
用户 G 栈	执行 Go 代码	✅ 是
g0 栈	调度、GC、系统调用等	❌ 否（runtime 保留）

graph TD
    A[用户G执行中] -->|触发STW条件| B[runtime.mcall]
    B --> C[切换SP至g0栈]
    C --> D[进入mstart→schedule→gcStart]

2.5 GDB+Ptrace联合调试：绕过Go runtime对ptrace的屏蔽策略

Go runtime 自 v1.11 起主动拦截 PTRACE_ATTACH，通过 runtime.syscall 中的 ptrace(ATTACH) 返回 EPERM 实现防御。但该屏蔽仅作用于非 TID=PID 的附加场景。

核心突破点

• Go 进程启动时未完全初始化 runtime.ptraceGuard
• gdb --pid <PID> 可触发 PTRACE_ATTACH 前的 waitpid(WSTOPPED) 捕获初始 SIGSTOP
• 利用 ptrace(PTRACE_SEIZE, PID, 0, PTRACE_O_TRACECLONE | PTRACE_O_TRACEFORK) 替代 ATTACH

关键代码片段

// 绕过 runtime 检查的 seize 调用（需在 runtime 初始化前注入）
long ret = ptrace(PTRACE_SEIZE, pid, 0,
                  PTRACE_O_TRACECLONE | PTRACE_O_TRACEFORK | PTRACE_O_TRACEEXEC);
// 参数说明：
// - PTRACE_SEIZE：不中断目标，避免触发 runtime 的 attach 钩子
// - PTRACE_O_*：启用子进程/线程/执行事件跟踪，绕过 fork 后的 ptrace 阻断

GDB 调试链路

graph TD
    A[GDB attach] --> B{waitpid WSTOPPED}
    B --> C[ptrace SEIZE + options]
    C --> D[拦截 execve/fork/clone 事件]
    D --> E[注入断点至 runtime.main]

方法	是否触发 runtime 拦截	支持 Go 协程追踪
PTRACE_ATTACH	是	否
PTRACE_SEIZE	否	是

第三章：Delve内核机制剖析与扩展开发

3.1 Delve调试会话生命周期与goroutine调度钩子注入

Delve 调试会话启动时，dlv exec 会注入 runtime.Breakpoint() 并劫持 g0 的调度路径，在 schedule() 和 newproc1() 等关键函数入口埋设断点钩子。

goroutine 创建时的钩子注入点

// 在 delve 源码 pkg/proc/internal/ebpf/bp.go 中注册：
bp, _ := proc.SetBreakpoint("runtime.newproc1", proc.BreakOnEntry)
// BreakOnEntry 触发后，Delve 可读取 caller SP、gp 地址及 fn 指针

该断点使 Delve 能在 goroutine 创建瞬间捕获其 goid、栈基址和启动函数，为后续 goroutine list 提供实时快照。

调度钩子生命周期阶段

阶段	触发时机	Delve 行为
Attach	ptrace(PTRACE_ATTACH)	注入 __dlv_trace_start stub
Resume	continue 命令执行	恢复前重置 GODEBUG=schedtrace=1
Detach	会话终止	清理所有 runtime.* 断点与 eBPF map

graph TD
    A[dlv attach] --> B[注入 g0 调度断点]
    B --> C{goroutine 创建？}
    C -->|是| D[捕获 newproc1 参数]
    C -->|否| E[等待 schedule 调度切换]
    D --> F[更新 goroutine 元数据缓存]

3.2 自定义Command插件开发：实现break-goroutine-if指令

break-goroutine-if 是一个动态条件断点指令，用于在满足指定 Go 表达式时暂停目标 goroutine（而非整个进程），提升并发调试精度。

核心能力设计

• 支持运行时求值 runtime.GoroutineProfile() 中的 goroutine 状态
• 可绑定至特定 goroutine ID 或匹配 Goroutine.panic/Goroutine.waitreason 字段
• 非侵入式注入，不修改目标二进制

关键代码片段

func (p *BreakGoroutineIfPlugin) OnCommand(cmd string, args []string) error {
    expr := strings.Join(args, " ") // 如 "g.id == 123 && g.state == 'waiting'"
    p.condExpr = expr
    return delve.RegisterBreakpoint(&api.Breakpoint{
        Addr:     0, // virtual breakpoint
        Cond:     expr,
        Tracepoint: false,
        Goroutine: true, // enable per-goroutine evaluation
    })
}

逻辑说明：Goroutine: true 告知 Delve 在每个 goroutine 切换时触发条件检查；Cond 字段交由 expr 模块解析执行，支持访问 g（当前 goroutine 的 *proc.G 实例）及其字段。Addr: 0 表示无物理地址绑定，纯逻辑断点。

支持的表达式变量表

变量	类型	说明
g.id	uint64	goroutine ID
g.state	string	"running", "waiting", "syscall" 等
g.pc	uint64	当前指令地址

执行流程

graph TD
    A[用户输入 break-goroutine-if g.state==“waiting”] --> B[解析表达式并注册虚拟断点]
    B --> C[调度器切换 goroutine 时调用 EvalCondition]
    C --> D{g.state == “waiting”?}
    D -->|true| E[暂停该 goroutine 并通知 UI]
    D -->|false| F[继续执行]

3.3 源码级goroutine过滤器：基于G结构体字段的条件断点引擎

Go 运行时中每个 goroutine 对应一个 runtime.g 结构体，其字段（如 g.status、g.m、g.sched.pc）天然支持细粒度调试控制。

核心过滤字段语义

• g.status：当前状态（_Grunnable/_Grunning/_Gwaiting）
• g.m：绑定的 M 指针，为 nil 表示无绑定
• g.labels：Go 1.22+ 引入的用户标签映射（map[string]string）

条件断点实现示例（Delve CLI）

(dlv) break -a -c 'g.status == 2 && g.m == 0' runtime.schedule

逻辑分析：-c 启用条件表达式；g.status == 2 匹配 _Grunnable 状态；g.m == 0 筛选未被 M 抢占的待调度 goroutine。该断点仅在调度器选取新 G 时触发，避开运行中 G 的干扰。

字段	类型	调试价值
g.stack	stack	定位栈溢出或非法栈访问
g.waitreason	waitReason	识别阻塞根源（如 semacquire）

graph TD
    A[触发断点] --> B{g.status == _Grunnable?}
    B -->|是| C[g.m == nil?]
    B -->|否| D[跳过]
    C -->|是| E[命中条件断点]
    C -->|否| D

第四章：清华调试实验室实战工具链集成

4.1 goroutine-aware trace：融合pprof与delve trace的混合采样器

传统性能分析面临两大割裂：pprof 提供高吞吐、低开销的统计采样，但缺乏 goroutine 生命周期与调度上下文；delve trace 可捕获精确的 goroutine 创建/阻塞/唤醒事件，却因高频插桩导致严重性能扰动。

核心设计思想

• 在 runtime 调度器关键路径（如 gopark, goready, newproc1）注入轻量钩子
• 仅对活跃 goroutine（Grunning, Grunnable）启用精细 trace，空闲 goroutine 退化为 pprof 定时采样

混合采样协同机制

维度	pprof 模式	delve trace 模式	协同策略
采样频率	100Hz 定时栈快照	事件驱动（goroutine 状态变更）	状态变更触发 pprof 快照锚定
数据粒度	全局聚合（symbol + PC）	goroutine ID + 状态 + 时间戳	trace 事件携带最近 pprof 栈哈希

// runtime/trace/hybrid.go（简化示意）
func onGoroutineStateChange(gp *g, oldState, newState uint32) {
    if isRelevantGoroutine(gp) && shouldEnableFineTrace(gp) {
        // 记录事件并关联当前 pprof 栈指纹
        traceEvent("goroutine.state", gp.goid, newState, 
                   pprof.StackHash(runtime.Caller(0))) // ← 关键：栈指纹对齐
    }
}

逻辑分析：pprof.StackHash() 对当前调用栈做快速哈希（非全量序列化），避免 trace 开销激增；该哈希值作为轻量标识，在后续 pprof 分析中可反查对应符号栈。参数 runtime.Caller(0) 获取当前帧，确保锚点精准。

数据同步机制

• 所有 trace 事件写入 lock-free ring buffer
• pprof 采样器定期将 buffer 中的 goroutine 关联事件批量导出为 execution_trace 格式

graph TD
    A[Scheduler Hook] -->|state change| B[Hybrid Trace Agent]
    B --> C{Is Active G?}
    C -->|Yes| D[Record Event + StackHash]
    C -->|No| E[Skip fine trace]
    D --> F[Ring Buffer]
    G[pprof Sampler] -->|Periodic Flush| F
    F --> H[Unified Trace File]

4.2 GoStackInspector：可视化goroutine阻塞链与锁持有图谱

GoStackInspector 是一个运行时诊断工具，通过 runtime.Stack() 与 debug.ReadGCStats() 协同采样，实时构建 goroutine 状态拓扑。

核心能力

• 捕获阻塞点（如 semacquire、futex 调用栈）
• 关联 sync.Mutex/RWMutex 持有者与等待者
• 生成跨 goroutine 的锁依赖有向图

示例分析代码

// 启动 Inspector 并注入阻塞检测钩子
insp := NewStackInspector(
    WithSampleInterval(100 * time.Millisecond),
    WithMaxDepth(16), // 控制栈深度避免OOM
)
insp.Start() // 后台 goroutine 持续轮询

WithSampleInterval 控制采样频率，过低易失真，过高难捕瞬态阻塞；WithMaxDepth 限制栈解析深度，保障性能可控。

锁持有关系表示（简化示意）

Holder GID	Locked At	Waiters GIDs	Lock Type
127	0x4d2a1c	[129, 135]	*Mutex

graph TD
    G127["Goroutine 127<br>holds mutex"] -->|blocks| G129["Goroutine 129"]
    G127 -->|blocks| G135["Goroutine 135"]
    G135 -->|waits on| G127

4.3 Delve-LLVM Bridge：利用LLVM IR重写实现无侵入式断点热插拔

Delve-LLVM Bridge 在调试器运行时动态拦截 Go 函数的 LLVM IR 表示，通过 llvm::IRBuilder 注入断点桩（breakpoint stub），避免修改源码或重编译。

核心重写流程

; 原始函数入口（简化）
define dso_local %struct.Foo* @NewFoo() {
entry:
  %obj = call %struct.Foo* @malloc(i64 16)
  ret %struct.Foo* %obj
}

→ 插入桩后：

define dso_local %struct.Foo* @NewFoo() {
entry:
  call void @__delve_breakpoint_hook(i64 0x12345678) ; 断点ID哈希
  %obj = call %struct.Foo* @malloc(i64 16)
  ret %struct.Foo* %obj
}

逻辑分析：@__delve_breakpoint_hook 是 JIT 注册的回调，接收唯一断点地址指纹（i64）；IR 重写在 FunctionPassManager 中执行，确保仅作用于已加载模块的活跃函数。

关键机制对比

特性	传统 ptrace 断点	Delve-LLVM Bridge
是否需修改内存页	是（PROT_WRITE）	否（纯 IR 层）
支持 goroutine 级粒度	否	是（按调度器上下文绑定）

graph TD
  A[Delve 接收断点请求] --> B[定位目标函数 LLVM Module]
  B --> C[Clang/LLVM IR Pass 注入 hook 调用]
  C --> D[LLVM JIT 编译并替换原代码段]
  D --> E[断点命中时触发 Go runtime 回调]

4.4 清华TDB（Tsinghua Debug Bridge）：支持跨版本Go二进制的符号兼容层

清华TDB 是一个轻量级符号翻译中间件，运行于调试器（如 Delve）与 Go 运行时之间，动态桥接不同 Go 版本（1.18–1.23）生成的二进制中符号格式差异。

核心能力

• 自动识别 .gopclntab 和 pclntab 结构演进
• 按需重映射函数名、行号表、变量 DWARF offset
• 零修改接入现有调试工作流

符号重绑定示例

// TDB 注入的符号解析钩子（伪代码）
func (t *TDB) ResolveSymbol(symName string, binVer uint16) (*SymbolInfo, error) {
    // binVer=122 → 映射到 Go 1.22 的 pclntab v2 解析器
    parser := t.parserForVersion(binVer)
    return parser.Parse(symName) // 返回统一 SymbolInfo 结构
}

该函数根据二进制标记的 Go 版本号选择对应解析器，确保 runtime.main 等关键符号在任意版本下均能准确定位。

兼容性支持矩阵

Go 版本	pclntab 版本	TDB 支持	行号精度
1.18–1.20	v1	✅	±1 行
1.21–1.22	v2	✅	精确
1.23+	v3（实验）	⚠️（beta）	精确

graph TD
    A[Delve 请求 symbol: main.main] --> B{TDB 路由器}
    B --> C{读取 binary header}
    C -->|Go 1.21| D[pclntab v2 解析器]
    C -->|Go 1.19| E[pclntab v1 解析器]
    D & E --> F[标准化 SymbolInfo]
    F --> G[返回给 Delve]

第五章：未来调试范式演进与开源协作倡议

调试即服务：GitHub Codespaces 与 VS Code Remote-Containers 的生产级实践

某金融科技团队将核心交易风控引擎（Go + PostgreSQL）迁移至远程开发环境后，构建了“可复现调试即服务”工作流。开发人员通过预配置的 devcontainer.json 启动包含完整依赖、模拟 Kafka 集群和故障注入模块的容器实例；调试会话直接挂载 CI 流水线生成的带 DWARF 符号的二进制包，支持跨进程断点（如从 HTTP handler 断点跳转至 gRPC client stub 内部）。该方案使平均故障复现时间从 47 分钟压缩至 92 秒，且所有调试上下文（内存快照、goroutine trace、SQL 查询计划）自动上传至内部 S3 并关联 Jira issue ID。

基于 eBPF 的无侵入式运行时观测体系

Linux 内核 5.15+ 环境下，团队采用 BCC 工具链部署自定义探针：

# 捕获特定 PID 下所有 SSL_write 调用的明文长度与 TLS 版本
sudo /usr/share/bcc/tools/trace 'p:/usr/lib/x86_64-linux-gnu/libssl.so.1.1:SSL_write "%d %s", arg2, (char*)arg1'

结合 Grafana Loki 日志聚合与 Prometheus 指标导出，实现加密流量异常检测——当某微服务连续 3 次调用 SSL_write 传入长度为 0 的 buffer 时，自动触发告警并保存 eBPF ring buffer 中的完整调用栈。该能力已在 2023 年某次 OpenSSL 补丁回滚事故中提前 11 分钟定位到 TLS 1.0 协议降级行为。

开源协作倡议：DebugKit 共建计划

组件	当前状态	贡献者来源	实战案例
Rust WASM 调试桥	v0.3.1 (Beta)	Mozilla + Cloudflare	Figma 插件热重载断点调试
Kubernetes Event Tracer	v1.2.0 (Stable)	CNCF Sandbox 项目	Argo CD 同步失败根因图谱生成
嵌入式 JTAG 云代理	RFC 已发布	Raspberry Pi 基金会	树莓派 Pico 固件 OTA 回滚调试

跨语言符号标准化：DWARF 5 与 BTF 的协同落地

Linux 内核模块与用户态 Go 程序共享统一调试元数据：内核启用 CONFIG_DEBUG_INFO_BTF=y 编译选项生成 BTF 信息，用户态通过 libbpfgo 加载并映射至 DWARF 5 的 .debug_info 段。在某边缘计算网关项目中，此机制使开发人员可在同一 VS Code 窗口中对 eBPF 数据平面程序（C）与控制平面 API 服务（Go）设置联动断点——当 eBPF map 更新触发 bpf_map_update_elem() 返回 -E2BIG 时，自动跳转至 Go 层 metricsCollector.Run() 方法检查缓冲区溢出逻辑。

社区驱动的调试知识图谱

基于 Apache AGE 图数据库构建的调试知识库已收录 12,847 条真实故障模式，节点类型包括 ErrorPattern（如 SIGSEGV in libjemalloc.so.2）、RootCause（如 arena_t::bins 数组越界）、FixCommit（如 jemalloc@f8a1c3e）。开发者提交新 issue 时，系统通过 AST 解析器提取堆栈关键帧，经图神经网络匹配相似子图，推荐历史修复方案及对应测试用例。某次 Redis 7.0.5 在 ARM64 上的 zmalloc 崩溃事件中，该图谱在 37 秒内定位到上游 jemalloc 补丁缺失问题，并附带可执行的 make check 验证脚本。