#include <linux/slab.h>

/* 分配物理连续内存 */
void *ptr = kmalloc(1024, GFP_KERNEL);
if (!ptr)
    return -ENOMEM;

/* 使用完毕释放 */
kfree(ptr);

/* 分配并清*/
struct my_device *dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (!dev)
    return -ENOMEM;
/* dev所有字段已清零，无需手动memset */

#include <linux/vmalloc.h>

/* 分配1MB虚拟连续内存 */
void *buf = vmalloc(1024 * 1024);
if (!buf)
    return -ENOMEM;

/* 释放 */
vfree(buf);

#include <linux/gfp.h>

/* 分配4页（16KB）连续物理内存，order=2表示2^2=4*/
unsigned long addr = __get_free_pages(GFP_KERNEL, 2);
if (!addr)
    return -ENOMEM;

/* 释放，order必须与分配时一*/
free_pages(addr, 2);

#include <linux/device.h>

/* probe中分配，remove时自动释*/
struct my_state *state = devm_kzalloc(dev, sizeof(*state), GFP_KERNEL);
if (!state)
    return -ENOMEM;

/* 不需要手动kfree，驱动卸载时自动释放 */

#include <linux/dma-mapping.h>

struct my_dev {
    struct device *dev;
    void *virt_addr;        /* CPU访问的虚拟地址 */
    dma_addr_t bus_addr;    /* 设备访问的总线地址 */
    size_t size;
};

static int alloc_coherent_buf(struct my_dev *md)
{
    md->size = 4096;

    /* 分配一致性DMA缓冲区，返回CPU虚拟地址，bus_addr输出总线地址 */
    md->virt_addr = dma_alloc_coherent(md->dev, md->size,
                                        &md->bus_addr, GFP_KERNEL);
    if (!md->virt_addr)
        return -ENOMEM;

    /* CPU写数*/
    memset(md->virt_addr, 0xAA, md->size);

    /* 设备用bus_addr访问同一块内存，数据一定是最新的 */
    dev_info(md->dev, "coherent buf: virt=%p bus=%pad size=%zu\n",
             md->virt_addr, &md->bus_addr, md->size);

    return 0;
}

static void free_coherent_buf(struct my_dev *md)
{
    if (md->virt_addr) {
        dma_free_coherent(md->dev, md->size,
                          md->virt_addr, md->bus_addr);
        md->virt_addr = NULL;
    }
}

struct stream_buf {
    void *virt;
    dma_addr_t bus;
    size_t size;
    enum dma_data_direction dir;
};

static int map_stream_buf(struct device *dev, struct stream_buf *sb)
{
    /* 映射：返回总线地址，同时处理cache一致*/
    sb->bus = dma_map_single(dev, sb->virt, sb->size, sb->dir);
    if (dma_mapping_error(dev, sb->bus))
        return -EIO;

    return 0;
}

static void sync_for_device(struct device *dev, struct stream_buf *sb)
{
    /* CPU写完数据后，刷cache让设备看到最新内存*/
    dma_sync_single_for_device(dev, sb->bus, sb->size, sb->dir);
}

static void sync_for_cpu(struct device *dev, struct stream_buf *sb)
{
    /* 设备写完数据后，使cache无效让CPU看到最新内存*/
    dma_sync_single_for_cpu(dev, sb->bus, sb->size, sb->dir);
}

static void unmap_stream_buf(struct device *dev, struct stream_buf *sb)
{
    dma_unmap_single(dev, sb->bus, sb->size, sb->dir);
}

// dma_demo.c - DMA缓冲区管理示例（Linux 6.8验证：#include <linux/module.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/dma-mapping.h>
#include <linux/slab.h>
#include <linux/platform_device.h>

#define COHERENT_SIZE  4096
#define STREAM_SIZE    2048

struct dma_demo_dev {
    struct device *dev;
    /* 一致性DMA */
    void *coh_virt;
    dma_addr_t coh_bus;
    /* 流式DMA */
    void *str_virt;
    dma_addr_t str_bus;
};

