ION内存管理器介绍

最新推荐文章于 2023-11-28 21:50:29 发布
最新推荐文章于 2023-11-28 21:50:29 发布
阅读量5.2k 收藏 51
点赞数 10
分类专栏： 内存管理 linux 文章标签： android
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/lunhui2016/article/details/111797978
版权

1. ION介绍

ION是google在Android4.0为了解决内存碎片化管理而引入的通用内存管理器，用来支持不同的内存分配机制，如CARVOUT(PMEM)，物理连续内存(kmalloc)，虚拟地址连续但物理地址不连续内存(vmalloc)，IOMMU等。

内核版本：linux-4.9

2. ION框架

在这里插入图片描述
名词解释：

ion client:ion的使用者，用户空间和内核驱动要使用ion的buffer，必须先创建一个client，一个client可以有多个ion buffer，用struct ion_buffer结构表示。

ion handle:将ion buffer抽象出来，通过ion handle来管理该buffer，一般用户直接拿到的都是handle，而不是buffer，ion handle用struct ion_handle表示。

ion head:用来表示内存分配的相关信息，包括id,type,name等，用struct ion_heap表示，在调用ion_device_create时指定。

各个数据结构关系如下图所示：

2.1 ION的数据结构

在这里插入图片描述

2.2 ION的数据结构介绍

ion_device : ion设备,一个平台只能创建一个,属于misc设备,vexpress_ion_probe中调用ion_device_create创建.

struct ion_device {
	struct miscdevice dev;		//混杂设备
	struct rb_root buffers;		//连接通过该ion_device创建的所有ion_buffer的树
	struct mutex buffer_lock;
	struct rw_semaphore lock;
	struct plist_head heaps;		//该ion_device所支持的ion_heap
	long (*custom_ioctl)(struct ion_client *client, unsigned int cmd,
				    unsigned long arg);		//用户指定的ioctl函数，当使用ION_IOC_CUSTOM命令时，会由ion_ioctl()委托给custom_ioctl
	struct rb_root clients;				//连接该ion_device下的所有ion_client的树，ion_client可以在用户空间通过ion_open创建，也可以在驱动通过ion_client_create创建
	struct dentry *debug_root;
	struct dentry *heaps_debug_root;
	struct dentry *clients_debug_root;
	int heap_cnt;							//ion heaps的数目
};

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

struct ion_client {
	struct rb_node node;			//挂在ion_device->clients树的节点
	struct ion_device *dev;		//指向所属的ion_device
	struct rb_root handles;		//管理该client下所有ion_handle的树
	struct idr idr;
	struct mutex lock;			//保护该client管理的handles树的互斥锁，修改该handles时需持锁
	const char *name;
	char *display_name;
	int display_serial;
	struct task_struct *task;
	pid_t pid;
	struct dentry *debug_root;
};

ion_handle ：访问ion_buffer的句柄.一个ion_buffer可能被不同ion_client共享, ion_client通过ion_handle来访问ion_buffer.

struct ion_handle {
	struct kref ref;					     //该ion_handle的引用计数
	struct ion_client *client;		//指向所属的ion_client
	struct ion_buffer *buffer;		//指向所关联的ion_buffer
	struct rb_node node;					//用于添加到ion_client->handles树的节点
	unsigned int kmap_cnt;				//该handle map到kernel的次数. 实际是对ion_buffer->kmap_cnt的封装
	int id;							   //由ion_client->idr分配的唯一id，每个ion_handle有且只有一个独立id
};

ion_buffer:ion分配的buffer的元数据. ion_device分配的所有buffer, 记录在ion_device->buffers链上

struct ion_buffer {
	struct kref ref;										 //ion_buffer的引用计数
	union {
		struct rb_node node;							//用于添加到ion_device->buffers树的节点
		struct list_head list;
	};
	struct ion_device *dev;						 //指向所属的ion_device
	struct ion_heap *heap;						  //指向所属的ion_heap
	unsigned long flags;						    //分配ion_buffer指定的flag
	unsigned long private_flags;
	size_t size;									//buffer的大小
	void *priv_virt;								//ion_buffer管理的对应ion_heap的私有数据
	struct mutex lock;
	int kmap_cnt;				//映射给内核的次数. 第一次时, 才真正调用heap->ops->map_kernel, 此后只增加kmap_cnt计数
	void *vaddr;			 //映射给内核的虚拟地址
	int dmap_cnt;			//dma映射次数
	struct sg_table *sg_table;	//dma映射得到的散列表
	struct page **pages;        //保存sg_table中内存对应的页帧信息，用于同步cache用
	struct list_head vmas;		//记录ion_bufer对应的内存区域，用户空间使用mmap系统调用时将相应内存区域加入该链表
	/* used to track orphaned buffers */
	int handle_count;			//对于共享buffer，用于记录多少个ion_handle关联到该buffer
	char task_comm[TASK_COMM_LEN];
	pid_t pid;
};

ion_heap：ion堆，用于管理各种类型内存的分配，释放，映射，解除映射等操作的抽象对象

struct ion_heap {
	struct plist_node node;					//用于添加到ion_device->heaps链表的节点
	struct ion_device *dev;				 //指向所属的ion_device
	enum ion_heap_type type;       //ion_heap的类型
	struct ion_heap_ops *ops;      //ion_heap对应的函数操作集合
	unsigned long flags;
	unsigned int id;							//ion heap的唯一id,在分配buffer时，决定哪一种类型的heap的优先级
	const char *name;
	struct shrinker shrinker;
	struct list_head free_list;
	size_t free_list_size;
	spinlock_t free_lock;					//用于保护free_list的原子锁
	wait_queue_head_t waitqueue;
	struct task_struct *task;
	int (*debug_show)(struct ion_heap *heap, struct seq_file *, void *);
};

常见的ion_heap介绍：

ION_HEAP_TYPE_SYSTEM: System类型，系统非物理连续类型堆，使用vmalloc分配，比如上层要求分配10M内存，实际会得到4M + 4M + 2M共一个内存块，组成散列数组(sg_table)，这个散列数组可直接给dma使用，用户态和内核态cpu访问时，需要通过map_user，map_kernel映射，映射后的是连续虚拟空间。

