ION概念

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表示。

/**
 * enum ion_heap_types - list of all possible types of heaps
 * @ION_HEAP_TYPE_SYSTEM:    memory allocated via vmalloc
 * @ION_HEAP_TYPE_SYSTEM_CONTIG: memory allocated via kmalloc
 * @ION_HEAP_TYPE_CARVEOUT:  memory allocated from a prereserved
 *               carveout heap, allocations are physically
 *               contiguous
 * @ION_HEAP_TYPE_IOMMU: IOMMU memory
 * @ION_HEAP_TYPE_CP:    memory allocated from a prereserved
 *              carveout heap, allocations are physically
 *              contiguous. Used for content protection.
 * @ION_HEAP_TYPE_DMA:          memory allocated via DMA API
 * @ION_HEAP_END:       helper for iterating over heaps
 */
enum ion_heap_type {
    ION_HEAP_TYPE_SYSTEM,
    ION_HEAP_TYPE_SYSTEM_CONTIG,
    ION_HEAP_TYPE_CARVEOUT,
    ION_HEAP_TYPE_IOMMU,
    ION_HEAP_TYPE_CP,
    ION_HEAP_TYPE_DMA,
    ION_HEAP_TYPE_CUSTOM, /* must be last so device specific heaps always
                 are at the end of this enum */
    ION_NUM_HEAPS,
};

/**
 * enum ion_heap_types - list of all possible types of heaps
 * @ION_HEAP_TYPE_SYSTEM:	 memory allocated via vmalloc
 * @ION_HEAP_TYPE_SYSTEM_CONTIG: memory allocated via kmalloc
 * @ION_HEAP_TYPE_CARVEOUT:	 memory allocated from a prereserved
 * 				 carveout heap, allocations are physically
 * 				 contiguous
 * @ION_HEAP_TYPE_IOMMU: IOMMU memory
 * @ION_HEAP_TYPE_CP:	 memory allocated from a prereserved
 *				carveout heap, allocations are physically
 *				contiguous. Used for content protection.
 * @ION_HEAP_TYPE_DMA:          memory allocated via DMA API
 * @ION_HEAP_END:		helper for iterating over heaps
 */
enum ion_heap_type {
	ION_HEAP_TYPE_SYSTEM,
	ION_HEAP_TYPE_SYSTEM_CONTIG,
	ION_HEAP_TYPE_CARVEOUT,
	ION_HEAP_TYPE_IOMMU,
	ION_HEAP_TYPE_CP,
	ION_HEAP_TYPE_DMA,
	ION_HEAP_TYPE_CUSTOM, /* must be last so device specific heaps always
				 are at the end of this enum */
	ION_NUM_HEAPS,
};

代碼中的註釋很明確地說明了哪種type對應的是分配哪種memory。不同type的heap需要不同的method去分配，不過都是用struction_heap_ops來表示的。如以下例子：

static struct ion_heap_ops carveout_heap_ops = {
    .allocate = ion_carveout_heap_allocate,
    .free = ion_carveout_heap_free,
    .phys = ion_carveout_heap_phys,
    .map_user = ion_carveout_heap_map_user,
    .map_kernel = ion_carveout_heap_map_kernel,
    .unmap_user = ion_carveout_heap_unmap_user,
    .unmap_kernel = ion_carveout_heap_unmap_kernel,
    .map_dma = ion_carveout_heap_map_dma,
    .unmap_dma = ion_carveout_heap_unmap_dma,
    .cache_op = ion_carveout_cache_ops,
    .print_debug = ion_carveout_print_debug,
    .map_iommu = ion_carveout_heap_map_iommu,
    .unmap_iommu = ion_carveout_heap_unmap_iommu,
};

static struct ion_heap_ops kmalloc_ops = {
    .allocate = ion_system_contig_heap_allocate,
    .free = ion_system_contig_heap_free,
    .phys = ion_system_contig_heap_phys,
    .map_dma = ion_system_contig_heap_map_dma,
    .unmap_dma = ion_system_heap_unmap_dma,
    .map_kernel = ion_system_heap_map_kernel,
    .unmap_kernel = ion_system_heap_unmap_kernel,
    .map_user = ion_system_contig_heap_map_user,
    .cache_op = ion_system_contig_heap_cache_ops,
    .print_debug = ion_system_contig_print_debug,
    .map_iommu = ion_system_contig_heap_map_iommu,
    .unmap_iommu = ion_system_heap_unmap_iommu,
};

