linux 之dma_buf (4)- mmap

最新推荐文章于 2024-06-26 21:40:17 发布
最新推荐文章于 2024-06-26 21:40:17 发布
阅读量967 收藏 28
点赞数 10
文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z20230508/article/details/139242952
版权

一、前言

前面几篇都是在 kernel space 对 dma-buf 进行访问的，本篇我们将一起来学习，如何在 user space 访问 dma-buf。当然，user space 访问 dma-buf 也属于 CPU Access 的一种。

二、mmap

为了方便应用程序能直接在用户空间读写 dma-buf 的内存，dma_buf_ops 为我们提供了一个 mmap 回调接口，可以把 dma-buf 的物理内存直接映射到用户空间，这样应用程序就可以像访问普通文件那样访问 dma-buf 的物理内存了。

在linux  设备驱动中，大多数驱动的 mmap 操作接口都是通过调用 remap_pfn_range() 函数来实现的，dma-buf 也不例外。

除了 dma_buf_ops 提供的 mmap 回调接口外，dma-buf 还为我们提供了 dma_buf_mmap() 内核 API，使得我们可以在其他设备驱动中就地取材，直接引用 dma-buf 的 mmap 实现，以此来间接的实现设备驱动的 mmap 文件操作接口.

 

接下来，我们将通过两个示例来演示如何在 Userspace 访问 dma-buf 的物理内存。

  • 示例一：直接使用 dma-buf 的 fd 做 mmap() 操作
  • 示例二：使用 exporter 的 fd 做 mmap() 操作

三、直接使用 dma-buf 的 fd 做 mmap() 操作

本示例主要演示如何在驱动层实现 dma-buf 的 mmap 回调接口，以及如何在用户空间直接使用 dma-buf 的 fd 进行 mmap() 操作。

export_test.c

#include <linux/dma-buf.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/miscdevice.h>

struct dma_buf *dmabuf_export;
EXPORT_SYMBOL(dmabuf_export);

static int exporter_attach(struct dma_buf* dmabuf,  struct dma_buf_attachment *attachment)
{
        pr_info("dmanbuf attach device :%s \n",dev_name(attachment->dev));
        return 0;

}

static void exporter_detach(struct dma_buf *dmabuf, struct dma_buf_attachment *attachment)
{
        pr_info("dmabuf detach device :%s \n",dev_name(attachment->dev));
}

static struct sg_table *exporter_map_dma_buf(struct dma_buf_attachment *attachment,
                                         enum dma_data_direction dir)
{
//      void *vaddr = attachment->dmabuf->priv;
        struct sg_table *table;
        int ret;

        table = kmalloc(sizeof(struct sg_table),GFP_KERNEL);

        ret = sg_alloc_table(table, 1, GFP_KERNEL);
        if(ret)
                pr_info("sg_alloc_table err\n");

        sg_dma_len(table->sgl) = PAGE_SIZE;
        pr_info("sg_dma_len: %d\n ", sg_dma_len(table->sgl));

//      sg_dma_address(table->sgl) = dma_map_single(NULL, vaddr, PAGE_SIZE,dir);
//      pr_info("sg_dma_address: 0x%llx\n",(unsigned long long)sg_dma_address(table->sgl));


        return table;
}

static void exporter_unmap_dma_buf(struct dma_buf_attachment *attachment,
                               struct sg_table *table,
                               enum dma_data_direction dir)
{
        dma_unmap_single(NULL, sg_dma_address(table->sgl), PAGE_SIZE, dir);
        sg_free_table(table);
        kfree(table);
}

static void exporter_release(struct dma_buf *dmabuf)
{
        return kfree(dmabuf->priv);
}

/*static void *exporter_kmap_atomic(struct dma_buf *dmabuf, unsigned long page_num)
{
        return NULL;
}

static void *exporter_kmap(struct dma_buf *dmabuf, unsigned long page_num)
{
        return NULL;
}*/
static void* exporter_vmap(struct dma_buf *dmabuf)
{



        return dmabuf->priv;

}
static int exporter_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma)
{
        void *vaddr = dmabuf->priv;
        struct page * page_ptr = virt_to_page(vaddr);


        return remap_pfn_range(vma,vma->vm_start, page_to_pfn(page_ptr),
                        PAGE_SIZE, vma->vm_page_prot);
}

static const struct dma_buf_ops exp_dmabuf_ops = {
        .attach = exporter_attach,
        .detach = exporter_detach,
        .map_dma_buf = exporter_map_dma_buf,
        .unmap_dma_buf = exporter_unmap_dma_buf,
        .release = exporter_release,
//      .map_atomic = exporter_kmap_atomic,
//      .map = exporter_kmap,

        .vmap = exporter_vmap,
        .mmap = exporter_mmap,
};

