专栏首页人人都是极客没有IOMMU的DMA操作

没有IOMMU的DMA操作

我们知道DMA通常需要访问连续的物理内存,除非设备支持iommu,当设备不支持iommu的话可以用以下方式:

  • 在内核启动时为设备保留内存
  • 将MMU内嵌到设备中,如GPU

这里GPU MMU的方式算是个例外,不在本篇文章讨论范围内。

我们知道DMA映射有两种方式,一种是一致性映射 dma_alloc_coherent一种是流式映射 dma_map_single (dma_map_sg可以映射多个dma buffer)。

一致性映射 dma_alloc_coherent

dma_alloc_coherent会调用dma_alloc_attrs:

static inline void *dma_alloc_attrs(struct device *dev, size_t size,
           dma_addr_t *dma_handle, gfp_t flag,
           unsigned long attrs)
{
 const struct dma_map_ops *ops = get_dma_ops(dev);
 void *cpu_addr;

 BUG_ON(!ops);

 if (dma_alloc_from_dev_coherent(dev, size, dma_handle, &cpu_addr))
  return cpu_addr;

 if (!arch_dma_alloc_attrs(&dev, &flag))
  return NULL;
 if (!ops->alloc)
  return NULL;

 cpu_addr = ops->alloc(dev, size, dma_handle, flag, attrs);
 debug_dma_alloc_coherent(dev, size, *dma_handle, cpu_addr);
 return cpu_addr;
}

ops->alloc对应的回调有两个注册,分别是swiotlb和iommu:

static struct dma_map_ops swiotlb_dma_ops = {
 .alloc = __dma_alloc, //dma_alloc_attrs
 .free = __dma_free,
 .mmap = __swiotlb_mmap,
 .get_sgtable = __swiotlb_get_sgtable,
 .map_page = __swiotlb_map_page, //dma_map_single
 .unmap_page = __swiotlb_unmap_page,
 .map_sg = __swiotlb_map_sg_attrs, //dma_map_sg
 .unmap_sg = __swiotlb_unmap_sg_attrs,
 .sync_single_for_cpu = __swiotlb_sync_single_for_cpu,
 .sync_single_for_device = __swiotlb_sync_single_for_device,
 .sync_sg_for_cpu = __swiotlb_sync_sg_for_cpu,
 .sync_sg_for_device = __swiotlb_sync_sg_for_device,
 .dma_supported = __swiotlb_dma_supported,
 .mapping_error = __swiotlb_dma_mapping_error,
};

static struct dma_map_ops iommu_dma_ops = {
 .alloc = __iommu_alloc_attrs,
 .free = __iommu_free_attrs,
 .mmap = __iommu_mmap_attrs,
 .get_sgtable = __iommu_get_sgtable,
 .map_page = __iommu_map_page,
 .unmap_page = __iommu_unmap_page,
 .map_sg = __iommu_map_sg_attrs,
 .unmap_sg = __iommu_unmap_sg_attrs,
 .sync_single_for_cpu = __iommu_sync_single_for_cpu,
 .sync_single_for_device = __iommu_sync_single_for_device,
 .sync_sg_for_cpu = __iommu_sync_sg_for_cpu,
 .sync_sg_for_device = __iommu_sync_sg_for_device,
 .map_resource = iommu_dma_map_resource,
 .unmap_resource = iommu_dma_unmap_resource,
 .mapping_error = iommu_dma_mapping_error,
};

非iommu的话即调用__dma_alloc:

static void *__dma_alloc(struct device *dev, size_t size,
    dma_addr_t *dma_handle, gfp_t flags,
    unsigned long attrs)
{
  ......
 size = PAGE_ALIGN(size);

 if (!coherent && !gfpflags_allow_blocking(flags)) {
    ......
  //coherent_pool
  void *addr = __alloc_from_pool(size, &page, flags); 

  if (addr)
   *dma_handle = phys_to_dma(dev, page_to_phys(page));

  return addr;
 }

 //cma or buddy or swiotlb
 ptr = __dma_alloc_coherent(dev, size, dma_handle, flags, attrs);
 if (!ptr)
  goto no_mem;
 ......
 return coherent_ptr;
}

