debugfs_create_dir 是指在 debugfs 文件系统中创建一个目录，返回值是指向dentry 的指针。

binder_debugfs_dir_entry_root = debugfs_create_dir("binder", NULL);

当 kernel 中禁用 debugfs 的话，返回值是-%ENODEV。默认是禁用的。如果需要打开，在目录/kernel/arch/arm64/configs/下找到目标defconfig 文件中添加一行 CONFIG_DEBUG_FS=y，再重新编译版本，即可打开debug_fs。

在android 11中我们发现：

__init binder_init(void)中核心的操作是在：

while ((device_name = strsep(&device_tmp, ","))) {
6142  			ret = init_binder_device(device_name);
6143  			if (ret)
6144  				goto err_init_binder_device_failed;
6145  		}

那么其中：init_binder_device 这个是很核心的方法：

这断代码的核心就是：misc_register  注册 misc 设备

      2.1.1 misc_register

     注册 misc 设备，miscdevice 结构体，便是前面注册 misc 设备时传递进去的参数 static struct miscdevice binder_miscd

当我们在去看的时候发现：misc_register  kernel/msm-4.14/drivers/char/misc.c在这个里面，而

  misc_register(&binder_device->miscdev); 在  /drivers/android/binder.c里面 如何关联

而：  /misc.c 

#include <linux/miscdevice.h>

binder.c 中：

#include <linux/miscdevice.h>

extern表明变量或者函数是定义在其他其他文件中的

引用了头文件，就可以调用其中的方法，通过search 发现方法的定义在：misc.c文件里面

回到正题发现是：miscdev结构体参数，那么我们下面来看一下这个结构体：

/include/linux/miscdevice.h

6061  	binder_device->miscdev.minor = MISC_DYNAMIC_MINOR; //设备号 动态分配
6062  	binder_device->miscdev.name = name;  //设备名
6063  
6064  	refcount_set(&binder_device->ref, 1);
6065  	binder_device->context.binder_context_mgr_uid = INVALID_UID;
6066  	binder_device->context.name = name;
6067  	mutex_init(&binder_device->context.context_mgr_node_lock);
6068  
6069  	ret = misc_register(&binder_device->miscdev);

2.2 binder_open

核心类里面：/kernel/msm-4.14/drivers/android/binder.c

    打开 binder 驱动设备

 static int binder_open(struct inode *nodp, struct file *filp)
{
struct binder_proc *proc; // binder 进程 
proc = kzalloc(sizeof(*proc), GFP_KERNEL); // 为 binder_proc 结构体在分配kernel 内存空间
if (proc == NULL)
return -ENOMEM;
get_task_struct(current);
proc->tsk = current; //将当前线程的 task 保存到 binder 进程的 tsk
INIT_LIST_HEAD(&proc->todo); //初始化 todo 列表
init_waitqueue_head(&proc->wait); //初始化 wait 队列
proc->default_priority = task_nice(current); //将当前进程的nice 值转换为进程优先级
binder_lock(__func__); //同步锁，因为 binder 支持多线程访问
binder_stats_created(BINDER_STAT_PROC); //BINDER_PROC 对象创建数加1

hlist_add_head(&proc->proc_node, &binder_procs); //将 proc_node 节点添加到binder_procs 为表头的队列
proc->pid = current->group_leader->pid;
INIT_LIST_HEAD(&proc->delivered_death); //初始化已分发的死亡通知列表filp->private_data = proc; //file 文件指针的 private_data 变量指向binder_proc 数据
binder_unlock(__func__); //释放同步锁
return 0;
}

创建 binder_proc 对象，并把当前进程等信息保存到 binder_proc 对象，该对象管理 IPC 所需的各种信息并拥有其他结构体的根结构体；再把binder_proc 对象保存到文件指针 filp，以及把 binder_proc 加入到全局链表binder_procs。

Binder 驱动中通过 static HLIST_HEAD(binder_procs);，创建了全局的哈希链表binder_procs，用于保存所有的 binder_proc 队列，每次新创建的binder_proc对象都会加入 binder_procs 链表中。

2.3 binder_mmap 

