ION基本概念介绍和原理分析

最新推荐文章于 2023-11-28 21:45:44 发布
最新推荐文章于 2023-11-28 21:45:44 发布
阅读量830 收藏 1
点赞数
分类专栏： Android开发

ION将内核态形形色色的内存分配纳入统一的管理接口之中，更重要的设计意图是为内存在不同用户态进程之间传递和访问提供了支持。

每个ion_buffer与一个struct file关联，其handle纳入进程file desc空间而不是/dev/ion设备内单独的handle空间，方便之处如下：

每个buffer一个handle，便于更灵活地细粒度地控制每个buffer的使用周期；

向用户进程输出fd，细粒度地对每个buffer进行mmap；

使用struct file可以重用已有struct file_operations进行mmap；

在binder driver中以BINDER_TYPE_FD类型为不同进程传递提供支撑，并借助fget/fput从struct file级别进行kref控制；

当不需要在用户态访问时，是不需要与struct file关联的，内核结构ion_handle/ion_buffer唯一的表征了该buffer，所以与struct file关联的工作是在ioctl(ion, ION_IOC_SHARE/ION_ION_MAP, &share)中完成并输出的，用于后续的mmap调用；或者该进程不需要mmap而是仅仅向别的进程binder transfer，这就实现了用户态进行buffer流转控制，而内核态完成buffer数据流转。

 

转自http://blog.csdn.net/kris_fei/article/details/8588661 ＆http://blog.csdn.net/kris_fei/article/details/8618587

考察平台：

chipset: MSM8X25Q

codebase: Android 4.1


ION概念：

 ION是Google的下一代内存管理器，用来支持不同的内存分配机制，如CARVOUT(PMEM)，物理连续内存(kmalloc), 虚拟地址连续但物理不连续内存(vmalloc)， IOMMU等。

用户空间和内核空间都可以使用ION，用户空间是通过/dev/ion来创建client的。

说到client, 顺便看下ION相关比较重要的几个概念。

 Heap: 用来表示内存分配的相关信息，包括id, type, name等。用struct ion_heap表示。

Client: Ion的使用者，用户空间和内核控件要使用ION的buffer,必须先创建一个client,一个client可以有多个buffer，用struct ion_buffer表示。

Handle: 将buffer该抽象出来，可以认为ION用handle来管理buffer，一般用户直接拿到的是handle,而不是buffer。 用struct ion_handle表示。

heap类型：

由于ION可以使用多种memory分配机制，例如物理连续和不连续的，所以ION使用enum ion_heap_type表示。

[cpp] view plain copy
  1. /** 
  2.  * enum ion_heap_types - list of all possible types of heaps 
  3.  * @ION_HEAP_TYPE_SYSTEM:    memory allocated via vmalloc 
  4.  * @ION_HEAP_TYPE_SYSTEM_CONTIG: memory allocated via kmalloc 
  5.  * @ION_HEAP_TYPE_CARVEOUT:  memory allocated from a prereserved 
  6.  *               carveout heap, allocations are physically 
  7.  *               contiguous 
  8.  * @ION_HEAP_TYPE_IOMMU: IOMMU memory 
  9.  * @ION_HEAP_TYPE_CP:    memory allocated from a prereserved 
  10.  *              carveout heap, allocations are physically 
  11.  *              contiguous. Used for content protection. 
  12.  * @ION_HEAP_TYPE_DMA:          memory allocated via DMA API 
  13.  * @ION_HEAP_END:       helper for iterating over heaps 
  14.  */  
  15. enum ion_heap_type {  
  16.     ION_HEAP_TYPE_SYSTEM,  
  17.     ION_HEAP_TYPE_SYSTEM_CONTIG,  
  18.     ION_HEAP_TYPE_CARVEOUT,  
  19.     ION_HEAP_TYPE_IOMMU,  
  20.     ION_HEAP_TYPE_CP,  
  21.     ION_HEAP_TYPE_DMA,  
  22.     ION_HEAP_TYPE_CUSTOM, /* must be last so device specific heaps always 
  23.                  are at the end of this enum */  
  24.     ION_NUM_HEAPS,  
  25. };  


代码中的注释很明确地说明了哪种type对应的是分配哪种memory。不同type的heap需要不同的method去分配，不过都是用struct ion_heap_ops来表示的。如以下例子：

[cpp] view plain copy
  1. static struct ion_heap_ops carveout_heap_ops = {  
  2.     .allocate = ion_carveout_heap_allocate,  
  3.     .free = ion_carveout_heap_free,  
  4.     .phys = ion_carveout_heap_phys,  
  5.     .map_user = ion_carveout_heap_map_user,  
  6.     .map_kernel = ion_carveout_heap_map_kernel,  
  7.     .unmap_user = ion_carveout_heap_unmap_user,  
  8.     .unmap_kernel = ion_carveout_heap_unmap_kernel,  
  9.     .map_dma = ion_carveout_heap_map_dma,  
  10.     .unmap_dma = ion_carveout_heap_unmap_dma,  
  11.     .cache_op = ion_carveout_cache_ops,  
  12.     .print_debug = ion_carveout_print_debug,  
  13.     .map_iommu = ion_carveout_heap_map_iommu,  
  14.     .unmap_iommu = ion_carveout_heap_unmap_iommu,  
  15. };  
  16.   
  17. static struct ion_heap_ops kmalloc_ops = {  
  18.     .allocate = ion_system_contig_heap_allocate,  
  19.     .free = ion_system_contig_heap_free,  
  20.     .phys = ion_system_contig_heap_phys,  
  21.     .map_dma = ion_system_contig_heap_map_dma,  
  22.     .unmap_dma = ion_system_heap_unmap_dma,  
  23.     .map_kernel = ion_system_heap_map_kernel,  
  24.     .unmap_kernel = ion_system_heap_unmap_kernel,  
  25.     .map_user = ion_system_contig_heap_map_user,  
  26.     .cache_op = ion_system_contig_heap_cache_ops,  
  27.     .print_debug = ion_system_contig_print_debug,  
  28.     .map_iommu = ion_system_contig_heap_map_iommu,  
  29.     .unmap_iommu = ion_system_heap_unmap_iommu,  
  30. };  


Heap ID：

同一种type的heap上当然可以分为若该干个chunk供用户使用，所以ION又使用ID来区分了。例如在type为ION_HEAP_TYPE_CARVEOUT的heap上，audio和display部分都需要使用，ION就用ID来区分。

Heap id用enumion_heap_ids表示。

[cpp] view plain copy
  1. /** 
  2.  * These are the only ids that should be used for Ion heap ids. 
  3.  * The ids listed are the order in which allocation will be attempted 
  4.  * if specified. Don't swap the order of heap ids unless you know what 
  5.  * you are doing! 
  6.  * Id's are spaced by purpose to allow new Id's to be inserted in-between (for 
  7.  * possible fallbacks) 
  8.  */  
  9.   
  10. enum ion_heap_ids {  
  11.     INVALID_HEAP_ID = -1,  
  12.     ION_CP_MM_HEAP_ID = 8,  
  13.     ION_CP_MFC_HEAP_ID = 12,  
  14.     ION_CP_WB_HEAP_ID = 16, /* 8660 only */  
  15.     ION_CAMERA_HEAP_ID = 20, /* 8660 only */  
  16.     ION_SF_HEAP_ID = 24,  
  17.     ION_IOMMU_HEAP_ID = 25,  
  18.     ION_QSECOM_HEAP_ID = 26,  
  19.     ION_AUDIO_HEAP_BL_ID = 27,  
  20.     ION_AUDIO_HEAP_ID = 28,  
  21.   
  22.     ION_MM_FIRMWARE_HEAP_ID = 29,  
  23.     ION_SYSTEM_HEAP_ID = 30,  
  24.   
  25.     ION_HEAP_ID_RESERVED = 31 /** Bit reserved for ION_SECURE flag */  
  26. };  


Heap 定义：

       了解了heaptype和id，看看如何被用到了，本平台使用的文件为board-qrd7627a.c，有如下定义：

