Binder驱动之内存映射全解

Binder通过open调用打开后，需要用户态进程需调用mmap进行内存映射。mmap系统调用，经过VFS最终会调用到binder驱动注册的binder_mmap函数。这里我们将揭开Binder通信高效的本质原因，：）

一 内存映射函数的实现 binder_mmap(kernel/drivers/android/binder.c)

static int binder_mmap(struct file *filp, struct vm_area_struct *vma/*用户态虚拟地址空间描述，地址空间在0～3G*/)
{
    int ret;
    /* 一块连续的由vmalloc分配内核虚拟地址空间描述，从 VMALLOC_START到VMALLOC_END*/
    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，如果大于4M就改为4M大小。app默认是1M左右
    if ((vma->vm_end - vma->vm_start) > SZ_4M)
          vma->vm_end = vma->vm_start + SZ_4M;

    //检查vma是否被forbidden，vma是一块连续的用户态虚拟内存地址空间的描述
    if (vma->vm_flags & FORBIDDEN_MMAP_FLAGS) {
          ret = -EPERM;
          failure_string = "bad vm_flags";
        goto err_bad_arg;
    }

    //打开VM_DONTCOPY,关闭VM_MAYWRITE
     vma->vm_flags = (vma->vm_flags | VM_DONTCOPY) & ~VM_MAYWRITE;

    //加上binder_mmap_lock互斥锁，因为接下来要操作proc结构体，可能发生多线程竞争
     mutex_lock(&binder_mmap_lock);

    //一个进程已经有一次mmap，如要执行新的map，需先将之前的unmap。
    if (proc->buffer) {
          ret = -EBUSY;
          failure_string = "already mapped";
          goto err_already_mapped;
    }

    /* 获取一块与用户态空间大小一致的内核的连续虚拟地址空间，
     * 注意虚拟地址空间是在此一次性分配的，物理页面却是需要时才去申请和映射
    */
    area = get_vm_area(vma->vm_end - vma->vm_start, VM_IOREMAP);
    if (area == NULL) {
          ret = -ENOMEM;
          failure_string = "get_vm_area";
        goto err_get_vm_area_failed;
    }

    //将内核虚拟地址记录在proc的buffer中 
     proc->buffer = area->addr;

    /* 记录用户态虚拟地址空间与内核态虚拟地址空间的偏移量，
     * 这样通过buffer和user_buffer_offset就可以计算出用户态的虚拟地址。
    */
     proc->user_buffer_offset = vma->vm_start - (uintptr_t)proc->buffer;

    /*释放互斥锁*/
     mutex_unlock(&binder_mmap_lock);
#ifdef CONFIG_CPU_CACHE_VIPT
    /* CPU的缓存方式是否为： VIPT（Virtual Index Physical Tag）：使用虚拟地址的索引域和物理地址的标记域。
     * 这里先不管，有兴趣的可参考：https://blog.csdn.net/Q_AN1314/article/details/78980191
    */
    if (cache_is_vipt_aliasing()) {
        while (CACHE_COLOUR((vma->vm_start ^ (uint32_t)proc->buffer))) {
               pr_info("binder_mmap: %d %lx-%lx maps %p bad alignment\n", proc->pid, vma->vm_start, vma->vm_end, proc->buffer);
               vma->vm_start += PAGE_SIZE;
        }
    }
#endif

    /*分配存放物理页地址的数组*/
    proc->pages = kzalloc(sizeof(proc->pages[0]) * ((vma->vm_end - vma->vm_start) / PAGE_SIZE), GFP_KERNEL);
    if (proc->pages == NULL) {
          ret = -ENOMEM;
          failure_string = "alloc page array";
        goto err_alloc_pages_failed;
    }

    /*将虚拟地址空间的大小记录在proc的buffer_size中*/
     proc->buffer_size = vma->vm_end - vma->vm_start;

    /* 安装vma线性空间操作函数：open，close，fault
    * open-> binder_vma_open: 简单的输出日志，pid，虚拟地址的起止、大小、标志位（vm_flags和vm_page_prot)
    * close -> binder_vma_close: 将proc的vma，vma_vm_mm设为NULL，并将proc加入到binder_deferred_workqueue队列，
    *                            binder驱动有一个单独的线程处理这个队列。
    * fault -> binder_vam_fault: 直接返回VM_FAULT_SIGBUS, 
    */
     vma->vm_ops = &binder_vm_ops;

    /*在vma的vm_private_data字段里存入proc的引指针*/
     vma->vm_private_data = proc;

    /* 先分配1个物理页，并将其分别映射到内核线性地址和用户态虚拟地址上，具体详见2
    */
    if (binder_update_page_range(proc, 1, proc->buffer, proc->buffer **+ PAGE_SIZE**, vma)) {
          ret = -ENOMEM;
          failure_string = "alloc small buf";
        goto err_alloc_small_buf_failed;
    }

    /*成功分配了物理页并建立好的映射关系后，内核起始虚地址做为第一个binder_buffer的地址*/
     buffer = proc->buffer;
    /*接着将内核虚拟内存链入proc的buffers和free_buffers链表中，free标志位设为1
     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;/*vma->vm_mm: vma对应的mm_struct,描述一个进程的虚拟地址空间，一个进程只有一个*/

    /*pr_info("binder_mmap: %d %lx-%lx maps %p\n",
           proc->pid, vma->vm_start, vma->vm_end, proc->buffer);*/

    return 0;

    /*出错处理*/
err_alloc_small_buf_failed:

     kfree(proc->pages);
     proc->pages = NULL;
err_alloc_pages_failed:
     mutex_lock(&binder_mmap_lock);
     vfree(proc->buffer);
     proc->buffer = NULL;
err_get_vm_area_failed:
err_already_mapped:
     mutex_unlock(&binder_mmap_lock);

err_bad_arg:
     pr_err("binder_mmap: %d %lx-%lx %s failed %d\n",
            proc->pid, vma->vm_start, vma->vm_end, failure_string, ret);
    return ret;
}