static int dma_demo_probe(struct platform_device *pdev)
{
    struct dma_demo_dev *md;
    int ret;

    md = kzalloc(sizeof(*md), GFP_KERNEL);
    if (!md)
        return -ENOMEM;

    md->dev = &pdev->dev;
    platform_set_drvdata(pdev, md);

    /* 检查DMA寻址能力 */
    ret = dma_set_mask_and_coherent(md->dev, DMA_BIT_MASK(32));
    if (ret) {
        dev_err(md->dev, "dma_set_mask failed: %d\n", ret);
        goto err_free;
    }

    /* 1. 一致性DMA分配 */
    md->coh_virt = dma_alloc_coherent(md->dev, COHERENT_SIZE,
                                       &md->coh_bus, GFP_KERNEL);
    if (!md->coh_virt) {
        dev_err(md->dev, "dma_alloc_coherent failed\n");
        ret = -ENOMEM;
        goto err_free;
    }
    /* CPU写数据，设备立即可见 */
    memset(md->coh_virt, 0x55, COHERENT_SIZE);
    dev_info(md->dev, "coherent: virt=%p bus=%pad\n",
             md->coh_virt, &md->coh_bus);

    /* 2. 流式DMA分配 */
    md->str_virt = kzalloc(STREAM_SIZE, GFP_KERNEL);
    if (!md->str_virt) {
        ret = -ENOMEM;
        goto err_free_coh;
    }

    /* CPU准备发送数*/
    memset(md->str_virt, 0xAA, STREAM_SIZE);

    /* 映射给设*/
    md->str_bus = dma_map_single(md->dev, md->str_virt,
                                  STREAM_SIZE, DMA_TO_DEVICE);
    if (dma_mapping_error(md->dev, md->str_bus)) {
        dev_err(md->dev, "dma_map_single failed\n");
        ret = -EIO;
        goto err_free_str;
    }
    dev_info(md->dev, "stream: virt=%p bus=%pad\n",
             md->str_virt, &md->str_bus);

    /* 传输完成后解除映*/
    dma_unmap_single(md->dev, md->str_bus, STREAM_SIZE, DMA_TO_DEVICE);

    dev_info(md->dev, "DMA demo probe ok\n");
    return 0;

err_free_str:
    kfree(md->str_virt);
err_free_coh:
    dma_free_coherent(md->dev, COHERENT_SIZE, md->coh_virt, md->coh_bus);
err_free:
    kfree(md);
    return ret;
}

static void dma_demo_remove(struct platform_device *pdev)
{
    struct dma_demo_dev *md = platform_get_drvdata(pdev);

    if (md->str_virt)
        kfree(md->str_virt);
    if (md->coh_virt)
        dma_free_coherent(md->dev, COHERENT_SIZE,
                          md->coh_virt, md->coh_bus);
    kfree(md);
    dev_info(&pdev->dev, "DMA demo removed\n");
}

