问题                          SLUB 的解法
──────────────────────────────────────────────────────────────
1. 粒度过粗: 对象 128B,        slab = 1..N 页的"容器",
   最小供货 4KB → 平均浪费      内切 N 个等大对象,
   94% 以上 (若整页单对象)      零售粒度 = 对象大小
2. 初始化重复: 释放/再分配      ctor 构造函数 + SLAB_TYPESAFE_BY_RCU
   间对象状态可复用             (不清零、不重构造, 只重声明)
3. 局部性差: 相邻分配落点      分配点集中在 per-CPU 捆上,
   随机散布于物理内存           同 CPU 热对象物理相邻

一次 dentry 创建销毁的两种命运:

 无对象缓存:                     有 SLUB:
 alloc_pages(1)  ~1μs+          kmem_cache_alloc(dentry_cache)
 填充初始化 4096B                 └─ main 捆弹出 ~20ns
 用 128B                          (对象在 CPU 缓存 L1 里, 热!)
 释放 → 整页回 buddy             kmem_cache_free → 入捆 ~20ns
 (冷页, TLB miss, 后续         ( freed 状态保留初始化,
  再分配是冷的)                   d_revalidate 等字段天然复用)

SLAB 的对象布局与三链 (回忆图):

 kmem_cache
   ├─ arrays[cpu]: 每 CPU 数组缓存 (热对象)
   └─ slabs 链:    slabs_full / slabs_partial / slabs_free
        slab: [slab_head][obj0][obj1]...[objN]
              (着色偏移使 obj0 落在不同 cache line)

SLOB 的碎片恶化示意:

 初始: [128B][128B][128B][128B][128B][128B]  (一个 768B 块)
 分配 A(256B): 首选适应切前两格
 分配 B(128B): 切第三格
 释放 A:       两格空洞 — 小于任何后续请求 → 永久浪费
 时间演化: 碎片率单调上升, 无凝聚机制 (buddy 的
   伙伴合并思想完全缺席)

SLUB 的两个原始招式 (6.x 时代形态):

1. 对象即链表节点: freelist 指针直接藏在空闲对象体内
   (21.5 节将看到 7.0 甚至把它藏进对象"中点"防溢出)
2. slab 即 page: struct slab 复用 struct page 的位布局
   (本树 mm/slab.h:74-99 + SLAB_MATCH 断言 :100-112)
   → 无需独立元数据分配, 18.4 节的 page 数组直接可用

每 CPU 缓存演进:
  6.x 及以前: cpu_slab->freelist/tid 单链指针
    分配 = 弹出 freelist 头 (一条 CAS)
  7.0 (本树): cpu_sheaves 成捆对象数组
    分配 = main->objects[--size]  (数组栈顶弹出, 连 CAS 都省)
    (slub.c:420-425 struct slub_percpu_sheaves)

三代 per-CPU 快路径的成本对比 (分配一次):

 SLAB:  数组缓存弹出 + 引用计数 + 可能的 batch 补货
 SLOB:  空闲链首选适应搜索 (O(碎片数))
 SLUB 旧: freelist 指针 CAS 弹出 (一条原子指令)
 SLUB 7.0: objects[--size]        (数组下标减一, 无原子!)
          (local_trylock 失败才走慢路径 —
           21.3.2 节 alloc_from_pcs)

// mm/slab.h:274-277（要点）
static inline bool cache_has_sheaves(struct kmem_cache *s)
{
    /* Test CONFIG_SLUB_TINY for code elimination purposes */
    return !IS_ENABLED(CONFIG_SLUB_TINY) && s->sheaf_capacity;
}

