关于进程间通信我们是再熟悉不过了,有时面试也经常被问到你了解 IPC 吗?我们一般都会答 AIDL ,Binder 驱动,共享内存?如果要我们再说详细点呢?或者说说共享内存的具体实现?这里推荐一篇罗升阳的博客 《Android进程间通信(IPC)机制Binder简要介绍和学习计划》。本文是基于 linux 进程间通信来写的,我们都知道 Android 是基于 linux 内核,因此了解了 linux 进程间通信也就基本了解了 Android 底层进程间通信。去年初来深圳去腾讯面试,被问到了知道进程间通信吗?我说 binder 驱动,还有吗?我说 Socket ,还有吗?我说其他的就不了解了。最后面试的结果也是不出所料,GG。
首先来了解一下进程间通信的本质是什么。在 Android 开发者需要知道的 Linux 知识 一文中提到,一个完整的进程在 32 位系统上的虚拟内存分布为: 0-3G 是用户空间,3-4G 是内核空间。操作系统在映射开辟物理内存时,每个进程的用户空间会映射到不同区域,每个进程的内核空间会映射到同一区域(可以简单的这么理解)。因此如果两个进程间需要传递数据是不能直接访问的,要交换数据必须通过内核,在内核中开辟一块缓冲区,进程 A 把数据拷贝到内存缓冲区,进程 B 再从内核缓冲区把数据读走,这种机制称为进程间通信(IPC,InterProcess Communication),因此进程间通信得要借助内核空间。
在 linux 中常见的进程间通信方式有:文件,管道,信号,信号量,共享内存,消息队列,套接字,命名管道,随着 linux 的发展到目前最最常见的有:
- 管道(使用最简单)
- 信号(开销最小)
- 共享映射区(无血缘关系)
- 本地套接字(低速稳定)
对于一个 Android 开发者来说,最最最常见的就只剩共享映射区了,像我们最熟悉的 Binder 驱动,腾讯开源的 MMKV, 自己实现高性能的日志库等等,都是基于共享映射区也就是我们所说的共享内存。因此本文我们着重来分析共享映射区,其他的内容就一笔带过了,如果大家实在感兴趣,可以自行查阅资料。
1. 管道
我们通常所说的管道一般是指无名管道,是 IPC 中最古老的一种形式。1. 数据不能自己写,自己读;2. 管道中数据不可反复读,一旦读走,管道中不再存在;3. 采用半双工通信方式,数据只能单方向上流动;4. 只能在带有血缘关系的进程间通信;5. 管道可以看成是一种特殊的文件,对于它的读写也可以使用普通的 read、write 等函数,但是它不是普通的文件,并不属于其他任何文件系统,并且只存在于内存中。
#include<stdio.h>
#include<unistd.h>
int main()
{
int fd[2]; // 两个文件描述符
pid_t pid;
char buff[20];
if(pipe(fd) < 0) // 创建管道
printf("Create Pipe Error!\n");
if((pid = fork()) < 0) // 创建子进程
printf("Fork Error!\n");
else if(pid > 0) // 父进程
{
close(fd[0]); // 关闭读端
write(fd[1], "hello pipe\n", 11);
}
else
{
close(fd[1]); // 关闭写端
read(fd[0], buff, 20);
printf("%s", buff);
}
return 0;
}
2. 信号
信号 (signal) 机制是 Linux 系统中最为古老的进程间通信机制,信号不能携带大量的数据信息,一般在满足特定场景时才会触发信号。信号啥时会产生?
- 按键产生,ctrl+c,ctrl+z
- 系统调用产生,kill,raise,abort
- 软件条件产生,alarm
- 硬件异常产生,非法访问内存,除0,内存对齐出错
- 命令产生,kill
信号出现时怎么处理?
- 忽略此信号,但有两种信号决不能被忽略,它们是: SIGKILL\SIGSTOP。 这是因为这两种信号向超级用户提供了一种终止或停止进程的方法。
- 执行系统默认动作,对大多数信号的系统默认动作是终止该进程。
- 执行用户希望的动作,通知内核在某种信号发生时,调用一个用户函数。在用户函数中,执行用户希望的处理。
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <signal.h>
int main(int argc, char* argv[]){
pid_t pid = fork();
if(pid < 0){
printf("fork error!\n");
}else if(pid > 0){
while(1){
printf("I am parent!\n");
sleep(1);
}
}else if(pid == 0){
sleep(5);
kill(getppid(), SIGKILL);
}
return 0;
}
上面是一个非常简单的小例子,大家不妨看一下 Process.killProcess() 的源码。
3. 共享映射区
有关于共享内存的实现方式,大家可以参考一下这篇文章《JNI 基础 - Android 共享内存的序列化过程》 ,这里我们主要来讲讲 mmap 这个函数作用与实现原理,在 Android 的 binder 驱动中,在腾讯开源的 MMKV库中,在一些高性能的日志库中,凡是关于共享映射区的地方都会有它的存在。先来看下函数的原型:
void *mmap(void *start,size_t length,int prot,int flags,int fd,off_t offsize);
参数 start:指向欲映射的内存起始地址,通常设为 NULL,代表让系统自动选定地址,映射成功后返回该地址。
参数 length:代表将文件中多大的部分映射到内存。
参数 prot:映射区域的保护方式。可以为以下几种方式的组合:
- PROT_EXEC 页内容可以被执行
- PROT_READ 页内容可以被读取
- PROT_WRITE 页可以被写入
- PROT_NONE 页不可访问
参数 flags:指定映射对象的类型,映射选项和映射页是否可以共享。可以为以下几种方式的组合:
- AP_FIXED 使用指定的映射起始地址,如果由start和len参数指定的内存区重叠于现存的映射空间,重叠部分将会被丢弃。如果指定的起始地址不可用,操作将会失败。并且起始地址必须落在页的边界上。
- MAP_SHARED 与其它所有映射这个对象的进程共享映射空间。对共享区的写入,相当于输出到文件。直到msync()或者munmap()被调用,文件实际上不会被更新。
- MAP_PRIVATE 建立一个写入时拷贝的私有映射。内存区域的写入不会影响到原文件。这个标志和以上标志是互斥的,只能使用其中一个。
- MAP_NORESERVE 不要为这个映射保留交换空间。当交换空间被保留,对映射区修改的可能会得到保证。当交换空间不被保留,同时内存不足,对映射区的修改会引起段违例信号。
- MAP_ANONYMOUS 匿名映射,映射区不与任何文件关联。
- 等等不常用的
参数 fd:文件句柄 fd。如果 MAP_ANONYMOUS 被设定,为了兼容问题,其值应为-1。
参数 offset:被映射对象内容的偏移位置(起点)。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <pthread.h>
struct person{
char name[24];
int age;
};
void sys_err(const char *str){
perror(str);
exit(0);
}
int main(int argc, char *argv[]){
int fd;
struct person stu = {"Darren", 25};
struct person *p;
fd = open("test_map", O_RDWR|O_CREAT|O_TRUNC, 0644);
if(fd == -1)
sys_err("open error");
ftruncate(fd, sizeof(stu));
p = (person*)mmap(NULL, sizeof(stu), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
if(p == MAP_FAILED)
sys_err("mmap error");
while(1){
memcpy(p, &stu, sizeof(stu));
stu.age++;
sleep(1);
}
munmap(p, sizeof(stu));
close(fd);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <pthread.h>
struct person{
char name[24];
int age;
};
void sys_err(const char *str){
perror(str);
exit(0);
}
int main(int argc, char *argv[]){
int fd;
struct person *p;
fd = open("test_map", O_RDONLY);
if(fd == -1)
sys_err("open error");
p = (person*)mmap(NULL, sizeof(person), PROT_READ, MAP_SHARED, fd, 0);
if(p == MAP_FAILED)
sys_err("mmap error");
while(1){
printf("name = %s, age = %d\n", p->name, p->age);
sleep(2);
}
munmap(p, sizeof(person));
close(fd);
return 0;
}
关于其实现的原理,最好的方式自然是看源码,但这里我们主要来聊聊 Android binder 中 mmap 的作用及原理(一次内存拷贝),关于 mmap 的源码大家可以自行阅读(不难的),具体的位置在
android/platform/bionic/libc/bionic/mmap.cpp
Android 应用在进程启动之初会创建一个单例的 ProcessState 对象,其构造函数执行时会同时完成 binder 的 mmap,为进程分配一块内存,专门用于 Binder 通信,如下。
ProcessState::ProcessState(const char *driver)
: mDriverName(String8(driver))
, mDriverFD(open_driver(driver))
...
{
if (mDriverFD >= 0) {
// mmap the binder, providing a chunk of virtual address space to receive transactions.
mVMStart = mmap(0, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE, mDriverFD, 0);
...
}
}
第一个参数是分配地址,为0意味着让系统自动分配,先在用户空间找到一块合适的虚拟内存,之后,在内核空间也找到一块合适的虚拟内存,修改两个控件的页表,使得两者映射到同一块物理内存。
Linux 的内存分用户空间跟内核空间,同时页表也分两类,用户空间页表跟内核空间页表,每个进程有一个用户空间页表,但是系统只有一个内核空间页表。而 Binder mmap 的关键是:也更新用户空间对应的页表的同时也同步映射内核页表,让两个页表都指向同一块地址,这样一来,数据只需要从 A 进程的用户空间,直接拷贝拷贝到 B 所对应的内核空间,而 B 多对应的内核空间在 B 进程的用户空间也有相应的映射,这样就无需从内核拷贝到用户空间了。
static int binder_mmap(struct file *filp, struct vm_area_struct *vma)
{
int ret;
...
if ((vma->vm_end - vma->vm_start) > SZ_4M)
vma->vm_end = vma->vm_start + SZ_4M;
...
// 在内核空间找合适的虚拟内存块
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;
...
proc->pages = kzalloc(sizeof(proc->pages[0]) * ((vma->vm_end - vma->vm_start) / PAGE_SIZE), GFP_KERNEL);
// 分配page,并更新用户空间及内核空间对应的页表
ret = binder_update_page_range(proc, 1, proc->buffer, proc->buffer + PAGE_SIZE, vma);
...
return ret;
}
static int binder_update_page_range(struct binder_proc *proc, int allocate,
void *start, void *end,
struct vm_area_struct *vma)
{
...
// 一页页分配
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];
*page = alloc_page(GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO);
...
// 修改页表,让物理空间映射到内核空间
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]);
}
...
return -ENOMEM;
}
上面的代码可以看到,binder 一次拷贝的关键是,完成内存的时候,同时完成了内核空间跟用户空间的映射,也就是说,同一份物理内存,既可以在用户空间用虚拟地址访问,也可以在内核空间用虚拟地址访问。
视频链接:https://pan.baidu.com/s/1_4GFw8AKzrhd4_8UJx-gSg
视频密码:eke1