ION_HEAP_TYPE_SYSTEM_CONTIG: system_contig类型，系统物理连续堆，分配由kmalloc完成，一次最多不能分配超过4M(linux系统限制)。

ION_HEAP_TYPE_CARVEOUT: Carveout类型，用户预留一块连续大物理内存(预留区不能在bank内，不能用memblock_reserve预留，可用memblock_remove预留)，通过gen_pool_alloc进行分配，一次能分配的大小不受系统4M限制，由预留量和使用情况决定，这种堆能满足de/ve对连续大块(超过4M)物理内存的需求，但缺点是预留后，系统不能使用，造成浪费。

ION_HEAP_TYPE_CHUNK: 和carveout类似，先预留一块大物理内存，再用gen_pool_alloc进行分配。不同是，只能按指定单元大小(chunk_size)来分配，比如要求分配10M内存，指定单元大小为4M，则最终得到的是3块内存区，每块大小4M，两块之间可能不连续。

ION_HEAP_TYPE_DMA: cma类型，内存分配由内存管理进行，主要通过dma map的相关ops完成。

ION_HEAP_TYPE_CUSTOM: 作为与用户自定义的堆的分界线，不实际使用;

ion_heap_ops:对于各种ion_heap的操作集合，实现buffer分配，释放，映射，解除映射等操作的集合。

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);
		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);
		int (*shrink)(struct ion_heap *heap, gfp_t gfp_mask, int nr_to_scan);
		int (*phys)(struct ion_heap *heap, struct ion_buffer *buffer,
						ion_phys_addr_t *addr, size_t *len);
};

2.3 ION初始化

在注册ION驱动中，实现对ion的初始化和封装，万事都从设备probe开始进行，代码如下：

static int vexpress_ion_probe(struct platform_device *pdev)
{
	struct vexpress_ion_dev *ipdev;
	int i;

	ipdev = devm_kzalloc(&pdev->dev, sizeof(*ipdev), GFP_KERNEL);
	if (!ipdev)
		return -ENOMEM;

	platform_set_drvdata(pdev, ipdev);

	ipdev->idev = ion_device_create(NULL);
	if (IS_ERR(ipdev->idev))
		return PTR_ERR(ipdev->idev);

	g_idev = ipdev->idev;
	ipdev->data = ion_parse_dt(pdev, vexpress_heaps);
	if (IS_ERR(ipdev->data))
		return PTR_ERR(ipdev->data);

	ipdev->heaps = devm_kzalloc(&pdev->dev,
				sizeof(struct ion_heap) * ipdev->data->nr,
				GFP_KERNEL);
	if (!ipdev->heaps) {
		ion_destroy_platform_data(ipdev->data);
		return -ENOMEM;
	}

	for (i = 0; i < ipdev->data->nr; i++) {
		ipdev->heaps[i] = ion_heap_create(&ipdev->data->heaps[i]);
		if (!ipdev->heaps) {
			ion_destroy_platform_data(ipdev->data);
			return -ENOMEM;
		}
		ion_device_add_heap(ipdev->idev, ipdev->heaps[i]);
	}
	return 0;
}

static int vexpress_ion_remove(struct platform_device *pdev)
{
	struct vexpress_ion_dev *ipdev;
	int i;

	ipdev = platform_get_drvdata(pdev);

	for (i = 0; i < ipdev->data->nr; i++)
		ion_heap_destroy(ipdev->heaps[i]);

	ion_destroy_platform_data(ipdev->data);
	ion_device_destroy(ipdev->idev);

	return 0;
}

static const struct of_device_id vexpress_ion_match_table[] = {
	{.compatible = "vexpress,ion"},
	{},
};

static struct platform_driver vexpress_ion_driver = {
	.probe = vexpress_ion_probe,
	.remove = vexpress_ion_remove,
	.driver = {
		.name = "ion-vexpress",
		.of_match_table = vexpress_ion_match_table,
	},
};

static int __init vexpress_ion_init(void)
{
	return platform_driver_register(&vexpress_ion_driver);
}

subsys_initcall(vexpress_ion_init);

2.4 ION内存的分配

2.4.1 用户空间ION内存的分配

在用户空间，如果想使用ion，需要进行以下两步操作：

1.创建ion client，只需简单的通过open系统调用打开/dev/ion设备，即可创建一个ion client。代码如下所示：

//在ion_device_create()中，将ion_device的文件操作集初始化为ion_fops
static const struct file_operations ion_fops = {
	.owner          = THIS_MODULE,
	.open           = ion_open,
	.release        = ion_release,
	.unlocked_ioctl = ion_ioctl,
	.compat_ioctl   = compat_ion_ioctl,
};

static int ion_open(struct inode *inode, struct file *file)
{
	struct miscdevice *miscdev = file->private_data;
	struct ion_device *dev = container_of(miscdev, struct ion_device, dev);
	struct ion_client *client;
	char debug_name[64];

	snprintf(debug_name, 64, "%u", task_pid_nr(current->group_leader));
	client = ion_client_create(dev, debug_name);		//创建ion client
	if (IS_ERR(client))
		return PTR_ERR(client);
	file->private_data = client;

	return 0;
}

2.在创建client之后，用户程序可以通过ioctl()函数的命令进行内存分配，释放，映射和解除映射等操作

3.ion在用户态使用ion的demo如下所示:

