// SLUB核心缓存描述符结构体（精简版）
struct kmem_cache {
    // Per-CPU私有缓存：无锁分配核心载体
    struct kmem_cache_cpu __percpu *cpu_slab;
    // 最小/最大页框阶数约束
    unsigned int min_order;
    unsigned int max_order;
    // 单slab页框对象数量阈值
    unsigned int objects;
    // 缓存回收权重与压力阈值
    unsigned int shrink_weight;
};

// Per-CPU私有缓存核心结构
struct kmem_cache_cpu {
    // 当前活跃slab页
    struct slub_page *page;
    // 当前页内空闲对象指针
    void *freelist;
    // 本地缓存剩余对象数
    unsigned int active;
};

static __always_inline void slab_free(struct kmem_cache *s,
                                      struct kmem_cache_cpu *c, void *x)
{
    // 1. 优先将释放对象放回当前CPU私有空闲链表
    *(void **)x = c->freelist;
    c->freelist = x;
    c->active--;

    // 2. 仅当私有缓存溢出、达到阈值时，才批量释放至页框层
    if (unlikely(c->active <= 0)) {
        __slab_flush_cpu_cache(s, c);
    }

    // 3. 无主动归还Buddy系统逻辑，被动等待内存压力触发回收
}

// SLUB partial链表核心结构（Linux 5.4）
struct kmem_cache {
    // 全局partial链表：存储半满slab页框
    struct list_head partial;
    // partial链表长度阈值
    unsigned int min_partial;
};

// 从partial链表获取slab页框核心逻辑
static struct page *get_partial_slab(struct kmem_cache *s, int cpu)
{
    struct page *page;
    
    // 遍历partial链表查找合适slab页框
    list_for_each_entry(page, &s->partial, lru) {
        // 校验页框是否有足够空闲对象
        if (page->slub_free >= s->min_objects) {
            // 从链表移除，加入CPU缓存
            list_del(&page->lru);
            return page;
        }
    }
    
    // partial链表无合适页框，申请新slab页框
    return allocate_new_slab(s);
}

// partial链表收缩判定逻辑
static int slub_shrink_partial(struct kmem_cache *s)
{
    struct page *page;
    int count = 0;
    
    // 遍历partial链表，回收空闲率高的页框
    list_for_each_entry_safe(page, tmp, &s->partial, lru) {
        // 空闲对象数超过阈值，回收至empty链表或释放
        if (page->slub_free >= s->min_objects) {
            list_del(&page->lru);
            free_slab_page(page);
            count++;
        }
        
        // 达到min_partial阈值，停止收缩
        if (count >= s->min_partial)
            break;
    }
    
    return count;
}

// 伙伴系统最大阶数（默认11阶，对应2^11=2048页）
#define MAX_ORDER 11

// 内存域空闲页框链表：按阶数分组
struct free_area {
    struct list_head free_list[MAX_ORDER];
    unsigned long nr_free[MAX_ORDER];
};

// 伙伴合并核心逻辑
static inline int buddy_merge(struct zone *zone, struct page *page, int order)
{
    struct page *buddy = find_buddy_page(page, order);
    // 仅同源、同阶数、空闲状态伙伴可合并
    if (buddy && page_is_buddy(page, buddy, order)) {
        remove_from_free_list(zone, buddy, order);
        // 合并为高一阶页框
        merge_page(page, buddy);
        return 1;
    }
    return 0;
}

// 内存规整核心函数（Linux 5.4）
static void compact_node(int nid)
{
    struct zone *zone;
    
    // 遍历所有内存域
    for (zone = NODE_DATA(nid)->node_zones; zone; zone++) {
        // 扫描内存域，识别可移动页框
        isolate_migratepages(zone);
        
        // 迁移页框至新位置，腾出连续空间
        migrate_pages(zone->migratepages, compact_alloc_page);
        
        // 合并腾出的连续页框为高阶页框
        release_freepages(zone);
    }
}

// 页框迁移核心逻辑
static int migrate_pages(struct list_head *from, struct page *to)
{
    struct page *page;
    
    list_for_each_entry(page, from, lru) {
        // 锁定源页框，阻止业务进程访问
        lock_page(page);
        
        // 复制页框数据至新位置
        copy_page_to(page, to);
        
        // 解锁源页框，释放原位置
        unlock_page(page);
        free_page(page);
    }
    
    return 0;
}