static struct ion_heap_ops carveout_heap_ops = {
	.allocate = ion_carveout_heap_allocate,
	.free = ion_carveout_heap_free,
	.phys = ion_carveout_heap_phys,
	.map_user = ion_carveout_heap_map_user,
	.map_kernel = ion_carveout_heap_map_kernel,
	.unmap_user = ion_carveout_heap_unmap_user,
	.unmap_kernel = ion_carveout_heap_unmap_kernel,
	.map_dma = ion_carveout_heap_map_dma,
	.unmap_dma = ion_carveout_heap_unmap_dma,
	.cache_op = ion_carveout_cache_ops,
	.print_debug = ion_carveout_print_debug,
	.map_iommu = ion_carveout_heap_map_iommu,
	.unmap_iommu = ion_carveout_heap_unmap_iommu,
};

static struct ion_heap_ops kmalloc_ops = {
	.allocate = ion_system_contig_heap_allocate,
	.free = ion_system_contig_heap_free,
	.phys = ion_system_contig_heap_phys,
	.map_dma = ion_system_contig_heap_map_dma,
	.unmap_dma = ion_system_heap_unmap_dma,
	.map_kernel = ion_system_heap_map_kernel,
	.unmap_kernel = ion_system_heap_unmap_kernel,
	.map_user = ion_system_contig_heap_map_user,
	.cache_op = ion_system_contig_heap_cache_ops,
	.print_debug = ion_system_contig_print_debug,
	.map_iommu = ion_system_contig_heap_map_iommu,
	.unmap_iommu = ion_system_heap_unmap_iommu,
};

Heap ID：

同一種type的heap上當然可以分爲若該幹個chunk供用戶使用，所以ION又使用ID來區分了。例如在type爲ION_HEAP_TYPE_CARVEOUT的heap上，audio和display部分都需要使用，ION就用ID來區分。

Heap id用enumion_heap_ids表示。

/**
 * These are the only ids that should be used for Ion heap ids.
 * The ids listed are the order in which allocation will be attempted
 * if specified. Don't swap the order of heap ids unless you know what
 * you are doing!
 * Id's are spaced by purpose to allow new Id's to be inserted in-between (for
 * possible fallbacks)
 */

enum ion_heap_ids {
    INVALID_HEAP_ID = -1,
    ION_CP_MM_HEAP_ID = 8,
    ION_CP_MFC_HEAP_ID = 12,
    ION_CP_WB_HEAP_ID = 16, /* 8660 only */
    ION_CAMERA_HEAP_ID = 20, /* 8660 only */
    ION_SF_HEAP_ID = 24,
    ION_IOMMU_HEAP_ID = 25,
    ION_QSECOM_HEAP_ID = 26,
    ION_AUDIO_HEAP_BL_ID = 27,
    ION_AUDIO_HEAP_ID = 28,

    ION_MM_FIRMWARE_HEAP_ID = 29,
    ION_SYSTEM_HEAP_ID = 30,

    ION_HEAP_ID_RESERVED = 31 /** Bit reserved for ION_SECURE flag */
};

/**
 * These are the only ids that should be used for Ion heap ids.
 * The ids listed are the order in which allocation will be attempted
 * if specified. Don't swap the order of heap ids unless you know what
 * you are doing!
 * Id's are spaced by purpose to allow new Id's to be inserted in-between (for
 * possible fallbacks)
 */

enum ion_heap_ids {
	INVALID_HEAP_ID = -1,
	ION_CP_MM_HEAP_ID = 8,
	ION_CP_MFC_HEAP_ID = 12,
	ION_CP_WB_HEAP_ID = 16, /* 8660 only */
	ION_CAMERA_HEAP_ID = 20, /* 8660 only */
	ION_SF_HEAP_ID = 24,
	ION_IOMMU_HEAP_ID = 25,
	ION_QSECOM_HEAP_ID = 26,
	ION_AUDIO_HEAP_BL_ID = 27,
	ION_AUDIO_HEAP_ID = 28,