binder_mmap(文件描述符，用户虚拟内存空间）

主要功能：首先在内核虚拟地址空间，申请一块与用户虚拟内存相同大小的内存；然后再申请 1 个 page 大小的物理内存，再将同一块物理内存分别映射到内核虚拟地址空间和用户虚拟内存空间，从而实现了用户空间的Buffer 和内核空间的Buffer 同步操作的功能。

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;
if ((vma->vm_end - vma->vm_start) > SZ_4M)
vma->vm_end = vma->vm_start + SZ_4M; //保证映射内存大小不超过4M
mutex_lock(&binder_mmap_lock); //同步锁
//采用 IOREMAP 方式，分配一个连续的内核虚拟空间，与进程虚拟空间大小一致

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 = area->addr; //指向内核虚拟空间的地址
//地址偏移量 = 用户虚拟地址空间 - 内核虚拟地址空间
proc->user_buffer_offset = vma->vm_start - (uintptr_t)proc->buffer;
mutex_unlock(&binder_mmap_lock); //释放锁
...
//分配物理页的指针数组，数组大小为 vma 的等效 page 个数；
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 = vma->vm_end - vma->vm_start;
vma->vm_ops = &binder_vm_ops;
vma->vm_private_data = proc;
//分配物理页面，同时映射到内核空间和进程空间，先分配 1 个物理页  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;
}
buffer = proc->buffer; //binder_buffer 对象 指向 proc 的 buffer 地址INIT_LIST_HEAD(&proc->buffers); //创建进程的 buffers 链表头
list_add(&buffer->entry, &proc->buffers); //将 binder_buffer 地址加入到所属进程的 buffers 队列
buffer->free = 1;
//将空闲 buffer 放入 proc->free_buffers 中
binder_insert_free_buffer(proc, buffer);
//异步可用空间大小为 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;
return 0;
...// 错误 flags 跳转处，free 释放内存之类的操作
return ret;
}

binder_mmap 通过加锁，保证一次只有一个进程分配内存，保证多进程间的并发访问。其中 user_buffer_offset 是虚拟进程地址与虚拟内核地址的差值(该值为负数)。也就是说同一物理地址，当内核地址为 kernel_addr，则进程地址为proc_addr = kernel_addr + user_buffer_offset。

2.3.1 binder_update_page_range

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; // 内存结构体
if (vma)
mm = NULL; //binder_mmap 过程 vma 不为空，其他情况都为空else
mm = get_task_mm(proc->tsk); //获取 mm 结构体
if (mm) {
down_write(&mm->mmap_sem); //获取 mm_struct 的写信号量
vma = proc->vma;
}
//此处 allocate 为 1，代表分配过程。如果为 0 则代表释放过程
if (allocate == 0)
goto free_range;
for (page_addr = start; page_addr < end; page_addr += PAGE_SIZE) {
int ret;
page = &proc->pages[(page_addr - proc->buffer) / PAGE_SIZE];
//分配一个 page 的物理内存
*page = alloc_page(GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO);
//物理空间映射到虚拟内核空间
ret = map_kernel_range_noflush((unsigned long)page_addr,
PAGE_SIZE, PAGE_KERNEL, page);
flush_cache_vmap((unsigned long)page_addr, (unsigned long)page_addr + PAGE_SIZE);
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); //减少 mm->mm_users 计数
}
return 0;
free_range:
... //释放内存的流程
return -ENOMEM;
}

主要工作如下：

binder_update_page_range 主要完成工作：分配物理空间，将物理空间映射到内核空间，将物理空间映射到进程空间. 另外，不同参数下该方法也可以释放物理页面。

binder_update_page_range 的调用时机：  binder_mmap: 用于分配内存，分配大小为 1page, vma 不为空； binder_alloc_buf：用于分配内存，vma 为空； binder_free_buf: 用于释放内存，vma 为空；  binder_delete_free_buffer：同样用于释放内存，vma 为空。

关于 mm_struct 结构体，定义在 mm_types.h 文件：

struct mm_struct {
struct vm_area_struct *mmap; //VMA 列表
struct rb_root mm_rb;
pgd_t * pgd;
atomic_t mm_users; //使用该内存的进程个数
atomic_t mm_count; //结构体 mm_struct 的引用个数
struct rw_semaphore mmap_sem; //读写信号量，用于同步
unsigned long flags;
...
};

下面，再说一说 binder_alloc_buf 过程

2.3.2 binder_alloc_buf