static const struct of_device_id dma_demo_of_match[] = {
    { .compatible = "linuxros,dma-demo" },
    { /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, dma_demo_of_match);

static struct platform_driver dma_demo_driver = {
    .probe  = dma_demo_probe,
    .remove = dma_demo_remove,
    .driver = {
        .name = "dma-demo",
        .of_match_table = dma_demo_of_match,
    },
};
module_platform_driver(dma_demo_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("linuxros");
MODULE_DESCRIPTION("DMA缓冲区管理示例);

obj-m := dma_demo.o

KDIR := /lib/modules/$(shell uname -r)/build

all:
    make -C $(KDIR) M=$(PWD) modules

clean:
    make -C $(KDIR) M=$(PWD) clean

#include <linux/dma-buf.h>
#include <linux/dma-heap.h>

/* 导出方：将自有缓冲区导出为dma_buf */
struct dma_buf_export_info exp_info = {
    .exp_name = "my-exporter",
    .owner = THIS_MODULE,
    .ops = &my_dma_buf_ops,   /* 实现attach/detach/map/unmap等回调*/
    .size = buf_size,
    .flags = O_RDWR,
    .priv = my_buf,            /* 传给ops回调的私有数*/
};
struct dma_buf *dmabuf = dma_buf_export(&exp_info);
int fd = dma_buf_fd(dmabuf, O_RDWR | O_CLOEXEC);

/* 导入方：通过fd获取dma_buf */
struct dma_buf *dmabuf = dma_buf_get(fd);
struct dma_buf_attachment *attach = dma_buf_attach(dmabuf, dev);
struct sg_table *sgt = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);
/* sgt中包含scatter-gather列表，可获取dma_addr_t */

/* 使用完毕 */
dma_buf_unmap_attachment(attach, sgt, DMA_BIDIRECTIONAL);
dma_buf_detach(dmabuf, attach);
dma_buf_put(dmabuf);

#include <linux/mempool.h>

/* 自定义分配和释放函数 */
static void *my_alloc(gfp_t gfp_mask, void *pool_data)
{
    return kmalloc(1024, gfp_mask);
}

static void my_free(void *element, void *pool_data)
{
    kfree(element);
}

/* 创建内存池，预分支个对*/
mempool_t *pool = mempool_create(5, my_alloc, my_free, NULL);
if (!pool)
    return -ENOMEM;

/* 从池中分支*/
void *obj = mempool_alloc(pool, GFP_KERNEL);

/* 归还池中 */
mempool_free(obj, pool);

/* 销毁池 */
mempool_destroy(pool);

# 查看所有slab缓存信息
cat /proc/slabinfo

# 查看特定缓存
cat /proc/slabinfo | grep kmalloc

# 在GRUB中添加内核参数slub_debug=FZP

# 参数含义。# F - 对齐检查（Faults。# Z - 红区检查（Red Zoning。# P - 毒化（Poisoning），分配时填。x6b，释放时填充0x6b
# T - 追踪（Tracing），记录分配/释放调用。# U - 用户追踪（User Tracking```

```bash
# 只调试特定slab缓存
slub_debug=FZP,kmalloc-64

# 运行时启。echo 1 > /sys/kernel/slab/kmalloc-64/validate

# 内核启动参数开销kmemleak=on

# 运行时操。echo scan > /sys/kernel/debug/kmemleak    # 触发扫描
cat /sys/kernel/debug/kmemleak             # 查看泄漏
echo clear > /sys/kernel/debug/kmemleak    # 清除报告

unreferenced object 0xffff888100123400 (size 64):
  comm "insmod", pid 1234, jiffies 4294901234
  hex dump (first 32 bytes):
    6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b 6b  kkkkkkkkkkkkkkkk
  backtrace:
    [<ffffffff81234567>] kmalloc_trace+0x67/0x120
    [<ffffffffc0001000>] my_probe+0x3a/0x100 [mymod]

# 查看vmalloc分配详情
cat /proc/vmallocinfo

# 典型输出
0xffffc90000000000-0xffffc90000001000   4096 dma_alloc_coherent+0x45/0x120 pages=1
0xffffc90000001000-0xffffc90000003000   8192 vmalloc+0x32/0x80 pages=2

/* 方案1：用mempool预分支*/
mempool_t *pool = mempool_create(8, my_alloc, my_free, NULL);
void *buf = mempool_alloc(pool, GFP_ATOMIC);  /* 不会失败 */

/* 方案2：减小分配大小，拆成多次小分支*/
/* 一次分支4KB可能失败，改。。6KB */

/* 方案3：在进程上下文预分配，中断里直接*/
struct my_dev *md = devm_kzalloc(dev, sizeof(*md), GFP_KERNEL);
/* 中断处理函数直接用md，不再分支*/

/* 发送方向：CPU写完必须同步给设*/
memcpy(buf, tx_data, len);
dma_sync_single_for_device(dev, bus_addr, len, DMA_TO_DEVICE);
/* 之后设备才能*/

/* 接收方向：设备写完必须同步给CPU */
dma_sync_single_for_cpu(dev, bus_addr, len, DMA_FROM_DEVICE);
/* 之后CPU才能*/
data = buf[0];