没有IOMMU的DMA操作

柔光的暖阳◎ 2022-11-14 11:45 231阅读 0赞

我们知道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**）

其分配流程如下图所示：![9b3fefc47ddb995aa3b16adffcc83b33.png][]

from nxp community by eric chen

相关解释：![297492368b26c0bb86550e4be6fb9a26.png][]

为了下面流式映射更好的理解，这里再详细讲下 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就登上了历史舞台。

![21e0f235cac71b3be27b1340f8bac45a.png][]

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就映射起来了

### 数据同步 ###

![115e59ade991b28043733ad918199713.png][]

*  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

![虚线阴影分割线][2977ee2f1a9dead45dce2e26e18dbb14.png]

![46bac42bee76d8d4890ff5ac296eb582.png][]

5T技术资源大放送！包括但不限于：C/C++，Arm, Linux，Android，人工智能，单片机，树莓派，等等。在公众号内回复「peter」，即可免费获取！！

![83b8437ac692ddb77b1cddf4d9e59cb0.gif][] **记得点击****分享****、****赞****和****在看****，给我充点儿电吧**

[9b3fefc47ddb995aa3b16adffcc83b33.png]: /images/20221022/10e8a24d892b440fbf754806b836ae48.png
[297492368b26c0bb86550e4be6fb9a26.png]: /images/20221022/f3c58f32009d42429e023be423818c3b.png
[21e0f235cac71b3be27b1340f8bac45a.png]: /images/20221022/b802c79970f448f697428f715bf097b7.png
[115e59ade991b28043733ad918199713.png]: /images/20221022/58016680090c445b99e95f582bba92e9.png
[2977ee2f1a9dead45dce2e26e18dbb14.png]: /images/20221022/d518eb4dd0804c3ba84093d81f97683a.png
[46bac42bee76d8d4890ff5ac296eb582.png]: /images/20221022/cf69751438e14c749ecb70ba19c4d6b3.png
[83b8437ac692ddb77b1cddf4d9e59cb0.gif]: /images/20221022/d9fb3878c7844a6ebe03e1230b2c687b.png