鬼臾区
鬼臾区

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

转载前的话：

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. 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中

    return handle; 

  14. } 

  15.  

先拿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


你可能感兴趣的:(android)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）... weixin_39762838 mac备份android手机通讯录导入iphone
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • Android实现监听事件的方法 Amy木婉清
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
  • 高级UI<第二十四篇>：Android中用到的矩阵常识 NoBugException
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
  • RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
  • kt文件和java文件_Java与Kotlin之间怎样进行互操作 铭空间 kt文件和java文件
    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
  • Android shell 常用 debug 命令 晨春计 Audiodebugandroidlinux
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面 2401_84544531 程序员android面试学习
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT) 计算机源码社 Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
  • android ndk 开发jni调用对象方法，数组参数 wulongkou 开发问题安卓的事ndkandroidstudiojni
    一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
  • Android jni中数组参数的传递方式 lokeyme Andriodandroid开发JNINDKjavac语言
    1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
  • 1-1.Jetpack 之 Navigation 简单编码模板 我命由我12345 Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack
    一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用 erhtre 程序员androidjetpack架构sqlite
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
  • Android干净架构MVI模板使用指南 井美婵Toby
    Android干净架构MVI模板使用指南android-clean-architecture-mvi-boilerplateAforkofourcleanarchitectureboilerplateusingtheModel-View-Intentpattern项目地址:https://gitcode.com/gh_mirrors/an/android-clean-architecture-mv
  • ⭐Unity 安卓环境中正确地读取和处理 XML 文件 惊鸿醉 Unityunityandroidxml
    写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
  • 《Android进阶之光》读书笔记 soleil雪寂 读书笔记#Android进阶之光
    文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
  • 《Android进阶之光》— Android 书籍 王睿丶 Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
  • 《android进阶之光》——多线程编程（上） TAING要一直努力 读书笔记
    今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
  • android进阶之光！Android面试必备的集合源码详解，系列篇 程序员Sunbu 程序员Android
    前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
  • Android-悬浮窗功能的实现（附Java、KT实现源码）(1) egrhef 程序员androidjava开发语言
    //获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
  • Visual Studio中的Android模拟器使用详解 wurui8 androidandroidstudioandroidandroid应用
    关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
  • Unity 热更 之 【HybirdCLR】+【YooAsset】 [安卓 Android端] [代码 + 资源热更] 功能的 简单实现演示 仙魁XAN Unity进阶unityHybirdCLRYooAssetHotUpdate热更新
    Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示目录Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示一、简单介绍二、HybridCLR三、YooAsset四、HybirdCLR引入工程五、YooAsset引入工程六、Python服务器简单构建七、Hybir
  • Android 用线程池实现一个简单的任务队列(Kotlin) 深海呐 Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
  • （小白入门）Windows环境下搭建React Native Android开发环境 码农老黑 前端ReactNative移动开发Androidstudio
    ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
  • Android Dialog圆角设置无效的问题 ly969434341 android
    一，参考AndroidDialog圆角设置无效的问题https://blog.csdn.net/woshi_awei/article/details/99664527Android自定义Dialog实现通用圆角对话框https://cloud.tencent.com/developer/article/1740956二，原因Diallog的默认背景是白色（直角背景），我自定义的Dialog背景也是
  • MultiSnapRecyclerView：让Android RecyclerView的滚动停靠更灵活 技术无疆 Androidandroiduiandroidstudioandroid-studiojavaandroidx
    在Android应用开发中，RecyclerView是一个强大且灵活的组件，用于展示大量数据集合。然而，标准的RecyclerView只支持单一的滚动停靠点，这在某些场景下可能不够灵活。为了解决这个问题，TakuSemba开发了一个名为MultiSnapRecyclerView的库，它允许开发者在RecyclerView中实现多个滚动停靠点。文章目录什么是MultiSnapRecyclerView
  • Android界面特效全汇总 小飞鹤 Android开发详解android
    （一）Activity页面切换的效果Android2.0之后有了overridePendingTransition（），其中里面两个参数，一个是前一个activity的退出两一个activity的进入，Java代码1.@OverridepublicvoidonCreate(BundlesavedInstanceState){2.super.onCreate(savedInstanceState);
  • 多线程编程之卫生间 周凡杨 java并发卫生间线程厕所
    如大家所知，火车上车厢的卫生间很小，每次只能容纳一个人，一个车厢只有一个卫生间，这个卫生间会被多个人同时使用，在实际使用时，当一个人进入卫生间时则会把卫生间锁上，等出来时打开门，下一个人进去把门锁上，如果有一个人在卫生间内部则别人的人发现门是锁的则只能在外面等待。问题分析：首先问题中有两个实体，一个是人，一个是厕所，所以设计程序时就可以设计两个类。人是多数的，厕所只有一个（暂且模拟的是一个车厢）。
  • How to Install GUI to Centos Minimal sunjing linuxInstallDesktopGUI
    http://www.namhuy.net/475/how-to-install-gui-to-centos-minimal.html   I have centos 6.3 minimal running as web server. I’m looking to install gui to my server to vnc to my server. You can insta
  • Shell 函数 daizj shell函数
    Shell 函数 linux shell 可以用户定义函数，然后在shell脚本中可以随便调用。 shell中函数的定义格式如下： [function] funname [()]{ action; [return int;] } 说明： 1、可以带function fun() 定义，也可以直接fun() 定义,不带任何参数。 2、参数返回
  • Linux服务器新手操作之一 周凡杨 Linux 简单 操作
    1.whoami      当一个用户登录Linux系统之后，也许他想知道自己是发哪个用户登录的。      此时可以使用whoami命令。      [ecuser@HA5-DZ05 ~]$ whoami       e
  • 浅谈Socket通信（一） 朱辉辉33 socket
    在java中ServerSocket用于服务器端，用来监听端口。通过服务器监听，客户端发送请求，双方建立链接后才能通信。当服务器和客户端建立链接后，两边都会产生一个Socket实例，我们可以通过操作Socket来建立通信。    首先我建立一个ServerSocket对象。当然要导入java.net.ServerSocket包    ServerSock
  • 关于框架的简单认识 西蜀石兰 框架
    入职两个月多，依然是一个不会写代码的小白，每天的工作就是看代码，写wiki。 前端接触CSS、HTML、JS等语言，一直在用的CS模型，自然免不了数据库的链接及使用，真心涉及框架，项目中用到的BootStrap算一个吧，哦，JQuery只能算半个框架吧，我更觉得它是另外一种语言。 后台一直是纯Java代码，涉及的框架是Quzrtz和log4j。 都说学前端的要知道三大框架，目前node.
  • You have an error in your SQL syntax; check the manual that corresponds to your 林鹤霄
    You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'option,changed_ids  ) values('0ac91f167f754c8cbac00e9e3dc372
  • MySQL5.6的my.ini配置 aigo mysql
    注意：以下配置的服务器硬件是：8核16G内存    [client]   port=3306   [mysql]   default-character-set=utf8     [mysqld]   port=3306   basedir=D:/mysql-5.6.21-win
  • mysql 全文模糊查找 便捷解决方案 alxw4616 mysql
    mysql 全文模糊查找 便捷解决方案 2013/6/14 by 半仙 [email protected] 目的: 项目需求实现模糊查找. 原则: 查询不能超过 1秒. 问题: 目标表中有超过1千万条记录. 使用like '%str%' 进行模糊查询无法达到性能需求. 解决方案: 使用mysql全文索引. 1.全文索引 : MySQL支持全文索引和搜索功能。MySQL中的全文索
  • 自定义数据结构 链表(单项 ,双向,环形) 百合不是茶 单项链表双向链表
         链表与动态数组的实现方式差不多,    数组适合快速删除某个元素    链表则可以快速的保存数组并且可以是不连续的       单项链表;数据从第一个指向最后一个   实现代码:        //定义动态链表 clas
  • threadLocal实例 bijian1013 javathreadjava多线程threadLocal
    实例1： package com.bijian.thread; public class MyThread extends Thread { private static ThreadLocal tl = new ThreadLocal() { protected synchronized Object initialValue() { return new Inte
  • activemq安全设置—设置admin的用户名和密码 bijian1013 javaactivemq
            ActiveMQ使用的是jetty服务器, 打开conf/jetty.xml文件，找到 <bean id="adminSecurityConstraint" class="org.eclipse.jetty.util.security.Constraint"> <p
  • 【Java范型一】Java范型详解之范型集合和自定义范型类 bit1129 java
    本文详细介绍Java的范型，写一篇关于范型的博客原因有两个，前几天要写个范型方法(返回值根据传入的类型而定)，竟然想了半天，最后还是从网上找了个范型方法的写法；再者，前一段时间在看Gson, Gson这个JSON包的精华就在于对范型的优雅简单的处理，看它的源代码就比较迷糊，只其然不知其所以然。所以，还是花点时间系统的整理总结下范型吧。   范型内容 范型集合类 范型类
  • 【HBase十二】HFile存储的是一个列族的数据 bit1129 hbase
    在HBase中，每个HFile存储的是一个表中一个列族的数据，也就是说，当一个表中有多个列簇时，针对每个列簇插入数据，最后产生的数据是多个HFile，每个对应一个列族，通过如下操作验证   1. 建立一个有两个列族的表   create 'members','colfam1','colfam2'   2. 在members表中的colfam1中插入50*5
  • Nginx 官方一个配置实例 ronin47 nginx 配置实例
    user www www; worker_processes 5; error_log logs/error.log; pid logs/nginx.pid; worker_rlimit_nofile 8192; events { worker_connections 4096;} http { include conf/mim
  • java-15.输入一颗二元查找树，将该树转换为它的镜像， 即在转换后的二元查找树中，左子树的结点都大于右子树的结点。 用递归和循环 bylijinnan java
    //use recursion public static void mirrorHelp1(Node node){ if(node==null)return; swapChild(node); mirrorHelp1(node.getLeft()); mirrorHelp1(node.getRight()); } //use no recursion bu
  • 返回null还是empty bylijinnan javaapachespring编程
    第一个问题，函数是应当返回null还是长度为0的数组（或集合）？ 第二个问题，函数输入参数不当时，是异常还是返回null？ 先看第一个问题 有两个约定我觉得应当遵守： 1.返回零长度的数组或集合而不是null（详见《Effective Java》） 理由就是，如果返回empty，就可以少了很多not-null判断： List<Person> list
  • [科技与项目]工作流厂商的战略机遇期 comsci 工作流
          在新的战略平衡形成之前，这里有一个短暂的战略机遇期，只有大概最短6年，最长14年的时间，这段时间就好像我们森林里面的小动物，在秋天中，必须抓紧一切时间存储坚果一样，否则无法熬过漫长的冬季。。。。         在微软，甲骨文，谷歌，IBM,SONY
  • 过度设计-举例 cuityang 过度设计
    过度设计，需要更多设计时间和测试成本，如无必要，还是尽量简洁一些好。 未来的事情，比如 访问量，比如数据库的容量，比如是否需要改成分布式  都是无法预料的 再举一个例子，对闰年的判断逻辑： 　　1、 if($Year%4==0) return True; else return Fasle; 　　2、if (   ($Year%4==0  &am
  • java进阶，《Java性能优化权威指南》试读 darkblue086 java性能优化
    记得当年随意读了微软出版社的.NET 2.0应用程序调试，才发现调试器如此强大，应用程序开发调试其实真的简单了很多，不仅仅是因为里面介绍了很多调试器工具的使用，更是因为里面寻找问题并重现问题的思想让我震撼，时隔多年，Java已经如日中天，成为许多大型企业应用的首选，而今天，这本《Java性能优化权威指南》让我再次找到了这种感觉，从不经意的开发过程让我刮目相看，原来性能调优不是简单地看看热点在哪里，
  • 网络学习笔记初识OSI七层模型与TCP协议 dcj3sjt126com 学习笔记
      协议：在计算机网络中通信各方面所达成的、共同遵守和执行的一系列约定 　　计算机网络的体系结构：计算机网络的层次结构和各层协议的集合。 　　两类服务： 　　面向连接的服务通信双方在通信之前先建立某种状态，并在通信过程中维持这种状态的变化，同时为服务对象预先分配一定的资源。这种服务叫做面向连接的服务。 　　面向无连接的服务通信双方在通信前后不建立和维持状态，不为服务对象
  • mac中用命令行运行mysql dcj3sjt126com mysqllinuxmac
    参考这篇博客：http://www.cnblogs.com/macro-cheng/archive/2011/10/25/mysql-001.html  感觉workbench不好用（有点先入为主了）。 1，安装mysql 在mysql的官方网站下载 mysql 5.5.23 http://www.mysql.com/downloads/mysql/，根据我的机器的配置情况选择了64
  • MongDB查询（1）——基本查询[五] eksliang mongodbmongodb 查询mongodb find
    MongDB查询 转载请出自出处：http://eksliang.iteye.com/blog/2174452 一、find简介 MongoDB中使用find来进行查询。 API:如下 function ( query , fields , limit , skip, batchSize, options ){.....}  参数含义： query:查询参数 fie
  • base64，加密解密 经融加密，对接 y806839048 经融加密对接
    String data0 = new String(Base64.encode(bo.getPaymentResult().getBytes(("GBK")))); String data1 = new String(Base64.decode(data0.toCharArray()),"GBK"); // 注意编码格式，注意用于加密，解密的要是同
  • JavaWeb之JSP概述 ihuning javaweb
      什么是JSP？为什么使用JSP？ JSP表示Java Server Page，即嵌有Java代码的HTML页面。使用JSP是因为在HTML中嵌入Java代码比在Java代码中拼接字符串更容易、更方便和更高效。   JSP起源    在很多动态网页中，绝大部分内容都是固定不变的，只有局部内容需要动态产生和改变。  如果使用Servl
  • apple watch 指南 啸笑天 apple
    1. 文档 WatchKit Programming Guide（中译在线版 By @CocoaChina） 译文 译者 原文 概览 - 开始为 Apple Watch 进行开发 @星夜暮晨 Overview - Developing for Apple Watch 概览 - 配置 Xcode 项目 - Overview - Configuring Yo
  • java经典的基础题目 macroli java编程
    1.列举出 10个JAVA语言的优势 a:免费，开源，跨平台(平台独立性)，简单易用，功能完善，面向对象，健壮性，多线程，结构中立，企业应用的成熟平台, 无线应用 2.列举出JAVA中10个面向对象编程的术语 a:包，类，接口，对象，属性，方法，构造器，继承，封装，多态，抽象，范型 3.列举出JAVA中6个比较常用的包 Java.lang;java.util;java.io;java.sql;ja
  • 你所不知道神奇的js replace正则表达式 qiaolevip 每天进步一点点学习永无止境纵观千象regex
    var v = 'C9CFBAA3CAD0'; console.log(v); var arr = v.split(''); for (var i = 0; i < arr.length; i ++) { if (i % 2 == 0) arr[i] = '%' + arr[i]; } console.log(arr.join('')); console.log(v.r
  • [一起学Hive]之十五-分析Hive表和分区的统计信息(Statistics) superlxw1234 hivehive分析表hive统计信息hive Statistics
    关键字：Hive统计信息、分析Hive表、Hive Statistics   类似于Oracle的分析表，Hive中也提供了分析表和分区的功能，通过自动和手动分析Hive表，将Hive表的一些统计信息存储到元数据中。   表和分区的统计信息主要包括：行数、文件数、原始数据大小、所占存储大小、最后一次操作时间等；   14.1 新表的统计信息 对于一个新创建
  • Spring Boot 1.2.5 发布 wiselyman spring boot
        Spring Boot 1.2.5已在7月2日发布，现在可以从spring的maven库和maven中心库下载。   这个版本是一个维护的发布版，主要是一些修复以及将Spring的依赖提升至4.1.7(包含重要的安全修复)。   官方建议所有的Spring Boot用户升级这个版本。   项目首页 | 源
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他