我们根据上面的流程图，依次看下slub是如何分配的
首先从kmem_cache_cpu中分配，如果没有则从kmem_cache_cpu的partial链表分配，如果还没有则从kmem_cache_node中分配，如果kmem_cache_node中也没有，则需要向伙伴系统申请内存。
第一步先看看kmem_cache_cpu是如何实现

/*
 * When changing the layout, make sure freelist and tid are still compatible
 * with this_cpu_cmpxchg_double() alignment requirements.
 */
struct kmem_cache_cpu {
    union {
        struct {
            void **freelist;  /* Pointer to next available object */
            unsigned long tid; /* Globally unique transaction id */
        };
        freelist_aba_t freelist_tid; /* 将 freelist 和 tid 封装为原子操作单元 */
    };
    struct slab *slab;        /* 当前用于分配对象的Slab页 */
#ifdef CONFIG_SLUB_CPU_PARTIAL
    struct slab *partial;     /* 部分分配的冻结Slab链表（仅启用CPU Partial时存在） */
#endif
    local_lock_t lock;        /* 保护上述字段的本地CPU锁 */
#ifdef CONFIG_SLUB_STATS
    unsigned stat[NR_SLUB_STAT_ITEMS]; /* Slab分配统计信息 */
#endif
};

接下来，我们可以详细拆解一下这段代码：
联合体（Union）中的 freelist 和 tid

union {
    struct {
        void **freelist;      // 指向当前Slab中下一个可用对象的指针
        unsigned long tid;    // 全局唯一的事务ID（Transaction ID）
    };
    freelist_aba_t freelist_tid; // 将两者封装为一个原子操作单元
};

目的：

无锁快速路径：在SLUB分配器中，对象的分配和释放通常通过无锁操作（如this_cpu_cmpxchg_double()）实现，以规避传统锁的性能开销。

ABA问题防御：tid（事务ID）用于防止ABA问题。每次修改freelist时，tid会递增，确保即使freelist的值在并发操作中“看似未变”（如A→B→A），其tid也已变化，使得原子操作能检测到状态不一致。

联合体的作用：

freelist_tid（类型通常为u64或类似）将freelist和tid在内存中紧密打包，确保它们占据连续且对齐的内存空间，满足双字原子操作（如cmpxchg_double）的硬件对齐要求。

例如，在64位系统中，freelist（8字节）和tid（8字节）组合为一个16字节的单元，对齐到16字节边界，从而允许通过单条指令原子地比较和交换这两个字段。## 对齐要求：

this_cpu_cmpxchg_double()需要操作的两个字段必须满足：
a. 在内存中连续。
b. 对齐到双字（例如，16字节对齐）。
联合体强制freelist和tid共享同一内存区域，确保它们的布局符合上述条件。

slab指针

struct slab *slab; // 当前活跃的Slab页，用于快速分配对象

作用：指向当前CPU正在使用的Slab页，其中包含可分配的对象。
性能优化：通过本地化访问减少NUMA或缓存一致性开销。

partial 指针（条件编译）

#ifdef CONFIG_SLUB_CPU_PARTIAL
struct slab *partial; // 部分空闲的冻结Slab链表
#endif

功能：

当启用CONFIG_SLUB_CPU_PARTIAL时，每个CPU会缓存部分空闲的Slab（称为“冻结”状态），避免频繁向全局链表归还/申请Slab。
在内存压力或特定条件下（如flush_slab），这些Partial Slab会被转移到全局链表（NUMA节点的partial链表）。

local_lock_t lock

local_lock_t lock; // 本地CPU锁，保护kmem_cache_cpu结构中的字段

作用：

在慢速路径（如Slab切换、统计更新）中，防止同一CPU上的不同上下文（如进程与中断）竞争访问kmem_cache_cpu结构。
注意：快速路径（无锁分配/释放）不依赖此锁，仅在慢速路径中使用。

stat 统计数组（条件编译）

#ifdef CONFIG_SLUB_STATS
unsigned stat[NR_SLUB_STAT_ITEMS]; // 统计计数器（如分配次数、缓存命中率等）
#endif

功能：在内核启用CONFIG_SLUB_STATS时，记录Slab分配器的运行时性能指标，用于调优和监控。

现在我们来看看kmem_cache_cpu在慢速分配时候是如何工作（___slab_alloc）

/*
 * Slow path. The lockless freelist is empty or we need to perform
 * debugging duties.
 *
 * Processing is still very fast if new objects have been freed to the
 * regular freelist. In that case we simply take over the regular freelist
 * as the lockless freelist and zap the regular freelist.
 *
 * If that is not working then we fall back to the partial lists. We take the
 * first element of the freelist as the object to allocate now and move the
 * rest of the freelist to the lockless freelist.
 *
 * And if we were unable to get a new slab from the partial slab lists then
 * we need to allocate a new slab. This is the slowest path since it involves
 * a call to the page allocator and the setup of a new slab.
 *
 * Version of __slab_alloc to use when we know that preemption is
 * already disabled (which is the case for bulk allocation).
 */