	ION_MM_FIRMWARE_HEAP_ID = 29,
	ION_SYSTEM_HEAP_ID = 30,

	ION_HEAP_ID_RESERVED = 31 /** Bit reserved for ION_SECURE flag */
};

Heap 定義：

       瞭解了heaptype和id，看看如何被用到了，本平臺使用的文件爲board-qrd7627a.c，有如下定義：

/**
 * These heaps are listed in the order they will be allocated.
 * Don't swap the order unless you know what you are doing!
 */
struct ion_platform_heap msm7627a_heaps[] = {
        {
            .id = ION_SYSTEM_HEAP_ID,
            .type   = ION_HEAP_TYPE_SYSTEM,
            .name   = ION_VMALLOC_HEAP_NAME,
        },
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
        /* PMEM_ADSP = CAMERA */
        {
            .id = ION_CAMERA_HEAP_ID,
            .type   = CAMERA_HEAP_TYPE,
            .name   = ION_CAMERA_HEAP_NAME,
            .memory_type = ION_EBI_TYPE,
            .extra_data = (void *)&co_mm_ion_pdata,
            .priv   = (void *)&ion_cma_device.dev,
        },
        /* AUDIO HEAP 1*/
        {
            .id = ION_AUDIO_HEAP_ID,
            .type   = ION_HEAP_TYPE_CARVEOUT,
            .name   = ION_AUDIO_HEAP_NAME,
            .memory_type = ION_EBI_TYPE,
            .extra_data = (void *)&co_ion_pdata,
        },
        /* PMEM_MDP = SF */
        {
            .id = ION_SF_HEAP_ID,
            .type   = ION_HEAP_TYPE_CARVEOUT,
            .name   = ION_SF_HEAP_NAME,
            .memory_type = ION_EBI_TYPE,
            .extra_data = (void *)&co_ion_pdata,
        },
        /* AUDIO HEAP 2*/
        {
            .id    = ION_AUDIO_HEAP_BL_ID,
            .type  = ION_HEAP_TYPE_CARVEOUT,
            .name  = ION_AUDIO_BL_HEAP_NAME,
            .memory_type = ION_EBI_TYPE,
            .extra_data = (void *)&co_ion_pdata,
            .base = BOOTLOADER_BASE_ADDR,
        },

#endif
};

/**
 * These heaps are listed in the order they will be allocated.
 * Don't swap the order unless you know what you are doing!
 */
struct ion_platform_heap msm7627a_heaps[] = {
		{
			.id	= ION_SYSTEM_HEAP_ID,
			.type	= ION_HEAP_TYPE_SYSTEM,
			.name	= ION_VMALLOC_HEAP_NAME,
		},
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
		/* PMEM_ADSP = CAMERA */
		{
			.id	= ION_CAMERA_HEAP_ID,
			.type	= CAMERA_HEAP_TYPE,
			.name	= ION_CAMERA_HEAP_NAME,
			.memory_type = ION_EBI_TYPE,
			.extra_data = (void *)&co_mm_ion_pdata,
			.priv	= (void *)&ion_cma_device.dev,
		},
		/* AUDIO HEAP 1*/
		{
			.id	= ION_AUDIO_HEAP_ID,
			.type	= ION_HEAP_TYPE_CARVEOUT,
			.name	= ION_AUDIO_HEAP_NAME,
			.memory_type = ION_EBI_TYPE,
			.extra_data = (void *)&co_ion_pdata,
		},
		/* PMEM_MDP = SF */
		{
			.id	= ION_SF_HEAP_ID,
			.type	= ION_HEAP_TYPE_CARVEOUT,
			.name	= ION_SF_HEAP_NAME,
			.memory_type = ION_EBI_TYPE,
			.extra_data = (void *)&co_ion_pdata,
		},
		/* AUDIO HEAP 2*/
		{
			.id    = ION_AUDIO_HEAP_BL_ID,
			.type  = ION_HEAP_TYPE_CARVEOUT,
			.name  = ION_AUDIO_BL_HEAP_NAME,
			.memory_type = ION_EBI_TYPE,
			.extra_data = (void *)&co_ion_pdata,
			.base = BOOTLOADER_BASE_ADDR,
		},

#endif
};