[cpp] view plain copy
  1. /** 
  2.  * These heaps are listed in the order they will be allocated. 
  3.  * Don't swap the order unless you know what you are doing! 
  4.  */  
  5. struct ion_platform_heap msm7627a_heaps[] = {  
  6.         {  
  7.             .id = ION_SYSTEM_HEAP_ID,  
  8.             .type   = ION_HEAP_TYPE_SYSTEM,  
  9.             .name   = ION_VMALLOC_HEAP_NAME,  
  10.         },  
  11. #ifdef CONFIG_MSM_MULTIMEDIA_USE_ION  
  12.         /* PMEM_ADSP = CAMERA */  
  13.         {  
  14.             .id = ION_CAMERA_HEAP_ID,  
  15.             .type   = CAMERA_HEAP_TYPE,  
  16.             .name   = ION_CAMERA_HEAP_NAME,  
  17.             .memory_type = ION_EBI_TYPE,  
  18.             .extra_data = (void *)&co_mm_ion_pdata,  
  19.             .priv   = (void *)&ion_cma_device.dev,  
  20.         },  
  21.         /* AUDIO HEAP 1*/  
  22.         {  
  23.             .id = ION_AUDIO_HEAP_ID,  
  24.             .type   = ION_HEAP_TYPE_CARVEOUT,  
  25.             .name   = ION_AUDIO_HEAP_NAME,  
  26.             .memory_type = ION_EBI_TYPE,  
  27.             .extra_data = (void *)&co_ion_pdata,  
  28.         },  
  29.         /* PMEM_MDP = SF */  
  30.         {  
  31.             .id = ION_SF_HEAP_ID,  
  32.             .type   = ION_HEAP_TYPE_CARVEOUT,  
  33.             .name   = ION_SF_HEAP_NAME,  
  34.             .memory_type = ION_EBI_TYPE,  
  35.             .extra_data = (void *)&co_ion_pdata,  
  36.         },  
  37.         /* AUDIO HEAP 2*/  
  38.         {  
  39.             .id    = ION_AUDIO_HEAP_BL_ID,  
  40.             .type  = ION_HEAP_TYPE_CARVEOUT,  
  41.             .name  = ION_AUDIO_BL_HEAP_NAME,  
  42.             .memory_type = ION_EBI_TYPE,  
  43.             .extra_data = (void *)&co_ion_pdata,  
  44.             .base = BOOTLOADER_BASE_ADDR,  
  45.         },  
  46.   
  47. #endif  
  48. };  


ION Handle：

当Ion client分配buffer时，相应的一个唯一的handle也会被指定，当然client可以多次申请ion buffer。申请好buffer之后，返回的是一个ion handle, 不过要知道Ion buffer才和实际的内存相关，包括size, address等信息。Struct ion_handle和struct ion_buffer如下：

[cpp] view plain copy
  1. /** 
  2.  * ion_handle - a client local reference to a buffer 
  3.  * @ref:        reference count 
  4.  * @client:     back pointer to the client the buffer resides in 
  5.  * @buffer:     pointer to the buffer 
  6.  * @node:       node in the client's handle rbtree 
  7.  * @kmap_cnt:       count of times this client has mapped to kernel 
  8.  * @dmap_cnt:       count of times this client has mapped for dma 
  9.  * 
  10.  * Modifications to node, map_cnt or mapping should be protected by the 
  11.  * lock in the client.  Other fields are never changed after initialization. 
  12.  */  
  13. struct ion_handle {  
  14.     struct kref ref;  
  15.     struct ion_client *client;  
  16.     struct ion_buffer *buffer;  
  17.     struct rb_node node;  
  18.     unsigned int kmap_cnt;  
  19.     unsigned int iommu_map_cnt;  
  20. };  
  21.   
  22. /** 
  23.  * struct ion_buffer - metadata for a particular buffer 
  24.  * @ref:        refernce count 
  25.  * @node:       node in the ion_device buffers tree 
  26.  * @dev:        back pointer to the ion_device 
  27.  * @heap:       back pointer to the heap the buffer came from 
  28.  * @flags:      buffer specific flags 
  29.  * @size:       size of the buffer 
  30.  * @priv_virt:      private data to the buffer representable as 
  31.  *          a void * 
  32.  * @priv_phys:      private data to the buffer representable as 
  33.  *          an ion_phys_addr_t (and someday a phys_addr_t) 
  34.  * @lock:       protects the buffers cnt fields 
  35.  * @kmap_cnt:       number of times the buffer is mapped to the kernel 
  36.  * @vaddr:      the kenrel mapping if kmap_cnt is not zero 
  37.  * @dmap_cnt:       number of times the buffer is mapped for dma 
  38.  * @sg_table:       the sg table for the buffer if dmap_cnt is not zero 
  39. */  
  40. struct ion_buffer {  
  41.     struct kref ref;  
  42.     struct rb_node node;  
  43.     struct ion_device *dev;  
  44.     struct ion_heap *heap;  
  45.     unsigned long flags;  
  46.     size_t size;  
  47.     union {  
  48.         void *priv_virt;  
  49.         ion_phys_addr_t priv_phys;  
  50.     };  
  51.     struct mutex lock;  
  52.     int kmap_cnt;  
  53.     void *vaddr;  
  54.     int dmap_cnt;  
  55.     struct sg_table *sg_table;  
  56.     int umap_cnt;  
  57.     unsigned int iommu_map_cnt;  
  58.     struct rb_root iommu_maps;  
  59.     int marked;  
  60. };  


ION Client：

         用户空间和内核空间都可以成为client，不过创建的方法稍稍有点区别，先了解下基本的操作流程吧。

 内核空间:

先创建client:

[cpp] view plain copy
  1. struct ion_client *ion_client_create(struct ion_device *dev,  
  2.                      unsigned int heap_mask,  
  3.                      const char *name)  

heap_mask: 可以分配的heap type，如carveout,system heap, iommu等。

高通使用msm_ion_client_create函数封装了下。

有了client之后就可以分配内存：

[cpp] view plain copy
  1. struct ion_handle *ion_alloc(struct ion_client *client, size_t len,  
  2.                  size_t align, unsigned int flags)  

flags: 分配的heap id.

有了handle也就是buffer之后就准备使用了，不过还是物理地址，需要map：

[cpp] view plain copy
  1. void *ion_map_kernel(struct ion_client *client, struct ion_handle *handle,  
  2.             unsigned long flags)  


用户空间:

         用户空间如果想使用ION，也必须先要创建client,不过它是打开/dev/ion,实际上它最终也会调用ion_client_create。

         不过和内核空间创建client的一点区别是，用户空间不能选择heap type（使用预订的heap id隐含heap type），但是内核空间却可以。

         另外，用户空间是通过IOCTL来分配内存的，cmd为ION_IOC_ALLOC.

[cpp] view plain copy
  1. ion_fd = open("/dev/ion", O_ RDONLY | O_SYNC);   
  2. ioctl(ion_fd, ION_IOC_ALLOC, alloc);   

alloc为struct ion_allocation_data,len是申请buffer的长度，flags是heap id。

[cpp] view plain copy
  1. /** 
  2.  * struct ion_allocation_data - metadata passed from userspace for allocations 
  3.  * @len:    size of the allocation 
  4.  * @align:  required alignment of the allocation 
  5.  * @flags:  flags passed to heap 
  6.  * @handle: pointer that will be populated with a cookie to use to refer 
  7.  *      to this allocation 
  8.  * 
  9.  * Provided by userspace as an argument to the ioctl 
  10.  */  
  11. struct ion_allocation_data {  
  12.     size_t len;  
  13.     size_t align;  
  14.     unsigned int flags;  
  15.     struct ion_handle *handle;  
  16. };  

分配好了buffer之后，如果用户空间想使用buffer，先需要mmap. ION是通过先调用IOCTL中的ION_IOC_SHARE/ION_IOC_MAP来得到可以mmap的fd,然后再执行mmap得到bufferaddress.

然后，你也可以将此fd传给另一个进程，如通过binder传递。在另一个进程中通过ION_IOC_IMPORT这个IOCTL来得到这块共享buffer了。

来看一个例子：

[cpp] view plain copy
  1. 进程A：  
  2. int ionfd = open("/dev/ion", O_RDONLY | O_DSYNC);   
  3. alloc_data.len = 0x1000;   
  4. alloc_data.align = 0x1000;   
  5. alloc_data.flags = ION_HEAP(ION_CP_MM_HEAP_ID);    
  6. rc = ioctl(ionfd,ION_IOC_ALLOC, &alloc_data);   
  7. fd_data.handle = alloc_data.handle;    
  8. rc = ioctl(ionfd,ION_IOC_SHARE,&fd_data);    
  9. shared_fd = fd_data.fd;   
  10.   
  11. 进程B：  
  12. fd_data.fd = shared_fd;   
  13. rc = ioctl(ionfd,ION_IOC_IMPORT,&fd_data);   


 

从上一篇ION基本概念中，我们了解了heaptype, heap id, client, handle以及如何使用，本篇再从原理上分析下ION的运作流程。

MSM8x25Q平台使用的是board-qrd7627.c，ION相关定义如下：

