public MemoryFile(String name, int length) throws IOException {
mLength = length;
mFD = native_open(name, length);
if (length > 0) {
mAddress = native_mmap(mFD, length, PROT_READ | PROT_WRITE);
} else {
mAddress = 0;
}
}
可以看到 Java层只是简单的封装,具体实现在native层 ,首先是通过native_open调用ashmem_create_region创建共享内存,
static jobject android_os_MemoryFile_open(JNIEnv* env, jobject clazz, jstring name, jint length)
{
const char* namestr = (name ? env->GetStringUTFChars(name, NULL) : NULL);
int result = ashmem_create_region(namestr, length);
if (name)
env->ReleaseStringUTFChars(name, namestr);
if (result < 0) {
jniThrowException(env, “java/io/IOException”, “ashmem_create_region failed”);
return NULL;
}
return jniCreateFileDescriptor(env, result);
}
接着通过native_mmap调用mmap将共享内存映射到当前进程空间,之后Java层就能利用FileDescriptor,像访问文件一样访问共享内存。
static jint android_os_MemoryFile_mmap(JNIEnv* env, jobject clazz, jobject fileDescriptor,
jint length, jint prot)
{
int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);
jint result = (jint)mmap(NULL, length, prot, MAP_SHARED, fd, 0);
if (!result)
jniThrowException(env, “java/io/IOException”, “mmap failed”);
return result;
}
ashmem_create_region这个函数是如何向Linux申请一块共享内存的呢?
int ashmem_create_region(const char *name, size_t size)
{
int fd, ret;
fd = open(ASHMEM_DEVICE, O_RDWR);
if (fd < 0)
return fd;
if (name) {
char buf[ASHMEM_NAME_LEN];
strlcpy(buf, name, sizeof(buf));
ret = ioctl(fd, ASHMEM_SET_NAME, buf);
if (ret < 0)
goto error;
}
ret = ioctl(fd, ASHMEM_SET_SIZE, size);
if (ret < 0)
goto error;
return fd;
error:
close(fd);
return ret;
}
ASHMEM_DEVICE其实就是抽象的共享内存设备,它是一个杂项设备(字符设备的一种),在驱动加载之后,就会在/dev下穿件ashem文件,之后用户就能够访问该设备文件,同一般的设备文件不同,它仅仅是通过内存抽象的,同普通的磁盘设备文件、串行端口字段设备文件不一样:
#define ASHMEM_DEVICE “/dev/ashmem”
static struct miscdevice ashmem_misc = {
.minor = MISC_DYNAMIC_MINOR,
.name = “ashmem”,
.fops = &ashmem_fops,
};
接着进入驱动看一下,如何申请共享内存,open函数很普通,主要是创建一个ashmem_area对象
static int ashmem_open(struct inode *inode, struct file *file)
{
struct ashmem_area *asma;
int ret;
ret = nonseekable_open(inode, file);
if (unlikely(ret))
return ret;
asma = kmem_cache_zalloc(ashmem_area_cachep, GFP_KERNEL);
if (unlikely(!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;
}
接着利用ashmem_ioctl设置共享内存的大小,
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_SET_SIZE:
ret = -EINVAL;
if (!asma->file) {
ret = 0;
asma->size = (size_t) arg;
}
break;
…
}
return ret;
}
可以看到,其实并未真正的分配内存,这也符合Linux的风格,只有等到真正的使用的时候,才会通过缺页中断分配内存,接着mmap函数,它会分配内存吗?
static int ashmem_mmap(struct file *file, struct vm_area_struct *vma)
{
struct ashmem_area *asma = file->private_data;
int ret = 0;
mutex_lock(&ashmem_mutex);
…
if (!asma->file) {
char *name = ASHMEM_NAME_DEF;
struct file *vmfile;
if (asma->name[ASHMEM_NAME_PREFIX_LEN] != ‘\0’)
name = asma->name;
// 这里创建的临时文件其实是备份用的临时文件,之类的临时文件有文章说只对内核态可见,用户态不可见,我们也没有办法通过命令查询到 ,可以看做是个隐藏文件,用户空间看不到!!
vmfile = shmem_file_setup(name, asma->size, vma->vm_flags);
asma->file = vmfile;
}
get_file(asma->file);
if (vma->vm_flags & VM_SHARED)
shmem_set_file(vma, asma->file);
else {
if (vma->vm_file)
fput(vma->vm_file);
vma->vm_file = asma->file;
}
vma->vm_flags |= VM_CAN_NONLINEAR;
out:
mutex_unlock(&ashmem_mutex);
return ret;
}
其实这里就复用了Linux的共享内存机制,虽然说是匿名共享内存,但底层其实还是给共享内存设置了名称(前缀ASHMEM_NAME_PREFIX+名字),如果名字未设置,那就默认使用ASHMEM_NAME_PREFIX作为名称。不过,在这里没直接看到内存分配的函数。但是,有两个函数shmem_file_setup与shmem_set_file很重要,也是共享内存比较不好理解的地方,shmem_file_setup是原生linux的共享内存机制,不过Android也修改Linux共享内存的驱动代码,匿名共享内存其实就是在Linux共享内存的基础上做了改进,
struct file *shmem_file_setup(char *name, loff_t size, unsigned long flags)
{
int error;
struct file *file;
struct inode *inode;
struct dentry *dentry, *root;
struct qstr this;
error = -ENOMEM;
this.name = name;
this.len = strlen(name);
this.hash = 0; /* will go */
root = shm_mnt->mnt_root;
dentry = d_alloc(root, &this);//分配dentry cat/proc/pid/maps可以查到
error = -ENFILE;
file = get_empty_filp(); //分配file
error = -ENOSPC;
inode = shmem_get_inode(root->d_sb, S_IFREG | S_IRWXUGO, 0, flags);//分配inode,分配成功就好比建立了文件,也许并未存在真实文件映射
d_instantiate(dentry, inode);//绑定
inode->i_size = size;
inode->i_nlink = 0; /* It is unlinked */
// 文件操作符,这里似乎真的是不在内存里面创建什么东西???
init_file(file, shm_mnt, dentry, FMODE_WRITE | FMODE_READ,
&shmem_file_operations);//绑定,并指定该文件操作指针为shmem_file_operations
…
}
通过shmem_file_setup在tmpfs临时文件系统中创建一个临时文件(也许只是内核中的一个inode节点),该文件与Ashmem驱动程序创建的匿名共享内存对应,不过用户态并不能看到该临时文件,之后就能够使用该临时文件了,注意共享内存机制真正使用map的对象其实是这个临时文件,而不是ashmem设备文件,这里之所以是一次mmap,主要是通过vma->vm_file = asma->file完成map对象的替换,当映射的内存引起缺页中断的时候,就会调用shmem_file_setup创建的对象的函数,而不是ashmem的,看下临时文件的对应的hook函数,
void shmem_set_file(struct vm_area_struct *vma, struct file *file)
{
if (vma->vm_file)
fput(vma->vm_file);
vma->vm_file = file;
vma->vm_ops = &shmem_vm_ops;
}
到这里回到之前的MemoryFile,看一下写操作:
public void writeBytes(byte[] buffer, int srcOffset, int destOffset, int count)
throws IOException {
if (isDeactivated()) {
throw new IOException(“Can’t write to deactivated memory file.”);
}
if (srcOffset < 0 || srcOffset > buffer.length || count < 0
|| count > buffer.length - srcOffset
|| destOffset < 0 || destOffset > mLength
|| count > mLength - destOffset) {
throw new IndexOutOfBoundsException();
}
native_write(mFD, mAddress, buffer, srcOffset, destOffset, count, mAllowPurging);
}
进入native代码
static jint android_os_MemoryFile_write(JNIEnv* env, jobject clazz,
jobject fileDescriptor, jint address, jbyteArray buffer, jint srcOffset, jint destOffset,
jint count, jboolean unpinned)
{
int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);
if (unpinned && ashmem_pin_region(fd, 0, 0) == ASHMEM_WAS_PURGED) {
ashmem_unpin_region(fd, 0, 0);
return -1;
}
env->GetByteArrayRegion(buffer, srcOffset, count, (jbyte *)address + destOffset);
if (unpinned) {
ashmem_unpin_region(fd, 0, 0);
}
return count;
}
在内核中,一块内存对应的数据结构是ashmem_area:
struct ashmem_area {
char name[ASHMEM_FULL_NAME_LEN];/* optional name for /proc/pid/maps */
struct list_head unpinned_list; /* list of all ashmem areas */
struct file file; / the shmem-based backing file */
size_t size; /* size of the mapping, in bytes */
unsigned long prot_mask; /* allowed prot bits, as vm_flags */
};
当使用Ashmem分配了一块内存,部分不被使用时,就可以将这块内存unpin掉,内核可以将unpin对应的物理页面回收,回收后的内存还可以再次被获得(通过缺页handler),因为unpin操作并不会改变已经mmap的地址空间,不过,MemoryFile只会操作整个共享内存,而不会分块访问,所以pin与unpin对于它没多大意义,可以看做整个区域都是pin或者unpin的,首次通过env->GetByteArrayRegion访问会引发缺页中断,进而调用tmpfs 文件的相应操作,分配物理页,在Android现在的内核中,缺页中断对应的vm_operations_struct中的函数是fault,在共享内存实现中,对应的是shmem_fault如下,
static struct vm_operations_struct shmem_vm_ops = {
.fault = shmem_fault,
#ifdef CONFIG_NUMA
.set_policy = shmem_set_policy,
.get_policy = shmem_get_policy,
#endif
};
当mmap的tmpfs文件引发缺页中断时, 就会调用shmem_fault函数,
static int shmem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
{
struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
int error;
int ret;
if (((loff_t)vmf->pgoff << PAGE_CACHE_SHIFT) >= i_size_read(inode))
return VM_FAULT_SIGBUS;
error = shmem_getpage(inode, vmf->pgoff, &vmf->page, SGP_CACHE, &ret);
if (error)
return ((error == -ENOMEM) ? VM_FAULT_OOM : VM_FAULT_SIGBUS);
return ret | VM_FAULT_LOCKED;
}
到这里,就可以看到会调用shmem_getpage函数分配真实的物理页,具体的分配策略比较复杂,不在分析。
Android匿名共享内存的pin与unpin
=======================
pin本身的意思是压住,定住,ashmem_pin_region和ashmem_unpin_region这两个函数从字面上来说,就是用来对匿名共享内存锁定和解锁,标识哪些内存正在使用需要锁定,哪些内存是不使用的,这样,ashmem驱动程序可以一定程度上辅助内存管理,提供一定的内存优化能力。匿名共享内存创建之初时,所有的内存都是pinned状态,只有用户主动申请,才会unpin一块内存,只有对于unpinned状态的内存块,用户才可以重新pin。现在仔细梳理一下驱动,看下pin与unpin的实现
static int __init ashmem_init(void)
{
int ret;
ashmem_area_cachep = kmem_cache_create(“ashmem_area_cache”,
sizeof(struct ashmem_area),
0, 0, NULL);
…
ashmem_range_cachep = kmem_cache_create(“ashmem_range_cache”,
sizeof(struct ashmem_range),
0, 0, NULL);
…
ret = misc_register(&ashmem_misc);
…
register_shrinker(&ashmem_shrinker);
return 0;
}
打开ashem的时候 ,会利用ashmem_area_cachep告诉缓存新建ashmem_area对象,并初始化unpinned_list,开始肯定为null
static int ashmem_open(struct inode *inode, struct file *file)
{
struct ashmem_area *asma;
int ret;
ret = nonseekable_open(inode, file);
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Android工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录大纲截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且后续会持续更新
如果你觉得这些内容对你有帮助,可以添加V获取:vip204888 (备注Android)
文末
我总结了一些Android核心知识点,以及一些最新的大厂面试题、知识脑图和视频资料解析。
以后的路也希望我们能一起走下去。(谢谢大家一直以来的支持)
部分资料一览:
- 330页PDF Android学习核心笔记(内含8大板块)
-
Android学习的系统对应视频
-
Android进阶的系统对应学习资料
- Android BAT大厂面试题(有解析)
]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录大纲截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且后续会持续更新
如果你觉得这些内容对你有帮助,可以添加V获取:vip204888 (备注Android)
[外链图片转存中…(img-oIGzyCSy-1711629365630)]
文末
我总结了一些Android核心知识点,以及一些最新的大厂面试题、知识脑图和视频资料解析。
以后的路也希望我们能一起走下去。(谢谢大家一直以来的支持)
部分资料一览:
- 330页PDF Android学习核心笔记(内含8大板块)
[外链图片转存中…(img-BjNSmIwg-1711629365631)]
[外链图片转存中…(img-RbgNL38I-1711629365631)]
-
Android学习的系统对应视频
-
Android进阶的系统对应学习资料
[外链图片转存中…(img-bgmTa7Am-1711629365631)]
- Android BAT大厂面试题(有解析)
[外链图片转存中…(img-hJIDBad1-1711629365632)]