4. 常见泄漏模式

内存泄漏并非单一现象，在内核驱动开发中，泄漏模式通常可以归纳为四种典型类型。理解这些模式是使用 kmemleak 进行高效排查的前提。本节将逐一剖析每种模式的成因、代码特征与排查要点。

4.1 分配后未释放（直接泄漏）

这是最原始、最容易理解的内存泄漏模式。驱动在某个执行路径上通过 kmalloc()、kzalloc()、alloc_pages() 等接口分配了内存，但在后续流程中完全没有对应的 kfree()、free_pages() 释放操作。分配的内存指针要么被覆盖，要么超出作用域后丢失，导致该内存块永久驻留。

// 错误示例：分配后未释放
static int __init my_driver_init(void)
{
    char *buf;

    buf = kmalloc(1024, GFP_KERNEL);
    if (!buf)
        return -ENOMEM;

    // 使用 buf 进行一些操作...

    // 错误：忘记调用 kfree(buf);
    // 函数返回后，buf 指针丢失，1024 字节永久泄漏

    return 0;
}
module_init(my_driver_init);

4.2 错误路径未释放（条件泄漏）

这种模式比直接泄漏更隐蔽。驱动在正常路径上正确地释放了内存，但在错误处理分支（如 if 判断失败、goto 跳转、异常提前返回）中遗漏了释放操作。常见于具有多层资源获取的初始化函数中。

// 错误示例：错误路径未释放
static int my_probe(struct platform_device *pdev)
{
    char *buf_a, *buf_b;

    buf_a = kmalloc(512, GFP_KERNEL);
    if (!buf_a)
        return -ENOMEM;

    buf_b = kmalloc(512, GFP_KERNEL);
    if (!buf_b) {
        // 错误：这里直接返回，没有释放 buf_a
        // 导致 512 字节泄漏
        return -ENOMEM;
    }

    // 正常使用...

    kfree(buf_b);
    kfree(buf_a);
    return 0;
}

4.3 引用计数泄漏

内核中许多对象（如 struct kref、设备模型中的 struct device、文件系统中的 struct inode）通过引用计数管理生命周期。每次 kref_get()、get_device()、kobject_get() 增加计数，对应的 kref_put()、put_device()、kobject_put() 减少计数。当计数无法归零时，对象的析构函数不会被调用，导致对象及其附属内存永久泄漏。

// 引用计数泄漏示例
static struct my_obj {
    struct kref refcount;
    int data;
} *g_obj;

static void obj_release(struct kref *ref)
{
    struct my_obj *obj = container_of(ref, struct my_obj, refcount);
    kfree(obj);  // 只有 kref_put 使计数归零时才会调用
}

static void callback(void *arg)
{
    struct my_obj *obj = (struct my_obj *)arg;
    // 错误：每次回调都增加引用，但从未减少
    kref_get(&obj->refcount);
    // 使用 obj...
    // 缺少 kref_put(&obj->refcount, obj_release);
}

// 结果：g_obj 的引用计数持续增长，永远无法释放

4.4 缓存对象泄漏（Slab 泄漏）

内核使用 slab 分配器（kmem_cache）管理频繁分配/释放的同类型对象。驱动通过 kmem_cache_alloc() 从缓存中获取对象，使用后应通过 kmem_cache_free() 归还。如果对象未归还，slab 缓存会持续膨胀，导致系统内存碎片化，甚至触发 OOM。

// 缓存对象泄漏示例
static struct kmem_cache *my_cache;

struct my_obj {
    int id;
    char name[64];
};

static int __init my_init(void)
{
    my_cache = kmem_cache_create("my_obj_cache",
                                 sizeof(struct my_obj),
                                 0, 0, NULL);
    if (!my_cache)
        return -ENOMEM;
    return 0;
}

static struct my_obj *my_alloc(void)
{
    struct my_obj *obj;

    obj = kmem_cache_alloc(my_cache, GFP_KERNEL);
    if (!obj)
        return NULL;

    // 使用 obj...
    // 错误：使用后未调用 kmem_cache_free(my_cache, obj);
    // 导致 slab 对象泄漏

    return obj;  // 调用者可能忘记释放
}

static void __exit my_exit(void)
{
    // 此时 my_cache 中仍有未归还的对象
    // kmem_cache_destroy 会报错并返回
    kmem_cache_destroy(my_cache);
}
module_exit(my_exit);

4.5 四种模式对比总结