投稿
  1. 云图网首页
  2. 技术专区
  3. 移动开发

binder 驱动的操作详解手机开发

• 移动开发 • 阅读 43

文章目录

以下源码均来自
https://github.com/aosp-mirror/kernel_common.git

Binder驱动四个基本操作

在进程启动的时候跟binder驱动交互有四个操作：

init -> open -> mmap -> ioctl

  • init: 初始化驱动

  • open: 打开驱动

  • mmap: 在内核分配binder_buffer

  • ioctl: 进程跟驱动的操作交互

初始化字符设备

static int __init binder_init(void) 
{
    
    int ret; 
    char *device_name, *device_tmp; 
    struct binder_device *device; 
    struct hlist_node *tmp; 
    char *device_names = NULL; 
    // 初始化 binder缓冲区 
    ret = binder_alloc_shrinker_init(); 
    // 创建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); 
     
    if (binder_debugfs_dir_entry_root) {
    
       // 创建binder/proc/state文件  
       debugfs_create_file("state", 
                    0444, 
                    binder_debugfs_dir_entry_root, 
                    NULL, 
                    &binder_state_fops); 
       // 创建binder/proc/stats文件  
        debugfs_create_file("stats", 
                    0444, 
                    binder_debugfs_dir_entry_root, 
                    NULL, 
                    &binder_stats_fops); 
       // 创建binder/proc/transactions文件  
        debugfs_create_file("transactions", 
                    0444, 
                    binder_debugfs_dir_entry_root, 
                    NULL, 
                    &binder_transactions_fops); 
       // 创建binder/proc/transaction_log文件  
        debugfs_create_file("transaction_log", 
                    0444, 
                    binder_debugfs_dir_entry_root, 
                    &binder_transaction_log, 
                    &binder_transaction_log_fops); 
       // 创建binder/proc/failed_transaction_log文件  
        debugfs_create_file("failed_transaction_log", 
                    0444, 
                    binder_debugfs_dir_entry_root, 
                    &binder_transaction_log_failed, 
                    &binder_transaction_log_fops); 
    } 
 
    if (!IS_ENABLED(CONFIG_ANDROID_BINDERFS) && 
        strcmp(binder_devices_param, "") != 0) {
    
        device_names = kstrdup(binder_devices_param, GFP_KERNEL); 
        // 创建binder设备 
        device_tmp = device_names; 
        while ((device_name = strsep(&device_tmp, ","))) {
    
            ret = init_binder_device(device_name); 
        } 
    } 
    ret = init_binderfs(); 
    return ret; 
}

打开binder驱动设备

static int binder_open(struct inode *nodp, struct file *filp) 
{
    
    struct binder_proc *proc; 
    struct binder_device *binder_dev; 
    struct binderfs_info *info; 
    struct dentry *binder_binderfs_dir_entry_proc = NULL; 
 
    //  分配binder_proc结构体 
    proc = kzalloc(sizeof(*proc), GFP_KERNEL); 
    if (proc == NULL) 
        return -ENOMEM; 
    spin_lock_init(&proc->inner_lock); 
    spin_lock_init(&proc->outer_lock); 
    get_task_struct(current->group_leader); 
    proc->tsk = current->group_leader; 
    // 初始化proc->todo队列 
    INIT_LIST_HEAD(&proc->todo); 
    // 设置进程优先级 
    proc->default_priority = task_nice(current); 
    … 
    // 初始化context，它记录了ServiceManager信息，是全局静态变量 
    proc->context = &binder_dev->context; 
    binder_alloc_init(&proc->alloc); 
    binder_stats_created(BINDER_STAT_PROC); 
    proc->pid = current->group_leader->pid; 
    INIT_LIST_HEAD(&proc->delivered_death); 
    INIT_LIST_HEAD(&proc->waiting_threads); 
    // 将proc保存到文件结构中,供下次调用使用 
    filp->private_data = proc; 
 
    mutex_lock(&binder_procs_lock); 
    // 将proc添加到全局的binder_procs 
    hlist_add_head(&proc->proc_node, &binder_procs); 
    mutex_unlock(&binder_procs_lock); 
 
    if (binder_debugfs_dir_entry_proc) {
    
        char strbuf[11]; 
        // 创建文件 /sys/kernel/debug/binde/proc/pid 
        proc->debugfs_entry = debugfs_create_file(strbuf, 0444, 
            binder_debugfs_dir_entry_proc, 
            (void *)(unsigned long)proc->pid, 
            &proc_fops); 
    } 
    ... 
    return 0; 
}