基本过程在上面的代码基本已经都注释了。几个需要注意的地方这里再说明一下：

• 调用get_vm_area获取内核态虚拟地址，地址是在32体系架构地址空间在： 3G+896M + 8M ～ 4G之间。proc中没有直接记录用户态的虚地址，而是存放一个用户态地址与内核态地址偏移量：proc->user_buffer_offset。

• vma操作函数 —— vma->vm_ops, Binder实现了open, close和fault三个接口。

  • open(binder_vma_open)的实现只是简单的输出一条进程id及vma地址及标志位相关信息的debug日志。
  • close(binder_vma_close)除了输出一条类似open的日志信息外，还会将proc->vma和proc->vma_vm_mm置空，接着调用binder_deferred_work在binder_deferred_workqueue队列中放入一个BINDER_DEFERRED_PUT_FILES状态的work，在之后binder线程执行到该work时会将proc->files置空, 接着调用put_files_struct来释放进程所属的文件资源。
  • fault(binder_vm_fault):简单的返回VM_FAULT_SIGBUS, 这个钩子是在访问的虚地址没有映射的物理页时（缺页）时，该函数被缺页处理程序调用，该函数负责返回物理页描述符，但因在binder中物理页框与虚拟地址的映射，在调用binder_alloc_buf分配binder_buffer时就已经建立好了，所以一般来说是不会发生缺页中断的。

• 需要调用binder_update_page_range分配一个页框（一页物理内存）的原因是：用于存放第一个binder_buffer，此时整个地址空间都在这个binder_buffer中管理， 但是随着地址空间被不断的分配和回收，会分裂成一系列的binder_buffer节点。

在binder_mmap中，仅仅是进行虚拟地址空间的分配，物理内存的分配和释放，Binder是通过binder_update_page_range来进行的。接下来我们就来看看binder_update_page_range的实现。

二 物理内存分配/与释放 – binder_update_page_range

• binder_update_page_range同时负责分配和释放物理页框，具体是分配还是释放通过参数allocate控制，如果该参数为0，则表示要解除内核态和用户态对物理页框的地址映射，释放物理页框；否则就是申请物理页框，并建立内核态和用户态的地址映射。

• 参数vma的类型是struct vm_area_struct是用户态虚拟地址空间描述。该参数为NULL表示binder_update_page_range在内核调用路径中，此时需尝试获取mm_struct并增加其引用计数，以防止进程的内存描述被释放，然后再在操作完成后减少它的引用计数(mmput)。