通过 binder_alloc_buf()方法来分配 binder_buffer 结构体, 只有在binder_transaction 过程才需要分配 buffer.

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;
if (proc->vma == NULL) {
return NULL; //虚拟地址空间为空，直接返回
}
size = ALIGN(data_size, sizeof(void *)) + ALIGN(offsets_size, sizeof(void
*));
if (size < data_size || size < offsets_size) {
return NULL; //非法的 size
}
if (is_async && proc->free_async_space < size + sizeof(struct binder_buffer)){
return NULL; // 剩余可用的异步空间，小于所需的大小
}
while (n) { //从 binder_buffer 的红黑树中查找大小相等的 buffer 块buffer = rb_entry(n, struct binder_buffer, rb_node);
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;
}
}
if (best_fit == NULL) {
return NULL; //内存分配失败，地址空间为空
}
if (n == NULL) {
buffer = rb_entry(best_fit, struct binder_buffer, rb_node);
buffer_size = binder_buffer_size(proc, buffer);
}
has_page_addr =(void *)(((uintptr_t)buffer->data + buffer_size) & PAGE_MAS
K);
if (n == NULL) {
if (size + sizeof(struct binder_buffer) + 4 >= buffer_size)
buffer_size = size;
else
buffer_size = size + sizeof(struct binder_buffer);
}
end_page_addr = (void *)PAGE_ALIGN((uintptr_t)buffer->data + buffer_size);
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;
rb_erase(best_fit, &proc->free_buffers);
buffer->free = 0;
binder_insert_allocated_buffer(proc, buffer);
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;
if (is_async) {
proc->free_async_space -= size + sizeof(struct binder_buffer);
}
}

这里介绍的 binder_alloc_buf 是内存分配函数。除此之外，还有内存释放相关方法：

binder_free_buf

 binder_delete_free_buffer

 binder_transaction_buffer_release

这里涉及强弱引用相关函数的操作：

2.4 binder_ioctl

binder_ioctl()函数负责在两个进程间收发 IPC 数据和 IPC reply 数据。

ioctl(文件描述符，ioctl 命令，数据类型)

(1) 文件描述符，是通过 open()方法打开 Binder Driver 后返回值；(2) ioctl 命令和数据类型是一体的，不同的命令对应不同的数据类型

这些命令中 BINDER_WRITE_READ命令使用率最为频繁，也是ioctl 最为核心的命令。

static long binder_ioctl(struct file *filp, unsigned int cmd, unsigned long arg){
int ret;
struct binder_proc *proc = filp->private_data;
struct binder_thread *thread; // binder 线程
unsigned int size = _IOC_SIZE(cmd);
void __user *ubuf = (void __user *)arg;
//进入休眠状态，直到中断唤醒
ret = wait_event_interruptible(binder_user_error_wait, binder_stop_on_user_error < 2);
if (ret)
goto err_unlocked;
binder_lock(__func__);
//获取 binder_thread【见 2.4.1】
thread = binder_get_thread(proc);
if (thread == NULL) {
ret = -ENOMEM;
goto err;
}
switch (cmd) {
case BINDER_WRITE_READ: //进行 binder 的读写操作
ret = binder_ioctl_write_read(filp, cmd, arg, thread); //【见2.4.2】if (ret)
goto err;
break;
case BINDER_SET_MAX_THREADS: //设置 binder 最大支持的线程数
if (copy_from_user(&proc->max_threads, ubuf, sizeof(proc->max_threads))){
ret = -EINVAL;
goto err;
}
break;
case BINDER_SET_CONTEXT_MGR: //成为 binder 的上下文管理者，也就是ServiceManager成为守护进程
ret = binder_ioctl_set_ctx_mgr(filp);
if (ret)
goto err;
break;
case BINDER_THREAD_EXIT: //当 binder 线程退出，释放 binder 线程binder_free_thread(proc, thread);
thread = NULL;
break;
case BINDER_VERSION: { //获取 binder 的版本号
struct binder_version __user *ver = ubuf;
if (size != sizeof(struct binder_version)) {
ret = -EINVAL;
goto err;
}
if (put_user(BINDER_CURRENT_PROTOCOL_VERSION,
&ver->protocol_version)) {
ret = -EINVAL;
goto err;
}
break;
}
default:
ret = -EINVAL;
goto err;
}
ret = 0;
err:
if (thread)
thread->looper &= ~BINDER_LOOPER_STATE_NEED_RETURN;
binder_unlock(__func__);
wait_event_interruptible(binder_user_error_wait, binder_stop_on_user_error <2);
err_unlocked:
trace_binder_ioctl_done(ret);
return ret;
}

执行 ioctl 过程，便需要加上 binder lock.

2.4.1 binder_get_thread 

从 binder_proc 中查找 binder_thread,如果当前线程已经加入到proc 的线程队列则直接返回，如果不存在则创建 binder_thread，并将当前线程添加到当前的proc