// mm/slab.h:197-265（节选, 保留关键注释）
struct kmem_cache {
    struct slub_percpu_sheaves __percpu *cpu_sheaves;   /* :199 每 CPU 捆 */
    /* Used for retrieving partial slabs, etc. */
    slab_flags_t flags;
    unsigned long min_partial;      /* 节点至少保留的 partial slab 数 */
    unsigned int size;      /* Object size including metadata */
    unsigned int object_size;   /* Object size without metadata */
    struct reciprocal_size; /* reciprocal_value: 除法换倒数乘法 */
    unsigned int offset;        /* Free pointer offset */
    unsigned int sheaf_capacity;    /* 每捆对象数 */
    struct kmem_cache_order_objects oo; /* 理想: 一 slab 的阶×对象数 */
    ...
    void (*ctor)(void *object); /* 对象构造函数 */
    unsigned int inuse;     /* Offset to metadata */
    unsigned int align;     /* Alignment */
    unsigned int red_left_pad;  /* Left redzone padding size */
    const char *name;       /* Name (only for display!) */
    struct list_head list;      /* 挂入 slab_caches 全链 */
    ...
#ifdef CONFIG_SLAB_FREELIST_HARDENED
    unsigned long random;       /* freelist 混淆密钥 (21.5 节) */
#endif
#ifdef CONFIG_SLAB_FREELIST_RANDOM
    unsigned int *random_seq;   /* 对象序随机排列 (21.5 节) */
#endif
    ...
    struct kmem_cache_node *node[MAX_NUMNODES]; /* :265 节点级 partial */
};

// mm/slab.h:74-99（节选）
/* Reuses the bits in struct page */
struct slab {
    memdesc_flags_t flags;

    struct kmem_cache *slab_cache;
    union {
        struct {
            struct list_head slab_list; /* partial 链节点 */
            /* Double-word boundary */
            struct freelist_counters;   /* 并发 freelist 计数 */
        };
        struct rcu_head rcu_head;
    };

    unsigned int __page_type;
    atomic_t __page_refcount;
#ifdef CONFIG_SLAB_OBJ_EXT
    unsigned long obj_exts;     /* 对象级扩展(memcg/kasan) */
#endif
};

#define SLAB_MATCH(pg, sl)                      \
    static_assert(offsetof(struct page, pg) == offsetof(struct slab, sl))
SLAB_MATCH(flags, flags);
SLAB_MATCH(compound_head, slab_cache);  /* Ensure bit 0 is clear */
SLAB_MATCH(_refcount, __page_refcount);
...
static_assert(sizeof(struct slab) <= sizeof(struct page));  /* :112 */

// mm/slub.c:396-425
struct node_barn {          /* :396 节点级捆池 */
    spinlock_t lock;
    struct list_head sheaves_full;
    struct list_head sheaves_empty;
    unsigned int nr_full;
    unsigned int nr_empty;
};

struct slab_sheaf {         /* :407 */
    union {
        struct rcu_head rcu_head;
        struct list_head barn_list;
        /* only used for prefilled sheafs */
        struct { unsigned int capacity; bool pfmemalloc; };
    };
    struct kmem_cache *cache;
    unsigned int size;      /* 当前已存对象数 */
    int node; /* only used for rcu_sheaf */
    void *objects[];        /* 柔性数组: 对象指针栈 */
};

struct slub_percpu_sheaves {        /* :420 */
    local_trylock_t lock;
    struct slab_sheaf *main; /* never NULL when unlocked */
    struct slab_sheaf *spare; /* empty or full, may be NULL */
    struct slab_sheaf *rcu_free; /* for batching kfree_rcu() */
};

7.0 SLUB 三级对象缓存:

 [per-CPU]  pcs->main   满/部分满的捆  ←分配/释放的主战场(无锁 trylock)
            pcs->spare  空捆或满捆    ← main 空了换 spare, 满了换 spare
            pcs->rcu_free  批量 kfree_rcu 缓冲
                │ main 空 & spare 空/满时
                v
 [节点]     node->barn  空捆池+满捆池    ← per-CPU 捆的补给站(自旋锁)
                │ barn 空时
                v
 [节点]     node->partial  半空 slab 链  ← 从 slab 里现切对象
                │ partial 空时
                v
 [伙伴系统]  new_slab() → alloc_frozen_pages()  ← 批发整页