int main(void)
{
	/*数据结构见drivers/staging/android/uapi/ion.h*/
	struct ion_allocation_data alloc_data;
	struct ion_handle_data handle_data;
	struct ion_fd_data fd_data;
	int fd, ret = 0, ret1 = 0;
	unsigned char *buffer;

	//open device
	fd = open("/dev/ion", O_RDONLY);
	if (fd < 0) {
		printf("open device error!\n");
		ret = -1;
		return ret;
	}
	//设置ion alloc的参数
	alloc_data.len = 1024 * 768 *4;
	alloc_data.align = 0;
	alloc_data.heap_id_mask = ION_HEAP_TYPE_DMA_MASK;	//使用cma堆
	alloc_data.flags = ION_FLAG_CACHED | ION_FLAG_CACHED_NEEDS_SYNC;
	ret = ioctl(fd, ION_IOC_ALLOC, &alloc_data);		//分配ion内存
	if (ret) {
		printf("ion alloc error!\n");
		goto out1;
	}

	//获取dmabuf的fd
	fd_data.handle = alloc_data.handle；
	ret = ioctl(fd, ION_IOC_MAP, &fd_data);
	if (ret) {
		printf("ion map error!\n");
		goto out2;
	}

	//mmap to user space
	buffer = mmap(NULL, alloc_data.len, PROT_READ|PROT_WRITE, MAP_SHARED, fd_data.fd, 0);
	if (MAP_FAILED == buffer) {
		printf("mmap to user space error!\n");
		goto out3;
	}

	//use in user space
	memset(buffer, 0, alloc_data.len);

	//after use, munmap user buffer
	ret = munmap(buffer, alloc_data.len);
	if (ret) {
		printf("munmap error!\n");
	}

out3:
	//close dmabuf fd
	close(fd_data.fd);

out2:
	//free buffer
	handle_data.handle = alloc_data.handle;
	ret = ioctl(fd, ION_IOC_FREE, &handle_data);
	if (ret) {
		printf("ion free buffer error!\n");
	}

out1:
	//close ion device
	close(fd);
	return ret;
}

2.4.2 内核空间ION内存的分配

内核空间使用ion跟用户空间差不多，只是它的使用对用户空间来说是透明的而已。

1.同样，通过调用ion_client_create()函数创建一个ion client，该函数在kernel空间被ION驱动中封装成以下函数：

struct ion_device *g_idev = NULL;

struct ion_client *vexpress_ion_client_create(char *name)
{
	/*
	* The assumption is that if there is a NULL device, the ion
	* driver has not yet probed.
	*/
	if (IS_ERR_OR_NULL(g_idev))
		return ERR_PTR(-EPROBE_DEFER);

	if (IS_ERR(g_idev))
		return (struct ion_client *)g_idev;

	return ion_client_create(g_idev, name);
}
EXPORT_SYMBOL(vexpress_ion_client_create);

2.通过ion_alloc()来进行内存分配

3.通过ion_map_kernel()来进行地址映射

4.如果有些硬件只能通过physical addresses来操作physically-contiguous buffers，那么，这些对应的drivers就需通过调用以下接口来获取虚拟地址所对应的物理地址才行。但ion框架中不推荐使用这种方式，而是建议通过ion_sg_table方式来使用。

int ion_phys(struct ion_client *client, struct ion_handle *handle,ion_phys_addr_t *addr, size_t *len)

5.如果多个设备使用到同一个ion buffer，可以使用以下几个个接口实现buffer的共享，减少buffer的拷贝过程，实现zero-copy.

struct dma_buf *ion_share_dma_buf(struct ion_client *client,struct ion_handle *handle);
int ion_share_dma_buf_fd(struct ion_client *client, struct ion_handle *handle);
int ion_share_dma_buf_fd2(struct ion_client *client, struct ion_handle *handle);
struct ion_handle *ion_import_dma_buf(struct ion_client *client,struct dma_buf *dmabuf);
struct ion_handle *ion_import_dma_buf_fd(struct ion_client *client, int fd);

以上两个接口分别实现了dma_buf的共享和获取。

2.4.3 ION内存分配流程

在这里插入图片描述

3. ION共享内存使用

内存共享和大块内存的使用，在实际场景下面的需求是很大的，这里举三个简单的应用场景:

  1. 用户态和内核态共享内存

  2. 用户态不同进程共享内存

  3. 内核态使用ION分配内存

3.1 用户态和内核态共享内存

用户态和内核态共享内存分两种情况，一种是内核态申请buffer，共享给用户态，另一种是用户态申请buffer，共享给内核态，这两种方法，都是通过fd方式进行共享即可，不用进行copy_to_user()或者copy_from_user()这些copy操作，即zero-copy。

3.1.1 用户态申请内存，共享给内核态

  1. 用户态申请dmabuf
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <sys/mman.h>
#include <unistd.h>
#include "dmabuf_test.h"
#include "ion.h"

#define PAGE_SIZE 4096

static int test_share_dmabuf_to_kernel(int fd)
{
	int ret = 0;
	struct dmabuf_test_rw_data data = {0};
	int ion_fd = 0;
	struct ion_allocation_data alloc_data;
	struct ion_handle_data handle_data;
	struct ion_fd_data fd_data;
	unsigned char *buffer;

	ion_fd = open("/dev/ion", O_RDONLY);
	if (ion_fd < 0) {
		printf("open ion device faile\n");
		return ion_fd;
	}

	alloc_data.len = PAGE_SIZE;
	alloc_data.align = 0;
	alloc_data.heap_id_mask = ION_HEAP_SYSTEM_MASK;
	alloc_data.flags = ION_FLAG_CACHED | ION_FLAG_CACHED_NEEDS_SYNC;

	/* alloc dmabuf */
	ret = ioctl(ion_fd, ION_IOC_ALLOC, &alloc_data);
	if (ret < 0) {
		printf("ion alloc error\n");
		goto close_fd;
	}

	/* get dmabuf fd */
	fd_data.handle = alloc_data.handle;
	ret = ioctl(ion_fd, ION_IOC_MAP, &fd_data);
	if (ret < 0) {
		printf("ion map error\n");
		goto free_buf;
	}

	//mmap to user space
	buffer = mmap(NULL, alloc_data.len, PROT_READ|PROT_WRITE, MAP_SHARED,
			fd_data.fd, 0);
	if (MAP_FAILED == buffer) {
		printf("mmap to user space error!\n");
		goto close_dmabuf_fd;
	}

	buffer[0] = 'a';
	buffer[1] = 'b';
	buffer[2] = 'c';
	buffer[3] = 'd';
	buffer[4] = '\n';

	data.fd = fd_data.fd;

	/* share dmabuf fd to kernel */
	ret = ioctl(fd, DMABUF_IOC_TEST_GET_FD_FROM_USER, &data);
	if (ret < 0) {
		printf("share dmabuf fd to kernel space error\n");
	}

	ret = munmap(buffer, alloc_data.len);
	if (ret < 0) {
		printf("munmap error\n!");
	}

close_dmabuf_fd:
	close(fd_data.fd);

free_buf:
	handle_data.handle = alloc_data.handle;
	ret = ioctl(ion_fd, ION_IOC_FREE, &handle_data);
	if (ret)
		printf("ion free buffer error\n");
close_fd:
	close(ion_fd);
	return ret;
}