static struct binder_thread *binder_get_thread(struct binder_proc *proc)
{
struct binder_thread *thread = NULL;
struct rb_node *parent = NULL;
struct rb_node **p = &proc->threads.rb_node;
while (*p) { //根据当前进程的 pid，从 binder_proc 中查找相应的 binder_thread
parent = *p;
thread = rb_entry(parent, struct binder_thread, rb_node);
if (current->pid < thread->pid)
p = &(*p)->rb_left;
else if (current->pid > thread->pid)
p = &(*p)->rb_right;
else
break;
}
if (*p == NULL) {
thread = kzalloc(sizeof(*thread), GFP_KERNEL); //新建 binder_thread 结构体if (thread == NULL)
return NULL;
binder_stats_created(BINDER_STAT_THREAD);
thread->proc = proc;
thread->pid = current->pid; //保存当前进程(线程)的 pid
init_waitqueue_head(&thread->wait);
INIT_LIST_HEAD(&thread->todo);
rb_link_node(&thread->rb_node, parent, p);
rb_insert_color(&thread->rb_node, &proc->threads);
thread->looper |= BINDER_LOOPER_STATE_NEED_RETURN;
thread->return_error = BR_OK;
thread->return_error2 = BR_OK;
}
return thread;
}

2.4.2 binder_ioctl_write_read

对于 ioctl()方法中，传递进来的命令是 cmd = BINDER_WRITE_READ 时执行该方法，arg 是一个 binder_write_read 结构体

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;
if (size != sizeof(struct binder_write_read)) {
ret = -EINVAL;
goto out;
}
if (copy_from_user(&bwr, ubuf, sizeof(bwr))) { //把用户空间数据ubuf 拷贝到bwrret = -EFAULT;
goto out;
}
if (bwr.write_size > 0) {
//当写缓存中有数据，则执行 binder 写操作
ret = binder_thread_write(proc, thread,
bwr.write_buffer, bwr.write_size, &bwr.write_consumed);
trace_binder_write_done(ret);
if (ret < 0) { //当写失败，再将 bwr 数据写回用户空间，并返回bwr.read_consumed = 0;
if (copy_to_user(ubuf, &bwr, sizeof(bwr)))
ret = -EFAULT;
goto out;
}
}
if (bwr.read_size > 0) {
//当读缓存中有数据，则执行 binder 读操作
ret = binder_thread_read(proc, thread,
bwr.read_buffer, bwr.read_size, &bwr.read_consumed,
filp->f_flags & O_NONBLOCK);
trace_binder_read_done(ret);
if (!list_empty(&proc->todo))
wake_up_interruptible(&proc->wait); //唤醒等待状态的线程if (ret < 0) { //当读失败，再将 bwr 数据写回用户空间，并返回if (copy_to_user(ubuf, &bwr, sizeof(bwr)))
ret = -EFAULT;
goto out;
}
}
if (copy_to_user(ubuf, &bwr, sizeof(bwr))) { //将内核数据 bwr 拷贝到用户空间ubuf
ret = -EFAULT;
goto out;
}out:
return ret;
}
对于 binder_ioctl_write_read 的流程图，如下：

流程：

      首先，把用户空间数据 ubuf 拷贝到内核空间 bwr

    当 bwr 写缓存有数据，则执行 binder_thread_write；当写失败则将bwr 数据写回用户空间并退出；

当 bwr 读缓存有数据，则执行 binder_thread_read；当读失败则再将bwr 数据写回用户空间并退出；

最后，把内核数据 bwr 拷贝到用户空间 ubuf。

这里涉及两个核心方法 binder_thread_write()和 binder_thread_read()方法

2.4 Command 使用场景

 ioctl 命令常见命令的使用场景，其中 BINDER_WRITE_READ 最为频繁

 BINDER_WRITE_READ

            Binder 读写交互场景，IPC.talkWithDriver

BINDER_SET_CONTEXT_MGR

              servicemanager 进 程 成 为 上 下文管理者，binder_become_context_manager()

BINDER_SET_MAX_THREADS

             初始化 ProcessState 对象，open_driver()

             主动调整参数，ProcessState.setThreadPoolMaxThreadCount()

BINDER_VERSION

             初始化 ProcessState 对象，open_driver()

2.5 小节

     binder_init：初始化字符设备；

    binder_open：打开驱动设备，过程需要持有 binder_main_lock 同步锁；

    binder_mmap：申请内存空间，该过程需要持有binder_mmap_lock 同步锁；

   binder_ioctl：执行相应的 ioctl 操作，该过程需要持有binder_main_lock同步锁；

当处于 binder_thread_read 过程，read_buffer 无数据则释放同步锁，并处于 wait_event_freezable 过程，等有数据到来则唤醒并尝试持有同步锁。