// order_fallback回退分配核心函数（Linux 5.4）
static struct page *__rmqueue_fallback(struct zone *zone, int order)
{
    struct page *page;
    int current_order;
    
    // 从低阶链表向上查找可用页框
    for (current_order = order + 1; current_order < MAX_ORDER; current_order++) {
        // 检查当前阶数是否有空闲页框
        if (!list_empty(&zone->free_area[current_order].free_list)) {
            // 从链表获取页框
            page = list_first_entry(&zone->free_area[current_order].free_list);
            
            // 拆分页框为低阶，满足分配需求
            expand_page(zone, page, current_order, order);
            
            // 锁定拆分后的低阶页框，阻止合并
            set_page_refcounted(page);
            
            return page;
        }
    }
    
    // 所有阶数均无空闲页框，分配失败
    return NULL;
}

// 页框拆分核心逻辑
static void expand_page(struct zone *zone, struct page *page, 
                        int high_order, int low_order)
{
    // 拆分高阶页框为多个低阶页框
    while (high_order > low_order) {
        high_order--;
        // 将拆分的页框加入低阶空闲链表
        add_to_free_list(zone, page, high_order);
        page += (1 << high_order);
    }
}

// SLUB创建slab页框时的阶数校验逻辑
static int kmem_cache_order_objects(struct kmem_cache *s, int size)
{
    int order = 0;
    // 计算适配对象大小的最小阶数
    while ((PAGE_SIZE << order) < size * s->objects)
        order++;

    // 强制限制不超过slub_max_order配置值
    order = min(order, s->max_order);
    // 同时不超过内核MAX_ORDER上限
    order = min(order, MAX_ORDER - 1);

    return order;
}

// SLUB shrink回收判定核心函数
static int slub_shrink_page_count(struct kmem_cache *s, struct page *page)
{
    int free_objects = page->slub_free;
    // 核心判定：空闲对象数 >= min_objects 才允许回收页框
    if (free_objects >= s->min_objects)
        return 1; // 可回收

    return 0; // 不可回收，永久滞留
}

// 内存水位计算核心函数（Linux 5.4）
static void setup_per_zone_wmarks(void)
{
    unsigned long min_free_kbytes = sysctl_min_free_kbytes;
    struct zone *zone;
    
    for_each_populated_zone(zone) {
        // 计算三级水位：min、low、high
        zone->watermark[WMARK_MIN] = min_free_kbytes * zone->managed_pages / total_pages;
        zone->watermark[WMARK_LOW] = zone->watermark[WMARK_MIN] * 2;
        zone->watermark[WMARK_HIGH] = zone->watermark[WMARK_MIN] * 3;
    }
}

// 内存水位校验与回收触发逻辑
static int zone_watermark_ok(struct zone *zone, int order)
{
    unsigned long free_pages = zone->free_pages;
    
    // 内存低于min水位，触发direct reclaim（阻塞业务进程）
    if (free_pages < zone->watermark[WMARK_MIN])
        return 0;
    
    // 内存低于low水位，唤醒kswapd后台回收
    if (free_pages < zone->watermark[WMARK_LOW])
        wakeup_kswapd(zone);
    
    return 1;
}

   # 推荐配置：总内存的5%-10%
   sysctl -w vm.min_free_kbytes=524288  # 512MB（适用于10GB内存服务器）

   # 查看内存域水位信息
   cat /proc/zoneinfo | grep -A 5 "Node"

   # 提高水位缩放因子，让 kswapd 更早启动后台回收（取值范围 1~1000，默认 10）
   sysctl -w vm.watermark_scale_factor=200

   # 查看direct reclaim触发次数（指标名为 allocstall，无下划线）
   cat /proc/vmstat | grep "allocstall"

// 1. 追踪slab对象分配探针
TRACEPOINT_EVENT(slub, slab_alloc,
    TP_ARGS(struct kmem_cache *, cache, void *, obj),
    TP_FAST_PROTO(struct kmem_cache *cache, void *obj),
    TP_FAST_ARGS(cache, obj)
)

// 2. 追踪slab对象释放探针
TRACEPOINT_EVENT(slub, slab_free,
    TP_ARGS(struct kmem_cache *, cache, void *, obj),
    TP_FAST_PROTO(struct kmem_cache *cache, void *obj),
    TP_FAST_ARGS(cache, obj)
)