int main()
{
	int fd;
	int ret = 0;

	printf("start demo\n");
	fd = open("/dev/dmabuf-test", O_RDONLY);
	if (fd < 0) {
		printf("open device faile\n");
		return fd;
	}

	ret = test_share_dmabuf_to_kernel(fd);

	close(fd);

	return ret;
}
  1. 内核驱动获取共享的dmabuf
static long dmabuf_test_ioctl(struct file *filp, unsigned int cmd,
				unsigned long arg)
{
	struct miscdevice *miscdev = filp->private_data;
	struct dmabuf_test_device *dev = container_of(miscdev, struct dmabuf_test_device, misc);
	unsigned int dir;
	struct dmabuf_test_rw_data data;

	dir = dmabuf_test_ioctl_dir(cmd);

	if (_IOC_SIZE(cmd) > sizeof(data))
		return -EINVAL;

	if (copy_from_user(&data, (void __user *)arg, _IOC_SIZE(cmd)))
		return -EFAULT;

	if (!(dir & _IOC_WRITE))
		memset(&data, 0, sizeof(data));

	switch(cmd) {
	case DMABUF_IOC_TEST_GET_FD_FROM_KERNEL:
	{

		/* share fd must keep it in device ioctl, otherwise userspace
		 * mapping file faile
		 */
		data.fd = ion_share_dma_buf_fd(dev->client, dev->handle);
		if (data.fd < 0) {
			pr_err("get dmabuf fd error\n");
			return -EBADF;
		}
		break;
	}
	case DMABUF_IOC_TEST_GET_FD_FROM_USER:
	{
		struct dma_buf *dmabuf;
		unsigned char *buf;
		int ret;

		dmabuf = dma_buf_get(data.fd);
		if (IS_ERR_OR_NULL(dmabuf)) {
			pr_err("get dmabuf from dmabuf fd:%d error\n", data.fd);
			return -EINVAL;
		}
		ret = dma_buf_begin_cpu_access(dmabuf, DMA_BIDIRECTIONAL);
		if (ret < 0) {
			pr_err("begin cpu access error\n");
			dma_buf_put(dmabuf);
			return -EFAULT;
		}

		/* buf size is PAGE_SIZE */
		buf = (unsigned char *)dma_buf_kmap(dmabuf, 0);
		if (IS_ERR_OR_NULL(buf)) {
			pr_err("map dmabuf to kernel space error\n");
			return -EFAULT;
		}
		printk("buf data:%s\n", buf);
		ret = dma_buf_end_cpu_access(dmabuf, DMA_BIDIRECTIONAL);
		if (ret < 0) {
			pr_err("end cpu access error\n");
			dma_buf_kunmap(dmabuf, 0, (void *)buf);
			dma_buf_put(dmabuf);
			return -EFAULT;
		}
		dma_buf_kunmap(dmabuf, 0, (void *)buf);
		dma_buf_put(dmabuf);
		break;
	}
	default:
		return -ENOTTY;
	}

	if (dir & _IOC_READ) {
		if (copy_to_user((void __user *)arg, &data, _IOC_SIZE(cmd))) {
			return -EFAULT;
		}
	}

	return 0;
}

3.1.2 内核态申请，共享给用户态

  1. 内核驱动申请dmabuf，通过驱动设备ioctl()接口共享dmabuf fd到userspace
/*
 *
 * Copyright (C) 2013 Google, Inc.
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */

#define pr_fmt(fmt) "dma-buf-test: " fmt

#include <linux/dma-buf.h>
#include <linux/dma-direction.h>
#include <linux/fs.h>
#include <linux/miscdevice.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/vmalloc.h>

#include "ion.h"
#include "../uapi/dmabuf_test.h"

struct dmabuf_test_device {
	struct miscdevice misc;
	struct ion_client *client;
	struct ion_handle *handle;
};

static int dmabuf_alloc_dmabuf(struct dmabuf_test_device *dev)
{
	struct ion_handle *handle = NULL;
	unsigned char *buf = NULL;
	unsigned int flags = ION_FLAG_CACHED | ION_FLAG_CACHED_NEEDS_SYNC;

	handle = ion_alloc(dev->client, PAGE_SIZE, 0, (1 << ION_HEAP_TYPE_SYSTEM), flags);

	if (IS_ERR_OR_NULL(handle)) {
		pr_err("ion alloc handle error\n");
		return -EINVAL;
	}

	dev->handle = handle;
	buf = (unsigned char *)ion_map_kernel(dev->client, handle);
	buf[0] = 'e';
	buf[1] = 'f';
	buf[2] = 'g';
	buf[3] = 'h';
	buf[4] = '\n';
	ion_unmap_kernel(dev->client, handle);
	return 0;
}

static int dmabuf_test_open(struct inode *inode, struct file *file)
{
	return 0;
}

static int dmabuf_test_release(struct inode *inode, struct file *file)
{
	return 0;
}

static unsigned long dmabuf_test_ioctl_dir(unsigned int cmd)
{
	switch(cmd) {
	case DMABUF_IOC_TEST_GET_FD_FROM_KERNEL:
	case DMABUF_IOC_TEST_GET_FD_FROM_USER:
		return _IOC_DIR(cmd);
	default:
		return _IOC_DIR(cmd);
	}
}