进程调用了binder_open打开驱动设备，binder内核会创建一个对应的binder_proc，初始化之后加入全局的红黑树binder_procs

mmap 分配 binder_buffer

static int binder_mmap(struct file *filp, struct vm_area_struct *vma) 
{
    
    int ret; 
    // 从flip文件取出binder_proc 
    struct binder_proc *proc = filp->private_data; 
    const char *failure_string; 
   // 映射分配内存 proc->alloc 
    ret = binder_alloc_mmap_handler(&proc->alloc, vma); 
 
    return 0; 
}

vm_struct描述的是内核虚拟地址, vm_area_struct 描述的是用户虚拟地址

// binder_alloc.c 
int binder_alloc_mmap_handler(struct binder_alloc *alloc, 
                  struct vm_area_struct *vma) 
{
    
    int ret; 
    const char *failure_string; 
    struct binder_buffer *buffer; 
 
    mutex_lock(&binder_alloc_mmap_lock); 
     // 内存大小，默认4m 
    alloc->buffer_size = min_t(unsigned long, vma->vm_end - vma->vm_start, SZ_4M); 
    mutex_unlock(&binder_alloc_mmap_lock); 
    // 设置alloc->buffer为用户虚拟地址vma首地址，vma->vm_start为用户空间起始地址 
    alloc->buffer = (void __user *)vma->vm_start; 
    // 分配page页数组物理空间，实际上page页还没申请物理内存 
    alloc->pages = kcalloc(alloc->buffer_size / PAGE_SIZE, sizeof(alloc->pages[0]), GFP_KERNEL); 
 
    // 分配创建一个binder_buffer 
    buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); 
 
    // 将binder_buffer的用户缓存地址指向alloc->buffer，也就是用户虚拟地址vma首地址 
    buffer->user_data = alloc->buffer; 
 
    //  将buffer加入到alloc当前进程的buffers列表中 
    list_add(&buffer->entry, &alloc->buffers); 
     
    buffer->free = 1; 
    // 从binder_proc的结构可得，每个binder进程会管理一个空闲内核缓冲区红黑树，当binder_mmap映射内存到进程空间时，将会把一个新创建的空闲buffer加入到红黑树中 
    binder_insert_free_buffer(alloc, buffer); 
    // 异步事务的内核缓冲区大小设置为总缓冲区大小的一半 
    alloc->free_async_space = alloc->buffer_size / 2; 
    // 设置用户空间地址 
    binder_alloc_set_vma(alloc, vma); 
    mmgrab(alloc->vma_vm_mm); 
 
    return 0; 
}

kmalloc、kzalloc、vmalloc

  • kmalloc: 在内核空间申请内存，不做清零初始化操作，申请获得物理内存。
  • kzalloc: 在kmalloc基础上增加初始化清零操作
  • vmalloc: 在内核空间申请内存，它申请的内存是位于vmalloc_start到vmalloc_end之间的虚拟内存，获取的是虚拟内存地址。

binder_mmap未做用户空间和内核空间的映射

开始调用binder_mmap()的时候，binder驱动只为进分配了一个buffer，所以这里的alloc->buffer与buffer->data地址相同，但是还没有将用户虚拟地址与内核的虚拟地址映射在物理页面中，真正的申请物理页和映射动作是在binder_transaction才会开始

参考：
https://segmentfault.com/a/1190000014643994?utm_source=channel-hottest#item-3-5

binder_update_page_range

binder_update_page_range: 管理物理内存的分配和释放alloc、映射用户空间和内核空间

