内存映射
用户空间在使用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;
......
}几个相关细节说明一下，
- 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的变化。