static long dmabuf_test_ioctl(struct file *filp, unsigned int cmd,
				unsigned long arg)
{
	struct miscdevice *miscdev = filp->private_data;
	struct dmabuf_test_device *dev = container_of(miscdev, struct dmabuf_test_device, misc);
	unsigned int dir;
	struct dmabuf_test_rw_data data;

	dir = dmabuf_test_ioctl_dir(cmd);

	if (_IOC_SIZE(cmd) > sizeof(data))
		return -EINVAL;

	if (copy_from_user(&data, (void __user *)arg, _IOC_SIZE(cmd)))
		return -EFAULT;

	if (!(dir & _IOC_WRITE))
		memset(&data, 0, sizeof(data));

	switch(cmd) {
	case DMABUF_IOC_TEST_GET_FD_FROM_KERNEL:
	{

		/* share fd must keep it in device ioctl, otherwise userspace
		 * mapping file faile
		 */
		data.fd = ion_share_dma_buf_fd(dev->client, dev->handle);
		if (data.fd < 0) {
			pr_err("get dmabuf fd error\n");
			return -EBADF;
		}
		break;
	}
	case DMABUF_IOC_TEST_GET_FD_FROM_USER:
	{
		struct dma_buf *dmabuf;
		unsigned char *buf;
		int ret;

		dmabuf = dma_buf_get(data.fd);
		if (IS_ERR_OR_NULL(dmabuf)) {
			pr_err("get dmabuf from dmabuf fd:%d error\n", data.fd);
			return -EINVAL;
		}
		ret = dma_buf_begin_cpu_access(dmabuf, DMA_BIDIRECTIONAL);
		if (ret < 0) {
			pr_err("begin cpu access error\n");
			dma_buf_put(dmabuf);
			return -EFAULT;
		}

		/* buf size is PAGE_SIZE */
		buf = (unsigned char *)dma_buf_kmap(dmabuf, 0);
		if (IS_ERR_OR_NULL(buf)) {
			pr_err("map dmabuf to kernel space error\n");
			return -EFAULT;
		}
		printk("buf data:%s\n", buf);
		ret = dma_buf_end_cpu_access(dmabuf, DMA_BIDIRECTIONAL);
		if (ret < 0) {
			pr_err("end cpu access error\n");
			dma_buf_kunmap(dmabuf, 0, (void *)buf);
			dma_buf_put(dmabuf);
			return -EFAULT;
		}
		dma_buf_kunmap(dmabuf, 0, (void *)buf);
		dma_buf_put(dmabuf);
		break;
	}
	default:
		return -ENOTTY;
	}

	if (dir & _IOC_READ) {
		if (copy_to_user((void __user *)arg, &data, _IOC_SIZE(cmd))) {
			return -EFAULT;
		}
	}

	return 0;
}

static const struct file_operations dmabuf_test_fops = {
	.owner = THIS_MODULE,
	.unlocked_ioctl = dmabuf_test_ioctl,
	.compat_ioctl = dmabuf_test_ioctl,
	.open = dmabuf_test_open,
	.release = dmabuf_test_release,
};

static int __init dmabuf_test_probe(struct platform_device *pdev)
{
	int ret;
	struct dmabuf_test_device *testdev;

	testdev = devm_kzalloc(&pdev->dev, sizeof(struct dmabuf_test_device),
			       GFP_KERNEL);
	if (!testdev)
		return -ENOMEM;

	testdev->misc.minor = MISC_DYNAMIC_MINOR;
	testdev->misc.name = "dmabuf-test";
	testdev->misc.fops = &dmabuf_test_fops;
	testdev->misc.parent = &pdev->dev;
	ret = misc_register(&testdev->misc);
	if (ret) {
		pr_err("failed to register misc device.\n");
		return ret;
	}

	/*create ion client */
	testdev->client = vexpress_ion_client_create("dmabuf-test-client");
	if (!testdev->client) {
		pr_err("failed to create ion client\n");
		return -EINVAL;
	}

	dmabuf_alloc_dmabuf(testdev);
	platform_set_drvdata(pdev, testdev);

	return 0;
}

static int dmabuf_test_remove(struct platform_device *pdev)
{
	struct dmabuf_test_device *testdev;

	testdev = platform_get_drvdata(pdev);
	if (!testdev)
		return -ENODATA;

	misc_deregister(&testdev->misc);
	return 0;
}

static struct platform_device *dmabuf_test_pdev;
static struct platform_driver dmabuf_test_platform_driver = {
	.remove = dmabuf_test_remove,
	.driver = {
		.name = "dmabuf-test",
	},
};

static int __init dmabuf_test_init(void)
{
	dmabuf_test_pdev = platform_device_register_simple("dmabuf-test",
							-1, NULL, 0);
	if (IS_ERR(dmabuf_test_pdev))
		return PTR_ERR(dmabuf_test_pdev);

	return platform_driver_probe(&dmabuf_test_platform_driver, dmabuf_test_probe);
}

static void __exit dmabuf_test_exit(void)
{
	platform_driver_unregister(&dmabuf_test_platform_driver);
	platform_device_unregister(dmabuf_test_pdev);
}

module_init(dmabuf_test_init);
module_exit(dmabuf_test_exit);
MODULE_LICENSE("GPL v2");
  1. 用户空间通过fd访问dmabuf
#include <sys/ioctl.h>
#include <stdio.h>
#include <sys/mman.h>
#include <unistd.h>
#include "dmabuf_test.h"
#include "ion.h"

#define PAGE_SIZE 4096

static int test_share_dmabuf_from_kernel(int fd)
{
	int ret = 0;
	unsigned char *buf = NULL;
	struct dmabuf_test_rw_data data = {0};

	ret = ioctl(fd, DMABUF_IOC_TEST_GET_FD_FROM_KERNEL, &data);
	if (ret < 0) {
		printf("get dmabuf fd faile\n");
		return ret;
	}

	buf = (unsigned char *)mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, data.fd, 0);
	if (buf == MAP_FAILED) {
		close(data.fd);
		printf("map dmabuf fail\n");
		return -1;
	}
	printf("user space buffer data:%s\n", buf);
	ret = munmap(buf, PAGE_SIZE);
	if (ret < 0) {
		printf("munmap error\n!");
	}

	close(data.fd);
	return 0;
}

