内存映射
用户空间在使用Binder进行IPC前，需要对Binder驱动进行初始化，这个过程主要执行了Binder驱动的open和mmap操作。mmap映射Binder传输使用的内存空间，大小为(1M - 8K)，但仅仅是进行虚拟地址空间映射，实际的物理内存分配会在数据传输时进行。mmap的源码如下，
static int binder_mmap(struct file *filp, struct vm_area_struct *vma) { int ret; struct vm_struct *area; struct binder_proc *proc = filp->private_data; const char *failure_string; struct binder_buffer *buffer;if (proc->tsk != current) return -EINVAL; // 映射空间不能大于4M if ((vma->vm_end - vma->vm_start) > SZ_4M) vma->vm_end = vma->vm_start + SZ_4M; ...... // fork的子进程无法复制映射空间，并且不允许修改写属性 vma->vm_flags = (vma->vm_flags | VM_DONTCOPY) & ~VM_MAYWRITE; ...... // 获取内核虚拟地址空间 area = get_vm_area(vma->vm_end - vma->vm_start, VM_IOREMAP); ...... proc->buffer = area->addr; proc->user_buffer_offset = vma->vm_start - (uintptr_t)proc->buffer; mutex_unlock(&binder_mmap_lock); ...... // 创建物理页结构体 proc->pages = kzalloc(sizeof(proc->pages[0]) * ((vma->vm_end - vma->vm_start) / PAGE_SIZE), GFP_KERNEL); ...... proc->buffer_size = vma->vm_end - vma->vm_start; vma->vm_ops = &binder_vm_ops; vma->vm_private_data = proc; // 分配一个物理页，并映射到虚拟地址空间 if (binder_update_page_range(proc, 1, proc->buffer, proc->buffer + PAGE_SIZE, vma)) { ...... // 创建buffers链表，插入第一个free buffer buffer = proc->buffer; INIT_LIST_HEAD(&proc->buffers); list_add(&buffer->entry, &proc->buffers); buffer->free = 1; binder_insert_free_buffer(proc, buffer); // 异步传输可用空间大小设置为映射大小的一半 proc->free_async_space = proc->buffer_size / 2; barrier(); proc->files = get_files_struct(current); proc->vma = vma; proc->vma_vm_mm = vma->vm_mm; ...... }</code></pre>
几个相关细节说明一下，
- kernel空间限制了mmap的大小不能超过4M，而Android中用户空间限制为(1M - 8K)。所以理论上是可以修改用户空间的限制到最大为4M。
- mmap时分配了一个页进行映射，用来存放第一个binder_buffer，这时整个Binder内存只有一个free buffer。映射还有一个作用就是在初始化时验证内存管理的有效性，有问题时及时终止。
- 数据结构binder_buffer也是存放在mmap空间的，那么实际Binder可传输的数据大小不等于映射的空间大小。
- mmap完成后，proc->buffers队列上只有一个节点，指向proc->buffer，大小为整个map空间。proc->free_buffers树上也只有proc->buffer一个节点，proc->allocated_buffers树为空。
物理内存的分配和虚拟地址空间的映射是通过binder_update_page_range()进行的。物理内存的回收同样也使用这个函数，通过参数allocate来区分。
static int binder_update_page_range(struct binder_proc *proc, int allocate, void *start, void *end, struct vm_area_struct *vma) { void *page_addr; unsigned long user_page_addr; struct vm_struct tmp_area; struct page **page; struct mm_struct *mm; ...... // 只有mmap时vma不为NULL，其他情况都会根据proc来获取内存相关数据 if (vma) mm = NULL; else // 获取内存描述符，并增加用户计数，防止mm_struct被释放 mm = get_task_mm(proc->tsk);if (mm) { down_write(&mm->mmap_sem); vma = proc->vma; if (vma && mm != proc->vma_vm_mm) { pr_err("%d: vma mm and task mm mismatch\n", proc->pid); vma = NULL; } } // 回收内存时allocate为0 if (allocate == 0) goto free_range; ...... // 循环分配物理页，每次分配一页 for (page_addr = start; page_addr < end; page_addr += PAGE_SIZE) { int ret; struct page **page_array_ptr; page = &proc->pages[(page_addr - proc->buffer) / PAGE_SIZE]; BUG_ON(*page); // 分配一个物理页，保存地址到proc中 *page = alloc_page(GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO); ...... tmp_area.addr = page_addr; tmp_area.size = PAGE_SIZE + PAGE_SIZE /* guard page? */; page_array_ptr = page; // 建立页表与物理页的映射 ret = map_vm_area(&tmp_area, PAGE_KERNEL, &page_array_ptr); ...... user_page_addr = (uintptr_t)page_addr + proc->user_buffer_offset; // 插入物理页到用户虚拟地址空间 ret = vm_insert_page(vma, user_page_addr, page[0]); ...... } if (mm) { up_write(&mm->mmap_sem); // 减少内存描述符的用户计数 mmput(mm); } return 0; free_range: for (page_addr = end - PAGE_SIZE; page_addr >= start; page_addr -= PAGE_SIZE) { page = &proc->pages[(page_addr - proc->buffer) / PAGE_SIZE]; if (vma) // 解除用户虚拟地址空间与物理页的映射 zap_page_range(vma, (uintptr_t)page_addr + proc->user_buffer_offset, PAGE_SIZE, NULL); err_vm_insert_page_failed: // 解除物理页与内核页表的映射 unmap_kernel_range((unsigned long)page_addr, PAGE_SIZE); err_map_kernel_failed: // 释放物理页 __free_page(*page); *page = NULL; err_alloc_page_failed: ; } ........
}
内存分配
Binder内存分配函数为binder_alloc_buf()，直接看源码。
static struct binder_buffer *binder_alloc_buf(struct binder_proc *proc, size_t data_size, size_t offsets_size, int is_async) { struct rb_node *n = proc->free_buffers.rb_node; struct binder_buffer *buffer; size_t buffer_size; struct rb_node *best_fit = NULL; void *has_page_addr; void *end_page_addr; size_t size; ...... // size按指针字节数对齐 size = ALIGN(data_size, sizeof(void *)) + ALIGN(offsets_size, sizeof(void *)); ...... // 在free_buffers上寻找匹配size大小的节点。循环结束后，如果n==NULL // 表示没有匹配节点，则best_fit为最接近的大于size的节点 while (n) { buffer = rb_entry(n, struct binder_buffer, rb_node); BUG_ON(!buffer->free); buffer_size = binder_buffer_size(proc, buffer);if (size < buffer_size) { best_fit = n; n = n->rb_left; } else if (size > buffer_size) n = n->rb_right; else { best_fit = n; break; } } ...... // free_buffers没有找到匹配的节点，使用best_fit节点来分配 if (n == NULL) { buffer = rb_entry(best_fit, struct binder_buffer, rb_node); buffer_size = binder_buffer_size(proc, buffer); } // best_fit节点最后一页的起始地址 has_page_addr = (void *)(((uintptr_t)buffer->data + buffer_size) & PAGE_MASK); // best_fit节点的内存大小，在分配size后如果不足以创建新的buffer，则不拆分 if (n == NULL) { if (size + sizeof(struct binder_buffer) + 4 >= buffer_size) buffer_size = size; /* no room for other buffers */ else buffer_size = size + sizeof(struct binder_buffer); } // 需要分配空间的最后一页的结束地址 end_page_addr = (void *)PAGE_ALIGN((uintptr_t)buffer->data + buffer_size); // end_page>has_page表明要分配的空间的结束地址在best_fit节点的最后一页上 // 这是修正分配的结束地址到has_page，因为最后一页已经映射过 if (end_page_addr > has_page_addr) end_page_addr = has_page_addr; // 分配物理页 if (binder_update_page_range(proc, 1, (void *)PAGE_ALIGN((uintptr_t)buffer->data), end_page_addr, NULL)) return NULL; // 将best_fit从free_buffers上擦除，让后将新建的buffer插入allocated_buffers rb_erase(best_fit, &proc->free_buffers); buffer->free = 0; binder_insert_allocated_buffer(proc, buffer); // 多余空间进行拆分，插入free_buffers if (buffer_size != size) { struct binder_buffer *new_buffer = (void *)buffer->data + size; list_add(&new_buffer->entry, &buffer->entry); new_buffer->free = 1; binder_insert_free_buffer(proc, new_buffer); } ...... buffer->data_size = data_size; buffer->offsets_size = offsets_size; buffer->async_transaction = is_async; ...... return buffer;
}
分配过程的重点在起始地址的计算上。如果在free_buffers树上可以找到匹配的buffer则使用。如果找不到匹配的buffer，就使用大于需求大小且最接近的buffer。因为proc->buffers队列上不会有连续的两个free buffer（在释放buffer时会合并），所以计算起始地址时就要考虑已分配的情况。当需求分配的起始地址在一个allocated buffer上，就不需要再申请这个页。
- 物理内存是按页分配的。
- proc->buffers上不会有连续的两个free buffer。
- 分配的起始地址按页向下对齐，PAGE_ALIGN((uintptr_t)buffer->data)。
- 分配的结束地址如果和下一个buffer的起始地址在同一页，则按页向上对齐，(((uintptr_t)buffer->data + buffer_size) & PAGE_MASK)。
- 分配的结束地址如果在一个空闲页上，则按页向下对齐，PAGE_ALIGN((uintptr_t)buffer->data + buffer_size)。
通过一张图来描述Binder内存的变化。
内存回收
同样看一下binder_free_buf()的源码。
static void binder_free_buf(struct binder_proc *proc,
struct binder_buffer *buffer)
{
size_t size, buffer_size;
// 获取要释放的buffer的大小
buffer_size = binder_buffer_size(proc, buffer);
// size按指针字节数对齐
size = ALIGN(buffer->data_size, sizeof(void *)) +
ALIGN(buffer->offsets_size, sizeof(void *));
......
// 释放物理页
binder_update_page_range(proc, 0,
(void *)PAGE_ALIGN((uintptr_t)buffer->data),
(void *)(((uintptr_t)buffer->data + buffer_size) & PAGE_MASK),
NULL);
// 将释放的buffer从allocated_buffers树上擦除
rb_erase(&buffer->rb_node, &proc->allocated_buffers);
buffer->free = 1;
// 如果proc->buffers中下一个buffer为free，则合并到正在释放的buffer上
if (!list_is_last(&buffer->entry, &proc->buffers)) {
struct binder_buffer *next = list_entry(buffer->entry.next,
struct binder_buffer, entry);
if (next->free) {
rb_erase(&next->rb_node, &proc->free_buffers);
binder_delete_free_buffer(proc, next);
}
}
// 如果proc->buffers中上一个buffer为free，则合并释放的buffer到上一个buffer中
if (proc->buffers.next != &buffer->entry) {
struct binder_buffer *prev = list_entry(buffer->entry.prev,
struct binder_buffer, entry);
if (prev->free) {
binder_delete_free_buffer(proc, buffer);
rb_erase(&prev->rb_node, &proc->free_buffers);
buffer = prev;
}
}
// 将处理好的buffer插入到free_buffers树中
binder_insert_free_buffer(proc, buffer);
}在内存回收的过程中，需要注意的还是边界地址的计算。与分配时相似，需要考虑释放的buffer与其他buffer在同一页上的情况。
- 释放的开始地址按页向下对齐，PAGE_ALIGN((uintptr_t)buffer->data。
- 释放的结束地址按页向上对齐，(((uintptr_t)buffer->data + buffer_size) & PAGE_MASK)。
内存回收时还要进行相连free buffer的合并，找到合并的buffer后，使用binder_delete_free_buffer()将下一buffer删除掉。
static void binder_delete_free_buffer(struct binder_proc *proc, struct binder_buffer *buffer) { struct binder_buffer *prev, *next = NULL; int free_page_end = 1; int free_page_start = 1;// 获取被删除buffer的前一个buffer prev = list_entry(buffer->entry.prev, struct binder_buffer, entry); // 如果被删除buffer与前一个buffer会共用到同一物理页，则不删除起始页，将free_page_start设置为0 if (buffer_end_page(prev) == buffer_start_page(buffer)) { free_page_start = 0; // 如果被删除buffer结束页也在这一页，则不会删除物理页，free_page_end也设为0 if (buffer_end_page(prev) == buffer_end_page(buffer)) free_page_end = 0; ...... } if (!list_is_last(&buffer->entry, &proc->buffers)) { // 获取被删除buffer的下一个buffer next = list_entry(buffer->entry.next, struct binder_buffer, entry); // 如果被删除buffer与下一个buffer会共用到同一物理页，则不删除结束页 if (buffer_start_page(next) == buffer_end_page(buffer)) { free_page_end = 0; // 如果被删除buffer起始页也在这一页，则不会删除物理页 if (buffer_start_page(next) == buffer_start_page(buffer)) free_page_start = 0; ...... } // 将buffer从proc->buffers列表中删除 list_del(&buffer->entry); if (free_page_start || free_page_end) { ...... // 释放物理页，参考了free_page_start和free_page_end binder_update_page_range(proc, 0, free_page_start ? buffer_start_page(buffer) : buffer_end_page(buffer), (free_page_end ? buffer_end_page(buffer) : buffer_start_page(buffer)) + PAGE_SIZE, NULL); }
}
最后用图来展示内存回收时buffer的变化。
转载自：https://segmentfault.com/a/1190000020846555
505
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