[cpp] view plain copy
  1. /** 
  2.  * These heaps are listed in the order they will be allocated. 
  3.  * Don't swap the order unless you know what you are doing! 
  4.  */  
  5. struct ion_platform_heap msm7627a_heaps[] = {  
  6.         {  
  7.             .id = ION_SYSTEM_HEAP_ID,  
  8.             .type   = ION_HEAP_TYPE_SYSTEM,  
  9.             .name   = ION_VMALLOC_HEAP_NAME,  
  10.         },  
  11. #ifdef CONFIG_MSM_MULTIMEDIA_USE_ION  
  12.         /* PMEM_ADSP = CAMERA */  
  13.         {  
  14.             .id = ION_CAMERA_HEAP_ID,  
  15.             .type   = CAMERA_HEAP_TYPE,  
  16.             .name   = ION_CAMERA_HEAP_NAME,  
  17.             .memory_type = ION_EBI_TYPE,  
  18.             .extra_data = (void *)&co_mm_ion_pdata,  
  19.             .priv   = (void *)&ion_cma_device.dev,  
  20.         },  
  21.         /* AUDIO HEAP 1*/  
  22.         {  
  23.             .id = ION_AUDIO_HEAP_ID,  
  24.             .type   = ION_HEAP_TYPE_CARVEOUT,  
  25.             .name   = ION_AUDIO_HEAP_NAME,  
  26.             .memory_type = ION_EBI_TYPE,  
  27.             .extra_data = (void *)&co_ion_pdata,  
  28.         },  
  29.         /* PMEM_MDP = SF */  
  30.         {  
  31.             .id = ION_SF_HEAP_ID,  
  32.             .type   = ION_HEAP_TYPE_CARVEOUT,  
  33.             .name   = ION_SF_HEAP_NAME,  
  34.             .memory_type = ION_EBI_TYPE,  
  35.             .extra_data = (void *)&co_ion_pdata,  
  36.         },  
  37.         /* AUDIO HEAP 2*/  
  38.         {  
  39.             .id    = ION_AUDIO_HEAP_BL_ID,  
  40.             .type  = ION_HEAP_TYPE_CARVEOUT,  
  41.             .name  = ION_AUDIO_BL_HEAP_NAME,  
  42.             .memory_type = ION_EBI_TYPE,  
  43.             .extra_data = (void *)&co_ion_pdata,  
  44.             .base = BOOTLOADER_BASE_ADDR,  
  45.         },  
  46.   
  47. #endif  
  48. };  
  49.   
  50. static struct ion_co_heap_pdata co_ion_pdata = {  
  51.     .adjacent_mem_id = INVALID_HEAP_ID,  
  52.     .align = PAGE_SIZE,  
  53. };  
  54.   
  55. static struct ion_co_heap_pdata co_mm_ion_pdata = {  
  56.     .adjacent_mem_id = INVALID_HEAP_ID,  
  57.     .align = PAGE_SIZE,  
  58. };  
  59.   
  60. static u64 msm_dmamask = DMA_BIT_MASK(32);  
  61.   
  62. static struct platform_device ion_cma_device = {  
  63.     .name = "ion-cma-device",  
  64.     .id = -1,  
  65.     .dev = {  
  66.         .dma_mask = &msm_dmamask,  
  67.         .coherent_dma_mask = DMA_BIT_MASK(32),  
  68.     }  
  69. };  


Qualcomm提示了不要轻易调换顺序，因为后面代码处理是将顺序定死了的，一旦你调换了，代码就无法正常运行了。

另外， 本系统中只使用了ION_HEAP_TYPE_CARVEOUT和 ION_HEAP_TYPE_SYSTEM这两种heap type.

对于ION_HEAP_TYPE_CARVEOUT的内存分配，后面将会发现，其实就是之前讲述过的使用mem pool来分配的。

Platform device如下,在msm_ion.c中用到。

[cpp] view plain copy
  1. static struct ion_platform_data ion_pdata = {  
  2.     .nr = MSM_ION_HEAP_NUM,  
  3.     .has_outer_cache = 1,  
  4.     .heaps = msm7627a_heaps,  
  5. };  
  6.   
  7. static struct platform_device ion_dev = {  
  8.     .name = "ion-msm",  
  9.     .id = 1,  
  10.     .dev = { .platform_data = &ion_pdata },  
  11. };  

ION初始化

转到msm_ion.c，ion.c的某些函数也被重新封装了下.万事都从设备匹配开始：

[cpp] view plain copy
  1. static struct platform_driver msm_ion_driver = {  
  2.     .probe = msm_ion_probe,  
  3.     .remove = msm_ion_remove,  
  4.     .driver = { .name = "ion-msm" }  
  5. };  
  6. static int __init msm_ion_init(void)  
  7. {  
  8.     /*调用msm_ion_probe */  
  9.     return platform_driver_register(&msm_ion_driver);  
  10. }  
  11.   
  12. static int msm_ion_probe(struct platform_device *pdev)  
  13. {  
  14.     /*即board-qrd7627a.c中的ion_pdata */  
  15.     struct ion_platform_data *pdata = pdev->dev.platform_data;  
  16.     int err;  
  17.     int i;  
  18.   
  19.     /*heap数量*/  
  20.     num_heaps = pdata->nr;  
  21.     /*分配struct ion_heap */  
  22.     heaps = kcalloc(pdata->nr, sizeof(struct ion_heap *), GFP_KERNEL);  
  23.   
  24.     if (!heaps) {  
  25.         err = -ENOMEM;  
  26.         goto out;  
  27.     }  
  28.     /*创建节点，最终是/dev/ion,供用户空间操作。*/  
  29.     idev = ion_device_create(NULL);  
  30.     if (IS_ERR_OR_NULL(idev)) {  
  31.         err = PTR_ERR(idev);  
  32.         goto freeheaps;  
  33.     }  
  34.     /*最终是根据adjacent_mem_id 是否定义了来分配相邻内存， 
  35. 我们没用到，忽略此函数。*/  
  36.     msm_ion_heap_fixup(pdata->heaps, num_heaps);  
  37.   
  38.     /* create the heaps as specified in the board file */  
  39.     for (i = 0; i < num_heaps; i++) {  
  40.         struct ion_platform_heap *heap_data = &pdata->heaps[i];  
  41.         /*分配ion*/  
  42.         msm_ion_allocate(heap_data);  
  43.   
  44.         heap_data->has_outer_cache = pdata->has_outer_cache;  
  45.         /*创建ion heap。*/  
  46.         heaps[i] = ion_heap_create(heap_data);  
  47.         if (IS_ERR_OR_NULL(heaps[i])) {  
  48.             heaps[i] = 0;  
  49.             continue;  
  50.         } else {  
  51.             if (heap_data->size)  
  52.                 pr_info("ION heap %s created at %lx "  
  53.                     "with size %x\n", heap_data->name,  
  54.                               heap_data->base,  
  55.                               heap_data->size);  
  56.             else  
  57.                 pr_info("ION heap %s created\n",  
  58.                               heap_data->name);  
  59.         }  
  60.         /*创建的heap添加到idev中，以便后续使用。*/  
  61.         ion_device_add_heap(idev, heaps[i]);  
  62.     }  
  63.     /*检查heap之间是否有重叠部分*/  
  64.     check_for_heap_overlap(pdata->heaps, num_heaps);  
  65.     platform_set_drvdata(pdev, idev);  
  66.     return 0;  
  67.   
  68. freeheaps:  
  69.     kfree(heaps);  
  70. out:  
  71.     return err;  
  72. }  
  73.   
  74. 通过ion_device_create创建/dev/ion节点：  
  75. struct ion_device *ion_device_create(long (*custom_ioctl)  
  76.                      (struct ion_client *client,  
  77.                       unsigned int cmd,  
  78.                       unsigned long arg))  
  79. {  
  80.     struct ion_device *idev;  
  81.     int ret;  
  82.       
  83.     idev = kzalloc(sizeof(struct ion_device), GFP_KERNEL);  
  84.     if (!idev)  
  85.         return ERR_PTR(-ENOMEM);  
  86.     /*是个misc设备*/  
  87.     idev->dev.minor = MISC_DYNAMIC_MINOR;  
  88.     /*节点名字为ion*/  
  89.     idev->dev.name = "ion";  
  90.     /*fops为ion_fops,所以对应ion的操作都会调用ion_fops的函数指针。*/  
  91.     idev->dev.fops = &ion_fops;  
  92.     idev->dev.parent = NULL;  
  93.     ret = misc_register(&idev->dev);  
  94.     if (ret) {  
  95.         pr_err("ion: failed to register misc device.\n");  
  96.         return ERR_PTR(ret);  
  97.     }  
  98.     /*创建debugfs目录，路径为/sys/kernel/debug/ion/*/  
  99.     idev->debug_root = debugfs_create_dir("ion", NULL);  
  100.     if (IS_ERR_OR_NULL(idev->debug_root))  
  101.         pr_err("ion: failed to create debug files.\n");  
  102.   
  103.     idev->custom_ioctl = custom_ioctl;  
  104.     idev->buffers = RB_ROOT;  
  105.     mutex_init(&idev->lock);  
  106.     idev->heaps = RB_ROOT;  
  107.     idev->clients = RB_ROOT;  
  108.     /*在ion目录下创建一个check_leaked_fds文件，用来检查Ion的使用是否有内存泄漏。如果申请了ion之后不需要使用却没有释放，就会导致memory leak.*/  
  109.     debugfs_create_file("check_leaked_fds", 0664, idev->debug_root, idev,  
  110.                 &debug_leak_fops);  
  111.     return idev;  
  112. }  
  113.   
  114. msm_ion_allocate：  
  115. static void msm_ion_allocate(struct ion_platform_heap *heap)  
  116. {  
  117.   
  118.     if (!heap->base && heap->extra_data) {  
  119.         unsigned int align = 0;  
  120.         switch (heap->type) {  
  121.         /*获取align参数*/  
  122.         case ION_HEAP_TYPE_CARVEOUT:  
  123.             align =  
  124.             ((struct ion_co_heap_pdata *) heap->extra_data)->align;  
  125.             break;  
  126.         /*此type我们没使用到。*/  
  127.         case ION_HEAP_TYPE_CP:  
  128.         {  
  129.             struct ion_cp_heap_pdata *data =  
  130.                 (struct ion_cp_heap_pdata *)  
  131.                 heap->extra_data;  
  132.             if (data->reusable) {  
  133.                 const struct fmem_data *fmem_info =  
  134.                     fmem_get_info();  
  135.                 heap->base = fmem_info->phys;  
  136.                 data->virt_addr = fmem_info->virt;  
  137.                 pr_info("ION heap %s using FMEM\n", heap->name);  
  138.             } else if (data->mem_is_fmem) {  
  139.                 const struct fmem_data *fmem_info =  
  140.                     fmem_get_info();  
  141.                 heap->base = fmem_info->phys + fmem_info->size;  
  142.             }  
  143.             align = data->align;  
  144.             break;  
  145.         }  
  146.         default:  
  147.             break;  
  148.         }  
  149.         if (align && !heap->base) {  
  150.             /*获取heap的base address。*/  
  151.             heap->base = msm_ion_get_base(heap->size,  
  152.                               heap->memory_type,  
  153.                               align);  
  154.             if (!heap->base)  
  155.                 pr_err("%s: could not get memory for heap %s "  
  156.                    "(id %x)\n", __func__, heap->name, heap->id);  
  157.         }  
  158.     }  
  159. }  
  160.   
  161. static unsigned long msm_ion_get_base(unsigned long size, int memory_type,  
  162.                     unsigned int align)  
  163. {  
  164.     switch (memory_type) {  
  165.     /*我们定义的是ebi type，看见没，此函数在mem pool中分析过了。 
  166. 原理就是使用Mempool 来管理分配内存。*/  
  167.     case ION_EBI_TYPE:  
  168.         return allocate_contiguous_ebi_nomap(size, align);  
  169.         break;  
  170.     case ION_SMI_TYPE:  
  171.         return allocate_contiguous_memory_nomap(size, MEMTYPE_SMI,  
  172.                             align);  
  173.         break;  
  174.     default:  
  175.         pr_err("%s: Unknown memory type %d\n", __func__, memory_type);  
  176.         return 0;  
  177.     }  
  178. }  
  179. ion_heap_create：  
  180. struct ion_heap *ion_heap_create(struct ion_platform_heap *heap_data)  
  181. {  
  182.     struct ion_heap *heap = NULL;  
  183.     /*根据Heap type调用相应的创建函数。*/  
  184.     switch (heap_data->type) {  
  185.     case ION_HEAP_TYPE_SYSTEM_CONTIG:  
  186.         heap = ion_system_contig_heap_create(heap_data);  
  187.         break;  
  188.     case ION_HEAP_TYPE_SYSTEM:  
  189.         heap = ion_system_heap_create(heap_data);  
  190.         break;  
  191.     case ION_HEAP_TYPE_CARVEOUT:  
  192.         heap = ion_carveout_heap_create(heap_data);  
  193.         break;  
  194.     case ION_HEAP_TYPE_IOMMU:  
  195.         heap = ion_iommu_heap_create(heap_data);  
  196.         break;  
  197.     case ION_HEAP_TYPE_CP:  
  198.         heap = ion_cp_heap_create(heap_data);  
  199.         break;  
  200. #ifdef CONFIG_CMA  
  201.     case ION_HEAP_TYPE_DMA:  
  202.         heap = ion_cma_heap_create(heap_data);  
  203.         break;  
  204. #endif  
  205.     default:  
  206.         pr_err("%s: Invalid heap type %d\n", __func__,  
  207.                heap_data->type);  
  208.         return ERR_PTR(-EINVAL);  
  209.     }  
  210.   
  211.     if (IS_ERR_OR_NULL(heap)) {  
  212.         pr_err("%s: error creating heap %s type %d base %lu size %u\n",  
  213.                __func__, heap_data->name, heap_data->type,  
  214.                heap_data->base, heap_data->size);  
  215.         return ERR_PTR(-EINVAL);  
  216.     }  
  217.     /*保存Heap的name,id和私有数据。*/  
  218.     heap->name = heap_data->name;  
  219.     heap->id = heap_data->id;  
  220.     heap->priv = heap_data->priv;  
  221.     return heap;  
  222. }  