// allocate 为1表示申请分配内存，为0表示释放内存 
static int binder_update_page_range(struct binder_alloc *alloc, int allocate, 
                    void __user *start, void __user *end) {
    
    void __user *page_addr; 
    unsigned long user_page_addr; 
    struct binder_lru_page *page; 
    struct vm_area_struct *vma = NULL; 
    struct mm_struct *mm = NULL; 
    bool need_mm = false; 
 
    if (end <= start) 
        return 0; 
 
    trace_binder_update_page_range(alloc, allocate, start, end); 
 
    if (allocate == 0) // 释放内存 
        goto free_range; 
 
    // 检查物理页面的地址，若为空，则进行映射 
    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_read(&mm->mmap_sem); 
        vma = alloc->vma; 
    } 
 
    // 遍历所有page 
    for (page_addr = start; page_addr < end; page_addr += PAGE_SIZE) {
    
        int ret; 
        bool on_lru; 
        size_t index; 
 
        index = (page_addr - alloc->buffer) / PAGE_SIZE; 
        page = &alloc->pages[index]; 
 
        if (page->page_ptr) {
    // 已经有分配内存和映射 
            trace_binder_alloc_lru_start(alloc, index); 
 
            on_lru = list_lru_del(&binder_alloc_lru, &page->lru); 
            WARN_ON(!on_lru); 
 
            trace_binder_alloc_lru_end(alloc, index); 
            continue; 
        } 
 
        trace_binder_alloc_page_start(alloc, index); 
        //分配一个page的物理内存，直接赋值给内核虚拟进程空间page->page_ptr 
        page->page_ptr = alloc_page(GFP_KERNEL |__GFP_HIGHMEM | __GFP_ZERO); 
 
        page->alloc = alloc; 
        INIT_LIST_HEAD(&page->lru); 
 
        user_page_addr = (uintptr_t)page_addr; 
        // 物理空间映射到用户虚拟进程空间 
        ret = vm_insert_page(vma, user_page_addr, page[0].page_ptr); 
 
        if (index + 1 > alloc->pages_high) 
            alloc->pages_high = index + 1; 
 
        trace_binder_alloc_page_end(alloc, index); 
    } 
    if (mm) {
    
        up_read(&mm->mmap_sem); 
        mmput(mm); 
    } 
    return 0; 
 
free_range: // 释放内存 
    for (page_addr = end - PAGE_SIZE; 1; page_addr -= PAGE_SIZE) {
    
        bool ret; 
        size_t index; 
 
        index = (page_addr - alloc->buffer) / PAGE_SIZE; 
        page = &alloc->pages[index]; 
 
        trace_binder_free_lru_start(alloc, index); 
 
        ret = list_lru_add(&binder_alloc_lru, &page->lru); 
        WARN_ON(!ret); 
 
        trace_binder_free_lru_end(alloc, index); 
        if (page_addr == start) 
            break; 
        continue; 
}

进程跟驱动的操作交互