int main()
{
	int fd;
	int ret = 0;

	printf("start demo\n");
	fd = open("/dev/dmabuf-test", O_RDONLY);
	if (fd < 0) {
		printf("open device faile\n");
		return fd;
	}

	ret = test_share_dmabuf_from_kernel(fd);

	close(fd);

	return ret;
}

3.2 用户态不同进程共享内存

服务进程

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <sys/mman.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <strings.h>
#include <sys/mman.h>

#define PAGE_SIZE 4096

int main()
{
	int clientfd, listenfd;
	struct sockaddr_un servaddr, cliaddr;
	int ret;
	struct msghdr msg;
	struct iovec iov[1];
	char buf[100];
	union {
		struct cmsghdr cm;
		char control[CMSG_SPACE(sizeof(int))];
	} control_un;
	struct cmsghdr *cmptr;
	int recvfd;
	socklen_t len;
	unsigned char *buffer;

	listenfd = socket(AF_UNIX, SOCK_STREAM, 0);
	if (listenfd < 0) {
		printf("socket failed\n");
		return listenfd;
	}

	unlink("test_socket");
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sun_family = AF_UNIX;
	strcpy(servaddr.sun_path, "test_socket");
	//servaddr.sun_path = "test_socket";

	ret = bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
	if (ret < 0) {
		printf("bind socket failed.\n");
		close(listenfd);
		return ret;
	}

	listen(listenfd, 5);

	while(1) {
		len = sizeof(cliaddr);
		clientfd = accept(listenfd, (struct sockaddr *)&cliaddr, &len);
		if (clientfd < 0) {
			printf("accept failed\n");
			continue;
		}
		msg.msg_control = control_un.control;
		msg.msg_controllen = sizeof(control_un.control);

		msg.msg_name = NULL;
		msg.msg_namelen = 0;
		iov[0].iov_base = buf;
		iov[0].iov_len = sizeof(buf)/sizeof(buf[0]);

		msg.msg_iov = iov;
		msg.msg_iovlen = 1;

		ret = recvmsg(clientfd, &msg, 0);
		if (ret < 0) {
			return ret;
		}

		//check recv data and len
		if ((cmptr = CMSG_FIRSTHDR(&msg)) != NULL && (cmptr->cmsg_len == CMSG_LEN(sizeof(int)))) {
			if(cmptr->cmsg_level != SOL_SOCKET) {
				printf("cmsg_level is not SOL_SOCKET\n");
				continue;
			}

			if (cmptr->cmsg_type != SCM_RIGHTS) {
				printf("cmsg_type is not SCM_RIGHTS\n");
				continue;
			}

			recvfd = *((int *)CMSG_DATA(cmptr));
			break;
		}
	}
	printf("recv fd:%d\n", recvfd);
	buffer = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, recvfd, 0);
	if (buffer == MAP_FAILED) {
		close(recvfd);
		printf("map dmmbuf fail\n");
		return MAP_FAILED;
	}

	printf("service buffer data:%s\n", buffer);

	ret = munmap(buffer, PAGE_SIZE);
	if (ret < 0) {
		printf("munmap error\n!");
	}

	close(recvfd);

	return ret;
}

服务进程主要工作：

  1. 监听本地socket，等待客户端进程共享dmabuf fd

  2. 拿到共享的dmabuf fd后，map到自己进程空间，访问该buffer

  3. 关闭dmabuf fd，退出进程

客户端进程

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <sys/mman.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <strings.h>
#include "dmabuf_test.h"
#include "ion.h"

#define PAGE_SIZE 4096

int test_share_dmabuf_in_process()
{
	int ret;
	int ion_fd = 0;
	struct ion_allocation_data alloc_data;
	struct ion_handle_data handle_data;
	struct ion_fd_data fd_data;
	unsigned char *buffer;
	/* use to process communication */
	int socket_fd;
	struct sockaddr_un addr;
	struct msghdr msg;
	union {
		struct cmsghdr cm;
		char control[CMSG_SPACE(sizeof(int))];
	} control_un;
	struct cmsghdr *cmptr;
	struct iovec iov[1];
	char buf[100];			//for what?

	ion_fd = open("/dev/ion", O_RDONLY);
	if (ion_fd < 0) {
		printf("open ion device faile\n");
		return ion_fd;
	}

	alloc_data.len = PAGE_SIZE;
	alloc_data.align = 0;
	alloc_data.heap_id_mask = ION_HEAP_SYSTEM_MASK;
	alloc_data.flags = ION_FLAG_CACHED | ION_FLAG_CACHED_NEEDS_SYNC;

	/* alloc dmabuf */
	ret = ioctl(ion_fd, ION_IOC_ALLOC, &alloc_data);
	if (ret < 0) {
		printf("ion alloc error\n");
		goto close_fd;
	}

	/* get dmabuf share fd */
	fd_data.handle = alloc_data.handle;
	ret = ioctl(ion_fd, ION_IOC_MAP, &fd_data);
	if (ret < 0) {
		printf("ion map error\n");
		goto free_buf;
	}

	//mmap to user space
	buffer = mmap(NULL, alloc_data.len, PROT_READ|PROT_WRITE, MAP_SHARED,
			fd_data.fd, 0);
	if (MAP_FAILED == buffer) {
		printf("mmap to user space error!\n");
		goto close_dmabuf_fd;
	}

	buffer[0] = '1';
	buffer[1] = '2';
	buffer[2] = '3';
	buffer[3] = '4';
	buffer[4] = '\n';

	printf("client buffer data:%s\n", buffer);
	ret = munmap(buffer, alloc_data.len);
	if (ret < 0) {
		printf("munmap error\n!");
		goto close_dmabuf_fd;
	}

	socket_fd = socket(AF_UNIX, SOCK_STREAM, 0);
	if (socket_fd < 0) {
		printf("create socket failed\n");
		ret = socket_fd;
		goto close_dmabuf_fd;
	}

	bzero(&addr, sizeof(addr));
	addr.sun_family = AF_UNIX;
	strcpy(addr.sun_path, "test_socket");
	//addr.sun_path = "test_socket";

	ret = connect(socket_fd, (struct sockaddr *)&addr, sizeof(addr));
	if(ret < 0) {
		printf("connect failed!\n");
		goto close_dmabuf_fd;
	}

	msg.msg_control = control_un.control;
	msg.msg_controllen = sizeof(control_un.control);

	cmptr = CMSG_FIRSTHDR(&msg);
	cmptr->cmsg_len = CMSG_LEN(sizeof(int));
	cmptr->cmsg_level = SOL_SOCKET;
	cmptr->cmsg_type = SCM_RIGHTS;
	*((int *) CMSG_DATA(cmptr)) = fd_data.fd;

	msg.msg_name = NULL;
	msg.msg_namelen = 0;
	iov[0].iov_base = buf;
	iov[0].iov_len = sizeof(buf)/sizeof(buf[0]);

	msg.msg_iov = iov;
	msg.msg_iovlen = 1;

	ret = sendmsg(socket_fd, &msg, 0);
	if (ret < 0) {
		printf("sendmsg failed\n");
		goto close_dmabuf_fd;
	}

	printf("ret :%d, fd:%d\n", ret, fd_data.fd);

close_dmabuf_fd:
	close(fd_data.fd);

free_buf:
	handle_data.handle = alloc_data.handle;
	ret = ioctl(ion_fd, ION_IOC_FREE, &handle_data);
	if (ret)
		printf("ion free buffer error\n");
close_fd:
	close(ion_fd);
	return ret;
}