从下面的代码可以得知，ION_HEAP_TYPE_SYSTEM_CONTIG使用kmalloc创建的，ION_HEAP_TYPE_SYSTEM使用的是vmalloc,而ion_carveout_heap_create就是系统预分配了一片内存区域供其使用。Ion在申请使用的时候，会根据当前的type来操作各自的heap->ops。分别看下三个函数：

[cpp] view plain copy
  1. struct ion_heap *ion_system_contig_heap_create(struct ion_platform_heap *pheap)  
  2. {  
  3.     struct ion_heap *heap;  
  4.   
  5.     heap = kzalloc(sizeof(struct ion_heap), GFP_KERNEL);  
  6.     if (!heap)  
  7.         return ERR_PTR(-ENOMEM);  
  8.     /*使用的是kmalloc_ops，上篇有提到哦*/  
  9.     heap->ops = &kmalloc_ops;  
  10.     heap->type = ION_HEAP_TYPE_SYSTEM_CONTIG;  
  11.     system_heap_contig_has_outer_cache = pheap->has_outer_cache;  
  12.     return heap;  
  13. }  
  14. struct ion_heap *ion_system_heap_create(struct ion_platform_heap *pheap)  
  15. {  
  16.     struct ion_heap *heap;  
  17.   
  18.     heap = kzalloc(sizeof(struct ion_heap), GFP_KERNEL);  
  19.     if (!heap)  
  20.         return ERR_PTR(-ENOMEM);  
  21.     /*和上面函数的区别仅在于ops*/  
  22.     heap->ops = &vmalloc_ops;  
  23.     heap->type = ION_HEAP_TYPE_SYSTEM;  
  24.     system_heap_has_outer_cache = pheap->has_outer_cache;  
  25.     return heap;  
  26. }  
  27. struct ion_heap *ion_carveout_heap_create(struct ion_platform_heap *heap_data)  
  28. {  
  29.     struct ion_carveout_heap *carveout_heap;  
  30.     int ret;  
  31.   
  32.     carveout_heap = kzalloc(sizeof(struct ion_carveout_heap), GFP_KERNEL);  
  33.     if (!carveout_heap)  
  34.         return ERR_PTR(-ENOMEM);  
  35.     /* 重新创建一个新的pool，这里有点想不通的是为什么不直接使用全局的mempools呢？*/  
  36.     carveout_heap->pool = gen_pool_create(12, -1);  
  37.     if (!carveout_heap->pool) {  
  38.         kfree(carveout_heap);  
  39.         return ERR_PTR(-ENOMEM);  
  40.     }  
  41.     carveout_heap->base = heap_data->base;  
  42.     ret = gen_pool_add(carveout_heap->pool, carveout_heap->base,  
  43.             heap_data->size, -1);  
  44.     if (ret < 0) {  
  45.         gen_pool_destroy(carveout_heap->pool);  
  46.         kfree(carveout_heap);  
  47.         return ERR_PTR(-EINVAL);  
  48.     }  
  49.     carveout_heap->heap.ops = &carveout_heap_ops;  
  50.     carveout_heap->heap.type = ION_HEAP_TYPE_CARVEOUT;  
  51.     carveout_heap->allocated_bytes = 0;  
  52.     carveout_heap->total_size = heap_data->size;  
  53.     carveout_heap->has_outer_cache = heap_data->has_outer_cache;  
  54.   
  55.     if (heap_data->extra_data) {  
  56.         struct ion_co_heap_pdata *extra_data =  
  57.                 heap_data->extra_data;  
  58.   
  59.         if (extra_data->setup_region)  
  60.             carveout_heap->bus_id = extra_data->setup_region();  
  61.         if (extra_data->request_region)  
  62.             carveout_heap->request_region =  
  63.                     extra_data->request_region;  
  64.         if (extra_data->release_region)  
  65.             carveout_heap->release_region =  
  66.                     extra_data->release_region;  
  67.     }  
  68.     return &carveout_heap->heap;  
  69. }  
  70.   
  71. Heap创建完成，然后保存到idev中：  
  72. void ion_device_add_heap(struct ion_device *dev, struct ion_heap *heap)  
  73. {  
  74.     struct rb_node **p = &dev->heaps.rb_node;  
  75.     struct rb_node *parent = NULL;  
  76.     struct ion_heap *entry;  
  77.   
  78.     if (!heap->ops->allocate || !heap->ops->free || !heap->ops->map_dma ||  
  79.         !heap->ops->unmap_dma)  
  80.         pr_err("%s: can not add heap with invalid ops struct.\n",  
  81.                __func__);  
  82.   
  83.     heap->dev = dev;  
  84.     mutex_lock(&dev->lock);  
  85.     while (*p) {  
  86.         parent = *p;  
  87.         entry = rb_entry(parent, struct ion_heap, node);  
  88.   
  89.         if (heap->id < entry->id) {  
  90.             p = &(*p)->rb_left;  
  91.         } else if (heap->id > entry->id ) {  
  92.             p = &(*p)->rb_right;  
  93.         } else {  
  94.             pr_err("%s: can not insert multiple heaps with "  
  95.                 "id %d\n", __func__, heap->id);  
  96.             goto end;  
  97.         }  
  98.     }  
  99.     /*使用红黑树保存*/  
  100.     rb_link_node(&heap->node, parent, p);  
  101.     rb_insert_color(&heap->node, &dev->heaps);  
  102.     /*以heap name创建fs,位于ion目录下。如vamlloc, camera_preview , audio 等*/  
  103.     debugfs_create_file(heap->name, 0664, dev->debug_root, heap,  
  104.                 &debug_heap_fops);  
  105. end:  
  106.     mutex_unlock(&dev->lock);  
  107. }  

