xiaoqiang 2019-06-27
static int __init binder_init(void)
binder设备初始化过程可以简化为如下步骤:
1.初始化binder缓冲区分配
ret = binder_alloc_shrinker_init();
2.创建binder相关目录
debugfs_create_dir
第一个参数为创建的目录,第二个参数为父目录,因此在前面binder就创建了/binder/proc
的目录
binder_debugfs_dir_entry_root = debugfs_create_dir("binder", NULL); if (binder_debugfs_dir_entry_root) binder_debugfs_dir_entry_proc = debugfs_create_dir("proc", binder_debugfs_dir_entry_root);
binder在/proc/binder目录下创建了5个文件,包括state,stats,transactions,transaction_log,failed_transaction_log
if (binder_debugfs_dir_entry_root) { debugfs_create_file("state", 0444, binder_debugfs_dir_entry_root, NULL, &binder_state_fops); debugfs_create_file("stats", 0444, binder_debugfs_dir_entry_root, NULL, &binder_stats_fops); debugfs_create_file("transactions", 0444, binder_debugfs_dir_entry_root, NULL, &binder_transactions_fops); debugfs_create_file("transaction_log", 0444, binder_debugfs_dir_entry_root, &binder_transaction_log, &binder_transaction_log_fops); debugfs_create_file("failed_transaction_log", 0444, binder_debugfs_dir_entry_root, &binder_transaction_log_failed, &binder_transaction_log_fops); }
3.创建binder设备
device_tmp = device_names; while ((device_name = strsep(&device_tmp, ","))) { ret = init_binder_device(device_name); if (ret) goto err_init_binder_device_failed; }
在init_binder_device()
中,实现了创建binder设备的操作.
static int __init init_binder_device(const char *name) { int ret; struct binder_device *binder_device; binder_device = kzalloc(sizeof(*binder_device), GFP_KERNEL); if (!binder_device) return -ENOMEM; binder_device->miscdev.fops = &binder_fops; binder_device->miscdev.minor = MISC_DYNAMIC_MINOR; binder_device->miscdev.name = name; binder_device->context.binder_context_mgr_uid = INVALID_UID; binder_device->context.name = name; mutex_init(&binder_device->context.context_mgr_node_lock); ret = misc_register(&binder_device->miscdev); if (ret < 0) { kfree(binder_device); return ret; } hlist_add_head(&binder_device->hlist, &binder_devices); return ret; }
该方法通过misc_register
创建设备,设备的参数通过binder_device
进行设置。最终该设备还加入到全局哈希表中binder_devices
static int binder_open(struct inode *nodp, struct file *filp)
binder_open
的流程如下:
1.创建binder进程
struct binder_proc *proc; proc = kzalloc(sizeof(*proc), GFP_KERNEL);
2.初始化binder_proc
spin_lock_init(&proc->inner_lock); spin_lock_init(&proc->outer_lock); get_task_struct(current->group_leader); proc->tsk = current->group_leader; mutex_init(&proc->files_lock); INIT_LIST_HEAD(&proc->todo);//初始化binder进程todo列表 proc->default_priority = task_nice(current); binder_dev = container_of(filp->private_data, struct binder_device, miscdev); proc->context = &binder_dev->context; binder_alloc_init(&proc->alloc);//初始化binder进程的内核缓冲区 binder_stats_created(BINDER_STAT_PROC); proc->pid = current->group_leader->pid; INIT_LIST_HEAD(&proc->delivered_death); INIT_LIST_HEAD(&proc->waiting_threads); filp->private_data = proc;//filp的private_data中保存binder进程结构体
这里注意而的是filp的private_data
保存了binder进程结构体,当进程打开/dev/binder后,内核返回一个文件描述符,该文件描述符与filp所指向的文件结构是一致的,当进程在之后的操作用该文件描述符作为参数调用方法mmap,ioctl等方法与binder驱动程序交互时,内核就会通过该文件描述符相关联的打开文件结构提传递给binder驱动,并通过其private_data
字段去获取binder_open
为进程创建的binder_proc
结构体。
3.将binder进程加入binder_procs
全局哈希表中
由于是全局的哈希表,因此需要使用互斥量。
mutex_lock(&binder_procs_lock); hlist_add_head(&proc->proc_node, &binder_procs); mutex_unlock(&binder_procs_lock);
4.创建以进程ID为名的文件
if (binder_debugfs_dir_entry_proc) { char strbuf[11]; snprintf(strbuf, sizeof(strbuf), "%u", proc->pid); proc->debugfs_entry = debugfs_create_file(strbuf, 0444, binder_debugfs_dir_entry_proc, (void *)(unsigned long)proc->pid, &binder_proc_fops); }
binder在打开了设备文件/dev/binder后,还需要通过mmap将该设备文件映射到进程地址空间,才可以进行进程间通信。
static int binder_mmap(struct file *filp, struct vm_area_struct *vma)
1.获取binder进程
通过参数的文件描述符的private_data
字段获取binder进程
struct binder_proc *proc = filp->private_data;
2.限定用户空间范围
if ((vma->vm_end - vma->vm_start) > SZ_4M) vma->vm_end = vma->vm_start + SZ_4M;
方法传参中,vma表示的是用空间虚拟地址,类型为vm_area_struct
,由此可见用户空间地址范围在4M以内。
3.检查用户空间是否可写
if (vma->vm_flags & FORBIDDEN_MMAP_FLAGS) { ret = -EPERM; failure_string = "bad vm_flags"; goto err_bad_arg; }
其中FORBIDDEN_MMAP_FLAGS
的值为:
#define FORBIDDEN_MMAP_FLAGS (VM_WRITE)
4.设置缓冲区参数
vma->vm_flags = (vma->vm_flags | VM_DONTCOPY) & ~VM_MAYWRITE; vma->vm_ops = &binder_vm_ops; vma->vm_private_data = proc;
Binder驱动为进程分配的内核缓冲区在用户空间设置为只可以读,不可以写。并且不可以进行复制。也将VM_MAYWRITE
位设置为非。
5.为进程分配内核缓冲区
ret = binder_alloc_mmap_handler(&proc->alloc, vma);
binder_alloc_mmap_handler
binder_alloc_mmap_handler
是实际为进程映射虚拟空间的函数,其定义如下:
int binder_alloc_mmap_handler(struct binder_alloc *alloc, struct vm_area_struct *vma)
alloc为内存分配结构体,vma为用户虚拟空间。其逻辑如下:
1.在内核地址空间分配空间
mutex_lock(&binder_alloc_mmap_lock); struct vm_struct *area; area = get_vm_area(vma->vm_end - vma->vm_start, VM_ALLOC); if (area == NULL) { ret = -ENOMEM; failure_string = "get_vm_area"; goto err_get_vm_area_failed; } alloc->buffer = area->addr; alloc->user_buffer_offset = vma->vm_start - (uintptr_t)alloc->buffer; mutex_unlock(&binder_alloc_mmap_lock);
vm_struct
描述的是内核虚拟地址,vm_area_structure
描述的是用户虚拟地址。get_vm_area
就会在进程的内核地址空间分配一段大小为vma->vm_end - vma->vm_start
的空间。申请成功后,将地址area->addr赋值给allloc->buffer。其中还会计算地址的差值:
alloc->user_buffer_offset = vma->vm_start - (uintptr_t)alloc->buffer;
vma->vm_start
为用户空间起始地址,alloc->buffer就是内核空间地址,由于进程的空间时连续的(物理页面不连续),所以它们的差值是固定差值,只要知道其中一个,即可算出另外的地址。
2.分配物理页面
alloc->pages = kzalloc(sizeof(alloc->pages[0]) * ((vma->vm_end - vma->vm_start) / PAGE_SIZE), GFP_KERNEL);
PAGE_SIZE
为物理页面大小4K,物理页面的指针大小为((vma->vm_end - vma->vm_start) / PAGE_SIZE)
,sizeof(alloc->pages[0])为单个页面的物理页面大小。
struct binder_buffer *buffer; .... alloc->buffer_size = vma->vm_end - vma->vm_start; buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); if (!buffer) { ret = -ENOMEM; failure_string = "alloc buffer struct"; goto err_alloc_buf_struct_failed; } buffer->data = alloc->buffer; list_add(&buffer->entry, &alloc->buffers); buffer->free = 1; binder_insert_free_buffer(alloc, buffer); alloc->free_async_space = alloc->buffer_size / 2; barrier(); alloc->vma = vma; alloc->vma_vm_mm = vma->vm_mm; mmgrab(alloc->vma_vm_mm);
这部分使用binder_buffer
来描述,并将其加入到alloc->buffers列表中。紧接着将buffer加入到空闲内核缓冲区红黑树中。并将异步事务的内核缓冲区大小设置为总缓冲区大小的一半。
binder_insert_free_buffer()
从binder_proc
的结构可得,每个binder进程会管理一个空闲内核缓冲区红黑树,当binder_mmap
映射内存到进程空间时,将会把一个新创建的空闲buffer加入到红黑树中。
static void binder_insert_free_buffer(struct binder_alloc *alloc, struct binder_buffer *new_buffer) { struct rb_node **p = &alloc->free_buffers.rb_node; struct rb_node *parent = NULL; struct binder_buffer *buffer; size_t buffer_size; size_t new_buffer_size; BUG_ON(!new_buffer->free); new_buffer_size = binder_alloc_buffer_size(alloc, new_buffer); binder_alloc_debug(BINDER_DEBUG_BUFFER_ALLOC, "%d: add free buffer, size %zd, at %pK\n", alloc->pid, new_buffer_size, new_buffer); while (*p) { parent = *p; buffer = rb_entry(parent, struct binder_buffer, rb_node); BUG_ON(!buffer->free); buffer_size = binder_alloc_buffer_size(alloc, buffer); if (new_buffer_size < buffer_size) p = &parent->rb_left; else p = &parent->rb_right; } rb_link_node(&new_buffer->rb_node, parent, p); rb_insert_color(&new_buffer->rb_node, &alloc->free_buffers); }
红黑树的流程简单而言就是,先获取新创建的buffer的大小,并在红黑树中找到合适的位置,并将其放入。规则是与二叉树相同。
其中涉及的计算buffer大小的方法binder_alloc_buffer_size
,其流程如下:
static size_t binder_alloc_buffer_size(struct binder_alloc *alloc, struct binder_buffer *buffer) { if (list_is_last(&buffer->entry, &alloc->buffers)) return (u8 *)alloc->buffer + alloc->buffer_size - (u8 *)buffer->data; return (u8 *)binder_buffer_next(buffer)->data - (u8 *)buffer->data; }
进程中的alloc对象会有一个buffers链表来记录所有的buffer,假如buffer是在链表的尾部,那么就直接使用alloc->buffer
(进程申请的内核空间的起始地址) + alloc->buffer_size
(进程申请的内核空间的大小) - buffer->data
(buffer的data起始位置),即buffer->data的大小。
|--|--sizeof(struct binder_buffer)---|---sizeof(buffer->data)-----| alloc->buffer buffer->data (alloc->buffer + alloc->buffer_size)
假如为非最后的buffer,即下一个buffer的起始位置,减去buffer->data的地址。
由于在开始调用binder_mmap()
的时候,binder驱动只为进分配了一个buffer,即只分配了一个物理内存,所以这里的alloc->buffer与buffer->data地址相同,但后面可能根据需要,分配更多的物理内存。
另外在红黑树插入空闲buffer的时候,获取每个节点的操作也值得玩味:
struct binder_buffer *buffer; buffer = rb_entry(parent, struct binder_buffer, rb_node);
rb_entry
的定义如下:
#define rb_entry(ptr, type, member) container_of(ptr, type, member)
其中ptr指向的红黑树的特定节点,type是binder_buffer
,rb_node
是binder_buffer
类型的成员。
至于container_of
的定义如下:
#undef offsetof #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) /** * container_of - cast a member of a structure out to the containing structure * @ptr: the pointer to the member. * @type: the type of the container struct this is embedded in. * @member: the name of the member within the struct. * */ #define container_of(ptr, type, member) ({ \ const typeof( ((type *)0)->member ) *__mptr = (ptr); \ (type *)( (char *)__mptr - offsetof(type,member) );})
offsetof:将地址0强制转换为type类型的指针,从而定位到member在结构体中偏移位置。编译器认为0是一个有效的地址,从而认为0是type指针的起始地址。
container_of
:
第一部分:const typeof( ((type *)0)->member ) *__mptr = (ptr);
通过typeof定义一个member指针类型的指针变量__mptr
,(即__mptr
是指向member类型的指针),并将__mptr
赋值为ptr。
第二部分: (type *)( (char *)__mptr - offsetof(type,member)
),通过offsetof宏计算出member在type中的偏移,然后用member的实际地址__mptr
减去偏移,得到type的起始地址,即指向type类型的指针。
由此可得buffer = rb_entry(parent, struct binder_buffer, rb_node);
,是通过获得一个成员变量类型为rb_node
的红黑树节点,去获得包含这个成员变量的结构体的起始地址,即binder_buffer
,从而完成从局部到整体的转换。
binder_update_page_range
上述步骤创建了内核空间以及物理页面,但是还没有将用户虚拟地址与内核的虚拟地址映射在物理页面中。而在进行该行为就binder_update_page_range
中实现。
该方法在4.16的调用栈如下:
binder_transaction
binder_alloc_new_buf
binder_alloc_new_buf_locked
binder_update_page_range
以往binder_update_page_range
在binder_mmap
就已经调用了,如今在调用binder_transaction
时才开始映射。
static int binder_update_page_range(struct binder_alloc *alloc, int allocate, void *start, void *end)
该方法通过allocate参数判断是分配物理页面还是释放物理页面,故流程分为两部分:
1.检查每个物理页面的地址是否为空,如果为空执行操作。
void *page_addr; bool need_mm = false; ... for (page_addr = start; page_addr < end; page_addr += PAGE_SIZE) { page = &alloc->pages[(page_addr - alloc->buffer) / PAGE_SIZE]; if (!page->page_ptr) { need_mm = true; break; } }
假如存在物理页面的地址为空,则重新尝试在用户空间映射页面,如果失败,则报错。
if (need_mm && mmget_not_zero(alloc->vma_vm_mm)) mm = alloc->vma_vm_mm; if (mm) { down_write(&mm->mmap_sem); vma = alloc->vma; } if (!vma && need_mm) { pr_err("%d: binder_alloc_buf failed to map pages in userspace, no vma\n", alloc->pid); goto err_no_vma; }
2.映射虚拟地址
映射内核地址空间的基本逻辑如下:
for (page_addr = start; page_addr < end; page_addr += PAGE_SIZE) { size_t index; index = (page_addr - alloc->buffer) / PAGE_SIZE; page = &alloc->pages[index];//获取每一个物理页面 ret = map_kernel_range_noflush((unsigned long)page_addr,//映射内核地址空间 PAGE_SIZE, PAGE_KERNEL, &page->page_ptr); flush_cache_vmap((unsigned long)page_addr, (unsigned long)page_addr + PAGE_SIZE); user_page_addr = (uintptr_t)page_addr + alloc->user_buffer_offset; ret = vm_insert_page(vma, user_page_addr, page[0].page_ptr);//映射用户空间地址
释放物理页面的逻辑如下:
if (allocate == 0) goto free_range; free_range: for (page_addr = end - PAGE_SIZE; page_addr >= start; page_addr -= PAGE_SIZE) { bool ret; size_t index; index = (page_addr - alloc->buffer) / PAGE_SIZE; page = &alloc->pages[index]; unmap_kernel_range((unsigned long)page_addr, PAGE_SIZE); __free_page(page->page_ptr); page->page_ptr = NULL; }