static struct dma_buf *exporter_alloc_page(void)
{
        DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
        struct dma_buf *dmabuf;
        void *vaddr;

        vaddr = kzalloc(PAGE_SIZE,GFP_KERNEL);

        exp_info.ops = &exp_dmabuf_ops;
        exp_info.size = PAGE_SIZE;
        exp_info.flags = O_CLOEXEC;
        exp_info.priv = vaddr;

        dmabuf= dma_buf_export(&exp_info);
        if(dmabuf == NULL)
                printk(KERN_INFO"DMA buf export error\n");


        sprintf(vaddr, "hello world");

        return dmabuf;
}

static long exporter_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
        int fd = dma_buf_fd(dmabuf_export, O_CLOEXEC);
       if(unlikely(copy_to_user((void __user*)arg, &fd,sizeof(fd)))){
               return -EFAULT;
       }

        return 0;

}
static struct file_operations  exporter_fops = {
        .owner = THIS_MODULE,
        .unlocked_ioctl = exporter_ioctl,

};

static struct miscdevice mdev ={

        .minor = MISC_DYNAMIC_MINOR,
        .name = "exporter",
        .fops = &exporter_fops,

};


static int __init exporter_init(void)
{
        dmabuf_export = exporter_alloc_page();
        return misc_register(&mdev);

}

static void __exit exporter_exit(void)
{
        misc_deregister(&mdev);

}
module_init(exporter_init);
module_exit(exporter_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("ZWQ");
MODULE_DESCRIPTION("zwq dma used buffer");

从上面的示例可以看到，除了要实现 dma-buf 的 mmap 回调接口外，我们还引入了 misc driver，目的是想通过 misc driver 的 ioctl 接口将 dma-buf 的 fd 传递给上层应用程序，这样才能实现应用程序直接使用这个 dma-buf fd 做 mmap() 操作。

补充：

 

static int exporter_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma)
{
        void *vaddr = dmabuf->priv;
        struct page * page_ptr = virt_to_page(vaddr);


        return remap_pfn_range(vma,vma->vm_start, page_to_pfn(page_ptr),
                        PAGE_SIZE, vma->vm_page_prot);
}
 

 上面的虚拟地址 vaddr 如果使用：

remap_pfn_range(vma, vma->vm_start, virt_to_pfn(vaddr), PAGE_SIZE, vma->vm_page_prot);

这个会编译不过，只能先把vaddr 转换page ,在page 转换成页号

为什么非要通过 ioctl 的方式来传递 fd ？这个问题我会在下一篇中详细讨论。

 在 ioctl 接口中，我们使用到了 dma_buf_fd() 函数，该函数用于创建一个新的 fd，并与该 dma-buf 的文件相绑定。关于该函数，我也会在下一篇中做详细介绍。

userspace 程序

mmap_dmabuf.c

#include <stdio.h>
#include <stddef.h>

#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <sys/mman.h>

int main(int argc, char *argv[])
{
        int fd;
        int dmabuf_fd = 0;

        fd = open("/dev/exporter", O_RDONLY);
        ioctl(fd, 0, &dmabuf_fd);
        close(fd);

        char *str = mmap(NULL, 4096, PROT_READ, MAP_SHARED, dmabuf_fd, 0);
        printf("read from dmabuf mmap: %s\n", str);

        return 0;
}

 编译运行后，结果如下：

可以看到，userspace 程序通过 mmap() 接口成功的访问到 dma-buf 的物理内存。

 

四、使用 exporter 的 fd 做 mmap() 操作

本示例主要演示如何使用 dma_buf_mmap() 内核 API，以此来简化设备驱动的 mmap 文件操作接口的实现。

export_test.c

新增 exporter_misc_mmap() 函数， 具体修改如下：

#include <linux/dma-buf.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/miscdevice.h>

struct dma_buf *dmabuf_export;
EXPORT_SYMBOL(dmabuf_export);

static int exporter_attach(struct dma_buf* dmabuf,  struct dma_buf_attachment *attachment)
{
        pr_info("dmanbuf attach device :%s \n",dev_name(attachment->dev));
        return 0;

}

static void exporter_detach(struct dma_buf *dmabuf, struct dma_buf_attachment *attachment)
{
        pr_info("dmabuf detach device :%s \n",dev_name(attachment->dev));
}

static struct sg_table *exporter_map_dma_buf(struct dma_buf_attachment *attachment,
                                         enum dma_data_direction dir)
{
//      void *vaddr = attachment->dmabuf->priv;
        struct sg_table *table;
        int ret;