static long binder_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 
{
    
    int ret; 
    // 从文件取出进程proc 
    struct binder_proc *proc = filp->private_data; 
    struct binder_thread *thread; 
    unsigned int size = _IOC_SIZE(cmd); 
    void __user *ubuf = (void __user *)arg; 
    binder_selftest_alloc(&proc->alloc); 
    ret = wait_event_interruptible(binder_user_error_wait, binder_stop_on_user_error < 2); 
    // 获取当前访问驱动的线程 
    thread = binder_get_thread(proc); 
 
    switch (cmd) {
    
    case BINDER_WRITE_READ: 
        // 读写数据，数据都封装在binder_write_read数据结构中 
        ret = binder_ioctl_write_read(filp, cmd, arg, thread); 
        break; 
    case BINDER_SET_MAX_THREADS: {
    
        // 设置最大线程数 
        int max_threads; 
        // 从用户空间读取最大线程数 
        if (copy_from_user(&max_threads, ubuf, 
                   sizeof(max_threads))) {
    
            ret = -EINVAL; 
            goto err; 
        } 
        binder_inner_proc_lock(proc); 
        proc->max_threads = max_threads; 
        binder_inner_proc_unlock(proc); 
        break; 
    } 
    case BINDER_SET_CONTEXT_MGR_EXT: {
    
        // 注册Service Manager服务 
        struct flat_binder_object fbo; 
        if (copy_from_user(&fbo, ubuf, sizeof(fbo))) {
    
            ret = -EINVAL; 
            goto err; 
        } 
        ret = binder_ioctl_set_ctx_mgr(filp, &fbo); 
        break; 
    } 
    case BINDER_SET_CONTEXT_MGR: 
       // 注册Service Manager服务 
        ret = binder_ioctl_set_ctx_mgr(filp, NULL); 
        break; 
    case BINDER_THREAD_EXIT: 
       // 退出释放当前线程 
        binder_thread_release(proc, thread); 
        thread = NULL; 
        break; 
    case BINDER_VERSION: {
    
       // 返回版本信息 
        struct binder_version __user *ver = ubuf; 
        if (put_user(BINDER_CURRENT_PROTOCOL_VERSION, 
                 &ver->protocol_version)) {
    
            ret = -EINVAL; 
            goto err; 
        } 
        break; 
    } 
    case BINDER_GET_NODE_INFO_FOR_REF: {
    
    // 获取binder_node信息 
        struct binder_node_info_for_ref info; 
 
        if (copy_from_user(&info, ubuf, sizeof(info))) {
    
            ret = -EFAULT; 
            goto err; 
        } 
 
        ret = binder_ioctl_get_node_info_for_ref(proc, &info); 
        if (copy_to_user(ubuf, &info, sizeof(info))) {
    
            ret = -EFAULT; 
            goto err; 
        } 
 
        break; 
    } 
    case BINDER_GET_NODE_DEBUG_INFO: {
    
    // 获取binder_node debug信息 
        struct binder_node_debug_info info; 
        if (copy_from_user(&info, ubuf, sizeof(info))) {
    
            ret = -EFAULT; 
            goto err; 
        } 
        ret = binder_ioctl_get_node_debug_info(proc, &info); 
        if (copy_to_user(ubuf, &info, sizeof(info))) {
    
            ret = -EFAULT; 
            goto err; 
        } 
        break; 
    } 
    ret = 0; 
    return ret; 
}

ioctl 基本流程

  1. 获取binder_proc
  2. binder_thread
  3. copyFromUser()
  4. 处理数据
  5. copyToUser()

ioctl 命令

  1. BINDER_WRITE_READ
    向驱动读取和写入数据.可同时读和写，数据结构是binder_write_read

  2. BINDER_SET_MAX_THREADS
    设置线程池的最大的线程数,达到上限后驱动将不会在通知应用层启动新线程

  3. BINDER_SET_CONTEXT_MGR
    将本进程设置为binder系统的管理进程,只有servicemanager进程才可以注册

  4. BINDER_THREAD_EXIT
    通知驱动当前线程要退出了,以便驱动清理该线程相关的数据

  5. BINDER_VERSION
    获取binder的版本号

  6. BC_INCREFS 、BC_ACQUIRE 、BC_RELEASE 、BC_DECREFS
    增加或减少Binder的引用计数，用以实现强指针或弱指针的功能。

binder_write_read命令

binder_ioctl_write_read是最重要的一步，跟用户进程如何交互数据

binder_write_read 是驱动内核处理binder数据的数据结构，内部分成读缓存和写缓存

static int binder_ioctl_write_read(struct file *filp, unsigned int cmd, unsigned long arg, struct binder_thread *thread) 
{
     
int ret = 0;  
struct binder_proc *proc = filp->private_data;  
unsigned int size = _IOC_SIZE(cmd);  
void __user *ubuf = (void __user *)arg; 
struct binder_write_read bwr;  
 
// 从用户空间的binder_write_read拷贝到内核空间的binder_write_read结构 
if (copy_from_user(&bwr, ubuf, sizeof(bwr))) {
     
    ret = -EFAULT;  
    goto out;  
} 
 
// 如果bwr有写缓存的数据 
if (bwr.write_size > 0) {
     
    ret = binder_thread_write(proc, thread, bwr.write_buffer, bwr.write_size, &bwr.write_consumed); 
}  
 
// 如果bwr有读缓存的数据 
if (bwr.read_size > 0) {
     
    ret = binder_thread_read(proc, thread, bwr.read_buffer, bwr.read_size, &bwr.read_consumed, filp->f_flags & O_NONBLOCK); 
} 
… 
 
// 将bwr拷贝回用户空间 
if (copy_to_user(ubuf, &bwr, sizeof(bwr))) {
     
    ret = -EFAULT; 
    goto out; 
} 
 
out: 
    return ret; 
}

binder_thread_write

binder_thread_write表示处理写缓存数据，表示的是binder的发起端，发起了一次请求

proc表示目标进程，thread表示目标线程

static int binder_thread_write(struct binder_proc *proc, struct binder_thread *thread, binder_uintptr_t binder_buffer, size_t size, binder_size_t *consumed) 
{
    
uint32_t cmd; 
struct binder_context *context = proc->context; 
void __user *buffer = (void __user *)(uintptr_t)binder_buffer; 
void __user *ptr = buffer + *consumed; 
void __user *end = buffer + size; 
 
while (ptr < end && thread->return_error.cmd == BR_OK) {
    
    int ret; 
    ptr += sizeof(uint32_t); 
    switch (cmd) {
    
        ... 
        case BC_TRANSACTION: 
        case BC_REPLY: {
    
            … 
        } 
    } 
return 0; 
}

binder_thread_read

binder_thread_read表示处理读缓存数据，表示的是binder的接收端，接收到了一次请求，可能需要写回去返回值

static int binder_thread_read(struct binder_proc *proc, struct binder_thread *thread, binder_uintptr_t binder_buffer, size_t size,binder_size_t *consumed, int non_block) 
{
     
void __user *buffer = (void __user *)(uintptr_t)binder_buffer; 
void __user *ptr = buffer + *consumed; 
void __user *end = buffer + size;  
int ret = 0;  
int wait_for_proc_work; 
 
retry: 
    binder_inner_proc_lock(proc); 
    // 获取当前线程是否空闲等待，即线程事务栈和todo队列都为空 
    wait_for_proc_work = binder_available_for_proc_work_ilocked(thread); 
    binder_inner_proc_unlock(proc); 
   // 线程即将进入睡眠等待，设置线程状态改为BINDER_LOOPER_STATE_WAITING*/ 
    thread->looper |= BINDER_LOOPER_STATE_WAITING; 
    if (non_block) {
    
        if (!binder_has_work(thread, wait_for_proc_work)) 
            ret = -EAGAIN; 
    } else {
    
        // wait_for_proc_work 线程没有事务项，需要进入阻塞等待 
        ret = binder_wait_for_work(thread, wait_for_proc_work); 
    } 
    thread->looper &= ~BINDER_LOOPER_STATE_WAITING; 
    if (ret) 
       return ret; 
 
     while (1) {
    
            uint32_t cmd; 
            struct binder_transaction_data_secctx tr;      
            struct binder_transaction_data *trd = &tr.transaction_data;  
            struct binder_work *w = NULL;  
            switch (w->type) {
    
                case BINDER_WORK_TRANSACTION: {
    
                   ... 
                } break;  
                case BINDER_WORK_RETURN_ERROR: {
    
                  ... 
                } break; 
            … 
        } 
done: 
    *consumed = ptr - buffer;  
    // 当满足条件时候，会创建一个binder_thread，同时告诉给用户进程空间 BR_SPAWN_LOOPER 去创建多一个线程 
    if (proc->requested_threads == 0 && list_empty(&thread->proc->waiting_threads) && proc->requested_threads_started < proc->max_threads && 
(thread->looper & (BINDER_LOOPER_STATE_REGISTERED | BINDER_LOOPER_STATE_ENTERED)  
        proc->requested_threads++; 
        if (put_user(BR_SPAWN_LOOPER, (uint32_t __user *)buffer))  
    	    return -EFAULT; 
        }  
    } 
    return 0; 
}

binder_wait_for_work

内核空间等待事务和唤醒，用户空间下的线程也会阻塞在ioctl中

// do_proc_work 表示是否阻塞等待 
static int binder_wait_for_work(struct binder_thread *thread, bool do_proc_work) 
{
     
    DEFINE_WAIT(wait); 
    struct binder_proc *proc = thread->proc; 
    int ret = 0; 
    freezer_do_not_count();  
 
    binder_inner_proc_lock(proc); 
 
    for (;;) {
     
        prepare_to_wait(&thread->wait, &wait, TASK_INTERRUPTIBLE);      
        if (binder_has_work_ilocked(thread, do_proc_work)) 
            break; 
        if (do_proc_work) 
             list_add(&thread->waiting_thread_node, &proc->waiting_threads); 
        binder_inner_proc_unlock(proc); 
        schedule(); 
        binder_inner_proc_lock(proc); 
        list_del_init(&thread->waiting_thread_node);  
        if (signal_pending(current)) {
     
            ret = -ERESTARTSYS; 
            break;  
        } 
    } 
    finish_wait(&thread->wait, &wait); 
    binder_inner_proc_unlock(proc); 
    freezer_count(); 
    return ret; 
}

Linux 手工休眠线程方式：

  1. 建立并初始化一个等待队列项
    DEFINE_WAIT(my_wait) <==> wait_queue_t my_wait; init_wait(&my_wait);
  2. 将等待队列项添加到等待队列头中，并设置进程的状态
    prepare_to_wait(wait_queue_head_t *queue, wait_queue_t *wait, int state)
  3. 调用schedule()，告诉内核调度别的进程运行
  4. schedule返回，完成后续清理工作 finish_wait()

原创文章，作者：奋斗，如若转载，请注明出处：https://blog.ytso.com/tech/app/6243.html

赞 (0)
0 0
上一篇 2021年7月17日 00:44
下一篇 2021年7月17日 00:44

相关推荐

发表回复

登录后才能评论