到此，ION初始化已经完成了。接下来该如何使用呢？嗯，通过前面创建的misc设备也就是idev了！还记得里面有个fops为ion_fops吗？先来看下用户空间如何使用ION，最后看内核空间如何使用。

ION用户空间使用

[cpp] view plain copy
  1. Ion_fops结构如下：  
  2. static const struct file_operations ion_fops = {  
  3.     .owner          = THIS_MODULE,  
  4.     .open           = ion_open,  
  5.     .release        = ion_release,  
  6.     .unlocked_ioctl = ion_ioctl,  
  7. };  
  8.   
  9. 用户空间都是通过ioctl来控制。先看ion_open.  
  10.   
  11. static int ion_open(struct inode *inode, struct file *file)  
  12. {  
  13.     struct miscdevice *miscdev = file->private_data;  
  14.     struct ion_device *dev = container_of(miscdev, struct ion_device, dev);  
  15.     struct ion_client *client;  
  16.     char debug_name[64];  
  17.   
  18.     pr_debug("%s: %d\n", __func__, __LINE__);  
  19.     snprintf(debug_name, 64, "%u", task_pid_nr(current->group_leader));  
  20.     /*根据idev和task pid为name创建ion client*/  
  21.     client = ion_client_create(dev, -1, debug_name);  
  22.     if (IS_ERR_OR_NULL(client))  
  23.         return PTR_ERR(client);  
  24.     file->private_data = client;  
  25.   
  26.     return 0;  
  27. }  

前一篇文章有说到，要使用ION, 必须要先创建ion_client, 因此用户空间在open ion的时候创建了client.

[cpp] view plain copy
  1. struct ion_client *ion_client_create(struct ion_device *dev,  
  2.                      unsigned int heap_mask,  
  3.                      const char *name)  
  4. {  
  5.     struct ion_client *client;  
  6.     struct task_struct *task;  
  7.     struct rb_node **p;  
  8.     struct rb_node *parent = NULL;  
  9.     struct ion_client *entry;  
  10.     pid_t pid;  
  11.     unsigned int name_len;  
  12.   
  13.     if (!name) {  
  14.         pr_err("%s: Name cannot be null\n", __func__);  
  15.         return ERR_PTR(-EINVAL);  
  16.     }  
  17.     name_len = strnlen(name, 64);  
  18.   
  19.     get_task_struct(current->group_leader);  
  20.     task_lock(current->group_leader);  
  21.     pid = task_pid_nr(current->group_leader);  
  22.     /* don't bother to store task struct for kernel threads, 
  23.        they can't be killed anyway */  
  24.     if (current->group_leader->flags & PF_KTHREAD) {  
  25.         put_task_struct(current->group_leader);  
  26.         task = NULL;  
  27.     } else {  
  28.         task = current->group_leader;  
  29.     }  
  30.     task_unlock(current->group_leader);  
  31.     /*分配ion client struct.*/  
  32.     client = kzalloc(sizeof(struct ion_client), GFP_KERNEL);  
  33.     if (!client) {  
  34.         if (task)  
  35.             put_task_struct(current->group_leader);  
  36.         return ERR_PTR(-ENOMEM);  
  37.     }  
  38.     /*下面就是保存一系列参数了。*/  
  39.     client->dev = dev;  
  40.     client->handles = RB_ROOT;  
  41.     mutex_init(&client->lock);  
  42.   
  43.     client->name = kzalloc(name_len+1, GFP_KERNEL);  
  44.     if (!client->name) {  
  45.         put_task_struct(current->group_leader);  
  46.         kfree(client);  
  47.         return ERR_PTR(-ENOMEM);  
  48.     } else {  
  49.         strlcpy(client->name, name, name_len+1);  
  50.     }  
  51.   
  52.     client->heap_mask = heap_mask;  
  53.     client->task = task;  
  54.     client->pid = pid;  
  55.   
  56.     mutex_lock(&dev->lock);  
  57.     p = &dev->clients.rb_node;  
  58.     while (*p) {  
  59.         parent = *p;  
  60.         entry = rb_entry(parent, struct ion_client, node);  
  61.   
  62.         if (client < entry)  
  63.             p = &(*p)->rb_left;  
  64.         else if (client > entry)  
  65.             p = &(*p)->rb_right;  
  66.     }  
  67.     /*当前client添加到idev的clients根树上去。*/  
  68.     rb_link_node(&client->node, parent, p);  
  69.     rb_insert_color(&client->node, &dev->clients);  
  70.   
  71.     /*在ION先创建的文件名字是以pid命名的。*/  
  72.     client->debug_root = debugfs_create_file(name, 0664,  
  73.                          dev->debug_root, client,  
  74.                          &debug_client_fops);  
  75.     mutex_unlock(&dev->lock);  
  76.   
  77.     return client;  
  78. }  

有了client之后，用户程序就可以开始申请分配ION buffer了！通过ioctl命令实现。

ion_ioct函数有若干个cmd，ION_IOC_ALLOC和ION_IOC_FREE相对应，表示申请和释放buffer。用户空间程序使用前先要调用ION_IOC_MAP才能得到buffer address，而ION_IOC_IMPORT是为了将这块内存共享给用户空间另一个进程。

[cpp] view plain copy
  1. static long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)  
  2. {  
  3.     struct ion_client *client = filp->private_data;  
  4.   
  5.     switch (cmd) {  
  6.     case ION_IOC_ALLOC:  
  7.     {  
  8.         struct ion_allocation_data data;  
  9.   
  10.         if (copy_from_user(&data, (void __user *)arg, sizeof(data)))  
  11.             return -EFAULT;  
  12.         /*分配buffer.*/  
  13.         data.handle = ion_alloc(client, data.len, data.align,  
  14.                          data.flags);  
  15.   
  16.         if (IS_ERR(data.handle))  
  17.             return PTR_ERR(data.handle);  
  18.   
  19.         if (copy_to_user((void __user *)arg, &data, sizeof(data))) {  
  20.             ion_free(client, data.handle);  
  21.             return -EFAULT;  
  22.         }  
  23.         break;  
  24.     }  
  25.     case ION_IOC_FREE:  
  26.     {  
  27.         struct ion_handle_data data;  
  28.         bool valid;  
  29.   
  30.         if (copy_from_user(&data, (void __user *)arg,  
  31.                    sizeof(struct ion_handle_data)))  
  32.             return -EFAULT;  
  33.         mutex_lock(&client->lock);  
  34.         valid = ion_handle_validate(client, data.handle);  
  35.         mutex_unlock(&client->lock);  
  36.         if (!valid)  
  37.             return -EINVAL;  
  38.         ion_free(client, data.handle);  
  39.         break;  
  40.     }  
  41.     case ION_IOC_MAP:  
  42.     case ION_IOC_SHARE:  
  43.     {  
  44.         struct ion_fd_data data;  
  45.         int ret;  
  46.         if (copy_from_user(&data, (void __user *)arg, sizeof(data)))  
  47.             return -EFAULT;  
  48.         /*判断当前cmd是否被调用过了，调用过就返回，否则设置flags.*/  
  49.         ret = ion_share_set_flags(client, data.handle, filp->f_flags);  
  50.         if (ret)  
  51.             return ret;  
  52.   
  53.         data.fd = ion_share_dma_buf(client, data.handle);  
  54.         if (copy_to_user((void __user *)arg, &data, sizeof(data)))  
  55.             return -EFAULT;  
  56.         if (data.fd < 0)  
  57.             return data.fd;  
  58.         break;  
  59.     }  
  60.     case ION_IOC_IMPORT:  
  61.     {  
  62.         struct ion_fd_data data;  
  63.         int ret = 0;  
  64.         if (copy_from_user(&data, (void __user *)arg,  
  65.                    sizeof(struct ion_fd_data)))  
  66.             return -EFAULT;  
  67.         data.handle = ion_import_dma_buf(client, data.fd);  
  68.         if (IS_ERR(data.handle))  
  69.             data.handle = NULL;  
  70.         if (copy_to_user((void __user *)arg, &data,  
  71.                  sizeof(struct ion_fd_data)))  
  72.             return -EFAULT;  
  73.         if (ret < 0)  
  74.             return ret;  
  75.         break;  
  76.     }  
  77.     case ION_IOC_CUSTOM:  
  78. ~~snip  
  79.     case ION_IOC_CLEAN_CACHES:  
  80.     case ION_IOC_INV_CACHES:  
  81.     case ION_IOC_CLEAN_INV_CACHES:  
  82.     ~~snip  
  83.     case ION_IOC_GET_FLAGS:  
  84. ~~snip  
  85.     default:  
  86.         return -ENOTTY;  
  87.     }  
  88.     return 0;  
  89. }  

