摘要

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。

排查过程:

  1. 通过slabtop观察到kmalloc-256和skbuff_fclone_cache的ACTIVE率持续在95%+
  2. 进一步通过perf采样发现热点在kmem_cache_alloc的慢速路径(需要向Buddy System申请新页)
  3. 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 内核工程的必经之路,也是理解现代系统级程序员必须驾驭的内存管理范式。


延伸阅读推荐:

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论
立即
投稿

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部