第一章：Go unsafe包的本质与设计哲学
unsafe 包并非 Go 语言的“后门”或“例外”，而是其类型安全体系中一块被精心隔离、显式标记的基石。它不提供新功能，而是暴露底层内存操作的原始能力——指针算术、类型绕过、结构体布局控制——所有这些能力都以 unsafe. 前缀强制声明：调用者必须主动承担全部责任。这种设计体现了一种克制的哲学：安全是默认，不安全是例外；而例外必须可见、可审计、不可隐式发生。
unsafe 的核心类型仅有三个：Pointer、Sizeof、Offsetof 和 Alignof。其中 Pointer 是唯一能桥接不同类型的“万能指针”，但它不能直接参与算术运算；必须先转换为 uintptr（一个无符号整数）才能做偏移计算，再转回 Pointer——这个“整数中转”步骤正是编译器插入安全检查的锚点，防止指针逃逸和 GC 误回收。
以下代码演示了如何安全地访问结构体私有字段（仅用于调试与反射实现原理理解）：
package main
import (
"fmt"
"unsafe"
)
type User struct {
name string // 首字段，偏移量为 0
age int
}
func main() {
u := User{name: "Alice", age: 30}
// 获取结构体首地址
p := unsafe.Pointer(&u)
// 计算 name 字段的地址：首地址 + name 字段偏移量
namePtr := (*string)(unsafe.Pointer(uintptr(p) + unsafe.Offsetof(u.name)))
fmt.Println(*namePtr) // 输出：Alice
*namePtr = "Bob" // 修改原值
fmt.Println(u.name) // 输出：Bob
}注意：该操作绕过了 Go 的封装约束，仅在极少数系统编程场景（如高性能序列化、自定义内存分配器、FFI 交互）中被接受，且必须配合 //go:noescape 或 //go:systemstack 等编译指示谨慎使用。
unsafe 的存在，本质是 Go 在“抽象安全”与“硬件直控”之间划出的一条清晰分界线——它不鼓励越界，但绝不阻止必要时的精确掌控。
第二章：unsafe.Pointer与uintptr转换的5条不可逾越红线
2.1 uintptr非法逃逸：栈地址泄露导致GC失效的实战复现与内存泄漏追踪
当 uintptr 被用于绕过 Go 的类型安全机制并存储栈变量地址时，GC 无法识别该引用，导致本应被回收的栈对象被意外“钉住”。
复现场景代码
func leakByUintptr() *int {
x := 42
return (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&x)))) // ❌ 非法逃逸：&x 是栈地址，转为 uintptr 后脱离 GC 跟踪
}&x 原为栈上临时地址；uintptr 是纯整数类型，不携带指针元信息，GC 忽略其值。返回后 x 的内存未被回收，但指针已悬空——后续读写触发未定义行为。
关键诊断线索
go tool trace中可见异常长生命周期的“ghost” goroutine 栈帧；pprof heap显示runtime.mspan持有大量不可达但未释放的 span；GODEBUG=gctrace=1输出中scanned数持续增长而collected不匹配。
| 现象 | 根本原因 |
|---|---|
| 对象永不被 GC | uintptr 隐藏指针，逃逸分析失效 |
runtime.ReadMemStats HeapInuse 持续攀升 |
栈内存被误判为堆存活 |
graph TD
A[函数调用创建局部变量x] --> B[取地址 &x]
B --> C[转为 uintptr]
C --> D[再转回 *int]
D --> E[返回指针]
E --> F[GC 无法识别该引用 → 泄漏]2.2 Pointer算术越界：基于reflect.SliceHeader篡改底层数组长度引发panic的深度剖析
底层内存布局本质
Go切片是三元组结构：ptr（指向底层数组首地址）、len（当前长度）、cap（容量）。reflect.SliceHeader提供对这三者的直接访问，但绕过编译器安全检查。
危险操作示例
s := []int{1, 2, 3}
hdr := (*reflect.SliceHeader)(unsafe.Pointer(&s))
hdr.Len = 10 // 越界篡改len → panic: runtime error: slice bounds out of range逻辑分析：
hdr.Len = 10使运行时认为切片可安全访问前10个元素，但底层数组仅分配3个int（24字节），后续读写将触发内存越界检测并立即panic。cap未同步修改加剧不一致。
关键约束对比
| 字段 | 安全修改条件 | 运行时校验时机 |
|---|---|---|
Len |
≤ Cap |
每次索引/切片操作时 |
Cap |
≤ 原底层数组总容量 | append 或 make 分配时 |
触发路径
graph TD
A[篡改SliceHeader.Len] --> B{Len > Cap?}
B -->|是| C[panic: slice bounds out of range]
B -->|否| D[可能静默越界写入相邻内存]2.3 unsafe.Pointer跨goroutine传递：竞态检测器（-race）无法捕获的隐式数据竞争实验验证
数据同步机制的盲区
-race 仅检测对同一地址的普通读写操作，但 unsafe.Pointer 的类型擦除特性使其转换后的指针访问绕过编译器跟踪：
var p unsafe.Pointer
go func() {
p = unsafe.Pointer(&x) // 写入指针值（race 不报）
}()
go func() {
y := *(*int)(p) // 读取解引用（race 不报，但可能读悬垂内存）
}()逻辑分析：
p是unsafe.Pointer类型变量，其赋值/读取本身不触发竞态检测；而*(*int)(p)的解引用发生在运行时，-race无法关联原始变量x的生命周期。
隐式竞争验证路径
- ✅
go run -race对p的读写静默通过 - ❌ 实际执行中
x可能已被栈回收或重用 - ⚠️ 竞争本质是内存生命周期错配，非传统数据竞争
| 检测维度 | -race 是否覆盖 |
原因 |
|---|---|---|
p 变量读写 |
否 | 指针值操作无类型语义 |
*(*int)(p) 访问 |
否 | 解引用地址动态生成，无符号关联 |
graph TD
A[goroutine1: p = &x] --> B[内存地址A存储x]
C[goroutine2: read *p] --> D[尝试读地址A]
B -.->|x栈帧已退出| E[读悬垂内存]
D -.->|无race标记| F[静默失败]2.4 类型对齐违规：struct字段偏移计算错误导致读写错位的汇编级调试实录
现象复现
某嵌入式通信模块在启用DMA直写结构体时，status字段始终读取为 0xdeadbeef（实际应为 0x01），GDB单步至 mov eax, [ebx+4] 指令后发现 ebx 指向地址 0x20001002 —— 非4字节对齐。
关键结构体定义
// 编译器默认#pragma pack(1)，但驱动层误设为__attribute__((aligned(4)))
typedef struct {
uint8_t id; // offset 0 → 实际被强制对齐到 offset 0
uint32_t value; // offset 4 → 但若id后无填充，此处应为 offset 1！
uint8_t status; // offset 8 → 错位成 offset 5 → 被DMA写入到相邻字段
} __attribute__((packed)) packet_t;逻辑分析：
__attribute__((packed))与外部#pragma pack(4)冲突，导致编译器按packed计算偏移（id=0,value=1,status=5），但汇编代码仍按aligned(4)假设生成mov [reg+4]访问value，实际却覆盖了status的内存位置。
对齐差异对照表
| 字段 | packed 偏移 |
aligned(4) 偏移 |
实际DMA写入地址 |
|---|---|---|---|
id |
0 | 0 | ✅ |
value |
1 | 4 | ❌（写入 offset 4） |
status |
5 | 8 | ❌（被 offset 4 覆盖） |
调试验证流程
graph TD
A[DMA触发写入] --> B{检查寄存器EBX值}
B --> C[反查struct布局：readelf -S + objdump -d]
C --> D[比对__alignof__与offsetof]
D --> E[修正为统一__attribute__((packed, aligned(1))) ]2.5 GC屏障绕过陷阱：通过uintptr绕过write barrier触发对象提前回收的CoreDump分析
数据同步机制
Go运行时依赖write barrier确保GC准确追踪指针写入。当开发者用uintptr强制转换指针并直接写入堆内存时，编译器无法插入屏障指令。
var p *int = new(int)
*p = 42
u := uintptr(unsafe.Pointer(p))
*(*int)(u + unsafe.Offsetof(struct{ x int }{}.x)) = 100 // 绕过write barrier！此操作跳过runtime.gcWriteBarrier调用，导致GC误判p指向对象不可达，可能在下一轮STW中提前回收该内存。
核心风险链
uintptr是整数类型，非指针，不参与逃逸分析与屏障插入- 直接解引用
uintptr生成的地址，绕过编译器所有内存安全检查 - GC仅扫描栈/全局变量中的
*T，忽略uintptr携带的“隐式指针”
| 风险等级 | 触发条件 | 典型表现 |
|---|---|---|
| Critical | uintptr写入堆对象字段 |
CoreDump + SIGSEGV |
graph TD
A[ptr := &obj] --> B[uintptr(ptr) → u]
B --> C[u + offset → target]
C --> D[*(*T)(target) = val]
D --> E[GC未标记obj存活]
E --> F[对象被回收 → 悬垂指针访问]第三章：反射机制中unsafe绕过的3个合法替代路径
3.1 使用unsafe.Slice替代unsafe.Pointer转[]byte：Go 1.20+零拷贝切片构造实践
在 Go 1.20 之前，开发者常借助 unsafe.Pointer 与 reflect.SliceHeader 手动构造 []byte，易出错且破坏内存安全边界：
// ❌ Go < 1.20：危险且需手动填充 SliceHeader
hdr := &reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(&data[0])),
Len: len(data),
Cap: len(data),
}
b := *(*[]byte)(unsafe.Pointer(hdr))逻辑分析：需显式构造
SliceHeader并执行类型转换，Data必须指向合法内存起始地址，Len/Cap超界将引发未定义行为；且reflect.SliceHeader非导出字段在 Go 1.20+ 已被标记为不安全。
✅ Go 1.20+ 推荐使用 unsafe.Slice：
// ✅ 安全、简洁、零拷贝
b := unsafe.Slice((*byte)(unsafe.Pointer(&data[0])), len(data))参数说明：
unsafe.Slice(ptr, len)接收*T类型指针和长度，返回[]T；编译器保证边界检查（若启用-gcflags="-d=checkptr"），且无需反射或 header 操作。
| 方案 | 安全性 | 可读性 | 兼容性 |
|---|---|---|---|
reflect.SliceHeader + unsafe |
❌ 低（易越界） | ❌ 差 | Go ≤ 1.19 |
unsafe.Slice |
✅ 高（编译期约束） | ✅ 优 | Go ≥ 1.20 |
使用前提
- 指针必须指向可寻址的连续内存（如数组首元素、C malloc 区域）；
- 长度不能超过底层内存容量。
3.2 通过unsafe.String实现只读字符串视图：避免分配与规避string header篡改风险
Go 1.20 引入 unsafe.String，为字节切片到字符串的零拷贝转换提供安全边界——它仅允许从 []byte 构造不可变字符串视图，且禁止反向写入或 header 污染。
安全转换模式
b := []byte("hello")
s := unsafe.String(&b[0], len(b)) // ✅ 合法：只读视图，无内存拷贝
// s[0] = 'H' // ❌ 编译错误（字符串字面量不可寻址）unsafe.String(ptr, len) 接收 *byte 和长度，绕过 runtime.allocString 分配，但生成的字符串 header 中 data 指向原切片底层数组，len 严格受控，cap 不暴露，杜绝 header 篡改可能。
与旧式 (*string)(unsafe.Pointer(&b)) 的对比
| 方式 | 内存分配 | header 可篡改 | 类型安全性 |
|---|---|---|---|
unsafe.String |
❌ 零分配 | ❌ 不可篡改（只读语义） | ✅ 编译期校验 |
(*string)(unsafe.Pointer(&b)) |
❌ 零分配 | ✅ 可强制修改 data/len |
❌ 运行时风险 |
核心约束机制
unsafe.String返回值无法取地址；- 底层
[]byte生命周期必须长于字符串视图； - 禁止通过反射或
unsafe修改其 header 字段。
3.3 利用reflect.Value.UnsafeAddr配合runtime.Pinner：安全固定堆对象生命周期的工程范式
runtime.Pinner 是 Go 1.23 引入的核心机制，用于在 GC 周期中临时固定堆上对象的内存地址，避免被移动。它必须与 reflect.Value.UnsafeAddr() 配合使用——后者提供对象在堆上的原始地址，但仅当该 Value 指向可寻址且未被 GC 移动的内存时才合法。
关键约束条件
- 对象必须已分配在堆上（如
&struct{}或new(T)） reflect.Value必须通过reflect.ValueOf(&x).Elem()获取可寻址值Pinner.Pin()必须在UnsafeAddr()调用前完成，否则地址可能失效
var data = make([]byte, 1024)
v := reflect.ValueOf(&data).Elem() // 获取切片头的可寻址Value
pin := runtime.Pinner{}
pin.Pin(v) // 立即固定底层数组内存
addr := v.UnsafeAddr() // ✅ 此时地址稳定有效逻辑分析：
Pin()锁定整个底层数组内存页；UnsafeAddr()返回切片数据起始地址（非切片头地址）。参数v必须为Elem()后的可寻址Value，否则Pin()无效且UnsafeAddr()panic。
典型适用场景对比
| 场景 | 是否适用 | 原因 |
|---|---|---|
| C FFI 内存传递 | ✅ | 需稳定地址供 C 代码长期引用 |
| DMA 直接内存访问 | ✅ | 硬件需物理地址不可变 |
| 无锁环形缓冲区元数据 | ❌ | 仅需原子操作，无需固定地址 |
graph TD
A[Go 堆分配对象] --> B{runtime.Pinner.Pin<br>获取固定权柄}
B --> C[reflect.Value.UnsafeAddr<br>获取稳定地址]
C --> D[传递给系统调用/C 函数/硬件]
D --> E[使用完毕]
E --> F[runtime.Pinner.Unpin<br>恢复 GC 可移动性]第四章：Go 1.22 memory.UnsafeSlice提案前瞻与演进路线
4.1 UnsafeSlice API设计原理：对比unsafe.Slice与新提案的语义差异与内存模型约束
Go 1.23 引入 unsafe.Slice 作为安全替代，但其语义仍受限于底层指针算术；新提案 UnsafeSlice 进一步收紧内存模型约束。
核心语义差异
unsafe.Slice(ptr, len)：仅要求ptr可寻址，不校验底层数组生命周期或边界对齐UnsafeSlice(ptr, len)：要求ptr必须源自合法切片/数组，且len不得越界（编译期+运行期双重检查）
内存模型约束强化
| 约束维度 | unsafe.Slice |
UnsafeSlice（提案） |
|---|---|---|
| 指针来源验证 | ❌ | ✅（需 &x[0] 或 &s[0] 形式） |
| 生命周期绑定 | ❌ | ✅（隐式关联原切片） |
| 对齐保证 | ❌ | ✅（强制 uintptr(ptr) 对齐） |
// 示例：UnsafeSlice 的典型调用
p := &arr[2] // 合法来源：数组元素地址
s := UnsafeSlice(p, 3) // ✅ 允许：p 来自 arr，3 ≤ len(arr)-2逻辑分析：
p必须是&arr[i]形式（非(*int)(unsafe.Pointer(...))），UnsafeSlice在运行时验证p所属内存块是否仍有效，并确保p + len*sizeof(T)未跨内存页边界。
graph TD
A[原始指针 p] --> B{是否 &x[i] 或 &s[i]？}
B -->|否| C[panic: invalid pointer origin]
B -->|是| D[检查 p+len*T 是否在同内存块内]
D -->|越界| E[panic: out-of-bounds]
D -->|合法| F[返回安全切片]4.2 编译器优化协同：如何让go tool compile识别UnsafeSlice为“可证明安全”的切片构造
Go 1.22+ 引入 unsafe.Slice 作为 unsafe.SliceHeader 构造的替代方案，其关键在于编译器可静态验证边界安全性。
编译器识别前提
unsafe.Slice(ptr, len) 被判定为“可证明安全”需同时满足：
ptr是指向已分配内存的指针（如&x[0]、new(T)返回值）len是编译期常量或来自同一底层数组的cap(x)/len(x)衍生表达式- 无中间指针算术（如
ptr + offset）破坏可追溯性
典型安全模式示例
func SafeView(data []byte) []byte {
if len(data) == 0 { return nil }
// ✅ 编译器可追溯：ptr 来自 data 底层，len ≤ cap(data)
return unsafe.Slice(&data[0], len(data))
}逻辑分析：
&data[0]提供非空指针证明；len(data)是已知≤cap(data)的有界整数，且二者同源。编译器通过 SSA 中的PtrMask和BoundsCheckElim阶段联合推导出无需运行时检查。
关键优化开关依赖
| 编译选项 | 作用 | 默认值 |
|---|---|---|
-gcflags="-d=ssa/check_bce" |
启用边界检查消除调试日志 | off |
-gcflags="-d=ssa/unsafe_slice" |
输出 unsafe.Slice 安全性判定路径 |
off |
graph TD
A[unsafe.Slice ptr,len] --> B{ptr 可溯源至 slice/array?}
B -->|Yes| C{len ≤ cap of source?}
B -->|No| D[插入 runtime.checkptr]
C -->|Yes| E[消除 bounds check & GC 潜在指针标记]
C -->|No| D4.3 运行时检查增强：runtime.unsafeSliceCheck在GC标记阶段的新增校验逻辑解析
Go 1.22 起，runtime.unsafeSliceCheck 不再仅限于 unsafe.Slice 调用时的即时校验，而是扩展至 GC 标记阶段对已注册的 unsafe.Slice 衍生对象进行存活期一致性验证。
校验触发时机
- GC 标记遍历到
mspan.specials中类型为specialSlice的条目时激活 - 仅对
slice.ptr指向堆内存且slice.len > 0的对象执行深度校验
新增校验逻辑核心
// runtime/slice.go 内部伪代码（简化）
if s.ptr != nil && s.len > 0 {
base := heapBase(s.ptr) // 获取所属 span 起始地址
if uintptr(s.ptr) < base ||
uintptr(s.ptr)+uintptr(s.len)*s.elemSize > base+span.size {
throw("unsafe.Slice: bounds violation detected during GC marking")
}
}参数说明：
s.ptr为切片底层数组首地址；s.elemSize来自类型信息；span.size是运行时分配的实际页大小。越界即表明原始unsafe.Slice已脱离其父对象生命周期。
校验维度对比表
| 维度 | 编译期检查 | 运行时调用检查 | GC 标记期检查 |
|---|---|---|---|
| 触发时机 | 静态分析 | unsafe.Slice 执行时 |
GC mark phase |
| 检查对象 | 无 | 当前 slice | 所有已注册 specialSlice |
| 能否捕获悬垂引用 | 否 | 否 | ✅ 是 |
graph TD
A[GC 开始标记] --> B{遍历 mspan.specials}
B --> C[发现 specialSlice]
C --> D[提取 ptr/len/elemSize]
D --> E[计算有效地址区间]
E --> F{ptr + len*elemSize ≤ span上限?}
F -->|否| G[panic with stack trace]
F -->|是| H[继续标记]4.4 向后兼容策略：Go 1.22中unsafe.Slice的弃用警告机制与迁移工具链支持
Go 1.22 引入编译期静态分析标记，对 unsafe.Slice(ptr, len) 的直接调用触发 -Wunused-unsafe-slice 警告（默认启用），但不中断构建。
警告触发条件
- 仅当
ptr类型为*T且len为int时激活 - 排除
unsafe.Slice(unsafe.StringData(s), len)等已知安全模式
迁移推荐路径
- ✅ 优先改用
slice := (*[1 << 30]T)(unsafe.Pointer(ptr))[:len:len] - ✅ 使用
golang.org/x/tools/go/analysis/passes/unsafeslice自动修复
// 旧写法（Go 1.21 可用，Go 1.22 编译警告）
p := (*int)(unsafe.Pointer(&x))
s := unsafe.Slice(p, 5) // ⚠️ 触发 warning: unsafe.Slice is deprecated
// 新写法（零开销、类型安全）
s := (*[5]int)(unsafe.Pointer(p))[:5:5]逻辑分析：
(*[N]T)(unsafe.Pointer(p))将指针转为固定长度数组指针，再切片生成[]T；N需在编译期确定（如5），避免运行时越界。参数p必须指向连续N*sizeof(T)字节内存。
| 工具 | 功能 |
|---|---|
go vet -unsafeslice |
检测并定位弃用调用 |
gofix -r |
批量重写为数组切片模式 |
graph TD
A[源码含unsafe.Slice] --> B{go build}
B -->|Go 1.22+| C[编译器注入警告]
C --> D[gofix 自动重写]
D --> E[通过 vet 验证]第五章：安全边界之外的系统级编程新范式
零拷贝网络栈在高频交易网关中的落地实践
某头部量化机构将传统基于 recv()/send() 的 TCP 网关重构为基于 io_uring + AF_XDP 的零拷贝路径。关键改造包括：绕过内核协议栈，将网卡 DMA 区域直接映射至用户态 ring buffer；使用 IORING_OP_RECV_ZC 原子获取数据指针，避免内存复制；配合 XDP_REDIRECT 将匹配风控规则的报文在驱动层丢弃。实测端到端延迟从 32μs 降至 8.7μs（P99），GC 压力下降 92%。以下为关键代码片段：
struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
io_uring_prep_recv_zc(sqe, sockfd, NULL, 0, MSG_DONTWAIT, 0);
io_uring_sqe_set_data(sqe, &ctx);
io_uring_submit(&ring);
// 收到完成事件后，直接通过 ctx.zc_cookie 访问原始 DMA 缓冲区内存安全型内核模块的 Rust 实现路径
Linux 6.1+ 已支持 Rust 编写的内核模块。某存储团队将 NVMe 超时恢复逻辑从 C 迁移至 Rust，利用 #![no_std] 和 core::sync::atomic 构建无锁状态机。关键约束包括：所有 unsafe 块必须附带形式化注释（如 // INVARIANT: queue_lock held, q->state == Q_ACTIVE）；使用 BTreeMap<AtomicU64, Arc<Request>> 替代哈希表以规避内存重哈希导致的临时锁竞争。构建流程强制启用 rustc --deny warnings --deny unsafe_code（仅对白名单 extern "C" 接口豁免）。
运行时可信执行环境（TEE）的混合部署模型
某金融云平台采用 Intel TDX + AMD SEV-SNP 混合架构支撑跨厂商密钥管理服务。核心设计如下：
| 组件 | 执行环境 | 数据隔离机制 | 启动验证方式 |
|---|---|---|---|
| 密钥派生引擎 | TDX Guest | CPU 硬件加密内存页 | TDREPORT + PCR18 |
| 审计日志代理 | SEV-SNP VM | 加密 VM 内存+寄存器 | SNP_REPORT + CHIP_ID |
| API 网关 | Host Kernel | SELinux MLS 策略 | IMA 测量链 |
所有跨环境调用均通过 ioctl(TDX_CMD_SUBMIT) 或 vmgexit(SEV_SNP_EXIT) 触发硬件辅助的上下文切换，杜绝软件侧内存窥探。
eBPF 程序的生产级可观测性注入
在 Kubernetes DaemonSet 中部署 bpftrace + libbpfgo 混合方案：静态编译的 eBPF 字节码嵌入 Go Agent，通过 bpf_map__update_elem() 动态注入采样阈值。当检测到 tcp_retransmit_skb 调用频次超 500/s 时，自动触发 kprobe 捕获 TCP 头部及 skb->cb[0] 中的自定义标记字段。生成的火焰图显示，83% 的重传源于特定网卡驱动的 tx_timeout 回调中未清除 SKB_GSO_TCP_ECN 标志位。
硬件辅助虚拟化的内存页共享漏洞利用复现
基于 CVE-2023-28772 的 PoC，在 QEMU/KVM 环境中构造跨 VM 的 KVM_GET_PAGE_DIRTY_LOG 竞态：Guest A 在 mmap(MAP_SHARED) 区域写入敏感数据后立即 msync()；Guest B 在同一物理页帧上执行 KVM_CLEAR_DIRTY_LOG；通过 KVM_GET_DIRTY_LOG 读取被清零前的脏页位图，结合 pagemap 推导出 Guest A 的 ASLR 偏移。修复方案要求 KVM 在 KVM_CLEAR_DIRTY_LOG 期间持有 mmu_lock 并禁用页表项更新。
用户态文件系统（FUSE）的实时防勒索策略
某备份系统在 libfuse3 层实现 write() hook：当检测到连续 5 秒内单文件写入量 >2GB 且 open() 标志含 O_TRUNC 时，立即冻结该 inode 的 f_op->write_iter 函数指针，并向 SOC 平台推送 FILE_ENCRYPT_PATTERN_DETECTED 事件。策略配置通过 /sys/fs/fuse/leware/rules 接口热加载，支持正则匹配文件路径与进程 cgroup 路径。