// mm/slub.c:7665（节选）
static int calculate_sizes(struct kmem_cache_args *args, struct kmem_cache *s)
{
    unsigned int size = s->object_size;
    ...
    size = ALIGN(size, sizeof(void *));     /* 字对齐 */
    ...
    s->inuse = size;            /* :7705 对象+redzone 的边界 */

    if (((flags & SLAB_TYPESAFE_BY_RCU) && !args->use_freeptr_offset) ||
        (flags & SLAB_POISON) || (s->ctor && ...) || ...) {
        s->offset = size;       /* freelist 槽放对象尾后 */
        size += sizeof(void *);
    } else if (...) {
        s->offset = args->freeptr_offset;   /* 调用者指定 */
    } else {
        /*
         * Store freelist pointer near middle of object to keep
         * it away from the edges of the object to avoid small
         * sized over/underflows from neighboring allocations.
         */
        s->offset = ALIGN_DOWN(s->object_size / 2, sizeof(void *)); /* :7735 */
    }
    ...
    if (flags & SLAB_STORE_USER) {      /* :7744 泄漏跟踪 */
        size += 2 * sizeof(struct track);
        ...
    }
    ...
    if (flags & SLAB_RED_ZONE) {        /* :7765 左 redzone 填充 */
        ...
        s->red_left_pad = sizeof(void *);
        s->red_left_pad = ALIGN(s->red_left_pad, s->align);
        size += s->red_left_pad;
    }
    /* 此后: 按 align 对齐 size, 用 calculate_order() 选 oo 阶 */
}

典型对象布局 (无调试, 100B 请求):

offset 0                    50      100        112
       ┌────────────────────┬──┬──────┬─────┐
       │   对象可用空间       │FP│ pad  │     │   FP = freelist 槽
       └────────────────────┴──┴──────┴─────┘        藏在对象中点(:7735)
       <─── object_size ──>        <── s->size = 112 ──>
       注: freeptr_outside_object()(slub.c:552) 的判别即 offset >= inuse

带调试布局 (STORE_USER+RED_ZONE):
       ┌─────┬──────────────┬─────┬────────┬────────┬──────┐
       │L-red│    对象       │R-red│ track A│ track F│ kmreq │
       └─────┴──────────────┴─────┴────────┴────────┴──────┘
        red_left_pad (:7765)   alloc/free 轨迹   原始请求大小

// mm/slub.c:4837-4869（节选）
static __fastpath_inline void *slab_alloc_node(struct kmem_cache *s, struct list_lru *lru,
        gfp_t gfpflags, int node, unsigned long addr, size_t orig_size)
{
    void *object;
    bool init = false;

    s = slab_pre_alloc_hook(s, gfpflags);       /* memcg/kasan 前钩 */
    if (unlikely(!s))
        return NULL;

    object = kfence_alloc(s, orig_size, gfpflags);  /* :4847 kfence 拦截池 */
    if (unlikely(object))
        goto out;

    object = alloc_from_pcs(s, gfpflags, node); /* :4850 快路径 */

    if (!object)
        object = __slab_alloc_node(s, gfpflags, node, addr, orig_size); /* :4852 */

    maybe_wipe_obj_freeptr(s, object);      /* init_on_alloc 配合 */
    init = slab_want_init_on_alloc(gfpflags, s);
out:
    slab_post_alloc_hook(s, lru, gfpflags, 1, &object, init, orig_size);
    return object;
}

// mm/slub.c:4871-4880
void *kmem_cache_alloc_noprof(struct kmem_cache *s, gfp_t gfpflags)
{
    void *ret = slab_alloc_node(s, NULL, gfpflags, NUMA_NO_NODE, _RET_IP_,
                    s->object_size);
    trace_kmem_cache_alloc(_RET_IP_, ret, s, gfpflags, NUMA_NO_NODE);
    return ret;
}
EXPORT_SYMBOL(kmem_cache_alloc_noprof);