// 3. 自定义内核埋点：统计单CPU缓存滞留对象
void slub_leak_monitor(void)
{
    struct kmem_cache_cpu *c;
    struct kmem_cache *s;
    // 遍历所有slab缓存
    list_for_each_entry(s, &slab_caches, list) {
        // 遍历每个CPU私有缓存
        for_each_possible_cpu(cpu) {
            c = per_cpu_ptr(s->cpu_slab, cpu);
            // 统计滞留未释放对象
            monitor_record(s->name, cpu, c->active, c->freelist);
        }
    }
}

# 1. 监控SLUB对象分配频次（按缓存类型分组）
bpftrace -e 'tracepoint:slub:slub_alloc {
    @alloc_count[args->cache->name] = count();
}'

# 2. 监控SLUB对象释放频次（检测泄漏）
bpftrace -e 'tracepoint:slub:slub_free {
    @free_count[args->cache->name] = count();
}'

# 3. 统计分配与释放差值（识别泄漏缓存）
bpftrace -e 'tracepoint:slub:slub_alloc { @alloc[args->cache->name]++; }
             tracepoint:slub:slub_free { @free[args->cache->name]--; }
             interval:s:5 { print(@alloc - @free); clear(@alloc); clear(@free); }'

# 4. 监控per-CPU缓存与partial链表状态
# 注：per-CPU 缓存对象数、partial 链表长度属于 SLUB 内部状态，
# 无稳定 tracepoint/kprobe，建议通过 /proc/slabinfo、/sys/kernel/slab/<cache>/* 或自定义内核模块读取。
bpftrace -e 'tracepoint:slub:slub_alloc {
    @alloc_by_cpu[cpu, args->s->name] = count();
}
tracepoint:slub:slub_free {
    @free_by_cpu[cpu, args->s->name] = count();
}
interval:s:5 {
    print(@alloc_by_cpu - @free_by_cpu);
    clear(@alloc_by_cpu); clear(@free_by_cpu);
}'

// libbpf SLUB监控程序核心结构
#include <bpf/bpf_helpers.h>

struct slab_event {
    char cache_name[64];
    u64 timestamp;
    u32 cpu;
    u32 obj_addr;
};

// 定义SLUB分配事件map
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 10000);
    __type(key, char[64]);
    __type(value, u64);
} alloc_count SEC(".maps");

// 挂载slab_alloc tracepoint
SEC("tracepoint/slub/slub_alloc")
int trace_slab_alloc(struct trace_event_raw_slub_alloc *ctx)
{
    char cache_name[64];
    u64 *count;
    
    // 获取缓存名称
    bpf_probe_read_kernel_str(cache_name, sizeof(cache_name), ctx->cache->name);
    
    // 统计分配次数
    count = bpf_map_lookup_elem(&alloc_count, cache_name);
    if (count) {
        (*count)++;
    } else {
        u64 init = 1;
        bpf_map_update_elem(&alloc_count, cache_name, &init, BPF_ANY);
    }
    
    return 0;
}

// 挂载slab_free tracepoint
SEC("tracepoint/slub/slub_free")
int trace_slab_free(struct trace_event_raw_slub_free *ctx)
{
    char cache_name[64];
    u64 *count;
    
    bpf_probe_read_kernel_str(cache_name, sizeof(cache_name), ctx->cache->name);
    
    // 统计释放次数（检测泄漏）
    count = bpf_map_lookup_elem(&alloc_count, cache_name);
    if (count && *count > 0) {
        (*count)--;
    }
    
    return 0;
}

char LICENSE[] SEC("license") = "GPL";

   # 安装libbpf依赖
   yum install libbpf-devel bpftool
   
   # 编译eBPF程序
   clang -g -O2 -target bpf -D__TARGET_ARCH_x86 \
         -c slub_monitor.c -o slub_monitor.bpf.o

   # 加载eBPF程序至内核
   bpftool prog load slub_monitor.bpf.o /sys/fs/bpf/slub_monitor
   
   # 挂载tracepoint
   bpftool prog attach slub_monitor tracepoint

   # 读取分配统计数据
   bpftool map dump name alloc_count
   
   # 持续监控（5秒刷新）
   watch -n 5 'bpftool map dump name alloc_count'