        table = kmalloc(sizeof(struct sg_table),GFP_KERNEL);

        ret = sg_alloc_table(table, 1, GFP_KERNEL);
        if(ret)
                pr_info("sg_alloc_table err\n");

        sg_dma_len(table->sgl) = PAGE_SIZE;
        pr_info("sg_dma_len: %d\n ", sg_dma_len(table->sgl));

//      sg_dma_address(table->sgl) = dma_map_single(NULL, vaddr, PAGE_SIZE,dir);
//      pr_info("sg_dma_address: 0x%llx\n",(unsigned long long)sg_dma_address(table->sgl));


        return table;
}

static void exporter_unmap_dma_buf(struct dma_buf_attachment *attachment,
                               struct sg_table *table,
                               enum dma_data_direction dir)
{
        dma_unmap_single(NULL, sg_dma_address(table->sgl), PAGE_SIZE, dir);
        sg_free_table(table);
        kfree(table);
}

static void exporter_release(struct dma_buf *dmabuf)
{
        return kfree(dmabuf->priv);
}

/*static void *exporter_kmap_atomic(struct dma_buf *dmabuf, unsigned long page_num)
{
        return NULL;
}

static void *exporter_kmap(struct dma_buf *dmabuf, unsigned long page_num)
{
        return NULL;
}*/
static void* exporter_vmap(struct dma_buf *dmabuf)
{



        return dmabuf->priv;

}
static int exporter_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma)
{
        void *vaddr = dmabuf->priv;
        struct page * page_ptr = virt_to_page(vaddr);


        return remap_pfn_range(vma,vma->vm_start, page_to_pfn(page_ptr),
                        PAGE_SIZE, vma->vm_page_prot);
}

static const struct dma_buf_ops exp_dmabuf_ops = {
        .attach = exporter_attach,
        .detach = exporter_detach,
        .map_dma_buf = exporter_map_dma_buf,
        .unmap_dma_buf = exporter_unmap_dma_buf,
        .release = exporter_release,
//      .map_atomic = exporter_kmap_atomic,
//      .map = exporter_kmap,

        .vmap = exporter_vmap,
        .mmap = exporter_mmap,
};

static struct dma_buf *exporter_alloc_page(void)
{
        DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
        struct dma_buf *dmabuf;
        void *vaddr;

        vaddr = kzalloc(PAGE_SIZE,GFP_KERNEL);

        exp_info.ops = &exp_dmabuf_ops;
        exp_info.size = PAGE_SIZE;
        exp_info.flags = O_CLOEXEC;
        exp_info.priv = vaddr;

        dmabuf= dma_buf_export(&exp_info);
        if(dmabuf == NULL)
                printk(KERN_INFO"DMA buf export error\n");


        sprintf(vaddr, "hello world");

        return dmabuf;
}

static long exporter_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
        int fd = dma_buf_fd(dmabuf_export, O_CLOEXEC);
       if(unlikely(copy_to_user((void __user*)arg, &fd,sizeof(fd)))){
               return -EFAULT;
       }

        return 0;

}
static int exporter_misc_mmap(struct file *file, struct vm_area_struct *vma)
{
        return dma_buf_mmap(dmabuf_export, vma, 0);
}

static struct file_operations  exporter_fops = {
        .owner = THIS_MODULE,
        .unlocked_ioctl = exporter_ioctl,
        .mmap = exporter_misc_mmap,
};

static struct miscdevice mdev ={

        .minor = MISC_DYNAMIC_MINOR,
        .name = "exporter",
        .fops = &exporter_fops,

};
static int __init exporter_init(void)
{
        dmabuf_export = exporter_alloc_page();
        return misc_register(&mdev);

}