下面分小节说明分配和共享的原理。

ION_IOC_ALLOC

[cpp] view plain copy
  1. struct ion_handle *ion_alloc(struct ion_client *client, size_t len,  
  2.                  size_t align, unsigned int flags)  
  3. {  
  4. ~~snip  
  5.   
  6.     mutex_lock(&dev->lock);  
  7.     /*循环遍历当前Heap链表。*/  
  8.     for (n = rb_first(&dev->heaps); n != NULL; n = rb_next(n)) {  
  9.         struct ion_heap *heap = rb_entry(n, struct ion_heap, node);  
  10. /*只有heap type和id都符合才去创建buffer.*/  
  11.         /* if the client doesn't support this heap type */  
  12.         if (!((1 << heap->type) & client->heap_mask))  
  13.             continue;  
  14.         /* if the caller didn't specify this heap type */  
  15.         if (!((1 << heap->id) & flags))  
  16.             continue;  
  17.         /* Do not allow un-secure heap if secure is specified */  
  18.         if (secure_allocation && (heap->type != ION_HEAP_TYPE_CP))  
  19.             continue;  
  20.         buffer = ion_buffer_create(heap, dev, len, align, flags);  
  21. ~~snip  
  22.     }  
  23.     mutex_unlock(&dev->lock);  
  24.   
  25. ~~snip  
  26.     /*创建了buffer之后，就相应地创建handle来管理buffer.*/  
  27.     handle = ion_handle_create(client, buffer);  
  28.   
  29. ~~snip  
  30. }  
  31.   
  32. 找到Heap之后调用ion_buffer_create：  
  33. static struct ion_buffer *ion_buffer_create(struct ion_heap *heap,  
  34.                      struct ion_device *dev,  
  35.                      unsigned long len,  
  36.                      unsigned long align,  
  37.                      unsigned long flags)  
  38. {  
  39.     struct ion_buffer *buffer;  
  40.     struct sg_table *table;  
  41.     int ret;  
  42.     /*分配struct ion buffer,用来管理buffer.*/  
  43.     buffer = kzalloc(sizeof(struct ion_buffer), GFP_KERNEL);  
  44.     if (!buffer)  
  45.         return ERR_PTR(-ENOMEM);  
  46.   
  47.     buffer->heap = heap;  
  48.     kref_init(&buffer->ref);  
  49.     /*调用相应heap type的ops allocate。还记得前面有提到过不同种类的ops吗， 
  50. 如carveout_heap_ops ，vmalloc_ops 。*/  
  51.     ret = heap->ops->allocate(heap, buffer, len, align, flags);  
  52.     if (ret) {  
  53.         kfree(buffer);  
  54.         return ERR_PTR(ret);  
  55.     }  
  56.   
  57.     buffer->dev = dev;  
  58.     buffer->size = len;  
  59.     /*http://lwn.net/Articles/263343/*/  
  60.     table = buffer->heap->ops->map_dma(buffer->heap, buffer);  
  61.     if (IS_ERR_OR_NULL(table)) {  
  62.         heap->ops->free(buffer);  
  63.         kfree(buffer);  
  64.         return ERR_PTR(PTR_ERR(table));  
  65.     }  
  66.     buffer->sg_table = table;  
  67.   
  68.     mutex_init(&buffer->lock);  
  69.     /*将当前ion buffer添加到idev 的buffers 树上统一管理。*/  
  70.     ion_buffer_add(dev, buffer);  
  71.     return buffer;  
  72. }  
[cpp] view plain copy
  1. <p>static struct ion_handle *ion_handle_create(struct ion_client *client,  
  2.          struct ion_buffer *buffer)  
  3. {  
  4.  struct ion_handle *handle;  
  5.  /*分配struct ion_handle.*/  
  6.  handle = kzalloc(sizeof(struct ion_handle), GFP_KERNEL);  
  7.  if (!handle)  
  8.   return ERR_PTR(-ENOMEM);  
  9.  kref_init(&handle->ref);  
  10.  rb_init_node(&handle->node);  
  11.  handle->client = client; //client放入handle中  
  12.  ion_buffer_get(buffer); //引用计数加1   
  13.  handle->buffer = buffer; //buffer也放入handle中</p><p> return handle;  
  14. }  
  15. </p>  

先拿heap type为ION_HEAP_TYPE_CARVEOUT为例，看下它是如何分配buffer的。

allocate对应ion_carveout_heap_allocate。

[cpp] view plain copy
  1. static int ion_carveout_heap_allocate(struct ion_heap *heap,  
  2.                       struct ion_buffer *buffer,  
  3.                       unsigned long size, unsigned long align,  
  4.                       unsigned long flags)  
  5. {  
  6.     buffer->priv_phys = ion_carveout_allocate(heap, size, align);  
  7.     return buffer->priv_phys == ION_CARVEOUT_ALLOCATE_FAIL ? -ENOMEM : 0;  
  8. }  
  9. ion_phys_addr_t ion_carveout_allocate(struct ion_heap *heap,  
  10.                       unsigned long size,  
  11.                       unsigned long align)  
  12. {  
  13.     struct ion_carveout_heap *carveout_heap =  
  14.         container_of(heap, struct ion_carveout_heap, heap);  
  15.     /*通过创建的mem pool来管理buffer,由于这块buffer在初始化的 
  16. 时候就预留了，现在只要从上面拿一块区域就可以了。*/  
  17.     unsigned long offset = gen_pool_alloc_aligned(carveout_heap->pool,  
  18.                             size, ilog2(align));  
  19.     /*分配不成功可能是没有内存空间可供分配了或者是有碎片导致的。*/  
  20.     if (!offset) {  
  21.         if ((carveout_heap->total_size -  
  22.               carveout_heap->allocated_bytes) >= size)  
  23.             pr_debug("%s: heap %s has enough memory (%lx) but"  
  24.                 " the allocation of size %lx still failed."  
  25.                 " Memory is probably fragmented.",  
  26.                 __func__, heap->name,  
  27.                 carveout_heap->total_size -  
  28.                 carveout_heap->allocated_bytes, size);  
  29.         return ION_CARVEOUT_ALLOCATE_FAIL;  
  30.     }  
  31.     /*已经分配掉的内存字节。*/  
  32.     carveout_heap->allocated_bytes += size;  
  33.     return offset;  
  34. }  

同样地，对于heap type为ION_HEAP_TYPE_SYSTEM的分配函数是ion_system_heap_allocate。

[cpp] view plain copy
  1. static int ion_system_contig_heap_allocate(struct ion_heap *heap,  
  2.                        struct ion_buffer *buffer,  
  3.                        unsigned long len,  
  4.                        unsigned long align,  
  5.                        unsigned long flags)  
  6. {  
  7.     /*通过kzalloc分配。*/  
  8.     buffer->priv_virt = kzalloc(len, GFP_KERNEL);  
  9.     if (!buffer->priv_virt)  
  10.         return -ENOMEM;  
  11.     atomic_add(len, &system_contig_heap_allocated);  
  12.     return 0;  
  13. }  

其他的几种Heap type可自行研究，接着调用ion_buffer_add将buffer添加到dev的buffers树上去

[cpp] view plain copy
  1. static void ion_buffer_add(struct ion_device *dev,  
  2.                struct ion_buffer *buffer)  
  3. {  
  4.     struct rb_node **p = &dev->buffers.rb_node;  
  5.     struct rb_node *parent = NULL;  
  6.     struct ion_buffer *entry;  
  7.   
  8.     while (*p) {  
  9.         parent = *p;  
  10.         entry = rb_entry(parent, struct ion_buffer, node);  
  11.   
  12.         if (buffer < entry) {  
  13.             p = &(*p)->rb_left;  
  14.         } else if (buffer > entry) {  
  15.             p = &(*p)->rb_right;  
  16.         } else {  
  17.             pr_err("%s: buffer already found.", __func__);  
  18.             BUG();  
  19.         }  
  20.     }  
  21. /*又是使用红黑树哦！*/  
  22.     rb_link_node(&buffer->node, parent, p);  
  23.     rb_insert_color(&buffer->node, &dev->buffers);  
  24. }  

