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

落日映苍穹つ 2022-06-02 00:59 746阅读 0赞

http://blog.csdn.net/cosmoslhf/article/details/41209925

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

转载  2014年11月17日 15:17:05

# [参考文档：][Link 1] #

[**http://lwn.net/Articles/480055/**][http_lwn.net_Articles_480055]

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

1.  [ION初始化][ION]
2.  [ION用户空间使用][ION 1]
    
    1.  [ION\_IOC\_ALLOC][ION_IOC_ALLOC]
    2.  [ION\_IOC\_MAP ION\_IOC\_SHARE][ION_IOC_MAP ION_IOC_SHARE]
    3.  [ION\_IOC\_IMPORT][ION_IOC_IMPORT]
3.  [ION内核空间使用][ION 2]
4.  [参考文档][Link 2]

**转载前的话：**

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_8588661] ＆[http://blog.csdn.net/kris\_fei/article/details/8618587][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][Link 1] [copy][Link 1]

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. \};

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

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

**\[cpp\]** [ view plain][Link 1] [copy][Link 1]

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. \};

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

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][Link 1] [copy][Link 1]

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. \};

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

Heap 定义：

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

**\[cpp\]** [ view plain][Link 1] [copy][Link 1]

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. \};

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

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][Link 1] [copy][Link 1]

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. \};

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

ION Client：

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

内核空间:

先创建client:

**\[cpp\]** [ view plain][Link 1] [copy][Link 1]

1.  struct ion\_client \*ion\_client\_create(struct ion\_device \*dev,  
2.                       unsigned int heap\_mask,  
3.                       const char \*name)

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

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

高通使用msm\_ion\_client\_create函数封装了下。

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

**\[cpp\]** [ view plain][Link 1] [copy][Link 1]

1.  struct ion\_handle \*ion\_alloc(struct ion\_client \*client, size\_t len,  
2.                   size\_t align, unsigned int flags)

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

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][Link 1] [copy][Link 1]

1.  void \*ion\_map\_kernel(struct ion\_client \*client, struct ion\_handle \*handle,  
2.              unsigned long flags)

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

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][Link 1] [copy][Link 1]

1.  ion\_fd = open("/dev/ion", O\_ RDONLY | O\_SYNC);   
2.  ioctl(ion\_fd, ION\_IOC\_ALLOC, alloc);

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

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][Link 1] [copy][Link 1]

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. \};

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

分配好了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][Link 1] [copy][Link 1]

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);

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

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

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

**\[cpp\]** [ view plain][Link 1] [copy][Link 1]

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

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][Link 1] [copy][Link 1]

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. \};

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

# ION初始化 #

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

**\[cpp\]** [ view plain][Link 1] [copy][Link 1]

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. \}

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

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

**\[cpp\]** [ view plain][Link 1] [copy][Link 1]

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. \}

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

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

# ION用户空间使用 #

**\[cpp\]** [ view plain][Link 1] [copy][Link 1]

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. \}

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

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

**\[cpp\]** [ view plain][Link 1] [copy][Link 1]

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. \}

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

有了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][Link 1] [copy][Link 1]

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. \}

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

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

## ION\_IOC\_ALLOC ##

**\[cpp\]** [ view plain][Link 1] [copy][Link 1]

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][view plain] [ copy][view plain]

**\[cpp\]** [ view plain][Link 1] [copy][Link 1]

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>

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

先拿heap type为ION\_HEAP\_TYPE\_CARVEOUT为例，看下它是如何分配buffer的。

allocate对应ion\_carveout\_heap\_allocate。

**\[cpp\]** [ view plain][Link 1] [copy][Link 1]

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. \}

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

同样地，对于heap type为ION\_HEAP\_TYPE\_SYSTEM的分配函数是ion\_system\_heap\_allocate。

**\[cpp\]** [ view plain][Link 1] [copy][Link 1]

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. \}

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

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

**\[cpp\]** [ view plain][Link 1] [copy][Link 1]

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. \}

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

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

## ION\_IOC\_MAP/ ION\_IOC\_SHARE ##

**\[cpp\]** [ view plain][Link 1] [copy][Link 1]

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. \}

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

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

**\[cpp\]** [ view plain][Link 1] [copy][Link 1]

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. \}

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

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

## ION\_IOC\_IMPORT ##

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

传进去的fd为在ION\_IOC\_SHARE中得到的。

**\[cpp\]** [ view plain][Link 1] [copy][Link 1]

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. \}

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

这样，用户空间另一个进程也得到了对应的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][Link 1] [copy][Link 1]

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.  \}

**\[cpp\]** [ view plain][view plain] [ copy][view plain]

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

msm\_ion\_client\_create -> ion\_alloc ->ion\_map\_kernel

为什么需要ION

回顾2011年末\[2\]，LWN审查了android kernel patch\[3\]，以期望将这些patch合并到kernel主线中。但是PMEM（android实现的 一个内存分配器）使这个愿望破灭了。为什么PMEM不被linux 社区接受的原因在\[3\]中有讲到。从那开始，PMEM很明确会被完全抛弃，取而代之的是ION内存管理器。ION是google在Android4.0 ICS为了解决内存碎片管理而引入的通用内存管理器，它会更加融合kernel。目前QCOM MSM, NVDIA Tegra, TI OMAP, MRVL PXA都用ION替换PMEM。

##  如何获取source code ##

http://android.googlesource.com/kernel/common.git

ION codes reside in drivers/gpu/ion

Specific usage examples on omap4:

http://android.googlesource.com/kernel/omap.git

##  ION 框架\[1\] ##

ION 定义了四种不同的heap，实现不同的内存分配策略。

*  ION\_HEAP\_TYPE\_SYSTEM : 通过vmalloc分配内存
 *  ION\_HEAP\_TYPE\_SYSTEM\_CONTIG: 通过kmalloc分配内存
 *  ION\_HEAP\_TYPE\_CARVEOUT: 在保留内存块中（reserve memory）分配内存
 *  ION\_HEAP\_TYPE\_CUSTOM: 由客户自己定义