static void *___slab_alloc(struct kmem_cache *s, gfp_t gfpflags, int node,
			  unsigned long addr, struct kmem_cache_cpu *c, unsigned int orig_size)
{
	void *freelist;
	struct slab *slab;
	unsigned long flags;
	struct partial_context pc;

	stat(s, ALLOC_SLOWPATH);

reread_slab:

	slab = READ_ONCE(c->slab);
	if (!slab) {
		/*
		 * if the node is not online or has no normal memory, just
		 * ignore the node constraint
		 */
		if (unlikely(node != NUMA_NO_NODE &&
			     !node_isset(node, slab_nodes)))
			node = NUMA_NO_NODE;
		goto new_slab;
	}
redo:

	if (unlikely(!node_match(slab, node))) {
		/*
		 * same as above but node_match() being false already
		 * implies node != NUMA_NO_NODE
		 */
		if (!node_isset(node, slab_nodes)) {
			node = NUMA_NO_NODE;
		} else {
			stat(s, ALLOC_NODE_MISMATCH);
			goto deactivate_slab;
		}
	}

	/*
	 * By rights, we should be searching for a slab page that was
	 * PFMEMALLOC but right now, we are losing the pfmemalloc
	 * information when the page leaves the per-cpu allocator
	 */
	if (unlikely(!pfmemalloc_match(slab, gfpflags)))
		goto deactivate_slab;

	/* must check again c->slab in case we got preempted and it changed */
	local_lock_irqsave(&s->cpu_slab->lock, flags);
	if (unlikely(slab != c->slab)) {
		local_unlock_irqrestore(&s->cpu_slab->lock, flags);
		goto reread_slab;
	}
	freelist = c->freelist;
	if (freelist)
		goto load_freelist;

	freelist = get_freelist(s, slab);

	if (!freelist) {
		c->slab = NULL;
		c->tid = next_tid(c->tid);
		local_unlock_irqrestore(&s->cpu_slab->lock, flags);
		stat(s, DEACTIVATE_BYPASS);
		goto new_slab;
	}

	stat(s, ALLOC_REFILL);

load_freelist:

	lockdep_assert_held(this_cpu_ptr(&s->cpu_slab->lock));

	/*
	 * freelist is pointing to the list of objects to be used.
	 * slab is pointing to the slab from which the objects are obtained.
	 * That slab must be frozen for per cpu allocations to work.
	 */
	VM_BUG_ON(!c->slab->frozen);
	c->freelist = get_freepointer(s, freelist);
	c->tid = next_tid(c->tid);
	local_unlock_irqrestore(&s->cpu_slab->lock, flags);
	return freelist;

deactivate_slab:

	local_lock_irqsave(&s->cpu_slab->lock, flags);
	if (slab != c->slab) {
		local_unlock_irqrestore(&s->cpu_slab->lock, flags);
		goto reread_slab;
	}
	freelist = c->freelist;
	c->slab = NULL;
	c->freelist = NULL;
	c->tid = next_tid(c->tid);
	local_unlock_irqrestore(&s->cpu_slab->lock, flags);
	deactivate_slab(s, slab, freelist);

new_slab:

	if (slub_percpu_partial(c)) {
		local_lock_irqsave(&s->cpu_slab->lock, flags);
		if (unlikely(c->slab)) {
			local_unlock_irqrestore(&s->cpu_slab->lock, flags);
			goto reread_slab;
		}
		if (unlikely(!slub_percpu_partial(c))) {
			local_unlock_irqrestore(&s->cpu_slab->lock, flags);
			/* we were preempted and partial list got empty */
			goto new_objects;
		}

		slab = c->slab = slub_percpu_partial(c);
		slub_set_percpu_partial(c, slab);
		local_unlock_irqrestore(&s->cpu_slab->lock, flags);
		stat(s, CPU_PARTIAL_ALLOC);
		goto redo;
	}

new_objects:

	pc.flags = gfpflags;
	pc.slab = &slab;
	pc.orig_size = orig_size;
	freelist = get_partial(s, node, &pc);
	if (freelist)
		goto check_new_slab;

	slub_put_cpu_ptr(s->cpu_slab);
	slab = new_slab(s, gfpflags, node);
	c = slub_get_cpu_ptr(s->cpu_slab);

	if (unlikely(!slab)) {
		slab_out_of_memory(s, gfpflags, node);
		return NULL;
	}

	stat(s, ALLOC_SLAB);

	if (kmem_cache_debug(s)) {
		freelist = alloc_single_from_new_slab(s, slab, orig_size);

		if (unlikely(!freelist))
			goto new_objects;

		if (s->flags & SLAB_STORE_USER)
			set_track(s, freelist, TRACK_ALLOC, addr);

		return freelist;
	}

	/*
	 * No other reference to the slab yet so we can
	 * muck around with it freely without cmpxchg
	 */
	freelist = slab->freelist;
	slab->freelist = NULL;
	slab->inuse = slab->objects;
	slab->frozen = 1;

	inc_slabs_node(s, slab_nid(slab), slab->objects);

check_new_slab:

	if (kmem_cache_debug(s)) {
		/*
		 * For debug caches here we had to go through
		 * alloc_single_from_partial() so just store the tracking info
		 * and return the object
		 */
		if (s->flags & SLAB_STORE_USER)
			set_track(s, freelist, TRACK_ALLOC, addr);

		return freelist;
	}

	if (unlikely(!pfmemalloc_match(slab, gfpflags))) {
		/*
		 * For !pfmemalloc_match() case we don't load freelist so that
		 * we don't make further mismatched allocations easier.
		 */
		deactivate_slab(s, slab, get_freepointer(s, freelist));
		return freelist;
	}

retry_load_slab:

	local_lock_irqsave(&s->cpu_slab->lock, flags);
	if (unlikely(c->slab)) {
		void *flush_freelist = c->freelist;
		struct slab *flush_slab = c->slab;

		c->slab = NULL;
		c->freelist = NULL;
		c->tid = next_tid(c->tid);

		local_unlock_irqrestore(&s->cpu_slab->lock, flags);

		deactivate_slab(s, flush_slab, flush_freelist);

		stat(s, CPUSLAB_FLUSH);

		goto retry_load_slab;
	}
	c->slab = slab;

	goto load_freelist;
}