int main()
{
	int fd;
	int ret = 0;

	printf("start demo\n");
	fd = open("/dev/dmabuf-test", O_RDONLY);
	if (fd < 0) {
		printf("open device faile\n");
		return fd;
	}

	ret = test_share_dmabuf_in_process();
	if (ret < 0) {
		printf("test share dmabuf in process faile\n");
	}
	close(fd);

	return 0;
}

客户端进程主要工作：

  1. 通过ION申请dmabuf，并且获取到dmabuf对应的fd

  2. 通过socket，把dmabuf fd共享到其他进程

  3. 释放自己进程申请的资源，解除buffer映射关系等

3.3 内核态使用ION分配内存

内核态使用ion分配内存，demo如下：

static int dmabuf_alloc_dmabuf(struct dmabuf_test_device *dev)
{
	struct ion_handle *handle = NULL;
	unsigned char *buf = NULL;
	unsigned int flags = ION_FLAG_CACHED | ION_FLAG_CACHED_NEEDS_SYNC;
	struct ion_client *client;

	client = vexpress_ion_client_create("dmabuf-test-client");

	handle = ion_alloc(client, PAGE_SIZE, 0, (1 << ION_HEAP_TYPE_SYSTEM), flags);

	if (IS_ERR_OR_NULL(handle)) {
		pr_err("ion alloc handle error\n");
		return -EINVAL;
	}

	dev->handle = handle;
	buf = (unsigned char *)ion_map_kernel(client, handle);
	buf[0] = 'e';
	buf[1] = 'f';
	buf[2] = 'g';
	buf[3] = 'h';
	buf[4] = '\n';
	ion_unmap_kernel(client, handle);
	return 0;
}

  1. 创建ion client

  2. 申请ion handle

  3. 通过ion_map_kernel()接口map dmabuf到kernel space

  4. 使用完后，调用ion_unmap_kernel()接口做解除映射