![SouthEast][]

下图是两个client共享内存的示意图。图中有2个heap（每种heap都有自己的内存分配策略），每个heap中分配了若干个buffer。client的handle管理到对应的buffer。两个client是通过文件描述符fd来实现内存共享的。

![SouthEast 1][]

## ION APIs ##

### 用户空间 API ###

定义了6种 ioctl 接口，可以与用户应用程序交互。

*  ION\_IOC\_ALLOC: 分配内存
 *  ION\_IOC\_FREE: 释放内存
 *  ION\_IOC\_MAP: 获取文件描述符进行mmap  (? 在code中未使用这个定义)
 *  ION\_IOC\_SHARE: 创建文件描述符来实现共享内存
 *  ION\_IOC\_IMPORT: 获取文件描述符
 *  ION\_IOC\_CUSTOM: 调用用户自定义的ioctl

ION\_IOC\_SHARE 及ION\_IOC\_IMPORT是基于DMABUF实现的，所以当共享进程获取文件描述符后，可以直接调用mmap来操作共享内存。mmap实现由DMABUF子系统调用ION子系统中mmap回调函数完成。

### 内核空间 API ###

内核驱动也可以注册为一个ION的客户端（client），可以选择使用哪种类型的heap来申请内存。

*  ion\_client\_create: 分配一个客户端。
 *  ion\_client\_destroy: 释放一个客户端及绑定在它上面的所有ion handle.

ion handle: 这里每个ion handle映射到一个buffer中，每个buffer关联一个heap。也就是说一个客户端可以操作多块buffer。

Buffer 申请及释放函数:

*  ion\_alloc: 申请ion内存，返回ion handle
 *  ion\_free: 释放ion handle

ION 通过handle来管理buffer，驱动需要可以访问到buffer的地址。ION通过下面的函数来达到这个目的

*  ion\_phys: 返回buffer的物理地址(address)及大小(size)
 *  ion\_map\_kernel: 给指定的buffer创建内核内存映射
 *  ion\_unmap\_kernel: 销毁指定buffer的内核内存映射
 *  ion\_map\_dma: 为指定buffer创建dma 映射，返回sglist（scatter/gather list）
 *  ion\_unmap\_dma: 销毁指定buffer的dma映射

ION是通过handle而非buffer地址来实现驱动间共享内存，用户空间共享内存也是利用同样原理。

*  ion\_share: given a handle, obtain a buffer to pass to other clients
 *  ion\_import: given an buffer in another client, import it
 *  ion\_import\_fd: given an fd obtained via ION\_IOC\_SHARE ioctl, import it

## Heap API ##

Heap 接口定义 \[drivers/gpu/ion/ion\_priv.h\]

这些接口不是暴露给驱动或者用户应用程序的。

/**
     * struct ion_heap_ops - ops to operate on a given heap
     * @allocate:           allocate memory
     * @free:               free memory
     * @phys                get physical address of a buffer (only define on physically contiguous heaps)
     * @map_dma             map the memory for dma to a scatterlist
     * @unmap_dma           unmap the memory for dma
     * @map_kernel          map memory to the kernel
     * @unmap_kernel        unmap memory to the kernel
     * @map_user            map memory to userspace
     */
    struct ion_heap_ops {
            int (*allocate) (struct ion_heap *heap, struct ion_buffer *buffer, unsigned long len,unsigned long align, unsigned long flags);
            void (*free) (struct ion_buffer *buffer);
            int (*phys) (struct ion_heap *heap, struct ion_buffer *buffer, ion_phys_addr_t *addr, size_t *len);
            struct scatterlist *(*map_dma) (struct ion_heap *heap, struct ion_buffer *buffer);
            void (*unmap_dma) (struct ion_heap *heap, struct ion_buffer *buffer);
            void * (*map_kernel) (struct ion_heap *heap, struct ion_buffer *buffer);
            void (*unmap_kernel) (struct ion_heap *heap, struct ion_buffer *buffer);
            int (*map_user) (struct ion_heap *mapper, struct ion_buffer *buffer, struct vm_area_struct *vma);
    };

## ION debug ##

ION 在/sys/kernel/debug/ion/ 提供一个debugfs 接口。

每个heap都有自己的debugfs目录，client内存使用状况显示在/sys/kernel/debug/ion/<<heap name>>

$cat /sys/kernel/debug/ion/ion-heap-1 
              client              pid             size
            test_ion             2890            16384

每个由pid标识的client也有一个debugfs目录/sys/kernel/debug/ion/<<pid>>

$cat /sys/kernel/debug/ion/2890 
           heap_name:    size_in_bytes
          ion-heap-1:    40960 11

参考文献

1. https://wiki.linaro.org/BenjaminGaignard/ion

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

3. http://lwn.net/Articles/472984/

### 内核内存池管理技术实现分析 ###

一．Linux系统内核内存管理简介

Linux采用“按需调页”算法，支持三层页式存储管理策略。将每个用户进程4GB长度的虚拟内存划分成固定大小的页面。其中0至3GB是用户态空间，由各进程独占；3GB到4GB是内核态空间，由所有进程共享，但只有内核态进程才能访问。

Linux将物理内存也划分成固定大小的页面，由数据结构page管理，有多少页面就有多少page结构，它们又作为元素组成一个数组mem\_map\[\]。

slab：在操作系统的运作过程中，经常会涉及到大量对象的重复生成、使用和释放问题。对象生成算法的改进，可以在很大程度上提高整个系统的性能。在Linux系统中所用到的对象，比较典型的例子是inode、task\_struct等，都又这些特点。一般说来，这类对象的种类相对稳定，每种对象的数量却是巨大的，并且在初始化与析构时要做大量的工作，所占用的时间远远超过内存分配的时间。但是这些对象往往具有这样一个性质，即他们在生成时，所包括的成员属性值一般都赋成确定的数值，并且在使用完毕，释放结构前，这些属性又恢复为未使用前的状态。因此，如果我们能够用合适的方法使得在对象前后两次背使用时，在同一块内存，或同一类内存空间，且保留了基本的数据结构，就可以大大提高效率。slab算法就是针对上述特点设计的。