以下即是具体的代码实现，整个流程相对直观，关键代码都已经注释，理解起来应该不难。

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 page **page;
    struct mm_struct *mm;

    binder_debug(BINDER_DEBUG_BUFFER_ALLOC,
             "%d: %s pages %p-%p\n", proc->pid,
             allocate ? "allocate" : "free", start, end);

    if (end <= start)
        return 0;

    trace_binder_update_page_range(proc, allocate, start, end);
    if (vma)
        mm = NULL; /*binder_mmap的调用走这里*/
    else
        /* 读取进程的内存描述符（mm_struct）, 
         * 并增加内存描述符(mm_struct)中的mm_users用户计数，防止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;
        }
    }

    /*本次调用是释放物理页，直接进入释放物理页框流程*/

    if (allocate == 0) 
        goto free_range;

    if (vma == NULL) {
        pr_err("%d: binder_alloc_buf failed to map pages in userspace, no vma\n",
            proc->pid);
        goto err_no_vma;
    }

    /* 开始循环分配物理页，并建立映射，每次循环分配1个页框*/
    for (page_addr = start; page_addr < end; page_addr += PAGE_SIZE) {
        int ret;
        /* 确定页框所存放的数组的位置，按内核虚拟地址由小到大排列*/
        page = &proc->pages[(page_addr - proc->buffer) / PAGE_SIZE];
        BUG_ON(*page);
         /*分配页框*/
        *page = alloc_page(GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO);
        if (*page == NULL) {
            pr_err("%d: binder_alloc_buf failed for page at %p\n",
                proc->pid, page_addr);
            goto err_alloc_page_failed;
        }

        /*将内核虚拟地址与该页框建立映射关系*/
        ret = map_kernel_range_noflush((unsigned long)page_addr,
                    PAGE_SIZE, PAGE_KERNEL, page);

        /* 将刚刚修改的内核页表项刷新到CPU高速缓存*/
        flush_cache_vmap((unsigned long)page_addr,
                (unsigned long)page_addr + PAGE_SIZE);

        if (ret != 1) {
            pr_err("%d: binder_alloc_buf failed to map page at %p in kernel\n",
                   proc->pid, page_addr);
            goto err_map_kernel_failed;
        }

        /*计算用户态虚地址*/
        user_page_addr =
            (uintptr_t)page_addr + proc->user_buffer_offset;

        /*将用户虚拟地址与该页框建立映射关系*/
        ret = vm_insert_page(vma, user_page_addr, page[0]);
        if (ret) {
            pr_err("%d: binder_alloc_buf failed to map page at %lx in userspace\n",
                   proc->pid, user_page_addr);
            goto err_vm_insert_page_failed;
        }
        /* vm_insert_page does not seem to increment the refcount */
    }

    if (mm) {
        /*释放写锁*/
        up_write(&mm->mmap_sem);
        mmput(mm);/*减少内存描述符(mm_struct)中的mm_users用户计数*/
    }

    /*分配物理页框流程到这里结束，接下去是释放物理页流程*/
    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:
        ;
    }

err_no_vma:
    if (mm) {
        /*释放写锁*/
        up_write(&mm->mmap_sem);
        mmput(mm);/*减少内存描述符中的mm_users用户计数*/
    }
    return -ENOMEM;
}

三 总结

• 整个地址映射流程大致可以归纳为以下几个步骤：
  • 参数检查。这里要注意的Binder驱动中，通信的内存映射大小上限是4MB，超过4MB，会截断到4MB。在用户态的ProccessStat.cpp实现中，调用mmap进行地址映射的大小是BINDER_VM_SIZE，它的值为1M - 2 * PAGE_SIZE，PAGE_SIZE一般为4KB，所以BINDER_VM_SIZE是1016KB，且同一时间只能进行一次mmap。即普通APP一次Binder通信最大的数据量是1016KB，要突破这个限制，就需要先unmap在ProcessStat映射的内存，再自行调用mmap进行内存映射，但是这样最大也只能进行扩大到4MB。
  • 在分配内核分配一块相同大小的虚拟地址空间。
  • 分配物理内存，并将它同时映射到内核地址空间和用户态地址空间，即用户态地址空间和用户态地址空间都是指向同一块物理内存空间。这是Binder通信只需要进行一次数据拷贝的精髓所在，当一个进程将其要进行Binder传输的数据从用户态传输态拷贝到内核态地址空间时，此时数据所在物理内存也是通信对方用户态虚拟地址所映射的区域，无需再从内核态再到用户态的数据拷贝。
  • 更新相关内存管理结构，如链表等。
• 异步只能使用整个映射地址空间的一半，这里应该是为了防止异步调用占用完所有的地址空间，导致同步调用无地址空间可用，毕竟同步调用是阻塞是调用，它的优先级应该高于异步调用。