ION Handle：

當Ion client分配buffer時，相應的一個唯一的handle也會被指定，當然client可以多次申請ion buffer。申請好buffer之後，返回的是一個ion handle, 不過要知道Ion buffer才和實際的內存相關，包括size, address等信息。Struct ion_handle和struct ion_buffer如下：

/**
 * ion_handle - a client local reference to a buffer
 * @ref:        reference count
 * @client:     back pointer to the client the buffer resides in
 * @buffer:     pointer to the buffer
 * @node:       node in the client's handle rbtree
 * @kmap_cnt:       count of times this client has mapped to kernel
 * @dmap_cnt:       count of times this client has mapped for dma
 *
 * Modifications to node, map_cnt or mapping should be protected by the
 * lock in the client.  Other fields are never changed after initialization.
 */
struct ion_handle {
    struct kref ref;
    struct ion_client *client;
    struct ion_buffer *buffer;
    struct rb_node node;
    unsigned int kmap_cnt;
    unsigned int iommu_map_cnt;
};

/**
 * struct ion_buffer - metadata for a particular buffer
 * @ref:        refernce count
 * @node:       node in the ion_device buffers tree
 * @dev:        back pointer to the ion_device
 * @heap:       back pointer to the heap the buffer came from
 * @flags:      buffer specific flags
 * @size:       size of the buffer
 * @priv_virt:      private data to the buffer representable as
 *          a void *
 * @priv_phys:      private data to the buffer representable as
 *          an ion_phys_addr_t (and someday a phys_addr_t)
 * @lock:       protects the buffers cnt fields
 * @kmap_cnt:       number of times the buffer is mapped to the kernel
 * @vaddr:      the kenrel mapping if kmap_cnt is not zero
 * @dmap_cnt:       number of times the buffer is mapped for dma
 * @sg_table:       the sg table for the buffer if dmap_cnt is not zero
*/
struct ion_buffer {
    struct kref ref;
    struct rb_node node;
    struct ion_device *dev;
    struct ion_heap *heap;
    unsigned long flags;
    size_t size;
    union {
        void *priv_virt;
        ion_phys_addr_t priv_phys;
    };
    struct mutex lock;
    int kmap_cnt;
    void *vaddr;
    int dmap_cnt;
    struct sg_table *sg_table;
    int umap_cnt;
    unsigned int iommu_map_cnt;
    struct rb_root iommu_maps;
    int marked;
};

/**
 * ion_handle - a client local reference to a buffer
 * @ref:		reference count
 * @client:		back pointer to the client the buffer resides in
 * @buffer:		pointer to the buffer
 * @node:		node in the client's handle rbtree
 * @kmap_cnt:		count of times this client has mapped to kernel
 * @dmap_cnt:		count of times this client has mapped for dma
 *
 * Modifications to node, map_cnt or mapping should be protected by the
 * lock in the client.  Other fields are never changed after initialization.
 */
struct ion_handle {
	struct kref ref;
	struct ion_client *client;
	struct ion_buffer *buffer;
	struct rb_node node;
	unsigned int kmap_cnt;
	unsigned int iommu_map_cnt;
};

/**
 * struct ion_buffer - metadata for a particular buffer
 * @ref:		refernce count
 * @node:		node in the ion_device buffers tree
 * @dev:		back pointer to the ion_device
 * @heap:		back pointer to the heap the buffer came from
 * @flags:		buffer specific flags
 * @size:		size of the buffer
 * @priv_virt:		private data to the buffer representable as
 *			a void *
 * @priv_phys:		private data to the buffer representable as
 *			an ion_phys_addr_t (and someday a phys_addr_t)
 * @lock:		protects the buffers cnt fields
 * @kmap_cnt:		number of times the buffer is mapped to the kernel
 * @vaddr:		the kenrel mapping if kmap_cnt is not zero
 * @dmap_cnt:		number of times the buffer is mapped for dma
 * @sg_table:		the sg table for the buffer if dmap_cnt is not zero
*/
struct ion_buffer {
	struct kref ref;
	struct rb_node node;
	struct ion_device *dev;
	struct ion_heap *heap;
	unsigned long flags;
	size_t size;
	union {
		void *priv_virt;
		ion_phys_addr_t priv_phys;
	};
	struct mutex lock;
	int kmap_cnt;
	void *vaddr;
	int dmap_cnt;
	struct sg_table *sg_table;
	int umap_cnt;
	unsigned int iommu_map_cnt;
	struct rb_root iommu_maps;
	int marked;
};