slab算法思路中最基本的一点被称为object-caching，即对象缓存。其核心做法就是保留对象初始化状态的不变部分，这样对象就用不着在每次使用时重新初始化（构造）及破坏（析构）。

面向对象的slab分配中有如下几个术语：

l         缓冲区（cache）：一种对象的所有实例都存在同一个缓存区中。不同的对象，即使大小相同，也放在不同的缓存区内。每个缓存区有若干个slab，按照满，半满，空的顺序排列。在slab分配的思想中，整个内核态内存块可以看作是按照这种缓存区来组织的，对每一种对象使用一种缓存区，缓存区的管理者记录了这个缓存区中对象的大小，性质，每个slab块中对象的个数以及每个slab块大小。

l         slab块：slab块是内核内存分配与页面级分配的接口。每个slab块的大小都是页面大小的整数倍，有若干个对象组成。slab块共分为三类：

完全块：没有空闲对象。

部分块：只分配了部分对象空间，仍有空闲对象。

空闲块：没有分配对象，即整个块内对象空间均可分配。

在申请新的对象空间时，如果缓冲区中存在部分块，那么首先查看部分块寻找空闲对象空间，若未成功再查看空闲块，如果还未成功则为这个对象分配一块新的slab块。

l         对象：将被申请的空间视为对象，使用构造函数初始化对象，然后由用户使用对象。

二．内存池的数据结构

Linux内存池是在2.6版内核中加入的，主要的数据结构定义在mm/mempool.c中。

typedef struct mempool\_s \{

spinlock\_t lock;

int min\_nr;             /\* elements数组中的成员数量 \*/

int curr\_nr;            /\* 当前elements数组中空闲的成员数量 \*/

void \*\*elements;    /\* 用来存放内存成员的二维数组，其长度为min\_nr，宽度是上述各个内存对象的长度，因为对于不同的对象类型，我们会创建相应的内存池对象，所以每个内存池对象实例的element宽度都是跟其内存对象相关的 \*/

void \*pool\_data;     /\* 内存池与内核缓冲区结合使用（上面的简介当中提到了，Linux采用slab技术预先为每一种内存对象分配了缓存区，每当我们申请某个类型的内存对象时，实际是从这种缓存区获取内存），这个指针一般是指向这种内存对象对应的缓存区的指针 \*/

mempool\_alloc\_t \*alloc; /\* 用户在创建一个内存池对象时提供的内存分配函数，这个函数可以用户自行编写（因为对于某个内存对象如何获取内存，其开发者完全可以自行控制），也可以采用内存池提供的分配函数 \*/

mempool\_free\_t \*free;   /\* 内存释放函数，其它同上 \*/

wait\_queue\_head\_t wait;/\* 任务等待队列 \*/

\} mempool\_t;

三．内核缓存区和内存池的初始化

上面提到，内存池的使用是与特定类型的内存对象缓存区相关联的。例如，在系统rpc服务中，系统初始化时，会为rpc\_buffers预先分配缓存区，调用如下语句：

rpc\_buffer\_slabp = kmem\_cache\_create("rpc\_buffers",

RPC\_BUFFER\_MAXSIZE,

0, SLAB\_HWCACHE\_ALIGN,

NULL, NULL);

调用kmem\_cache\_create函数从系统缓存区cache\_cache中获取长度为RPC\_BUFFER\_MAXSIZE的缓存区大小的内存，作为rpc\_buffer使用的缓存区。而以后对rpc操作的所有数据结构内存都是从这块缓存区申请，这是linux的slab技术的要点，而内存池也是基于这段缓存区进行的操作。

一旦rpc服务申请到了一个缓存区rpc\_buffer\_slabp以后，就可以创建一个内存池来管理这个缓存区了：

rpc\_buffer\_mempool = mempool\_create(RPC\_BUFFER\_POOLSIZE,

mempool\_alloc\_slab,

mempool\_free\_slab,

rpc\_buffer\_slabp);

mempool\_create函数就是内存池创建函数，负责为一类内存对象构造一个内存池，传递的参数包括，内存池大小，定制的内存分配函数，定制的内存析构函数，这个对象的缓存区指针。下面是mempool\_create函数的具体实现：

/\*\*

\* mempool\_create – 创建一个内存池对象

\* @min\_nr:       为内存池分配的最小内存成员数量

\* @alloc\_fn:       用户自定义内存分配函数

\* @free\_fn:       用户自定义内存释放函数

\* @pool\_data:     根据用户自定义内存分配函数所提供的可选私有数据，一般是缓存区指针

\*/

mempool\_t \* mempool\_create(int min\_nr, mempool\_alloc\_t \*alloc\_fn,

mempool\_free\_t \*free\_fn, void \*pool\_data)

mempool\_t \*pool;

/\*为内存池对象分配内存\*/

pool = kmalloc(sizeof(\*pool), GFP\_KERNEL);

if (!pool)

return NULL;

memset(pool, 0, sizeof(\*pool));

/\*根据内存池的最小长度为elements数组分配内存\*/

pool->elements = kmalloc(min\_nr \* sizeof(void \*), GFP\_KERNEL);