// mm/slub.c:4668-4753（节选）
static __fastpath_inline
void *alloc_from_pcs(struct kmem_cache *s, gfp_t gfp, int node)
{
    ...
    node_requested = IS_ENABLED(CONFIG_NUMA) && node != NUMA_NO_NODE;
    if (unlikely(node_requested && node != numa_mem_id())) {
        stat(s, ALLOC_NODE_MISMATCH);
        return NULL;            /* 跨节点请求不碰本地捆 */
    }

    if (!local_trylock(&s->cpu_sheaves->lock))
        return NULL;            /* 捆被占(中断中): 立即让路 */

    pcs = this_cpu_ptr(s->cpu_sheaves);

    if (unlikely(pcs->main->size == 0)) {       /* main 捆空 */
        pcs = __pcs_replace_empty_main(s, pcs, gfp);
        if (unlikely(!pcs))
            return NULL;
    }

    object = pcs->main->objects[pcs->main->size - 1];   /* 栈顶对象 */

    if (unlikely(node_requested)) {
        /* CPU 迁移窗口: 对象可能来自别的节点, 校验 */
        if (page_to_nid(virt_to_page(object)) != node) {
            local_unlock(&s->cpu_sheaves->lock);
            stat(s, ALLOC_NODE_MISMATCH);
            return NULL;
        }
    }

    pcs->main->size--;

    local_unlock(&s->cpu_sheaves->lock);

    stat(s, ALLOC_FASTPATH);

    return object;
}

// mm/slub.c:4374-4451（节选, 保留三级策略注释）
static void *___slab_alloc(struct kmem_cache *s, gfp_t gfpflags, int node,
               unsigned long addr, unsigned int orig_size)
{
    ...
new_objects:
    pc.flags = gfpflags;
    /*
     * 指定了首选节点且无 __GFP_THISNODE 时:
     * 1) 先只对目标节点找 partial (给 pc.flags 加 __GFP_THISNODE)
     * 2) 失败则以 NOWAIT|THISNODE 试图在目标节点开新 slab
     * 3) 再失败: 恢复原始 gfp, 允许扫其他节点 partial / 他节点进货
     */
    if (unlikely(node != NUMA_NO_NODE && !(gfpflags & __GFP_THISNODE)
             && try_thisnode)) {
        ...
        pc.flags = GFP_NOWAIT | __GFP_THISNODE;
    }

    pc.orig_size = orig_size;
    object = get_from_partial(s, node, &pc);    /* 局部链取对象 :4416 */
    if (object)
        goto success;

    slab = new_slab(s, pc.flags, node);     /* 批发新页 :4421 */

    if (unlikely(!slab)) {
        if (node != NUMA_NO_NODE && !(gfpflags & __GFP_THISNODE)
            && try_thisnode) {
            try_thisnode = false;
            goto new_objects;   /* 放宽节点限制重跑 */
        }
        slab_out_of_memory(s, gfpflags, node);
        return NULL;
    }
    ...
    alloc_from_new_slab(s, slab, &object, 1, allow_spin);
    ...
success:
    if (kmem_cache_debug_flags(s, SLAB_STORE_USER))
        set_track(s, object, TRACK_ALLOC, addr, gfpflags);
    return object;
}

分配全链路汇总 (无调试、命中快路径为 1 步):

 kmem_cache_alloc(s)
  └─ slab_alloc_node()                    slub.c:4837
      ├─ kfence_alloc 采样改道             :4847
      ├─ alloc_from_pcs                   :4668
      │   ├─ trylock 失败 → 让路慢路径
      │   ├─ main 空 → __pcs_replace_empty_main (spare/barn/切 slab)
      │   └─ objects[--size]  ← 命中: 全程 ~20 条指令
      └─ __slab_alloc_node → ___slab_alloc  :4453; :4374
          ├─ get_from_partial (本节点 → 他节点)
          ├─ new_slab → alloc_frozen_pages (伙伴系统, 18.3)
          └─ slab_out_of_memory 报警