lunhui2016
关注
  • 10
    点赞
  • 踩
  • 51
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux内存管理（四十四）：ION 内存管理器——总篇
私房菜
04-28 1383
ION是 Google 在 Android 4.0 中引入，目的主要是通过在硬件设备和用户空间之间分配和共享内存，实现设备之间零拷贝共享内存，多用于多媒体，比如 camera、display、graphic等。ION是一个内存管理器，管理不同type的内存堆（heap），而不同的type的内存又通过不同的内存分配器来分配，比如cma、kmalloc、vmalloc等。
Android学习之ION memory manager
最新发布
我的博客
05-28 1114
ion_device是miscdevice的封装，buffers是存放ion_buffer对象的根结点，heaps为存放ion_heap对象的列表，custom_ioctl为自定义的操作函数，clients为客户端根结点。每一种类型的memory都对应一个ion_heap类型的对象，ion_heap的对象存放在dev中，内存的类型存放做type中，ops为内存的操作函数指针。ION 模块是可扩展的（API都是统一的），支持各种形式的内存分配方式，可以表述不同的硬件资源和他们的一些限制。
Android ION 用户空间与内核共享内存
Android驱动开发
04-06 3353
Android 系统中，SurfaceFlinger分配buf 或 CameraService拿到出的图像buf都是通过ION的机制； Android中通过Binder实现 IonFd跨进程共享，IonFd方便应用程序 user space 以及各驱动模块间零拷贝访问buf。 测试用例 项目中使用到的一段代码，部分不完整，但记录下的基本流程以及使用的API还是很清晰的 用户空间 int test::open(){ int rc = -1; mFd = ::open("/dev/test", O_RDWR
ION基本概念介绍和原理分析[转]
maze的专栏
04-23 3248
转载前的话： ION将内核态形形色色的内存分配纳入统一的管理接口之中，更重要的设计意图是为内存在不同用户态进程之间传递和访问提供了支持。 每个ion_buffer与一个struct file关联，其handle纳入进程file desc空间而不是/dev/ion设备内单独的handle空间，方便之处如下： 每个buffer一个handle，便于更灵活地细粒度地控制每个buffer的使用周期；...
ION基本概念介绍和原理分析
热门推荐
zirconsdu的专栏
05-24 3万+
转载前的话： ION将内核态形形色色的内存分配纳入统一的管理接口之中，更重要的设计意图是为内存在不同用户态进程之间传递和访问提供了支持。 每个ion_buffer与一个struct file关联，其handle纳入进程file desc空间而不是/dev/ion设备内单独的handle空间，方便之处如下： 每个buffer一个handle，便于更灵活地细粒度地控制每个buffer的使用周期；
内存管理 —— ION
zhuyong006的博客
07-23 2万+
ION 是当前 Android 流行的内存分配管理机制，在多媒体部分中使用的最多，例如从 Camera 到 Display，从 Mediaserver 到 Surfaceflinger，都会利用 ION 进行内存分配管理。 ION 的前任是 PMEM，关于 PMEM 我在 M030/M04X 项目中有接触过，后来由于 PMEM 的一些局限性，Google 推出了 ION 来取代 PMEM，当前 I...
ION内存管理
yameoooo_的博客
04-04 731
为了避免内存碎片化，或者为一些有着特殊内存需求的硬件，如GPU，display，camera等，在系统 启动的时候，会为他们预留一部分mem pool，而这些mem pool是有ION统一管理，另外通过ION就可 在user和space之间实现zero-copy的内存共享； 通过ION heaps来展示它对应的mem pools，不同的Android硬件会要求不同的ION heaps typ...
io端口和io内存
bugouyonggan的专栏
12-11 7469
linux中的 IO端口映射和IO内存映射 （一）地址的概念 1）物理地址：CPU地址总线传来的地址，由硬件电路控制其具体含义。物理地址中很大一部分是留给内存条中的内存的，但也常被映射到其他存储器上 （如显存、BIOS等）。在程序指令中的虚拟地址经过段映射和页面映射后，就生成了物理地址，这个物理地址被放到CPU的地址线上。         物理地址空间，一部分给物理RAM（内存）用，
ION内存管理.doc
10-12
ION内存管理器概述 ION内存管理器是Google在Android 4.0 ICS中引入的一种通用存管理器，旨在解决存碎片管理问题。ION取代了之前的PMEM存分配器，以提供更加融合kernel的存管理解决方案。 ION框架定义了四种不同的...
Linux内存管理（六十三）：ION 内存管理器-system heap
12-15
system heap refill
内存管理器 （最新版）
04-10
以上是内存管理的关键概念，但具体的“内存管理器（最新版）”可能包含更先进的技术和策略，例如现代Linux内核的内存管理机制、硬件辅助的内存管理技术，以及针对特定应用场景的优化策略。PrcMgr可能是内存管理程序...
linux内存管理
05-05
原创，共五章，基于工作中使用的3.10版本内核，包括 内存启动初始化过程，linux内核内存管理，进程虚拟地址管理
ion_chunk_heap.rar_ION_android
09-24
标题中的"Ion_chunk_heap.rar_ION_android"暗示了我们正在探讨的是Android系统中与Ion内存管理框架相关的组件，特别是"Ion_chunk_heap"部分。Ion是Android操作系统中的一个内存分配器，设计用于高效地处理硬件加速...
linux内存管理之 ION 内存管理器浅析Ⅰ（system heap）
04-06 7971
目录 1 什么是ION 2 ION中不同 type 的 heap 3 ION分配（以system heap为例） 3.1 ion_alloc() 3.2 ion_system_heap_allocate() 3.3 alloc_largest_available() 3.4alloc_buffer_page() 3.5 ion_page_pool_alloc() 3.6 ion_page_pool_remove() 3.7 ion_page_pool_alloc_pages() 4..
android 内存管理 ion,ION 内存管理
weixin_39652810的博客
05-25 189
FeatureIONDMABUFMemory Manager RoleION replaces PMEM as the manager of provisioned memory pools. The list of ION heaps can be extended per device.DMABUF is a buffer sharing framework, designed to inte...
Linux内存管理（四十六）：ION 内存管理器——system heap
私房菜
11-28 1292
ION是 Google 在 Android 4.0 中引入，目的主要是通过在硬件设备和用户空间之间分配和共享内存，实现设备之间零拷贝共享内存，多用于多媒体，比如 camera、display、graphic等。ION是一个内存管理器，管理不同type的内存堆（heap），而不同的type的内存又通过不同的内存分配器来分配，比如cma、kmalloc、vmalloc等。通过《ION 总篇》
ION内存分配
wmzjzwlzs的专栏
06-18 2384
转自：Android系列-ION内存管理简介 - 简书Android系列-ION内存管理简介Android的ION子系统的目的主要是通过在硬件设备和用户空间之间分配和共享内存，实现设备之间零拷贝共享内存。说来简单，其实不易。在Soc硬件中，许多设备可以进行DMA，这些设备可能有不同的能力，以及不同的内存访问机制。ION是Google在Android 4.0 ICS中引入，用于改善对于当前不同的android设备，有着各种不同内存管理接口管理相应内存的状况。当前存在着各种不同的但是功能却类似的内存管理接口，例
Android ION内存分配
River的专栏
12-04 455
ION设计的目标 为了避免内存碎片化，或者为一些有着特殊内存需求的硬件，比如GPUs、display controller以及camera等，在系统启动的时候，会为他们预留一些memory pools，这些memory pools就由ION来管理。通过ION就可以在硬件以及user space之间实现zero-copy的内存share。 给自己挖个坑, 参考些不错的文章, 后续研究....
android的内存管理模块ion的优缺点
05-25
ION（Interconnected Open Network）是Android系统中的一种内存管理模块，主要用于处理媒体和图形缓冲区。它的优缺点如下： 优点： 1. 高效的内存管理：ION通过管理内存池，可以高效地分配和释放内存，避免了频繁的内存分配和释放操作，提高了系统的性能。 2. 支持多种内存类型：ION支持多种内存类型，包括物理内存、DMA内存和虚拟内存等，可以根据不同的应用场景选择合适的内存类型。 3. 易于使用：ION提供了简单易用的API，开发者可以轻松地使用ION来管理内存，而不需要了解复杂的硬件架构和内存管理机制。 缺点： 1. 兼容性问题：ION对硬件的兼容性存在一定的问题，不同的硬件厂商实现的ION可能不同，需要进行适配。 2. 安全性问题：ION使用的是共享内存机制，可能存在数据泄露的风险，需要加强安全性措施。 3. 代码维护问题：ION的代码比较复杂，需要专业的开发人员进行维护和更新，对开发和维护人员的技术要求比较高。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值