`___slab_alloc 是 SLUB 分配器的慢速路径函数，当快速路径（无锁分配）失败时，负责处理复杂场景

___slab_alloc 是 Linux 内核 SLUB 分配器中处理慢速路径的核心函数，主要用于以下场景和逻辑：

---

核心作用

1. 处理快速路径失败
   当 CPU 本地缓存（kmem_cache_cpu->freelist）无可用对象时，通过慢速路径获取新对象。
2. NUMA 优化
   确保内存分配符合请求的 NUMA 节点，减少跨节点访问延迟。
3. 调试与隔离
   支持调试功能（如内存跟踪、毒化）和隔离 PFMEMALLOC 内存（用于内存回收的专用页）。
4. 并发同步
   通过锁和事务 ID（tid）确保多核环境下的数据一致性，避免 ABA 问题。

---

核心逻辑流程

1. 初始化检查

   • 读取当前 CPU 的活跃 Slab（c->slab），若为空则跳转至新 Slab 分配（new_slab）。
   • 检查 NUMA 节点是否有效，若无效则忽略节点约束。

2. NUMA 与 PFMEMALLOC 匹配

   • 若 Slab 的 NUMA 节点与请求不匹配，停用当前 Slab（deactivate_slab）。
   • 检查 Slab 的 PFMEMALLOC 标志是否与分配标志（gfpflags）匹配，不匹配则停用。

3. 加锁与状态重验

   • 获取本地锁（local_lock_irqsave），防止同一 CPU 上的进程与中断竞争。
   • 二次验证 Slab 是否被其他上下文修改，若已修改则重新读取（reread_slab）。

4. 获取空闲链表（Freelist）

   • 若本地 freelist 存在可用对象，直接分配。
   • 若本地 freelist 为空，尝试从 Slab 页获取新 freelist（get_freelist）。
   • 若获取失败，标记 Slab 失效（c->slab = NULL），触发新 Slab 分配。

5. 分配新对象

   • 从 CPU 的 Partial 链表获取：若启用 CONFIG_SLUB_CPU_PARTIAL，优先重用部分空闲 Slab。
   • 从节点的 Partial 链表获取：通过 get_partial 批量获取部分空闲对象。
   • 分配全新 Slab：调用伙伴系统（new_slab）分配新页，初始化并冻结 Slab。

6. 更新状态

   • 递增事务 ID（c->tid），确保后续快速路径能检测到状态变化。
   • 若启用调试，记录内存分配跟踪信息（set_track）。

7. 异常处理

   • 若内存不足（slab_out_of_memory），触发 OOM 处理。
   • 若并发冲突（如锁内发现 Slab 被修改），回滚并重试。

---

关键设计

1. 锁与无锁混合

   • 快速路径无锁：通过原子操作（this_cpu_cmpxchg_double）实现高效分配。
   • 慢速路径加锁：使用本地锁保护 kmem_cache_cpu 结构，避免并发修改。

2. 事务 ID（tid）防 ABA

   • 每次修改 freelist 后递增 tid，确保并发操作能检测到状态变化。

3. Partial 链表优化

   • 缓存部分空闲 Slab，减少全局锁争用和内存碎片化。

4. NUMA 感知

   • 优先从请求的 NUMA 节点分配，降低跨节点访问开销。

---

性能影响

• 快速恢复：通过重用 Partial 链表，减少全新 Slab 分配频率。
• 最小化锁范围：仅对关键操作加锁，缩短锁持有时间。
• 统计与调试：通过 stat() 记录性能事件，支持调优和问题排查。

---

总结

___slab_alloc 是 SLUB 分配器在复杂场景下（如本地缓存耗尽、NUMA 约束、调试需求）实现内存分配的核心逻辑。其通过精细的状态管理、锁优化和资源重用，平衡了性能与可靠性，确保多核系统中内存分配的高效性和正确性。

（参考链接：https://zhuanlan.zhihu.com/p/382056680#/）