其中__alloc_from_pool用来分配 coherent_pool 的内存,__dma_alloc_coherent用来分配 cma 或者 buddy 或者 swiotlb的内存。(实际方案中一般通过memblock的方式划分coherent pool,cma,swiotlb这三种reserved mem

其分配流程如下图所示:

from nxp community by eric chen

相关解释:

为了下面流式映射更好的理解,这里再详细讲下 swiotlb 的分配过程。

__dma_alloc_coherent->swiotlb_alloc_coherent->map_single

static phys_addr_t
map_single(struct device *hwdev, phys_addr_t phys, size_t size,
    enum dma_data_direction dir, unsigned long attrs)
{
 dma_addr_t start_dma_addr;

 if (swiotlb_force == SWIOTLB_NO_FORCE) {
  dev_warn_ratelimited(hwdev, "Cannot do DMA to address %pa\n",
         &phys);
  return SWIOTLB_MAP_ERROR;
 }

 start_dma_addr = swiotlb_phys_to_dma(hwdev, io_tlb_start);
 return swiotlb_tbl_map_single(hwdev, start_dma_addr, phys, size,
          dir, attrs);
}

phys_addr_t swiotlb_tbl_map_single(struct device *hwdev,
       dma_addr_t tbl_dma_addr,
       phys_addr_t orig_addr, size_t size,
       enum dma_data_direction dir,
       unsigned long attrs)
{

  if (io_tlb_list[index] >= nslots) {
   int count = 0;

   for (i = index; i < (int) (index + nslots); i++)
    io_tlb_list[i] = 0;
   for (i = index - 1; (OFFSET(i, IO_TLB_SEGSIZE) != IO_TLB_SEGSIZE - 1) && io_tlb_list[i]; i--)
    io_tlb_list[i] = ++count;
   tlb_addr = io_tlb_start + (index << IO_TLB_SHIFT);

   /*
    * Update the indices to avoid searching in the next
    * round.
    */
   io_tlb_index = ((index + nslots) < io_tlb_nslabs
     ? (index + nslots) : 0);

   goto found;
  }
    ......
    return tlb_addr;
}
  • 申请bounce buffer并且返回虚拟地址,出去再转为dma地址
  • 系统启动的时候就做好了slots和swiotlb内存的映射,这里根据slot可以返回其地址。

至此,dma_alloc_coherent的分配流程就完成了。我们可以看出虽然申请api都是dma_alloc_coherent函数,但是后台的实现有很多种,并且和是否是dma zone也没什么必然关系,本质上只是一块0x0000_0000到0xFFFF_FFFF范围内的连续内存

流式映射 dma_map_single

因为DMA受32位访问的限制,所以只能访问0x0000_0000到0xFFFF_FFFF地址空间的内存,再加上DMA需要访问连续的物理内存,故coherent pool,cma,buddy,swiotlb必须保证在0x0000_0000~0xFFFF_FFFF以内的连续物理空间。 这些没毛病。

但是如果一个64位系统的话,CPU访问内存完全是可以大于0xFFFF_FFFF范围的。比如一个内存的基地址是0x80000000,内存大小是4G,则内存的物理地址范围是0x8000_0000~0x18000_0000。由于DMA寻址范围为0x0000_0000~0xFFFF_FFFF,如果CPU把数据放在0x10000_0000~0x18000_0000这段空间,DMA就无法访问了。

怎么解决上面的问题?

此时swiotlb就登上了历史舞台。

from nxp community by eric chen

swiotlb做的工作如上图所示,主要通过map_single从swiotlb里找到一块buffer叫做Bounce Buffer,然后把CPU访问的Data Buffer与Bounce Buffer映射起来,最后通过swiotlb_bounce把这两个buffer中的数据做个同步(memcpy)。

下面我们通过代码把上面的过程梳理一下。

物理页映射

dma_map_single->dma_map_single_attrs->(ops->map_page)->__swiotlb_map_page-> swiotlb_map_page-> map_single

dma_addr_t swiotlb_map_page(struct device *dev, struct page *page,
       unsigned long offset, size_t size,
       enum dma_data_direction dir,
       unsigned long attrs)
{
 //根据页号获取物理地址,进而获得DMA地址
 phys_addr_t map, phys = page_to_phys(page) + offset;
 dma_addr_t dev_addr = phys_to_dma(dev, phys);

 BUG_ON(dir == DMA_NONE);
 /*
  * If the address happens to be in the device's DMA window,
  * we can safely return the device addr and not worry about bounce
  * buffering it.
  */
 //判断DMA的寻址能力是否能够覆盖上一步得到的物理地址,如果能的话,直接返回物理地址,否则采用swiotlb机制分配内存。
 if (dma_capable(dev, dev_addr, size) && swiotlb_force != SWIOTLB_FORCE)
  return dev_addr;

 trace_swiotlb_bounced(dev, dev_addr, size, swiotlb_force);

 /* Oh well, have to allocate and map a bounce buffer. */
 //用swiotlb机制分配内存
 map = map_single(dev, phys, size, dir, attrs);
 //判断调用swiotlb机制分配的内存物理地址是否在DMA寻址能力范围内,如果在的话直接返回,否则直接返回备用地址
 if (map == SWIOTLB_MAP_ERROR) {
  swiotlb_full(dev, size, dir, 1);
  return swiotlb_phys_to_dma(dev, io_tlb_overflow_buffer);
 }

 dev_addr = swiotlb_phys_to_dma(dev, map);

 /* Ensure that the address returned is DMA'ble */
 if (dma_capable(dev, dev_addr, size))
  return dev_addr;

 attrs |= DMA_ATTR_SKIP_CPU_SYNC;
 swiotlb_tbl_unmap_single(dev, map, size, dir, attrs);

 return swiotlb_phys_to_dma(dev, io_tlb_overflow_buffer);
}
  • CPU访问的内存转为DMA地址
  • 判断DMA的寻址能力是否能够覆盖上一步得到的地址,如果能的话,直接返回地址,否则采用swiotlb机制分配内存。
  • 通过map_single用swiotlb机制分配内存,详情见上面

至此,CPU对应的Data Buffer和DMA对应的Bounce Buffer就映射起来了

数据同步

  • dma_sync_single_for_device
dma_sync_single_for_device
    _swiotlb_sync_single_for_device
        swiotlb_sync_single_for_device
          swiotlb_sync_single(..., SYNC_FOR_DEVICE)
            swiotlb_tbl_sync_single
              swiotlb_bounce(..., DMA_TO_DEVICE)
                memcpy(vaddr, buffer + offset, sz) //将数据从Data Buffer处拷贝到Bounce Buffer
        __dma_map_area
            ENTRY(__dma_map_area)
              cmp     w2, #DMA_FROM_DEVICE
              b.eq    __dma_inv_area //invalid就是使cache中内容无效,下次使用时需要从内存中重新读取
              b       __dma_clean_area //把cache中内容刷到内存中
            ENDPIPROC(__dma_map_area)
  • dma_sync_single_for_cpu
dma_sync_single_for_cpu
    __swiotlb_sync_single_for_cpu
        __dma_unmap_area
            ENTRY(__dma_unmap_area)
              cmp     w2, #DMA_TO_DEVICE
              b.ne    __dma_inv_area //invalid就是使cache中内容无效,下次使用时需要从内存中重新读取
              ret
            ENDPIPROC(__dma_unmap_area)
        swiotlb_sync_single_for_cpu
          swiotlb_sync_single(..., SYNC_FOR_CPU)
            swiotlb_tbl_sync_single
              swiotlb_bounce(..., DMA_FROM_DEVICE)
                memcpy(buffer + offset, vaddr, sz) //将数据从Bounce Buffer处拷贝到Data Buffer

本文分享自微信公众号 - 人人都是极客(rrgeek),作者:布道师Peter

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2021-03-28

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • IOMMU(四)-dma remapping

    DMA remapping就是在DMA的过程中IOMMU进行了一次转换,MMU把CPU的虚拟地址(va)转换成物理地址(pa),IOMMU的作用就是把DMA的虚...

    惠伟
  • DMA和IOMMU(一)-简单介绍

    DMA全称Direct Memory Access,CPU访问外设内存很慢,如果由CPU给外设大量搬运数据,CPU会大量空转等待搬运数据完成,所以发明出DMA ...

    惠伟
  • IOMMU(二)-从配置说起

    做过DPDK/SPDK开发或者用kvm做过pci passthrough的一定知道以下的配置:

    惠伟
  • IOMMU(三)-初始化

    BIOS收集IOMMU相关的信息,通过ACPI中的特定表组织数据,放置在内存中,等操作系统接管硬件后,它会加载驱动,驱动再详细解析ACPI表中的信息。

    惠伟
  • VFIO(Virtual Function IO)研究

    VFIO的全称是Virtual Function IO,但这个名字并不能反应它的特点,以下两个假名字更能反应VFIO的特点:

    Linux阅码场
  • 宋宝华:那些年你误会的Linux DMA(关于Linux DMA ZONE和API最透彻的一篇)

    互联网、Linux内核书籍上充满了各种关于Linux DMA ZONE和dma_alloc_coherent、dma_map_single等的各种讲解,由于很多...

    Linux阅码场
  • 新发现的 thunderclap 漏洞允许黑客使用 Thunderbolt/USB-C 外设攻击 PC

    2月28日早些时候由剑桥大学计算机科学与技术系、莱斯大学和斯坦福国际研究所的一组研究人员公布一个新漏洞Thunderclap,影响所有主要平台,包括MacOS和...

    C4rpeDime
  • DPDK内存篇(一): 基本概念

    内存管理是数据面开发套件(DPDK)的一个核心部分,以此为基础,DPDK的其他部分和用户应用得以发挥其最佳性能。本系列文章将详细介绍DPDK提供的各种内存管理的...

    Linux阅码场
  • ARM SMMU的原理与IOMMU

    如上图所示,smmu 的作用和mmu 类似,mmu作用是替cpu翻译页表将进程的虚拟地址转换成cpu可以识别的物理地址。同理,smmu的作用就是替设备将dma请...

    Linux阅码场

扫码关注云+社区

领取腾讯云代金券