**源码基于:**Andoird U + Kernel-5.10
0. 简介
ashmem 称为匿名共享内存(Anonymous Shared Memory),它以驱动程序的形式实现在内核空间中。它有两个特点:
-
能否辅助内存管理系统来有效地管理不再使用的内存块(pin / unpin);
-
通过Binder进程间通信机制来实现内存共享;
虽然 Binder机制已经可以实现了跨进程的高效通信,但是Binder 通信所允许的数据是有限制的(如下代码),如果需要大量数据交互就有限制了。
cpp
frameworks/native/libs/binder/ProcessState.cpp
//限制了大小为
#define BINDER_VM_SIZE ((1 * 1024 * 1024) - sysconf(_SC_PAGE_SIZE) * 2)
ashmem 系统大概分三层:
-
Java 层使用 MemoryFile.java 或 SharedMemory.java 来创建ashmem 共享内存;
-
Native 层分两部分:
-
一部分是从Java 层调下来的 JNI 接口,另外是给Native 层使用的MemoryHeapBase.cpp 文件;
-
另一部分是ashmem 的lib,实现的函数定义在 ashmem-dev.cpp 文件中;
-
-
Kernel 层就是 ashmem 的驱动,ashmem 的核心就是通过驱动来管理共享内存;
1. ashmem 驱动原理分析
源码:drivers/staging/android/ashmem.c
-
用户层都是通过fd 进行mmap 进行映射;
-
虽然 fd 在不同的进程可能不相同,但其对应的 file 结构是相同的;
-
file 结构中的成员 private_data 指向 ashmem_area,这就是匿名共享内存的核心数据结构;
-
ashmem_area 中的file 是映射的实际文件,通过shmem_file_setup() 函数创建,并指定其fops 为shmem_file_operations,该 fops 也被存在 ashmem 中的静态局部变量 vmfile_fops 中;
-
vmfile_fops 只初始化一次,后面再次调用 ashmem_mmap() 函数时将直接使用;
1.1 ashmem 的重要数据结构和变量
1.1.1 变量 ashmem_misc
cpp
static struct miscdevice ashmem_misc = {
.minor = MISC_DYNAMIC_MINOR,
.name = "ashmem",
.fops = &ashmem_fops,
};
在 ashmem 驱动初始化的时候会调用 misc_register() 进行注册,详细可以查看 ashmem_init() 函数。
该设备中指定的 file_operations 是 ashmem_fops,如下。
1.1.2 变量 ashmem_fops
cpp
static const struct file_operations ashmem_fops = {
.owner = THIS_MODULE,
.open = ashmem_open, //节点文件open函数
.release = ashmem_release, //节点文件结构被释放时会调用release函数
.read_iter = ashmem_read_iter,
.llseek = ashmem_llseek,
.mmap = ashmem_mmap, //节点文件的mmap函数
.unlocked_ioctl = ashmem_ioctl, //节点文件的ioctl函数
#ifdef CONFIG_COMPAT
.compat_ioctl = compat_ashmem_ioctl, //32位用户系统调用64位驱动的ioctl函数时使用
#endif
#ifdef CONFIG_PROC_FS
.show_fdinfo = ashmem_show_fdinfo, //查询/proc/pid/fdinfos/[fd]时打印
#endif
};
compat_ioctl对于64bit 的驱动必须要实现的ioctl,当有32 bit 的用户层调用 ioctl() 时,会callback 到这里,否则会返回 Not a typewriter 的错误。
64bit 用户层调用 64bit 驱动,或者 32bit 用户层调用 32bit 驱动时,都是callback unlocked_ioctl函数。
show_fdinfo 函数用于查询 /proc/<pid>/fdinfos/<fd>时打印,例如:
bash
phone_shift:/ # cat /proc/967/fdinfo/34
pos: 0
flags: 0400002
mnt_id: 45
ino: 1210
inode: 6146
name: gralloc_shared_memory
size: 2404
1.1.3 struct ashmem_area
cpp
struct ashmem_area {
char name[ASHMEM_FULL_NAME_LEN]; //共享内存区域的名称,在/proc/<pid>/maps中携带
struct list_head unpinned_list; //用以串联所有的 ashmem_area
struct file *file; //该共享内存的实际file
size_t size; //该共享内存的大小
unsigned long prot_mask; //该共享内存文件的属性,包括r、w、x
};
驱动中通过该数据结构管理所有的共享内存区域,每个共享内存区域都有一个名字,前缀是ASHMEM_NAME_PREFIX(dev/ashmem/),这个名字通过 /proc/<pid>/maps 查看到,例如:
bash
130|phone_shift:/ # cat /proc/967/maps | grep ashmem
76b525e000-76b526e000 rw-s 00000000 00:01 13 /dev/ashmem/MessageQueue (deleted)
76b5309000-76b5319000 rw-s 00000000 00:01 2057 /dev/ashmem/MessageQueue (deleted)
76b55c2000-76b55c3000 rw-s 00000000 00:01 3095 /dev/ashmem/gralloc_shared_memory (deleted)
76b55c4000-76b55c5000 rw-s 00000000 00:01 4099 /dev/ashmem/gralloc_shared_memory (deleted)
这是 hwc 进程中 ashmem 对应的 vma。在申请ashmem 的时候,都会指定其 name。
每个ashmem 都会在临时文件系统 tmpfs 中对应一个文件,也就是成员变量 file,并且通过 prot_mask 指定文件访问的权限,该 ashmem 在初始化的时候 prot_mask 被指定为 PROT_MASK,后期根据实际情况可以通过接口进行修改。
cpp
#define PROT_MASK (PROT_EXEC | PROT_READ | PROT_WRITE)
ashmem 机制中,需要使用内存块(ashmem_range) 时需要调用ashmem_pin() 函数进行锁定,不被使用的内存会解除锁定。
如果内存块(ashmem_range) 解除锁定,会将这些内存块(ashmem_range) 添加到 asma->unpinned_list链表中,且添加到 ashmem_lru_list 中便于内存紧张时进行回收。但是两个链表的插入方式不同:
-
asma->unpinned_list 是将 ashmem_range 的地址从大到小串联起来;
-
ashmem_lru_list 是按照LRU 方式将最新的 ashmem_range 插入到链表尾;
1.1.4 struct ashmem_range
cpp
struct ashmem_range {
struct list_head lru; //串联链表使用
struct list_head unpinned; //用以标记是否加入unpinned list
struct ashmem_area *asma; //该块内存归属于ashmem_area
size_t pgstart; //内存的起始page
size_t pgend; //内存的结尾page,这块内存区间是[pgstart, pgend]
unsigned int purged; //标记这块区间是否被回收
};
ashmem_range 可以理解为 ashmem_area 中的内存块。
每个 ashmem_area 会被分成很多的小块(ashmem_range),这些小块会有两种状态:pin 和 unpin。如果该内存块为 unpin,则该内存块会被添加到 ashmem_area 中的unpinned_list 链表中,通过成员变量 unpinned。
每个小块的内存区间是 [pgstart, pgend]。
1.1.5 struct ashmem_pin
cpp
struct ashmem_pin {
__u32 offset; /* offset into region, in bytes, page-aligned */
__u32 len; /* length forward from offset, in bytes, page-aligned */
};
提供给用户的结构体,标记pin/unpin 时的内存区域,但是有一定要求:
-
len 可以为0,这样内存空间 ashmem_area 从 offset 之后的所有空间;
-
offset和 len 需要页对齐;
-
offset + len 不能超过 32位无符号数;
-
offset + len 不能超过 ashmem_area 空间;
1.1.6 ashmem_lru_list
cpp
/* LRU list of unpinned pages, protected by ashmem_mutex */
static LIST_HEAD(ashmem_lru_list);
static unsigned long lru_count;
在 ashmem_pin() 或这 ashmem_unpin() 中会分配新的 ashmem_range 对象,该结构体中成员 lru 用以串联链表并存放在 ashmem_lru_list 这个全局链表中,便于在内存使用紧张的时候进行回收。
与 ashmem_lru_list 对应的还有 lru_count 用于统计该 list 中页面数量。
1.2 ashmem 初始化
cpp
static int __init ashmem_init(void)
{
int ret = -ENOMEM;
ashmem_area_cachep = kmem_cache_create("ashmem_area_cache",
sizeof(struct ashmem_area),
0, 0, NULL);
if (!ashmem_area_cachep) {
pr_err("failed to create slab cache\n");
goto out;
}
ashmem_range_cachep = kmem_cache_create("ashmem_range_cache",
sizeof(struct ashmem_range),
0, 0, NULL);
if (!ashmem_range_cachep) {
pr_err("failed to create slab cache\n");
goto out_free1;
}
ret = misc_register(&ashmem_misc);
if (ret) {
pr_err("failed to register misc device!\n");
goto out_free2;
}
ret = register_shrinker(&ashmem_shrinker);
if (ret) {
pr_err("failed to register shrinker!\n");
goto out_demisc;
}
pr_info("initialized\n");
return 0;
out_demisc:
misc_deregister(&ashmem_misc);
out_free2:
kmem_cache_destroy(ashmem_range_cachep);
out_free1:
kmem_cache_destroy(ashmem_area_cachep);
out:
return ret;
}
device_initcall(ashmem_init);
代码比较清晰,主要做了几件事:
-
创建两个 slab cache:ashmem_area_cache 和 ashmem_range_cache,后面struct ashmem_area 和 struct ashmem_range 都是从slab 中分配内存;
-
misc_register() 函数注册 ashmem 设备;
-
register_shrinker() 注册回收函数,当内存不足时系统会通过shrink_slab() 函数轮训系统中所有调用 register_shrinker() 注册的回收函数;
1.3 ashmem_open()
cpp
static int ashmem_open(struct inode *inode, struct file *file)
{
struct ashmem_area *asma;
int ret;
ret = generic_file_open(inode, file);
if (ret)
return ret;
asma = kmem_cache_zalloc(ashmem_area_cachep, GFP_KERNEL);
if (!asma)
return -ENOMEM;
INIT_LIST_HEAD(&asma->unpinned_list);
memcpy(asma->name, ASHMEM_NAME_PREFIX, ASHMEM_NAME_PREFIX_LEN);
asma->prot_mask = PROT_MASK;
file->private_data = asma;
return 0;
}
用户通过 open("/dev/ashmem") 函数进而触发该函数,主要目的是创建一个 ashmem_area 并初始化。
注意三点:
-
ashmem_area 名称初始化就有了,默认是 "/dev/ashmem/";
-
默认ashmem_area 对应的共享文件是 PROT_MASK 权限;
-
ashmem_area 会被记录到 file->private_data 中;
1.4 ashmem_release()
cpp
static int ashmem_release(struct inode *ignored, struct file *file)
{
struct ashmem_area *asma = file->private_data;
struct ashmem_range *range, *next;
mutex_lock(&ashmem_mutex);
list_for_each_entry_safe(range, next, &asma->unpinned_list, unpinned)
range_del(range);
mutex_unlock(&ashmem_mutex);
if (asma->file)
fput(asma->file);
kmem_cache_free(ashmem_area_cachep, asma);
return 0;
}
当最后一个打开设备的用户执行 close() 系统调用时,内核会调用驱动设定的 fops->release() 函数。对应 ashmem 驱动来说就是调用 ashmem_release() 函数。
主要做了三件事情:
-
遍历所有的 unpinned_list,将其中的 range 内存都释放掉;
-
fput() 将文件的计数减 1,如果发现 f_count为0了,那么将其对应的struct file结构删除。与其对应的是 fget() 函数,用以获取 struct file 结构并将 f_count 计数加 1;
-
释放ashmem_area 内存;
1.5 ashmem_mmap()
cpp
static int ashmem_mmap(struct file *file, struct vm_area_struct *vma)
{
static struct file_operations vmfile_fops;
struct ashmem_area *asma = file->private_data;
int ret = 0;
mutex_lock(&ashmem_mutex);
/* user needs to SET_SIZE before mapping */
//用户在调用mmap进行映射之前需要先调用 set_size()函数配置大小,否则无法mmap
if (!asma->size) {
ret = -EINVAL;
goto out;
}
/* requested mapping size larger than object size */
//要求ashmem_area的size大于请求mapping的大小
if (vma->vm_end - vma->vm_start > PAGE_ALIGN(asma->size)) {
ret = -EINVAL;
goto out;
}
/* requested protection bits must match our allowed protection mask */
//检测需要映射的vma的保护权限是否超过了ashmem_area的权限
if ((vma->vm_flags & ~calc_vm_prot_bits(asma->prot_mask, 0)) &
calc_vm_prot_bits(PROT_MASK, 0)) {
ret = -EPERM;
goto out;
}
vma->vm_flags &= ~calc_vm_may_flags(~asma->prot_mask);
//这是ashmem_mmap()函数的核心处理,创建一个临时文件
if (!asma->file) {
char *name = ASHMEM_NAME_DEF;
struct file *vmfile;
struct inode *inode;
//临时文件名默认/dev/ashmem,但如果asma->name已经配置好,则使用asma->name
if (asma->name[ASHMEM_NAME_PREFIX_LEN] != '\0')
name = asma->name;
/* ... and allocate the backing shmem file */
//利用linux原生的shmem,在tmpfs中创建一个临时文件,该文件只对内核态可见,用户态不可见
vmfile = shmem_file_setup(name, asma->size, vma->vm_flags);
if (IS_ERR(vmfile)) {
ret = PTR_ERR(vmfile);
goto out;
}
//临时文件初始化
vmfile->f_mode |= FMODE_LSEEK;
inode = file_inode(vmfile);
lockdep_set_class(&inode->i_rwsem, &backing_shmem_inode_class);
//更新asma->file,此后的共享内存对应临时文件
asma->file = vmfile;
//更新临时文件的fops,覆盖掉mmap函数,临时文件mmap不再做任何事情
//并且,要覆盖掉get_unmapped_area接口,获取进程没有映射的内存空间
//vmfile_fops为staic,只需要更新一次
if (!vmfile_fops.mmap) {
vmfile_fops = *vmfile->f_op; //拿到vmfile的 fops,准备更新
vmfile_fops.mmap = ashmem_vmfile_mmap;
vmfile_fops.get_unmapped_area =
ashmem_vmfile_get_unmapped_area;
}
//每次创建的临时文件的fops都使用vmfile_fops
vmfile->f_op = &vmfile_fops;
}
get_file(asma->file);
//如果该vma已经处于共享状态,调用shmem_zero_setup()配置vma->vm_ops为shmem_vm_ops
//vma->vm_file在后面会更新掉
if (vma->vm_flags & VM_SHARED) {
ret = shmem_zero_setup(vma);
if (ret) {
fput(asma->file);
goto out;
}
} else {
vma_set_anonymous(vma);
}
//vma->vm_file将指定到asma->file,即指定到创建好的临时vmfile
if (vma->vm_file)
fput(vma->vm_file);
vma->vm_file = asma->file;
out:
mutex_unlock(&ashmem_mutex);
return ret;
}
当第一次mmap 时,会通过shmem_file_setup() 在tmpfs 文件系统中创建一个临时文件(也许只是内核中的一个inode 节点)。该临时文件 vmfile 创建好之后会覆盖 asma->file,至此ashmem 与该vmfile 对应,ashmem 机制真正使用的map 对象就是该临时文件vmfile。
1.6 ashmem_ioctl()
涉及的命令有:
cpp
drivers/staging/android/uapi/ashmem.h
#define __ASHMEMIOC 0x77
#define ASHMEM_SET_NAME _IOW(__ASHMEMIOC, 1, char[ASHMEM_NAME_LEN])
#define ASHMEM_GET_NAME _IOR(__ASHMEMIOC, 2, char[ASHMEM_NAME_LEN])
#define ASHMEM_SET_SIZE _IOW(__ASHMEMIOC, 3, size_t)
#define ASHMEM_GET_SIZE _IO(__ASHMEMIOC, 4)
#define ASHMEM_SET_PROT_MASK _IOW(__ASHMEMIOC, 5, unsigned long)
#define ASHMEM_GET_PROT_MASK _IO(__ASHMEMIOC, 6)
#define ASHMEM_PIN _IOW(__ASHMEMIOC, 7, struct ashmem_pin)
#define ASHMEM_UNPIN _IOW(__ASHMEMIOC, 8, struct ashmem_pin)
#define ASHMEM_GET_PIN_STATUS _IO(__ASHMEMIOC, 9)
#define ASHMEM_PURGE_ALL_CACHES _IO(__ASHMEMIOC, 10)
具体实现可以查看源码,主要来看下 pin 和 unpin:
cpp
static long ashmem_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct ashmem_area *asma = file->private_data;
long ret = -ENOTTY;
switch (cmd) {
...
case ASHMEM_PIN:
case ASHMEM_UNPIN:
case ASHMEM_GET_PIN_STATUS:
ret = ashmem_pin_unpin(asma, cmd, (void __user *)arg);
break;
}
return ret;
}
1.7 ashmem_pin_unpin()
cpp
static int ashmem_pin_unpin(struct ashmem_area *asma, unsigned long cmd,
void __user *p)
{
struct ashmem_pin pin;
size_t pgstart, pgend;
int ret = -EINVAL;
struct ashmem_range *range = NULL;
//用户等调用pin/unpin时,会传递ashmem_pin类型的参数
if (copy_from_user(&pin, p, sizeof(pin)))
return -EFAULT;
//当调用pin/unpin接口时,创建一个ashmem_range对象
if (cmd == ASHMEM_PIN || cmd == ASHMEM_UNPIN) {
range = kmem_cache_zalloc(ashmem_range_cachep, GFP_KERNEL);
if (!range)
return -ENOMEM;
}
mutex_lock(&ashmem_mutex);
//等待回收的完成
wait_event(ashmem_shrink_wait, !atomic_read(&ashmem_shrink_inflight));
//如果临时文件vmfile还没有创建好,无法进行pin/unpin操作
if (!asma->file)
goto out_unlock;
//pin.len的值可以设为0,即从pin.offset之后的全部内存
if (!pin.len)
pin.len = PAGE_ALIGN(asma->size) - pin.offset;
//偏移地址和大小要求页对齐
if ((pin.offset | pin.len) & ~PAGE_MASK)
goto out_unlock;
//需要操作内存末尾地址不能超出
if (((__u32)-1) - pin.offset < pin.len)
goto out_unlock;
//需要操作内存末尾地址不能超过ashmem_area指定的size
if (PAGE_ALIGN(asma->size) < pin.offset + pin.len)
goto out_unlock;
//操作区间需要页对齐
pgstart = pin.offset / PAGE_SIZE;
pgend = pgstart + (pin.len / PAGE_SIZE) - 1;
switch (cmd) {
case ASHMEM_PIN:
ret = ashmem_pin(asma, pgstart, pgend, &range);
break;
case ASHMEM_UNPIN:
ret = ashmem_unpin(asma, pgstart, pgend, &range);
break;
case ASHMEM_GET_PIN_STATUS:
ret = ashmem_get_pin_status(asma, pgstart, pgend);
break;
}
out_unlock:
mutex_unlock(&ashmem_mutex);
if (range)
kmem_cache_free(ashmem_range_cachep, range);
return ret;
}
pin/unpin 对于 offset 和 len 有一定的要求:
-
len 可以为0,这样内存空间 ashmem_area 从 offset 之后的所有空间;
-
offset和len 需要页对齐;
-
offset + len 不能超过 32位无符号数;
-
offset + len 不能超过 ashmem_area 空间;
ashmem 机制中,正在使用的 ashmem_range 需要 pin,不被使用的 ashmem_range 需要 unpin。unpin 的ashmem_range 会添加到 asma->unpinned_list 链表中,且该 ashmem_range 会被添加到ashmem_lru_list 中。
pin 和 unpin 只是改变相关状态标记,并不会改变已经 mapping 的地址空间,因此,用户可以在unpin 后重新pin 住内存块。
注意:
函数的返回值为实际处理函数的范围值,有两种情况:ASHMEM_NOT_PURGED 和ASHMEM_WAS_PURGED。ASHMEM_NOT_PURGED 表示该内存块物理内存没有被回收。
1.7.1 ashmem_unpin()
cpp
static int ashmem_unpin(struct ashmem_area *asma, size_t pgstart, size_t pgend,
struct ashmem_range **new_range)
{
struct ashmem_range *range, *next;
unsigned int purged = ASHMEM_NOT_PURGED;
restart:
list_for_each_entry_safe(range, next, &asma->unpinned_list, unpinned) {
/* short circuit: this is our insertion point */
if (range_before_page(range, pgstart))
break;
/*
* The user can ask us to unpin pages that are already entirely
* or partially pinned. We handle those two cases here.
*/
if (page_range_subsumed_by_range(range, pgstart, pgend))
return 0;
if (page_range_in_range(range, pgstart, pgend)) {
pgstart = min(range->pgstart, pgstart);
pgend = max(range->pgend, pgend);
purged |= range->purged;
range_del(range);
goto restart;
}
}
range_alloc(asma, range, purged, pgstart, pgend, new_range);
return 0;
}
如 struct ashmem_area 中所述,一块匿名共享内存中的所有解锁内存块,都是按照地址从大到小的顺序保存在 unpinned_list 中。
该函数的目的是将该内存块(ashmem_range) 添加到 asma->unpinned_list 和 ashmem_lru_list 链表中。
当内存块插入到 asma->unpinned_list 时会考虑内存合并,有如下几种处理方式(绿色是old,红色是new):
-
A:新添加的内存块地址大于最大range,将直接添加到asma->unpinned_list 头部;
-
B:新添加的内存块完全处于某range 中,不做任何处理,原先的range 已经unpinned 了;
-
C、D、E:三种情况是合并的情况,都会将原先range 与新的range 进行合并,并将原先range删掉,保留新的range;
1.7.2 ashmem_pin()
cpp
static int ashmem_pin(struct ashmem_area *asma, size_t pgstart, size_t pgend,
struct ashmem_range **new_range)
{
struct ashmem_range *range, *next;
int ret = ASHMEM_NOT_PURGED;
list_for_each_entry_safe(range, next, &asma->unpinned_list, unpinned) {
/* moved past last applicable page; we can short circuit */
if (range_before_page(range, pgstart))
break;
if (page_range_in_range(range, pgstart, pgend)) {
ret |= range->purged;
/* Case #1: Easy. Just nuke the whole thing. */
if (page_range_subsumes_range(range, pgstart, pgend)) {
range_del(range);
continue;
}
/* Case #2: We overlap from the start, so adjust it */
if (range->pgstart >= pgstart) {
range_shrink(range, pgend + 1, range->pgend);
continue;
}
/* Case #3: We overlap from the rear, so adjust it */
if (range->pgend <= pgend) {
range_shrink(range, range->pgstart,
pgstart - 1);
continue;
}
/*
* Case #4: We eat a chunk out of the middle. A bit
* more complicated, we allocate a new range for the
* second half and adjust the first chunk's endpoint.
*/
range_alloc(asma, range, range->purged,
pgend + 1, range->pgend, new_range);
range_shrink(range, range->pgstart, pgstart - 1);
break;
}
}
return ret;
}
ashmem机制中的一个内存块,最开始一定处于锁定状态,被解锁之后会被放入到 asma->unpinned_list 中。该函数的目的是遍历该 unpinned_list,寻找和指定的pgstart和pgend 相交或包含的内存块,对其进行重新锁定。
同ashmem_unpinned(),仍然将处理方式分为如下几种(绿色是old,红色是new):
A:需要pinned 的内存块不在 asma->unpinned_list 中,那不用过多考虑;
B:需要pinned 的内存块完全包含range中,继续轮询确认是否与其他range有交叉;
C、D:并不会删除range 后再重新分配,而是直接修改 range->pgstart 和 range->pgend,并相应的减少 LRU list中的页面数量;
E:这种情况比较特殊,会将range 切成两块,[range->pgstart, pgstart) 算在原来的range 中,(pgend, range->pgend] 算到new range中;
2. ashmem 在进程间共享的原理
假设进程 A 调用 open() 函数打开 /dev/ashmem,这样会得到一个匿名共享内存的一个struct file 和文件描述符,假如是 file1 和 fd1. 然后进程 B 通过 Binder 进程间通信机制请求进程 A 将fd1 返回给它,但 fd1 只在进程 A 中有效,因此 Binder 驱动程序在进程B 中创建一个新的描述符 fd2,使得fd2 也指向 file1,最后再将 fd2 返回给进程 B。这样描述符 fd1 和 fd2 就指向同一个文件结构体 file1,即指向同一个匿名共享内存。
3. ashmem 注意点
-
ashmem 机制相当于Linux 共享内存的扩展,扩展后使用更加便捷;
-
Android 中通过 binder 机制将 ashmem 的 fd 进行传递,增加安全性,同时避免了 buffer 拷贝,效率提升;
-
ashmem 不会占用Dalvik heap 和 Native heap,所以不会导致 OOM;
-
ashmem 占用空间的计算,是计算到第一个创建它的进程中,其他进程不会将 ashmem 计算在内;
参考:
https://www.kancloud.cn/alex_wsc/androids/477718
https://blog.csdn.net/vviccc/article/details/123237169
https://blog.csdn.net/run068/article/details/121695036