至此，已经得到client和handle，buffer分配完成！

ION_IOC_MAP/ ION_IOC_SHARE

[cpp] view plain copy
  1. int ion_share_dma_buf(struct ion_client *client, struct ion_handle *handle)  
  2. {  
  3.     struct ion_buffer *buffer;  
  4.     struct dma_buf *dmabuf;  
  5.     bool valid_handle;  
  6.     int fd;  
  7.   
  8.     mutex_lock(&client->lock);  
  9.     valid_handle = ion_handle_validate(client, handle);  
  10.     mutex_unlock(&client->lock);  
  11.     if (!valid_handle) {  
  12.         WARN(1, "%s: invalid handle passed to share.\n", __func__);  
  13.         return -EINVAL;  
  14.     }  
  15.   
  16.     buffer = handle->buffer;  
  17.     ion_buffer_get(buffer);  
  18.     /*生成一个新的file描述符*/  
  19.     dmabuf = dma_buf_export(buffer, &dma_buf_ops, buffer->size, O_RDWR);  
  20.     if (IS_ERR(dmabuf)) {  
  21.         ion_buffer_put(buffer);  
  22.         return PTR_ERR(dmabuf);  
  23.     }  
  24.     /*将file转换用户空间识别的fd描述符。*/  
  25.     fd = dma_buf_fd(dmabuf, O_CLOEXEC);  
  26.     if (fd < 0)  
  27.         dma_buf_put(dmabuf);  
  28.   
  29.     return fd;  
  30. }  
  31. struct dma_buf *dma_buf_export(void *priv, const struct dma_buf_ops *ops,  
  32.                 size_t size, int flags)  
  33. {  
  34.     struct dma_buf *dmabuf;  
  35.     struct file *file;  
  36. ~~snip  
  37.     /*分配struct dma_buf.*/  
  38.     dmabuf = kzalloc(sizeof(struct dma_buf), GFP_KERNEL);  
  39.     if (dmabuf == NULL)  
  40.         return ERR_PTR(-ENOMEM);  
  41.     /*保存信息到dmabuf，注意ops为dma_buf_ops，后面mmap为调用到。*/  
  42.     dmabuf->priv = priv;  
  43.     dmabuf->ops = ops;  
  44.     dmabuf->size = size;  
  45.     /*产生新的file*/  
  46.     file = anon_inode_getfile("dmabuf", &dma_buf_fops, dmabuf, flags);  
  47.   
  48.     dmabuf->file = file;  
  49.   
  50.     mutex_init(&dmabuf->lock);  
  51.     INIT_LIST_HEAD(&dmabuf->attachments);  
  52.   
  53.     return dmabuf;  
  54. }  

通过上述过程，用户空间就得到了新的fd,重新生成一个新的fd的目的是考虑了两个用户空间进程想共享这块heap内存的情况。然后再对fd作mmap，相应地kernel空间就调用到了file 的dma_buf_fops中的dma_buf_mmap_internal。

[cpp] view plain copy
  1. static const struct file_operations dma_buf_fops = {  
  2.     .release    = dma_buf_release,  
  3.     .mmap       = dma_buf_mmap_internal,  
  4. };  
  5. static int dma_buf_mmap_internal(struct file *file, struct vm_area_struct *vma)  
  6.  {  
  7.     struct dma_buf *dmabuf;  
  8.    
  9.     if (!is_dma_buf_file(file))  
  10.         return -EINVAL;  
  11.    
  12.     dmabuf = file->private_data;  
  13.     /*检查用户空间要映射的size是否比目前dmabuf也就是当前heap的size 
  14. 还要大，如果是就返回无效。*/  
  15.     /* check for overflowing the buffer's size */  
  16.     if (vma->vm_pgoff + ((vma->vm_end - vma->vm_start) >> PAGE_SHIFT) >  
  17.         dmabuf->size >> PAGE_SHIFT)  
  18.         return -EINVAL;  
  19.     /*调用的是dma_buf_ops 的mmap函数*/  
  20.     return dmabuf->ops->mmap(dmabuf, vma);  
  21.  }  
  22.   
  23. struct dma_buf_ops dma_buf_ops = {  
  24.     .map_dma_buf = ion_map_dma_buf,  
  25.     .unmap_dma_buf = ion_unmap_dma_buf,  
  26.     .mmap = ion_mmap,  
  27.     .release = ion_dma_buf_release,  
  28.     .begin_cpu_access = ion_dma_buf_begin_cpu_access,  
  29.     .end_cpu_access = ion_dma_buf_end_cpu_access,  
  30.     .kmap_atomic = ion_dma_buf_kmap,  
  31.     .kunmap_atomic = ion_dma_buf_kunmap,  
  32.     .kmap = ion_dma_buf_kmap,  
  33.     .kunmap = ion_dma_buf_kunmap,  
  34. };  
  35. static int ion_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma)  
  36. {  
  37.     struct ion_buffer *buffer = dmabuf->priv;  
  38.     int ret;  
  39.   
  40.     if (!buffer->heap->ops->map_user) {  
  41.         pr_err("%s: this heap does not define a method for mapping "  
  42.                "to userspace\n", __func__);  
  43.         return -EINVAL;  
  44.     }  
  45.   
  46.     mutex_lock(&buffer->lock);  
  47.     /* now map it to userspace */  
  48.     /*调用的是相应heap的map_user，如carveout_heap_ops 调用的是 
  49. ion_carveout_heap_map_user ，此函数就是一般的mmap实现，不追下去了。*/  
  50.     ret = buffer->heap->ops->map_user(buffer->heap, buffer, vma);  
  51.   
  52.     if (ret) {  
  53.         mutex_unlock(&buffer->lock);  
  54.         pr_err("%s: failure mapping buffer to userspace\n",  
  55.                __func__);  
  56.     } else {  
  57.         buffer->umap_cnt++;  
  58.         mutex_unlock(&buffer->lock);  
  59.   
  60.         vma->vm_ops = &ion_vm_ops;  
  61.         /* 
  62.          * move the buffer into the vm_private_data so we can access it 
  63.          * from vma_open/close 
  64.          */  
  65.         vma->vm_private_data = buffer;  
  66.     }  
  67.     return ret;  
  68. }  

至此，用户空间就得到了bufferaddress，然后可以使用了！

ION_IOC_IMPORT

当用户空间另一个进程需要这块heap的时候，ION_IOC_IMPORT就派上用处了！注意，

传进去的fd为在ION_IOC_SHARE中得到的。

[cpp] view plain copy
  1. struct ion_handle *ion_import_dma_buf(struct ion_client *client, int fd)  
  2. {  
  3.       
  4.     struct dma_buf *dmabuf;  
  5.     struct ion_buffer *buffer;  
  6.     struct ion_handle *handle;  
  7.   
  8.     dmabuf = dma_buf_get(fd);  
  9.     if (IS_ERR_OR_NULL(dmabuf))  
  10.         return ERR_PTR(PTR_ERR(dmabuf));  
  11.     /* if this memory came from ion */  
  12. ~~snip  
  13.     buffer = dmabuf->priv;  
  14.   
  15.     mutex_lock(&client->lock);  
  16.     /* if a handle exists for this buffer just take a reference to it */  
  17. /*查找是否已经存在对应的handle了，没有则创建。因为另外一个进程只是 
  18. 调用了open 接口，对应的只创建了client，并没有handle。 
  19. */  
  20.     handle = ion_handle_lookup(client, buffer);  
  21.     if (!IS_ERR_OR_NULL(handle)) {  
  22.         ion_handle_get(handle);  
  23.         goto end;  
  24.     }  
  25.     handle = ion_handle_create(client, buffer);  
  26.     if (IS_ERR_OR_NULL(handle))  
  27.         goto end;  
  28.     ion_handle_add(client, handle);  
  29. end:  
  30.     mutex_unlock(&client->lock);  
  31.     dma_buf_put(dmabuf);  
  32.     return handle;  
  33. }  

这样，用户空间另一个进程也得到了对应的bufferHandle，client/buffer/handle之间连接起来了！然后另一个一个进程就也可以使用mmap来操作这块heap buffer了。

和一般的进程使用ION区别就是共享的进程之间struction_buffer是共享的，而struct ion_handle是各自的。

 可见，ION的使用流程还是比较清晰的。不过要记得的是，使用好了ION，一定要释放掉，否则会导致内存泄露。

ION内核空间使用

内核空间使用ION也是大同小异，按照创建client,buffer,handle的流程，只是它的使用对用户空间来说是透明的罢了！

ion_client_create在kernel空间被Qualcomm给封装了下。