static void __exit exporter_exit(void)
{
        misc_deregister(&mdev);

}
module_init(exporter_init);
module_exit(exporter_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("ZWQ");
MODULE_DESCRIPTION("zwq dma used buffer");

与示例一的驱动相比，示例二的驱动可以不再需要把 dma-buf 的 fd 通过 ioctl 传给上层，而是直接将 dma-buf 的 mmap 回调接口嫁接到 misc driver 的 mmap 文件操作接口上。这样上层在对 misc device 进行 mmap() 操作时，实际映射的是 dma-buf 的物理内存。

userspace 程序

mmap_dmabuf.c

#include <stdio.h>
#include <stddef.h>

#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <sys/mman.h>

int main(int argc, char *argv[])
{
        int fd;
//      int dmabuf_fd = 0;

        fd = open("/dev/exporter", O_RDONLY);
#if 0
        ioctl(fd, 0, &dmabuf_fd);
        close(fd);

        char *str = mmap(NULL, 4096, PROT_READ, MAP_SHARED, dmabuf_fd, 0);
        printf("read from dmabuf mmap: %s\n", str);
#endif
        char *str = mmap(NULL, 4096, PROT_READ, MAP_SHARED,
                        fd, 0);
        printf("read from dmabuf mmap: %s\n", str);
        return 0;
}

与示例一的 userspace 程序相比，示例二不再通过 ioctl() 方式获取 dma-buf 的 fd，而是直接使用 exporter misc device 的 fd 进行 mmap() 操作，此时执行的则是 misc driver 的 mmap 文件操作接口。当然最终输出的结果都是一样的

运行结果：

z20230508
关注
  • 10
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
linux开源显卡驱动 dma,Linux内核笔记之DMA_BUF
weixin_42509614的博客
05-15 970
内存管理始终是底层软件的核心部分，尤其是对于音视频的解码显示功能。本文将通过编写一个实例驱动程序，同内核中的i915显卡驱动进行内存方面的交互来剖析 Linux内核中的通用子系统DMA_BUF。DMA_BUF需求背景考虑这样一种场景，摄像头采集的视频数据需要送到GPU中进行编码、显示。负责数据采集和编码的模块是Linux下不同的驱动设备，将采集设备中的数据送到编码设备中 需要一种方法。最简单的方法...
linux 之dma_buf (3)- dma_buf_attach/dma_buf_map_attachment
z20230508的博客
05-27 576
在上一篇中，我们学习了如何使用 CPU 在 kernel 空间访问 dma-buf 物理内存，但通常这种操作方法在内核中出现的频率并不高，因为 dma-buf 设计之初就是为满足那些大内存访问需求的硬件而设计的，如GPU/DPU。在这种场景下，如果使用CPU直接去访问 memory，那么性能会大大降低。因此，dma-buf 在内核中出现频率最高的还是它的 dma_buf_attach() 和 dma_buf_map_attachment() 接口。
linux 之dma_buf (5)- file
z20230508的博客
05-28 557
曾提到过这个函数，该函数用于创建一个新的 fd，并与dma_buf 的文件关联起来。本篇我们一起来重点学习 dma-buf 与 file 相关的操作接口，以及它们的注意事项。为什么需要 fd？方便应用程序直接在 user space 访问该 buffer（通过 mmap）；方便该 buffer 在各个驱动模块之间流转，而无需拷贝；降低了各驱动之间的耦合度；如何实现 fd 跨进程共享？Binder!get / put 将影响 dma-buf 的内存释放参考资料。
linux 之dma_buf (2)- vmap
z20230508的博客
05-27 528
在内核代码中，我们见得最多的 dma-buf API 莫过于 dma_buf_attach() 、dma_buf_map_attachment()，以至于有些小伙伴会问：dma-buf 难道只能给 DMA 硬件来访问吗？dma_buf_ops 中的 map / map_atomic 接口名，其实原本就叫 kmap / kmap_atomic，只是后来发现与 highmem.h 中的宏定义重名了，为了避免开发人员在自己的驱动中引用 highmem.h 而带来的命名冲突问题，于是去掉了前面的“k”字。
linux之DMA-BUF使用指南
热门推荐
EthanYYYY的博客
11-15 1万+
目录 1 DMA-BUF API使用指南 1.1 数据结构 1.2 外设的dma-buf操作函数 1.3 内核处理器访问dma-buf缓冲区对象 1.4 用户空间通过mmap直接访问缓冲区 2 共享内存：mmap函数实现 3 GstDmaBufAllocator 1 DMA-BUF API使用指南 by JHJ(jianghuijun211@gmail.com) 转载出自：ht...
dma_buf_export
wmzjzwlzs的专栏
06-10 548
/** * DOC: dma buf device access * * For device DMA access to a shared DMA buffer the usual sequence of operations * is fairly simple: * * 1. The exporter defines his exporter instance using * DEFINE_DMA_BUF_EXPORT_INFO() and calls dma_buf_export
Linux图形子系统之dma-buf
fs3296的博客
06-21 1736
dma-buf是linux内核提供的一种机制，用于不同模块实现内存共享。它提供生产者和消费者模式来实现不同模块对内存共享同时，不用关心各个模块的内部实现细节，从而解耦。在drm框架中也集成了dma-buf方式的内存管理。drm通过DRM_IOCTL_PRIME_HANDLE_TO_FD实现将一个gem对象句柄转为dma-buf的fd。其中会调用struct drm_driver的prime_handle_to_fd回调，drm_gem_prime_handle_to_fd函数是prime_handle_to
Linux内核笔记之DMA_BUF
abc3240660的博客
08-22 7986
Linux内核笔记之DMA_BUF Apr 18, 2018 DMA_BUF 需求背景 概述 dma-buf实现 运作流程 Importer驱动实例剖析 Export驱动实例编写 内存管理...
udmabuf:适用于Linux的用户空间可映射dma缓冲区设备驱动程序
05-04
u-dma-buf是Linux设备驱动程序，用于在内核空间中分配连续的内存块作为DMA缓冲区，并使它们在用户空间中可用。 当用户应用程序使用UIO（用户空间I / O）在用户空间中实现设备驱动程序时，打算将这些存储块用作DMA...
linux数据栈的关键数据结构skb_buf
06-05
Linux 数据栈中的关键数据结构 skb_buf 是网络代码中最重要的数据结构之一，它表示接收或发送数据包的包头信息。该结构在 `<include/linux/skbuff.h>` 中定义，并包含了许多成员变量供网络代码中的各子系统使用。 ...
linux数据栈的关键数据结构skb_buf.doc
02-23
linux数据栈的关键数据结构skb
ASM.rar_add buf1_buf2
09-24
已知BUF1,BUF2字节单元中各存放一个无符号数，编写程序完成下述功能： 若两个数中一个是奇数一个是偶数，则奇数存入BUF1单元，偶数存入BUF2单元。 若两个数均为奇数，则分别加1后存回原单元 若两个数均为偶数，则不...
xfs_buf_item.rar_V2
09-24
xfs buf log format size for Linux v2.13.6.
SUSE linux的快照和恢复
大龄IT民工
06-19 1483
openSUSE默认提供了通用场景下的快照设置，你也可以根据需要进行修改。
[Linux] 文件系统
WenBayBay的博客
06-19 652
etc/passwd存放的是用户账户信息，不是密码信息，它有7个字段。/etc/shadow存放的是用户密码信息，有九个字段。一般与系统有关的信息都存放在etc目录下。文件和目录的命名约束。
运维.Linux下执行定时任务（上：Cron简介与用法解析）
jclee95的个人博客
06-25 1321
介绍Linux/Linux系统下，用于执行定时任务的Cron
【LinuxC语言】网络编程中粘包问题
m0_62599305的博客
06-24 399
在进行网络编程时，我们经常会遇到一个非常常见但又往往被忽视的问题，那就是"粘包"问题。粘包是指在基于TCP/IP协议的数据传输过程中，由于TCP/IP协议是基于字节流的，这就可能会导致多个数据包被一起接收，从而形成"粘包"。这个问题在很多网络应用中都可能会出现，特别是在需要进行大量数据传输的应用中，如文件传输、视频流等。粘包是网络编程中一个需要重点关注的问题。虽然TCP/IP协议本身并没有提供解决粘包的机制，但我们可以通过在应用层增加数据包边界，或者使用固定长度的数据包等方法来避免粘包问题。
【Linux】进程信号_3
最新发布
m0_69828905的博客
06-26 345
在进程的PCB中，有两个位图，一个是判断是否收到相应信号的位图pending，一个是决定该位置的信号是否阻塞的位图block。注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,而忽略是在递达之后可选的一种处理动作。被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞,才执行递达的动作。信号从产生到递达之间的状态,称为信号未决(Pending)。9号信号、19号信号无法被屏蔽，18号信号会做特殊处理。可以读取或更改进程的信号屏蔽字(阻塞信号集)。进程可以选择阻塞 (Block )某个信号。
dma_buf_get(BUFSIZE, DMA_ATTR_WRITE_COMBINE); error: too many arguments to function 'dma_buf_get
06-09
这个错误提示表明在调用dma_buf_get函数时传递了太多的参数，导致编译器无法识别该函数。 根据DMA缓冲区的API，dma_buf_get只接受两个参数，分别是缓冲区大小和DMA属性。因此，如果要调用dma_buf_get函数，应该只传递这两个参数，例如： ``` dma_buf_get(BUFSIZE, DMA_ATTR_WRITE_COMBINE); ``` 如果需要将DMA缓冲区映射到用户空间，可以使用dma_buf_vmap函数，例如： ``` struct dma_buf *buf = dma_buf_get(BUFSIZE, DMA_ATTR_WRITE_COMBINE); void *vaddr = dma_buf_vmap(buf); ``` 这样可以将dma_buf_get函数返回的DMA缓冲区映射到用户空间，并返回映射后的虚拟地址。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值