摘要
Linux内核内存管理分为两个层级:Buddy System负责物理页帧的分配与回收(以2的幂次大小的页块为单位),而Slab/Slub分配器在此之上构建了高效的对象级(object-level)分配机制。内核中数以万计的结构体——task_struct、file、dentry、inode、sk_buff——都通过Slab分配器创建和销毁。本文将深入剖析Slab分配器的三代演进(slab → slub → slob)、核心数据结构、对象生命周期管理、调试机制,并给出生产环境中的性能调优实战与排障方法论。
1. 为什么需要Slab分配器?
Buddy System以页(通常4KB)为最小分配单位。但内核中大量对象的尺寸远小于一页——task_struct约1.7KB,file约256B,dentry约192B。如果直接从Buddy System分配整页使用,会产生严重的内部碎片。
更微小的对象如果直接使用vmalloc或逐页分配,还会带来:
- 高昂的初始化开销:每个对象都需要执行完整的构造函数初始化
- 内存局部性差:散落在不同物理页上的对象导致缓存命中率低下
- 频繁的页表操作:每次分配都可能触发页表修改和TLB刷新
Slab分配器的核心思想是对象缓存池(Object Cache):从Buddy System获取整页内存后,将其切割为多个固定大小的对象槽位,放入空闲链表。分配时直接从链表取出已初始化的对象,释放时归还到链表而非归还页,避免重复构造/析构开销。
2. 三代分配器演进
2.1 第一代:SLAB(1994,Jeff Bonwick)
原创设计来自Solaris,Linux由Jeff Bonwick引入。核心数据结构:
kmem_cache (缓存描述符)
├─ slab_full (完全使用的slab链表)
├─ slab_partial (部分使用的slab链表)
└─ slab_free (完全空闲的slab链表)
每个slab:
├─ 一个或多个连续物理页
├─ 对象槽位数组
└─ 本地空闲链表(free list)
SLAB的复杂之处在于它不仅维护了三个链表,还包含着色区(coloring)、本地CPU缓存(kmem_cache.cpu_slab)等精细设计,导致代码路径冗长、锁争用严重。
2.2 第二代:SLUB(2007, Christoph Lameter)
SLUB(Unqueued Slab Allocator)是目前Linux默认的分配器,核心简化思路:
- 取消per-CPU的本地空闲链表,直接用单个链表管理所有空闲对象
- 将管理元数据嵌入页结构(
struct page中的freelist、inuse、objects字段) - 无队列(unqueue)概念:不再维护
slab_full、slab_partial、slab_free三个链表,只有一个node级别的partial链表 - 每个NUMA节点维护独立的partial链表,避免跨节点锁争用
SLUB的数据结构大幅简化:
struct kmem_cache {
struct kmem_cache_cpu *cpu_slab; // per-CPU快速路径
unsigned long flags;
unsigned int size; // 对象实际大小
unsigned int object_size; // 原始请求大小
unsigned int offset; // 空闲指针偏移
struct kmem_cache_node *node[MAX_NUMNODES]; // 各NUMA节点
};
struct kmem_cache_cpu {
void **freelist; // 空闲对象链表头
unsigned long tid; // 版本号,防止ABA问题
struct page *page; // 当前正在使用的slab页
};
struct kmem_cache_node {
spinlock_t list_lock;
unsigned long nr_partial;
struct list_head partial; // 部分空闲slab链表
};
2.3 第三代的探索:SLOB(SLOppy allocator)
SLOB是最简单的分配器,用首次适应(first-fit)算法管理内存,专门针对嵌入式等极小内存场景。它没有per-object metadata,直接将链表嵌入空闲内存区域本身。由于其碎片化严重、性能差,在大多数场景下已被SLUB取代。
| 特性 | SLAB | SLUB | SLOB |
|---|---|---|---|
| 默认分配器(2.6.23前) | ✅ | — | — |
| 默认分配器(2.6.23后) | — | ✅ | — |
| NUMA感知 | 中 | 强 | 弱 |
| 代码复杂度 | 高 | 中 | 极低 |
| 内存开销 | 高 | 中 | 最低 |
| 适用场景 | 已废弃 | 通用/服务器 | 嵌入式 |
3. SLUB核心数据结构与分配流程
3.1 对象在内存中的布局
一个SLUB管理的slab页,典型内存布局如下:
┌────────────────────────────────────────────┐
│ struct page 头部 │
│ freelist | inuse | objects | ... │
├────────────────────────────────────────────┤
│ [Slot 0] [Slot 1] [Slot 2] ... [Slot N] │
│ 空闲指针 空闲指针 已分配 空闲指针 │
├────────────────────────────────────────────┤
│ Red Zone (调试模式) │
├────────────────────────────────────────────┤
│ Padding / Coloring │
└────────────────────────────────────────────┘
关键设计要点:
- 空闲对象内嵌指针:当一个对象槽位空闲时,其前
sizeof(void *)字节存储指向下一个空闲对象的指针,与Linux内核的list机制异曲同工 - 着色(Cache Coloring):在不同slab之间引入偏移量,使得对象的起始地址在Cache Line上对齐到不同位置,减少Cache Line冲突
- Red Zone:在对象边界外添加不可访问区域,捕捉越界写操作
3.2 分配路径(快速路径 vs 慢速路径)
kmem_cache_alloc(cache)
│
▼
┌─────────────────────────────┐
│ CPU快速路径(无锁) │
│ 1. 读取 cpu_slab->freelist │
│ 2. 取出一个空闲对象 │
│ 3. 更新 freelist │
│ 4. 成功 → 返回 │
└──────────┬──────────────────┘
│ freelist 为空
▼
┌─────────────────────────────┐
│ 从 node->partial 链表获取 │
│ 一个部分空闲的slab │
│ → 设为 cpu_slab->page │
│ → 重试快速路径 │
└──────────┬──────────────────┘
│ partial 为空
▼
┌─────────────────────────────┐
│ 慢速路径:向Buddy System │
│ 申请新页(alloc_pages) │
│ → 初始化slab头 │
│ → 构建空闲链表 │
│ → 返回对象 │
└─────────────────────────────┘
核心优化在于:热路径完全无锁,只有当需要切换到新slab或向Buddy System申请页时才会触发锁争用。这在高频分配场景下(如网络收发包每秒百万次)至关重要。
3.3 释放路径
kmem_cache_free(cache, obj)
│
▼
┌─────────────────────────────┐
│ 1. 设置 obj 前8字节为 next │
│ 指向当前 freelist │
│ 2. freelist = obj │
│ 3. inuse-- │
└──────────┬────────────────────┘
│ slab从partial变为完全空闲
▼
┌─────────────────────────────┐
│ 是否归还页给Buddy System? │
│ 取决于 node->min_partial │
│ 和系统内存压力 │
└─────────────────────────────┘
不完全归还策略:SLUB不会在slab变为空闲时立刻归还页面给Buddy System(除非内存紧张),而是维持在node->partial链表中。这样做是因为重新申请页并初始化的开销远大于保留。
4. SLAB缓存的创建与层次
4.1 专用缓存 vs 通用缓存
内核中的对象分配有两个层次:
专用缓存(Size-Specific Cache):通过kmem_cache_create()为特定结构体类型创建,大小精确匹配:
// 内核初始化时的例子
vm_area_cachep = kmem_cache_create("vm_area_struct",
sizeof(struct vm_area_struct),
0, SLAB_HWCACHE_ALIGN, NULL);
files_cachep = kmem_cache_create("files_cache",
sizeof(struct files_struct),
0, SLAB_HWCACHE_ALIGN, NULL);
signal_cachep = kmem_cache_create("signal_cache",
sizeof(struct signal_struct),
0, SLAB_HWCACHE_ALIGN, NULL);
通用缓存(Size Cache / kmalloc Caches):对于不固定大小的小内存分配请求,SLUB维护了一组等比数列排列的通用缓存,覆盖从8B到8KB范围:
kmalloc-8, kmalloc-16, kmalloc-32, kmalloc-64,
kmalloc-96, kmalloc-128, kmalloc-192, kmalloc-256,
kmalloc-512, kmalloc-1024, kmalloc-1536, kmalloc-2048,
kmalloc-3072, kmalloc-4096(常规上限), ...
kmalloc()的实现就是根据请求大小向上取整到对应缓存,然后调用kmem_cache_alloc()。
4.2 两类缓存的关系图
┌───────────────────┐
│ kmalloc() │ 通用内存分配接口
└────────┬──────────┘
│ 按大小路由
┌────────────────────┼────────────────────┐
▼ ▼ ▼
┌───────────┐ ┌───────────┐ ┌───────────────┐
│kmalloc-64 │ │kmalloc-256│ │kmalloc-4096 │
│ kmem_cache│ │ kmem_cache│ │ kmem_cache │
└─────┬─────┘ └─────┬─────┘ └──────┬────────┘
│ │ │
└──────────────────┼────────────────────┘
▼
┌───────────────┐
│ alloc_pages() │ ← 从 Buddy System 获取页
│ __get_free_pages│
└───────┬───────┘
▼
┌───────────────┐
│ Buddy System │ ← 物理页帧分配器
│ (物理内存管理) │
└───────────────┘
5. SLAB调试机制(SLAB_DEBUG)
SLAB分配器内置了业界领先的内存调试能力,几乎是检测内存越界、UAF(释放后重用)和未初始化使用的最佳工具。
5.1 核心调试选项
在创建缓存时通过flags启用,或全局开启slab_debug:
| 选项 | 作用 |
|---|---|
SLAB_RED_ZONE |
在对象两侧填充特殊魔术字,捕获越界访问 |
SLAB_POISON |
释放时用0x5a/0xa5填充对象内存,捕获UAF和未初始化使用 |
SLAB_HWCACHE_ALIGN |
对象按Cache Line对齐,消除伪共享 |
SLAB_CACHE_DMA |
从DMA区域分配,保证物理地址在DMA范围内 |
SLAB_STORE_USER |
记录分配/释放时的调用栈,精确定位泄漏源头 |
5.2 Red Zone检测原理
┌──────────┬──────────────────┬──────────┐
│ Red Zone │ 对象实际 │ Red Zone │
│ 64字节 │ 数据区域 │ 64字节 │
│ 0x12345678│ │ 0x87654321│
└──────────┴──────────────────┴──────────┘
↑ ↑
写越界从这里开始 写越界从这里开始
释放时检查此魔术字 释放时检查此魔术字
当释放对象时,若发现Red Zone的魔术字已被修改,内核立即打印调用栈定位越界写入的位置。
5.3 Poison机制
释放时填充的有意义模式:
分配时:对象内存 = 0x5a5a5a5a (分配后未初始化使用)
释放后:对象内存 = 0x6b6b6b6b (释放后重用会读到这个模式)
在内核代码中使用/*. poison = 0x6b, */关键字,通过查看include/linux/poison.h定义:
#define POISON_FREE 0x6b /* 已释放的内存 */
#define POISON_INUSE 0x5a /* 分配后未初始化 */
#define POISON_DEAD 0xde /* 双重释放检测 */
6. 生产环境调优实战
6.1 关键可调参数
通过/sys/kernel/slab/<cache>/下的文件进行运行时调优:
# 查看每个缓存的基本统计
cat /proc/slabinfo
# 关键参数:
# -`limit`: 每个node的partial链表最多保留的slab数量(超出则归还Buddy)
# -`batchcount`: per-CPU批量搬运的对象数
# -`shared`: 跨CPU共享的空闲对象数
/proc/slabinfo输出示例:
slabinfo - version: 2.1
# name <active_objs> <num_objs> <objsize> <objperslab> <pagesperslab> : ...
kmalloc-256 28456 32768 256 16 1 : ...
dentry 18932 20480 192 21 1 : ...
vm_area_struct 4096 4096 208 19 1 : ...
task_struct 512 512 6272 1 2 : ...
各字段含义:
active_objs:当前已分配出去的对象数num_objs:该缓存中对象总容量(= active_objs + 空闲数)objsize:单个对象实际包含元数据的大小objperslab:每个slab页可放多少个对象<num_objs> - <active_objs>= 碎片化的空闲对象数
6.2 调优案例:高并发网络服务Cache抖动
现象:某HTTP网关在100Gbps网络吞吐下,延迟P99从50μs飙升至800μs。
排查过程:
- 通过
slabtop观察到kmalloc-256和skbuff_fclone_cache的ACTIVE率持续在95%+ - 进一步通过
perf采样发现热点在kmem_cache_alloc的慢速路径(需要向Buddy System申请新页) - CAT(Cache Allocation Technology)监控显示LLC miss率异常高
根因:skbuff_fclone_cache的对象分配过于集中,导致SLUB的partial链表频繁耗尽,每次分配都要走慢速路径。同时大量对象分散在不同slab页上,Cache Line利用率低。
解决方案:
# 方案1:增大分配器的slab预取数量
echo 64 > /sys/kernel/slab/skbuff_fclone_cache/cpu_partial
# 方案2:确保应用层使用SO_REUSEPORT分担socket pressure
# 方案3:在NUMA场景下,确保应用线程本地分配
echo 1 > /proc/sys/kernel/numa_balancing # 开启NUMA自动均衡
效果:P99延迟回落至80μs以下,cpu_partial调整后partial链表保留更多slab,分配命中率提升40%。
6.3 调优案例:内存泄漏检测
现象:系统在持续运行72小时后,可用内存从64GB降至8GB,但free显示buffers/cache也在减少,说明非页缓存问题。
排查:
# 1. 通过/proc/slabinfo找到持续增长的对象
watch -n 60 'cat /proc/slabinfo | sort -k3 -n | tail'
# 2. 发现`kmalloc-128`的`num_objs`从12000持续增长到890000
# 3. 使用slab_debug追踪泄漏源
echo 1 > /sys/kernel/slab/kmalloc-128/store_user
echo 1 > /sys/kernel/slab/kmalloc-128/poison
# 4. 等待5分钟后抓取分配栈
cat /sys/kernel/slab/kmalloc-128/trace
根因追踪:通过/sys/kernel/slab/kmalloc-128/trace输出的alloc调用栈,定位到某个内核模块的定时器回调中反复kmalloc(128, GFP_KERNEL)但忘记kfree。
7. 自定义SLAB缓存:内核模块开发实战
当编写需要频繁分配特定结构体的内核模块时,创建自己的缓存是最佳实践:
#include <linux/slab.h>
struct my_struct {
u64 id;
char name[64];
struct list_head list;
atomic_t refcnt;
u8 data[128];
};
static struct kmem_cache *my_cache;
static int __init my_init(void)
{
/* 创建专用缓存,按Cache Line对齐 */
my_cache = kmem_cache_create("my_struct_cache",
sizeof(struct my_struct),
L1_CACHE_BYTES,
SLAB_HWCACHE_ALIGN | SLAB_POISON | SLAB_RED_ZONE,
NULL);
if (!my_cache)
return -ENOMEM;
pr_info("Created slab cache ob_size=%u, align=%u\n",
my_cache->size, my_cache->align);
return 0;
}
static void __exit my_exit(void)
{
kmem_cache_destroy(my_cache);
}
/* 使用示例 */
struct my_struct *obj = kmem_cache_alloc(my_cache, GFP_KERNEL);
if (obj) {
atomic_set(&obj->refcnt, 1);
/* ... 使用 ... */
kmem_cache_free(my_cache, obj);
}
module_init(my_init);
module_exit(my_exit);
关键注意事项:
- 已销毁缓存不能继续释放对象(会导致use-after-free的程度更深)
GFP_ATOMIC在上下文中分配不能失败时要小心kmem_cache_destroy()会检查是否有未归还的对象,若有则打印泄漏警告
8. 内核SLAB与用户态分配器的交叉对比
了解SLAB机制有助于理解为什么用户态内存分配器在现代场景中逐渐超越glibc malloc:
| 维度 | SLUB(内核) | glibc malloc(用户态) | tcmalloc(Google) |
|---|---|---|---|
| 粒度 | 对象级+页级 | 块划分 | ThreadCache+PageHeap |
| per-CPU缓存 | ✅ cpu_slab | ❌ 全局锁 | ✅ ThreadCache |
| 无锁快速路径 | ✅ | ❌ | ✅ |
| 碎片控制 | 优秀(着色对齐) | 中等(ptmalloc bins) | 优秀(span-based) |
| 调试能力 | 最强 | AddressSanitizer | AddressSanitizer |
| NUMA感知 | ✅ | ✅ NUMA-aware arena | 有限 |
| 分配大小范围 | 数百B ~ 8KB | 任意 | 小中对象 |
用户态高性能分配器(tcmalloc/jemalloc)本质上借鉴了SLUB的设计哲学——per-CPU无锁快速路径 + 中央缓存层 + 页级分配,但在per-thread缓存策略和碎片整理算法上做了更多创新。
9. 常见陷阱与最佳实践
9.1 陷阱:在错误上下文使用GFP_KERNEL
GFP_KERNEL允许睡眠等待Buddy System释放内存。在硬中断上下文、自旋锁持有期间使用会导致系统崩溃甚至死锁。正确选择:
- 进程上下文,可以睡眠 →
GFP_KERNEL - 中断上下文或持有自旋锁 →
GFP_ATOMIC - I/O路径不允许失败 →
GFP_NOIO - 文件系统不允许递归I/O →
GFP_NOFS
9.2 陷阱:kfree(NULL)安全,但kmem_cache_free(cache, NULL)危险
kfree()对NULL指针是no-op,但kmem_cache_free()对其不保证——传入NULL会直接导致解引用空指针crash。
9.3 陷阱:重复创建缓存
同一结构体类型不应在不同代码路径中创建多个kmem_cache实例。正确做法是在统一的内核初始化阶段创建全局缓存指针(如task_struct_cachep、vm_area_cachep),所有调用者共享。
9.4 调试最佳实践组合
# 开启全局slab调试
slab_debug=FPZ # F=StoreUser, P=Poison, Z=RedZone
# 运行时监控增长
watch -n 5 'cat /proc/slabinfo | awk "\$2-\$1 > 1000 {print}"'
# 用slabtop实时观察
slabtop -o --sort=c
10. 总结与展望
Slab/Slub分配器作为Linux内核内存管理体系的核心支柱,通过三层抽象(Buddy System → Slab页切割 → 对象缓存池)实现了极致的小对象分配性能。其设计哲学——per-CPU无锁快速路径 + 批量页级管理 + 对象着色对齐——不仅服务于内核,也深刻影响了用户态高性能分配器的架构方向。
随着Linux内核持续演进,SLUB也在不断增强:
CONFIG_SLUB_DEBUG成为默认开启项,强化运行时检测CONFIG_SLUB_MEMCG支持内存cgroup级别的缓存统计与限制- Folio机制(5.16+)在页管理层革新,间接影响Slab的页获取路径
- Rust for Linux 引入新的分配器接口,探索类型安全的Slab包装
掌握Slab分配器的原理与调优,不仅是深入 Linux 内核工程的必经之路,也是理解现代系统级程序员必须驾驭的内存管理范式。
延伸阅读推荐:
- Understanding the Linux Virtual Memory Manager, Chapter 11
- LWN: The SLUB allocator
- kernel docs: slab allocator
- Robert Love — "Linux Kernel Development" 第11章

发表评论 取消回复