[cpp] view plain copy
  1. struct ion_client *msm_ion_client_create(unsigned int heap_mask,  
  2.                     const char *name)  
  3. {  
  4.     return ion_client_create(idev, heap_mask, name);  
  5. }  

调用的流程也类似，不过map的时候调用的是heap对应的map_kernel()而不是map_user().

msm_ion_client_create -> ion_alloc ->ion_map_kernel

参考文档：

http://lwn.net/Articles/480055/

《ARM体系结构与编程》存储系统章节。

安然无忧
关注
专栏目录
基于Q-learning的深度Q网络 DQN 的工作原理、特点、适用场景和局限性 Deep QLearning Explained
AI天才研究院
08-04 1077
在深度学习（Deep Learning）的热潮下，强化学习（Reinforcement learning，RL）领域也经历了一次变革，各类强化学习算法的最新研究也有所突破。其中一项重量级技术——基于Q-learning的深度Q网络（Deep Q Network，DQN）已经在游戏、Atari、国际象棋等领域中取得了不错的成绩。本文将从Q-learning到DQN，通过详实的论述，阐明DQN的基础知识和原理，并通过示例和图表来具体展示DQN的运行过程。
ION内存管理器介绍
lunhui2016的博客
12-27 5884
ION与CMA学习 1. ION介绍 ION是google在Android4.0为了解决内存碎片化管理而引入的通用内存管理器，用来支持不同的内存分配机制，如CARVOUT(PMEM)，物理连续内存(kmalloc)，虚拟地址连续但物理地址不连续内存(vmalloc)，IOMMU等。 2. ION框架 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0CxQF3tE-1609049784161)(./figures/framework.png)] 名词解释： ion clien
ION基本概念介绍
Kris Fei's blog
02-18 9322
chipset: MSM8X25Q codebase: Android 4.1 ION概念：  ION是Google的下一代内存管理器，用来支持不同的内存分配机制，如CARVOUT(PMEM)，物理连续内存(kmalloc), 虚拟地址连续但物理不连续内存(vmalloc)， IOMMU等。 用户空间和内核空间都可以使用ION，用户空间是通过/dev/ion来创建client的
内存管理 —— ION
热门推荐
zhuyong006的博客
07-23 2万+
ION 是当前 Android 流行的内存分配管理机制，在多媒体部分中使用的最多，例如从 Camera 到 Display，从 Mediaserver 到 Surfaceflinger，都会利用 ION 进行内存分配管理。 ION 的前任是 PMEM，关于 PMEM 我在 M030/M04X 项目中有接触过，后来由于 PMEM 的一些局限性，Google 推出了 ION 来取代 PMEM，当前 I...
ION概念及原理
颇锐克
12-17 2064
ION将内核态形形色色的内存分配纳入统一的管理接口之中，更重要的设计意图是为内存在不同用户态进程之间传递和访问提供了支持。 每个ion_buffer与一个struct file关联，其handle纳入进程file desc空间而不是/dev/ion设备内单独的handle空间，方便之处如下： 每个buffer一个handle，便于更灵活地细粒度地控制每个buffer的使用周期； 向用户进程输
ION原理分析
Kris Fei's blog
02-27 1万+
平台: MSM8x25Q 系统: Android4.1 从上一篇ION基本概念中，我们了解了heaptype, heap id, client, handle以及如何使用，本篇再从原理上分析下ION的运作流程。          MSM8x25Q平台使用的是board-qrd7627.c，ION相关定义如下： /** * These heaps are listed in the o
ion-android:ION Android应用程序的源代码-Android app source code
03-24
这个项目提供了深入理解Android应用开发的机会，特别是对于那些想要探索和学习Android应用底层工作原理的开发者而言，是一个宝贵的资源。让我们详细了解一下这个开源项目及其包含的知识点。 首先，"ION Android"的...
深入解析SpringBoot核心运行原理和运作原理源码
m0_63437643的博客
02-25 1677
SpringBoot核心运行原理 Spring Boot 最核心的功能就是自动配置，第 1 章中我们已经提到，功能的实现都是基于“约定优于配置”的原则。那么 Spring Boot 是如何约定，又是如何实现自动配置功能的呢? 本章会带领大家通过源码学习 Spring Boot 的核心运作原理，内容涉及自动配置的运作原理、核心功能模块、核心注解以及使用到的核心源代码分析。 核心运行原理 使用 Spring Boot 时，我们只需引|入对应的 Starters, Spring Boot 启动时便会自动加
Linux内存管理（四十五）：ION 内存管理器——cma heap
私房菜
11-28 1267
ION是 Google 在 Android 4.0 中引入，目的主要是通过在硬件设备和用户空间之间分配和共享内存，实现设备之间零拷贝共享内存，多用于多媒体，比如 camera、display、graphic等。ION是一个内存管理器，管理不同type的内存堆（heap），而不同的type的内存又通过不同的内存分配器来分配，比如cma、kmalloc、vmalloc等。通过《ION 总篇》
Linux内核驱动：ion memory
hong
02-22 3016
高通msm平台为例，以下是这个平台定义的几个ion内存。 qcom,ion { compatible = "qcom,msm-ion"; #address-cells = <1>; #size-cells = <0>; qcom,ion-heap@25 { reg = <25>; qc
ION 概述
颇锐克
10-02 3983
原文转载自http://blog.csdn.net/g_salamander/article/details/8424334 增加了Gralloc模块的平台背景和功能概述部分。 对原文针对msm8960 Android display做了修正。 增加了Surfaceflinger初始化FrameBufferNativeWindow的代码部分。 平台中内存有ashmen、PMEM等多种内
计算机基础（七）：ION定义与使用方法
TheDayIn_CSDN的博客
01-24 3038
一、ION定义 （1）ION是Google的下一代内存管理器，用来支持不同的内存分配机制，如CARVOUT(PMEM)，物理连续内存(kmalloc), 虚拟地址连续但物理不连续内存(vmalloc)， IOMMU等。 （2）用户空间和内核空间都可以使用ION，用户空间是通过/dev/ion来创建client的。 （3）相关概念 ...
Linux驱动学习--android中的内存管理机制ION(一)--简单介绍
文艺小少年的博客
08-04 1717
目录 一、引言 二、ION的介绍及使用 ------> ION介绍 ------> ION的使用 ------> HEAP种类 三、接口分析 ------> 主要数据结构 ------> 常用接口 一、引言 最近在看android中多图层显示的问题，发现其中用到了一个很重要的内存机制–ION，所以今天就来整理一下 二、ION的介绍及使用 ION的介绍 ION是google在Android4.0 为了解决内存碎片管理而引入的通用内存管理器，是当前 Android 流行的内存分配管
ION memory allocator
qq69696698的专栏
04-16 2787
什么是ION ? 我的理解就是google在android4.0引入的一种内存管理器，来替代之前各个芯片厂家(高通、Intel、TI等)自己的方案.以下是网上找到的：   it has become clear that PMEM is considered obsolete and will be replaced by the ION memory manager . ION is a
The Android ION memory allocator
The simple, The best.
04-18 570
The Android ION memory allocatorION heapsION设计的目标ION的实现在user space使用ION使用场景具体使用细节在kernel中share ION buffer比较ION和DMABUF参考 The Android ION memory allocator 英文原文 ION heaps ION设计的目标 为了避免内存碎片化，或者为一些有着特殊内存需求...
android ion 内存分析
最新发布
12-16
Android ION（IPC over NETwork）是一种使用Android的Binder IPC通信机制进行进程间通信的开源库。在进行内存分析时，我们可以通过以下几个步骤来分析Android ION的内存使用情况。 首先，我们可以使用内存分析工具，如Android Studio提供的Memory Profiler，通过单击“Start Recording”按钮开始记录内存使用情况。然后，我们可以执行包含Android ION代码的操作，例如分配和释放ION内存缓冲区。 接下来，我们可以使用Memory Profiler工具来分析我们的应用程序在执行这些操作时所使用的内存。工具会提供一个内存使用情况的图表，我们可以根据这个图表来判断再分配和释放ION内存缓冲区时是否存在内存泄漏或者过度内存使用的情况。 此外，我们还可以使用Android的Debug.MemoryInfo API来获取有关Android ION内存使用情况的更详细信息。通过使用MemoryInfo对象的getMemoryStats()方法，我们可以获取关于Android ION的内存使用情况的一些统计数据，例如分配的内存缓冲区的数量、总大小等。 最后，在进行完内存分析后，我们可以根据分析结果来优化我们的应用程序。例如，我们可以检查我们的代码是否正确地释放了ION内存缓冲区，并确保我们只分配了我们实际需要的内存大小。我们还可以考虑使用更有效的算法来减少对ION内存缓冲区的需求，从而降低内存使用量。 总结来说，通过使用内存分析工具和Android的Debug.MemoryInfo API，我们可以对Android ION的内存使用情况进行分析和优化，以确保我们的应用程序能够有效地使用ION内存缓冲区，并避免内存泄漏和过度内存使用的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值