// mm/slub.c:5768-5788（节选）
bool free_to_pcs(struct kmem_cache *s, void *object, bool allow_spin)
{
    struct slub_percpu_sheaves;

    if (!local_trylock(&s->cpu_sheaves->lock))
        return false;           /* 同快路径让路策略 */

    pcs = this_cpu_ptr(s->cpu_sheaves);

    if (unlikely(pcs->main->size == s->sheaf_capacity)) {
        pcs = __pcs_replace_full_main(s, pcs, allow_spin);
        if (unlikely(!pcs))
            return false;       /* 满捆无处安放: 走慢路径 */
    }

    pcs->main->objects[pcs->main->size++] = object; /* 栈顶压入 */

    local_unlock(&s->cpu_sheaves->lock);

    stat(s, FREE_FASTPATH);

    return true;
}

// mm/slub.c:5474（要点）
static void __slab_free(struct kmem_cache *s, struct slab *slab,
            void *head, void *tail, int cnt,
            unsigned long addr)
{
    ...
    do {
        /* CAS: 把 [head..tail] 插回 slab 的 freelist 头 */
    } while (!slab_update_freelist(s, slab, &old, &new, "__slab_free"));    /* :5528 */

    /* slab 从 full → partial 的转换点:
       这里检查 was_full, 把 slab 挂上 node->partial 链,
       并按 min_partial 决定是否留仓 (21.4 节) */
}