ION Client：

         用戶空間和內核空間都可以成爲client，不過創建的方法稍稍有點區別，先了解下基本的操作流程吧。

 內核空間:

先創建client:

struct ion_client *ion_client_create(struct ion_device *dev,
                     unsigned int heap_mask,
                     const char *name)

struct ion_client *ion_client_create(struct ion_device *dev,
				     unsigned int heap_mask,
				     const char *name)

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

高通使用msm_ion_client_create函數封裝了下。

 有了client之後就可以分配內存：

struct ion_handle *ion_alloc(struct ion_client *client, size_t len,
                 size_t align, unsigned int flags)

struct ion_handle *ion_alloc(struct ion_client *client, size_t len,
			     size_t align, unsigned int flags)

flags: 分配的heap id.

 有了handle也就是buffer之後就準備使用了，不過還是物理地址，需要map：

void *ion_map_kernel(struct ion_client *client, struct ion_handle *handle,
            unsigned long flags)

void *ion_map_kernel(struct ion_client *client, struct ion_handle *handle,
			unsigned long flags)

用戶空間:

         用戶空間如果想使用ION，也必須先要創建client,不過它是打開/dev/ion,實際上它最終也會調用ion_client_create。

         不過和內核空間創建client的一點區別是，用戶空間不能選擇heap type，但是內核空間卻可以。

         另外，用戶空間是通過IOCTL來分配內存的，cmd爲ION_IOC_ALLOC.

ion_fd = open("/dev/ion", O_ RDONLY | O_SYNC);
ioctl(ion_fd, ION_IOC_ALLOC, alloc);

ion_fd = open("/dev/ion", O_ RDONLY | O_SYNC); 
ioctl(ion_fd, ION_IOC_ALLOC, alloc); 

alloc爲struct ion_allocation_data,len是申請buffer的長度，flags是heap id。

/**
 * struct ion_allocation_data - metadata passed from userspace for allocations
 * @len:    size of the allocation
 * @align:  required alignment of the allocation
 * @flags:  flags passed to heap
 * @handle: pointer that will be populated with a cookie to use to refer
 *      to this allocation
 *
 * Provided by userspace as an argument to the ioctl
 */
struct ion_allocation_data {
    size_t len;
    size_t align;
    unsigned int flags;
    struct ion_handle *handle;
};

/**
 * struct ion_allocation_data - metadata passed from userspace for allocations
 * @len:	size of the allocation
 * @align:	required alignment of the allocation
 * @flags:	flags passed to heap
 * @handle:	pointer that will be populated with a cookie to use to refer
 *		to this allocation
 *
 * Provided by userspace as an argument to the ioctl
 */
struct ion_allocation_data {
	size_t len;
	size_t align;
	unsigned int flags;
	struct ion_handle *handle;
};

分配好了buffer之後，如果用戶空間想使用buffer，先需要mmap. ION是通過先調用IOCTL中的ION_IOC_SHARE/ION_IOC_MAP來得到可以mmap的fd,然後再執行mmap得到bufferaddress.

         然後，你也可以將此fd傳給另一個進程，如通過binder傳遞。在另一個進程中通過ION_IOC_IMPORT這個IOCTL來得到這塊共享buffer了。

 來看一個例子：

進程A：
int ionfd = open("/dev/ion", O_RDONLY | O_DSYNC);
alloc_data.len = 0x1000;
alloc_data.align = 0x1000;
alloc_data.flags = ION_HEAP(ION_CP_MM_HEAP_ID);
rc = ioctl(ionfd,ION_IOC_ALLOC, &alloc_data);
fd_data.handle = alloc_data.handle;
rc = ioctl(ionfd,ION_IOC_SHARE,&fd_data);
shared_fd = fd_data.fd;

進程B：
fd_data.fd = shared_fd;
rc = ioctl(ionfd,ION_IOC_IMPORT,&fd_data);