if (!pool->elements) \{

kfree(pool);

return NULL;

spin\_lock\_init(&pool->lock);

/\*初始化内存池的相关参数\*/

pool->min\_nr = min\_nr;

pool->pool\_data = pool\_data;

init\_waitqueue\_head(&pool->wait);

pool->alloc = alloc\_fn;

pool->free = free\_fn;

/\*首先为内存池预先分配min\_nr个element对象，这些对象就是为了存储相应类型的内存对象的。数据结构形入：

![.bmp][]

\*/

while (pool->curr\_nr < pool->min\_nr) \{

void \*element;

element = pool->alloc(GFP\_KERNEL, pool->pool\_data);

if (unlikely(!element)) \{

free\_pool(pool);

return NULL;

/\*将刚刚申请到的内存挂到elements数组的相应位置上，并修改curr\_nr的值\*/

add\_element(pool, element);

/\*若成功创建内存池，则返回内存池对象的指针，这样就可以利用mempool\_alloc和mempool\_free访问内存池了。\*/

return pool;

四．内存池的使用

如果需要使用已经创建的内存池，则需要调用mempool\_alloc从内存池中申请内存以及调用mempool\_free将用完的内存还给内存池。

void \* mempool\_alloc(mempool\_t \*pool, int gfp\_mask)

void \*element;

unsigned long flags;

DEFINE\_WAIT(wait);

int gfp\_nowait = gfp\_mask & ~(\_\_GFP\_WAIT | \_\_GFP\_IO);

repeat\_alloc:

/\**这里存在一些不明白的地方，先将用户传递进来的gfp掩码标志去掉\_\_GFP\_WAIT 和 \_\_GFP\_IO 两个标志，试图调用用户自定义分配函数从缓存区申请一个内存对象，而不是首先从内存池从分配，如果申请不到，再从内存池中分配。*\*/

element = pool->alloc(gfp\_nowait|\_\_GFP\_NOWARN, pool->pool\_data);

if (likely(element != NULL))

return element;

/\*如果池中的成员（空闲）的数量低于满时的一半时，需要额外从系统中申请内存，而不是从内存池中申请了。但是如果这段内存使用完了，则调用mempool\_free将其存放到内存池中，下次使用就不再申请了。\*/

mb();

if ((gfp\_mask & \_\_GFP\_FS) && (gfp\_mask != gfp\_nowait) &&

(pool->curr\_nr <= pool->min\_nr/2)) \{

element = pool->alloc(gfp\_mask, pool->pool\_data);

if (likely(element != NULL))

return element;

spin\_lock\_irqsave(&pool->lock, flags);

/\*如果当前内存池不为空，则从池中获取一个内存对象，返回给申请者\*/

if (likely(pool->curr\_nr)) \{

element = remove\_element(pool);

spin\_unlock\_irqrestore(&pool->lock, flags);

return element;

spin\_unlock\_irqrestore(&pool->lock, flags);

/\* We must not sleep in the GFP\_ATOMIC case \*/

if (!(gfp\_mask & \_\_GFP\_WAIT))

return NULL;

/\*下面一部分应该和内核调度有关，所以暂时不看了\*/

prepare\_to\_wait(&pool->wait, &wait, TASK\_UNINTERRUPTIBLE);

mb();

if (!pool->curr\_nr)

io\_schedule();

finish\_wait(&pool->wait, &wait);

goto repeat\_alloc;

如果申请者调用mempool\_free准备释放内存，实际上是将内存对象重新放到内存池中。源码实现如下：

void mempool\_free(void \*element, mempool\_t \*pool)

unsigned long flags;

mb();

/\*如果当前内存池已经满，则直接调用用户内存释放函数将内存还给系统\*/

if (pool->curr\_nr < pool->min\_nr) \{

spin\_lock\_irqsave(&pool->lock, flags);

if (pool->curr\_nr < pool->min\_nr) \{

/\*如果内存池还有剩余的空间，则将内存对象放入池中，唤醒等待队列\*/

add\_element(pool, element);

spin\_unlock\_irqrestore(&pool->lock, flags);

wake\_up(&pool->wait);

return;

spin\_unlock\_irqrestore(&pool->lock, flags);

pool->free(element, pool->pool\_data);

这个函数十分简单，没有什么过多的分析了。

五．内存池实现总结

通过上面的分析，我们发现Linux内核的内存池实现相当简单。而C++STL中，实现了二级分配机制，初始化时将内存池按照内存的大小分成数个级别（每个级别均是8字节的整数倍，一般是8，16，24，…，128字节），每个级别都预先分配了20块内存。二级分配机制的基本思想是：如果用户申请的内存大于我们预定义的级别，则直接调用malloc从堆中分配内存，而如果申请的内存大小在128字节以内，则从最相近的内存大小中申请，例如申请的内存是10字节，则可以从16字节的组中取出一块交给申请者，如果该组的内存储量（初始是20）小于一定的值，就会根据一个算法（成为refill算法），再次从堆中申请一部分内存加入内存池，保证池中有一定量的内存可用。

而Linux的内存池实际上是与特定内存对象相关联的，每一种内存对象（例如task\_struct）都有其特定的大小以及初始化方法，这个与STL的分级有点相似，但是内核主要还是根据实际的对象的大小来确定池中对象的大小。

内核内存池初始时从缓存区申请一定量的内存块，需要使用时从池中顺序查找空闲内存块并返回给申请者。回收时也是直接将内存插入池中，如果池已经满，则直接释放。内存池没有动态增加大小的能力，如果内存池中的内存消耗殆尽，则只能直接从缓存区申请内存，内存池的容量不会随着使用量的增加而增加。

#      #

# [        memory pool 原理及使用        ][memory pool]     #

#         分类：            [内存管理][Link 3]             2013-01-23 16:23     719人阅读     [评论][Link 4](0)     [收藏][Link 5]     [举报][Link 6]      chipset: msm8x25  codebase: android4.1       **\[html\]** [ view plain][view plain 1] [copy][view plain 1] [print][view plain 1] [?][view plain 1]  一、  初始化：        int \_\_init memory\_pool\_init(void)    \{        int i;            alloc\_root = RB\_ROOT;        mutex\_init(&alloc\_mutex);        for (i = 0; i < ARRAY\_SIZE(mpools); i++) \{            mutex\_init(&mpools\[i\].pool\_mutex);            mpools\[i\].gpool = NULL;        \}            return 0;    \}            Mpools结构体如下，最多能存放8个，存放类型由平台自己决定:    \#define MAX\_MEMPOOLS 8    struct mem\_pool mpools\[MAX\_MEMPOOLS\];    struct mem\_pool \{        struct mutex pool\_mutex;        struct gen\_pool \*gpool;        unsigned long paddr;        //存放的是物理或者虚拟地址都可以。        unsigned long size;         //pool 的size大小。        unsigned long free;         //还有多少空闲部分可用。        unsigned int id;    \};        本平台定义的type如下：    enum \{        MEMTYPE\_NONE = -1,        MEMTYPE\_SMI\_KERNEL = 0,        MEMTYPE\_SMI,        MEMTYPE\_EBI0,        MEMTYPE\_EBI1,        MEMTYPE\_MAX,    \};        下面函数是和平台相关，其中调用了kernel中的initialize\_memory\_pool函数，    当然自己使用的时候也可用按照这种写法：    static void \_\_init initialize\_mempools(void)    \{        struct mem\_pool \*mpool;        int memtype;        struct memtype\_reserve \*mt;            //保留内存相关信息，其实type为MEMTYPE\_EBI0部分才有size，    因为平台用的就是EBI1接口的DDR。        mt = &reserve\_info->memtype\_reserve\_table\[0\];        for (memtype = 0; memtype < MEMTYPE\_MAX; memtype++, mt++) \{            if (!mt->size)                continue;            //依次将平台所用到的保留内存信息保存到mpool中。            mpool = initialize\_memory\_pool(mt->start, mt->size, memtype);            if (!mpool)                pr\_warning("failed to create %s mempool\\n",                    memtype\_name\[memtype\]);        \}    \}        好了，看公共的函数initialize\_memory\_pool：    struct mem\_pool \*initialize\_memory\_pool(unsigned long start,        unsigned long size, int mem\_type)    \{        int id = mem\_type;            //类型不符合或者size小于4k就返回        if (id >= MAX\_MEMPOOLS || size <= PAGE\_SIZE || size % PAGE\_SIZE)            return NULL;            mutex\_lock(&mpools\[id\].pool\_mutex);            mpools\[id\].paddr = start;   //保留内存的虚拟地址，注意是虚拟地址。        mpools\[id\].size = size;     //能使用的总size        mpools\[id\].free = size;     //空闲size,一开始肯定和总size一样。        mpools\[id\].id = id;        mutex\_unlock(&mpools\[id\].pool\_mutex);            pr\_info("memory pool %d (start %lx size %lx) initialized\\n",            id, start, size);        return &mpools\[id\];    \}        二、  使用：    平台提供了两种接口供我们分配mempool：allocate\_contiguous\_ebi 和 allocate\_contiguous\_ebi\_nomap， 区别只在于是否map。    void \*allocate\_contiguous\_ebi(unsigned long size,        unsigned long align, int cached)    \{        return allocate\_contiguous\_memory(size, get\_ebi\_memtype(),            align, cached);    \}    EXPORT\_SYMBOL(allocate\_contiguous\_ebi);        unsigned long allocate\_contiguous\_ebi\_nomap(unsigned long size,        unsigned long align)    \{        return \_allocate\_contiguous\_memory\_nomap(size, get\_ebi\_memtype(),            align, \_\_builtin\_return\_address(0));    \}    EXPORT\_SYMBOL(allocate\_contiguous\_ebi\_nomap);        static int get\_ebi\_memtype(void)    \{        /\* on 7x30 and 8x55 "EBI1 kernel PMEM" is really on EBI0 \*/        if (cpu\_is\_msm7x30() || cpu\_is\_msm8x55())            return MEMTYPE\_EBI0;        //平台返回的是这个。        return MEMTYPE\_EBI1;    \}    其实对应地就是调用了kernel的分配连续内存接口，就看allocate\_contiguous\_memory如何实现。        void \*allocate\_contiguous\_memory(unsigned long size,        int mem\_type, unsigned long align, int cached)    \{        //叶框对齐        unsigned long aligned\_size = PFN\_ALIGN(size);        struct mem\_pool \*mpool;            mpool = mem\_type\_to\_memory\_pool(mem\_type);        if (!mpool)            return NULL;        return \_\_alloc(mpool, aligned\_size, align, cached,            \_\_builtin\_return\_address(0));        \}        先看mem\_type\_to\_memory\_pool：    static struct mem\_pool \*mem\_type\_to\_memory\_pool(int mem\_type)    \{        //取得mem\_type对应的mpool.        struct mem\_pool \*mpool = &mpools\[mem\_type\];            //这里只有MEMTYPE\_EBI1对应的size有赋值，    所以其他的mpool都直接返回。        if (!mpool->size)            return NULL;            mutex\_lock(&mpool->pool\_mutex);        //初始化gpool        if (!mpool->gpool)            mpool->gpool = initialize\_gpool(mpool->paddr, mpool->size);        mutex\_unlock(&mpool->pool\_mutex);        if (!mpool->gpool)            return NULL;            return mpool;    \}        static struct gen\_pool \*initialize\_gpool(unsigned long start,        unsigned long size)    \{        struct gen\_pool \*gpool;            //先创建gpool        gpool = gen\_pool\_create(PAGE\_SHIFT, -1);            if (!gpool)            return NULL;        //添加gen pool         if (gen\_pool\_add(gpool, start, size, -1)) \{            gen\_pool\_destroy(gpool);            return NULL;        \}            return gpool;    \}        struct gen\_pool \*gen\_pool\_create(int min\_alloc\_order, int nid)    \{        struct gen\_pool \*pool;        //比较简单，分配gen\_pool空间。        pool = kmalloc\_node(sizeof(struct gen\_pool), GFP\_KERNEL, nid);        if (pool != NULL) \{            spin\_lock\_init(&pool->lock);            INIT\_LIST\_HEAD(&pool->chunks);            // min\_alloc\_order为PAGE\_SHIFT =12.            pool->min\_alloc\_order = min\_alloc\_order;        \}        return pool;    \}        static inline int gen\_pool\_add(struct gen\_pool \*pool, unsigned long addr,                       size\_t size, int nid)    \{        return gen\_pool\_add\_virt(pool, addr, -1, size, nid);    \}        int gen\_pool\_add\_virt(struct gen\_pool \*pool, unsigned long virt, phys\_addr\_t phys,             size\_t size, int nid)    \{        struct gen\_pool\_chunk \*chunk;        //看意思是一个PAGE\_SIZE作为一个bit来计算。        int nbits = size >> pool->min\_alloc\_order;        //nbits都存放在gen\_pool\_chunk的bits\[0\]数组中，用bitmap来管理。        int nbytes = sizeof(struct gen\_pool\_chunk) +                    (nbits + BITS\_PER\_BYTE - 1) / BITS\_PER\_BYTE;            //分配struct gen\_pool\_chunk空间。        if (nbytes <= PAGE\_SIZE)            chunk = kmalloc\_node(nbytes, \_\_GFP\_ZERO, nid);        else            chunk = vmalloc(nbytes);        if (unlikely(chunk == NULL))            return -ENOMEM;        if (nbytes > PAGE\_SIZE)            memset(chunk, 0, nbytes);            chunk->phys\_addr = phys; //保存物理地址，传进来的是-1,说明还没计算出来。        chunk->start\_addr = virt;    //其实这个值是虚拟或者物理地址都可以。如果是//物理地址，就调用allocate\_contiguous\_memory，会ioremap一次。否则使用//\_allocate\_contiguous\_memory\_nomap就可以了。        chunk->end\_addr = virt + size;    //chuank结束地址。        atomic\_set(&chunk->avail, size);  //保存当前chunk有效size到avail中。            spin\_lock(&pool->lock);    //以rcu的形式添加到pool的chunks列表中。            list\_add\_rcu(&chunk->next\_chunk, &pool->chunks);                   spin\_unlock(&pool->lock);            return 0;    \}        再看\_\_alloc，要动真格了：    static void \*\_\_alloc(struct mem\_pool \*mpool, unsigned long size,        unsigned long align, int cached, void \*caller)    \{        unsigned long paddr;        void \_\_iomem \*vaddr;            unsigned long aligned\_size;        int log\_align = ilog2(align);            struct alloc \*node;            aligned\_size = PFN\_ALIGN(size);        //从gen pool去分配内存。        paddr = gen\_pool\_alloc\_aligned(mpool->gpool, aligned\_size, log\_align);        if (!paddr)            return NULL;            node = kmalloc(sizeof(struct alloc), GFP\_KERNEL);        if (!node)            goto out;            //这里返回的肯定是物理内存，所以需要ioremap，调用、//\_allocate\_contiguous\_memory\_nomap那就不需要了。        if (cached)            vaddr = ioremap\_cached(paddr, aligned\_size);        else            vaddr = ioremap(paddr, aligned\_size);            if (!vaddr)            goto out\_kfree;            node->vaddr = vaddr;        //保留相对应参数到node节点中。        node->paddr = paddr;        node->len = aligned\_size;        node->mpool = mpool;        node->caller = caller;        //插入到红黑树中去管理。        if (add\_alloc(node))            goto out\_kfree;            mpool->free \-= aligned\_size;            return vaddr;    out\_kfree:        if (vaddr)            iounmap(vaddr);        kfree(node);    out:        gen\_pool\_free(mpool->gpool, paddr, aligned\_size);        return NULL;    \}        分析关键函数gen\_pool\_alloc\_aligned：    unsigned long gen\_pool\_alloc\_aligned(struct gen\_pool \*pool, size\_t size,                         unsigned alignment\_order)    \{        struct gen\_pool\_chunk \*chunk;        unsigned long addr = 0, align\_mask = 0;        int order = pool\->min\_alloc\_order;        int nbits, start\_bit = 0, remain;        \#ifndef CONFIG\_ARCH\_HAVE\_NMI\_SAFE\_CMPXCHG        BUG\_ON(in\_nmi());    \#endif            if (size == 0)            return 0;            if (alignment\_order > order)            align\_mask = (1 << (alignment\_order - order)) - 1;                //获取当前申请size所对应的nbits数量。        nbits = (size + (1UL << order) - 1) >> order;            rcu\_read\_lock();        //在当前pool的chunks列表上依次查询        list\_for\_each\_entry\_rcu(chunk, &pool->chunks, next\_chunk) \{            unsigned long chunk\_size;            if (size > atomic\_read(&chunk->avail))                continue;            //本chunk所以拥有的总chunk size.            chunk\_size = (chunk->end\_addr - chunk->start\_addr) >> order;        retry:            //寻找未被使用区域的start bit位置            start\_bit = bitmap\_find\_next\_zero\_area\_off(chunk->bits, chunk\_size,                                   0, nbits, align\_mask,                                   chunk->start\_addr);            //如果超出chunk size，那么再看下一个chunk。            if (start\_bit >= chunk\_size)                continue;            //没超出那就设置nbits的大小表示这部分内存已经被使用了            remain = bitmap\_set\_ll(chunk->bits, start\_bit, nbits);            if (remain) \{                remain = bitmap\_clear\_ll(chunk->bits, start\_bit,                             nbits - remain);                BUG\_ON(remain);                goto retry;            \}                //获取当前申请size对应的address，这里为物理地址。            addr = chunk\->start\_addr + ((unsigned long)start\_bit << order);            size = nbits << pool->min\_alloc\_order;            //计算还有多少size可以供其他进程申请。            atomic\_sub(size, &chunk->avail);            break;        \}        rcu\_read\_unlock();        return addr;    \}        对于bitmap如何使用，这里就不具体追踪了，看函数名知道大概就可以了。                最后，我们看下\_allocate\_contiguous\_memory\_nomap，其实和上面的区别在于是否remap.    unsigned long \_allocate\_contiguous\_memory\_nomap(unsigned long size,        int mem\_type, unsigned long align, void \*caller)    \{        unsigned long paddr;        unsigned long aligned\_size;            struct alloc \*node;        struct mem\_pool \*mpool;        int log\_align = ilog2(align);            mpool = mem\_type\_to\_memory\_pool(mem\_type);        if (!mpool || !mpool->gpool)            return 0;            aligned\_size = PFN\_ALIGN(size);        paddr = gen\_pool\_alloc\_aligned(mpool->gpool, aligned\_size, log\_align);        if (!paddr)            return 0;            node = kmalloc(sizeof(struct alloc), GFP\_KERNEL);        if (!node)            goto out;            node->paddr = paddr;            /\* We search the tree using node->vaddr, so set         \* it to something unique even though we don't         \* use it for physical allocation nodes.         \* The virtual and physical address ranges         \* are disjoint, so there won't be any chance of         \* a duplicate node->vaddr value.         \*/        //区别就在于这一步，因为这个函数传进来的就是虚拟地址，所以我们没必要再ioremap了，直接使用。        node->vaddr = (void \*)paddr;        node->len = aligned\_size;        node->mpool = mpool;        node->caller = caller;        if (add\_alloc(node))            goto out\_kfree;            mpool->free \-= aligned\_size;        return paddr;    out\_kfree:        kfree(node);    out:        gen\_pool\_free(mpool->gpool, paddr, aligned\_size);        return 0;    \}            Mempool还是比较简单的，后续的ION的使用我们就会看到它使用了mempool了。            2013/01/23       3.内核缓冲区   (1)终端缓冲  　　终端设备有输入和输出队列缓冲区,如下图所示  　　![点击查看大图][95425051743.png]  　　以输入队列为例,从键盘输入的字符经线路规程过滤后进入输入队列,用户程序以先进先出的顺序 从队列中读取字符,一般情况下,当输入队列满的时候再输入字符会丢失,同时系统会响铃警报。 终端可以配置成回显(Echo)模式,在这种模式下,输入队列中的每个字符既送给用户程序也送给 输出队列,因此我们在命令行键入字符时,该字符不仅可以被程序读取,我们也可以同时在屏幕上 看到该字符的回显。          注意上述情况是用户进程([shell][]进程也是)调用read/write等unbuffer I/O函数的情况,当调用printf/scanf(底层实现也是read/write)等C标准I/O库函数时,当用户程序调用scanf读取键盘输入时,开始输入的字符都存到C标准库的I/O缓冲区,直到我们遇到换行符(标准输入和标准输出都是行缓冲的)时,[系统][Link 7]调用read将缓冲区的内容读到内核的[终端][Link 8]输入队列;当调用printf打印一个字符串时,如果语句中带换行符,则立刻将放在I/O缓冲区的字符串调用write写到内核的输出队列,打印到屏幕上,如果printf语句没带换行符,则由上面的讨论可知,程序退出时会做fflush操作.          (2)虽然write 系统调用位于C标准库I/O缓冲区的底 层,被称为Unbuffered I/O函数,但在write 的底层也可以分配一个内核I/O缓冲区,所以write 也不一定是直接写到文件的,也 可能写到内核I/O缓冲区中,可以使用fsync函数同步至[磁盘][Link 9]文件，至于究竟写到了文件中还是内核缓冲区中对于进程来说是没有差别 的,如果进程A和进程B打开同一文件,进程A写到内核I/O缓冲区中的数据从进程B也能读到,因为内核空间是进程共享的, 而c标准库的I/O缓冲区则不具有这一特性,因为进程的用户空间是完全独立的.     　　(3)为了减少读盘次数,内核缓存了目录的树状结构,称为dentry(directory entry(目录下项) cache  　　(4)FIFO和UNIX Domain Socket这两种IPC机制都是利用文件[系统][Link 7]中的特殊文件来[标识][Link 10]的。FIFO文件在[磁盘][Link 9]上没有数据块,仅用来标识内核中的一条通道,各进程可以打开这个文件进行read / write ,实际上是在读写内核通道(根本原因在于这个file 结构体所指向的read 、write 函数 和常规文件不一样),这样就实现了进程间[通信][Link 11]。UNIX Domain Socket和FIFO的原理类似,也需 要一个特殊的socket文件来标识内核中的通道,文件类型s表示socket,这些文件在磁盘上也没有数据块。UNIX Domain Socket是目前最广泛使用 的IPC机制.如下图:  　　![95426051743.png][]  　　4.stack overflow 无穷递归或者定义的极大数组都可能导致[操作系统][Link 12]为程序预留的栈空间耗尽 程序崩溃(段错误) #

[Link 1]: http://blog.csdn.net/zirconsdu/article/details/8969749#
[http_lwn.net_Articles_480055]: http://lwn.net/Articles/480055/
[ION]: http://blog.csdn.net/zirconsdu/article/details/8969749#t0
[ION 1]: http://blog.csdn.net/zirconsdu/article/details/8969749#t1
[ION_IOC_ALLOC]: http://blog.csdn.net/zirconsdu/article/details/8969749#t2
[ION_IOC_MAP ION_IOC_SHARE]: http://blog.csdn.net/zirconsdu/article/details/8969749#t3
[ION_IOC_IMPORT]: http://blog.csdn.net/zirconsdu/article/details/8969749#t4
[ION 2]: http://blog.csdn.net/zirconsdu/article/details/8969749#t5
[Link 2]: http://blog.csdn.net/zirconsdu/article/details/8969749#t6
[http_blog.csdn.net_kris_fei_article_details_8588661]: http://blog.csdn.net/kris_fei/article/details/8588661
[http_blog.csdn.net_kris_fei_article_details_8618587]: http://blog.csdn.net/kris_fei/article/details/8618587
[view plain]: http://blog.csdn.net/cosmoslhf/article/details/41209925#
[SouthEast]: /images/20220602/2616e1ddbc2b40d3babad36dd5aa6a30.png
[SouthEast 1]: /images/20220602/3fc4d11df17245d49f1085333877ef90.png
[.bmp]: /images/20220602/e1f60548fea040338c3281952dcecbbc.png
[memory pool]: http://blog.csdn.net/kris_fei/article/details/8534727
[Link 3]: http://blog.csdn.net/kris_fei/article/category/1406625
[Link 4]: http://blog.csdn.net/kris_fei/article/details/8534727#comments
[Link 5]: http://blog.csdn.net/cosmoslhf/article/details/41209925
[Link 6]: http://blog.csdn.net/kris_fei/article/details/8534727#report
[view plain 1]: http://blog.csdn.net/kris_fei/article/details/8534727#
[95425051743.png]: http://img.educity.cn/img_16/334/2014031805/95425051743.png
[shell]: http://cpro.baidu.com/cpro/ui/uijs.php?rs=1&u=http%3A%2F%2Fwww%2Eeducity%2Ecn%2Flinux%2F1241891%2Ehtml&p=baidu&c=news&n=10&t=tpclicked3_hc&q=67051059_cpr&k=shell&k0=shell&k1=%CD%A8%D0%C5&k2=%C9%E8%BC%C6&k3=%B1%EA%CA%B6&k4=%B2%D9%D7%F7%CF%B5%CD%B3&k5=%D6%D5%B6%CB&sid=796705ebb6369e0b&ch=0&tu=u1740074&jk=af60547919c377af&cf=29&fv=15&stid=9&urlid=0&luki=3&seller_id=1&di=128
[Link 7]: http://cpro.baidu.com/cpro/ui/uijs.php?rs=1&u=http%3A%2F%2Fwww%2Eeducity%2Ecn%2Flinux%2F1241891%2Ehtml&p=baidu&c=news&n=10&t=tpclicked3_hc&q=67051059_cpr&k=%CF%B5%CD%B3&k0=%CF%B5%CD%B3&k1=shell&k2=%CD%A8%D0%C5&k3=%C9%E8%BC%C6&k4=%B1%EA%CA%B6&k5=%B2%D9%D7%F7%CF%B5%CD%B3&sid=796705ebb6369e0b&ch=0&tu=u1740074&jk=af60547919c377af&cf=29&fv=15&stid=9&urlid=0&luki=2&seller_id=1&di=128
[Link 8]: http://cpro.baidu.com/cpro/ui/uijs.php?rs=1&u=http%3A%2F%2Fwww%2Eeducity%2Ecn%2Flinux%2F1241891%2Ehtml&p=baidu&c=news&n=10&t=tpclicked3_hc&q=67051059_cpr&k=%D6%D5%B6%CB&k0=%D6%D5%B6%CB&k1=memory&k2=domain&k3=%B4%C5%C5%CC&k4=%CF%B5%CD%B3&k5=shell&sid=796705ebb6369e0b&ch=0&tu=u1740074&jk=af60547919c377af&cf=29&fv=15&stid=9&urlid=0&luki=8&seller_id=1&di=128
[Link 9]: http://cpro.baidu.com/cpro/ui/uijs.php?rs=1&u=http%3A%2F%2Fwww%2Eeducity%2Ecn%2Flinux%2F1241891%2Ehtml&p=baidu&c=news&n=10&t=tpclicked3_hc&q=67051059_cpr&k=%B4%C5%C5%CC&k0=%B4%C5%C5%CC&k1=%CF%B5%CD%B3&k2=shell&k3=%CD%A8%D0%C5&k4=%C9%E8%BC%C6&k5=%B1%EA%CA%B6&sid=796705ebb6369e0b&ch=0&tu=u1740074&jk=af60547919c377af&cf=29&fv=15&stid=9&urlid=0&luki=1&seller_id=1&di=128
[Link 10]: http://cpro.baidu.com/cpro/ui/uijs.php?rs=1&u=http%3A%2F%2Fwww%2Eeducity%2Ecn%2Flinux%2F1241891%2Ehtml&p=baidu&c=news&n=10&t=tpclicked3_hc&q=67051059_cpr&k=%B1%EA%CA%B6&k0=%B1%EA%CA%B6&k1=%B2%D9%D7%F7%CF%B5%CD%B3&k2=%D6%D5%B6%CB&k3=memory&k4=domain&k5=%B4%C5%C5%CC&sid=796705ebb6369e0b&ch=0&tu=u1740074&jk=af60547919c377af&cf=29&fv=15&stid=9&urlid=0&luki=6&seller_id=1&di=128
[Link 11]: http://cpro.baidu.com/cpro/ui/uijs.php?rs=1&u=http%3A%2F%2Fwww%2Eeducity%2Ecn%2Flinux%2F1241891%2Ehtml&p=baidu&c=news&n=10&t=tpclicked3_hc&q=67051059_cpr&k=%CD%A8%D0%C5&k0=%CD%A8%D0%C5&k1=%C9%E8%BC%C6&k2=%B1%EA%CA%B6&k3=%B2%D9%D7%F7%CF%B5%CD%B3&k4=%D6%D5%B6%CB&k5=memory&sid=796705ebb6369e0b&ch=0&tu=u1740074&jk=af60547919c377af&cf=29&fv=15&stid=9&urlid=0&luki=4&seller_id=1&di=128
[95426051743.png]: http://img.educity.cn/img_16/334/2014031805/95426051743.png
[Link 12]: http://cpro.baidu.com/cpro/ui/uijs.php?rs=1&u=http%3A%2F%2Fwww%2Eeducity%2Ecn%2Flinux%2F1241891%2Ehtml&p=baidu&c=news&n=10&t=tpclicked3_hc&q=67051059_cpr&k=%B2%D9%D7%F7%CF%B5%CD%B3&k0=%B2%D9%D7%F7%CF%B5%CD%B3&k1=%D6%D5%B6%CB&k2=memory&k3=domain&k4=%B4%C5%C5%CC&k5=%CF%B5%CD%B3&sid=796705ebb6369e0b&ch=0&tu=u1740074&jk=af60547919c377af&cf=29&fv=15&stid=9&urlid=0&luki=7&seller_id=1&di=128