// mm/slab_common.c:785
    if (size && size <= KMALLOC_MAX_CACHE_SIZE) {
        /* 走通用档 kmem_cache */

一次典型的"消耗-补货"循环 (capacity = 32):

 main 捆消耗           __pcs_replace_empty_main() 的补给顺序
 ┌─────────┐
 │#### ▓   │ main 空  ──┬─ 1. spare 满? 交换 main<->spare   (零成本)
 └─────────┘            ├─ 2. barn 满捆池有货? 取一捆      (自旋锁+链摘)
                        ├─ 3. 从 partial slab 现切一捆    (slab 锁)
                        └─ 4. 开新 slab 批发后灌满一捆

 释放侧对称:
 main 满 ──┬─ 1. spare 空? 满捆挪去 spare
           ├─ 2. barn 空捆池有空位? 满捆存入 (换出空捆)
           └─ 3. barn 满? 整捆对象退回各 slab (__sheaf_... / __slab_free)

 main/spare/barn 的库存视角:

 per-CPU:  main[██──]  spare[████]  ← 零成本互转
                    ↕ (捆为粒度的流量)
 node barn: full 池 [捆][捆]   empty 池 [捆][捆]
                    ↕ (满捆吸收/供给)
 slabs:     partial [s1 半空][s2 半空]  ← min_partial 保底

// mm/slub.c:428-438
struct kmem_cache_node {
    spinlock_t list_lock;
    unsigned long nr_partial;
    struct list_head partial;       /* 半空 slab 链 */
#ifdef CONFIG_SLUB_DEBUG
    atomic_long_t nr_slabs;
    atomic_long_t total_objects;
    struct list_head full;
#endif
    struct node_barn *barn;         /* :437 捆池 */
};

半空 slab 的生命周期状态机:

   新 slab 进货           最后一个对象被取走
  ┌──────────┐  ──────>  ┌──────────┐  ──────>  ┌──────┐
  │  EMPTY   │           │ PARTIAL  │           │ FULL │
  │ (刚批发)  │  <──────  │ (在链上)  │  <──────  │(离链) │
  └──────────┘  放回对象   └──────────┘  放回对象  └──────┘
       │            首个对象        ^   释放首个对象       │
       │ 无人认领(高水位退页)         │                    │
       v                          │                    │
   还给伙伴系统 ────────────────────┘    min_partial 保底 ←┘

// mm/slub.c:5790（节选）
static void rcu_free_sheaf(struct rcu_head *head)
{
    sheaf = container_of(head, struct slab_sheaf, rcu_head);
    s = sheaf->cache;
    ...
    if (__rcu_free_sheaf_prepare(s, sheaf))     /* 解钩(含调试过滤) */
        goto flush;
    n = get_node(s, sheaf->node);
    ...
    /* 满捆直接存回 barn 满捆池: 对象一次都不落 slab */
}

观测入口:

 /proc/slabinfo        每缓存: 活跃对象/总数, slab 数, 阶
 /sys/kernel/slab/<c>/  order, objects, partial, cpu_sheaves...
   alias 子目录         合并别名缓存共享同一仓库 (21.1 节)

调参入口:

 slub_debug=KPZ,...    启动参数开调试区(红区/毒化/trace)
 min_partial (sysfs)   节点保底半空 slab 数
 slab_merge/nomerge    控制同规格缓存合并 (slab_common.c:60)
 sheaf_capacity        捆容量 (auto: 按对象大小与缓存行折算)

 碎片恶化的典型信号:
 slabinfo 里 "对象总数高而 active 占比低"
 → 大量半空 slab 驻留。治理顺序:
   [1] 查泄漏 (STORE_USER 定位分配点, 21.5.3)
   [2] 评估 min_partial 水位
   [3] cgroup 场景查 memory.kmem 绑死
       (slab 无法跨 cgroup 复用 = 伪碎片, 12 章)

一次 1 万次 alloc/free 脉冲的分流估算 (capacity=32, 4 CPU):

 10000 次分配
   ├─ ~9700 次: main 捆命中 (数组弹出, ~20ns)   ← 97%
   ├─ ~250 次: 触发补给 (每次搬 32 个) —
   │           大半由 spare/barn 承接 (捆粒度)
   └─ ~50 次: 穿透到 partial/新 slab (批发生意)
 对比无捆设计: ~10000 次都碰 freelist CAS,
   争用同一缓存行 — 多核扩展性差一个数量级

 慢路径成本 ÷ 捆容量 = 摊薄后的单次成本
 这就是"捆"存在的全部数学

// mm/slub.c:494-524（节选）
/*
 * Returns freelist pointer (ptr). With hardening, this is obfuscated
 * with an XOR of the address where the pointer is held and a per-cache
 * random number.
 */
static inline freeptr_t freelist_ptr_encode(const struct kmem_cache *s,
                        void *ptr, unsigned long ptr_addr)
{
    unsigned long encoded;

#ifdef CONFIG_SLAB_FREELIST_HARDENED
    encoded = (unsigned long)ptr ^ s->random ^ swab(ptr_addr);
#else
    encoded = (unsigned long)ptr;
#endif
    return (freeptr_t){.v = encoded};
}

// mm/slub.c:540-542
#ifdef CONFIG_SLAB_FREELIST_HARDENED
    BUG_ON(object == fp); /* naive detection of double free or corruption */
#endif

// mm/slub.c:3307-3341（节选）
static int init_cache_random_seq(struct kmem_cache *s)
{
    unsigned int count = oo_objects(s->oo);
    int err;

    /* Bailout if already initialised */
    if (s->random_seq)
        return 0;

    err = cache_random_seq_create(s, count, GFP_KERNEL);    /* 生成随机排列 */
    if (err) {
        pr_err("SLUB: Unable to initialize free list for %s\n", s->name);
        return err;
    }

    /* Transform to an offset on the set of pages */
    if (s->random_seq) {
        unsigned int i;
        for (i = 0; i < count; i++)
            s->random_seq[i] *= s->size;    /* 序号×stride=偏移 */
    }
    return 0;
}

SLAB_RED_ZONE    对象前后埋哨兵, free/alloc 时校验   (布局见 21.2.4 图)
SLAB_POISON      释放时填充 0x6b, 分配时校验 0x6b    (UAF 写探针)
SLAB_STORE_USER  对象尾附 track: 分配/释放的调用栈   (泄漏/溢出定位)
SLAB_CONSISTENCY_CHECKS  链表与计数全量校验
slub_debug=FPZU  开启组合; slub_debug=<cachename> 定点开