Android系统匿名共享内存Ashmem(Anonymous Shared Memory)驱动程序源代码分析(上)

在上一文章Android系统匿名共享内存Ashmem(Anonymous Shared Memory)简要介绍和学习计划中,我们简要介绍了Android系统的匿名共享内存机制,其中,简要提到了它具有辅助内存管理系统来有效地管理内存的特点,但是没有进一步去了解它是如何实现的。在本文中,我们将通过分析Android系统的匿名共享内存Ashmem驱动程序的源代码,来深入了解它是如何辅助内存管理系

        Android系统的匿名共享内存Ashmem机制并没有自立山头,从头搞一套自己的共享内存机制,而是建立在Linux内核实现的共享内存的基础上的。与此同时,它又向Linux内存管理系统的内存回收算法注册接口,告诉Linux内存管理系统它的某些内存块不再使用了,可以被回收了,不过,这些不再使用的内存需要由它的使用者来告诉Ashmem驱动程序。通过这种用户-Ashmem驱动程序-内存管理系统三者的紧密合作,实现有效的内存管理机制,适合移动设备小内存的特点。

        Android系统的匿名共享内存Ashmem驱动程序利用了Linux的共享内存子系统导出的接口来实现自己的功能,因此,它的实现非常小巧,总共代码不到700行。虽然代码很少,但是这里不打算机械式地一行一行地阅读和分析Ashmem驱动程序的源代码,而是通过使用情景来分析,这样可以帮助我们清晰地理解它的实现原理。我们这里所说的使用情景,将从Android系统的应用程序框架层提供的匿名共享内存接口开始,经过系统运行时库层,最终到达驱动程序层,通过这样一个完整的过程来理解Android系统的匿名共享内存Ashmem机制。这里,我们将从上一篇文章Android系统匿名共享内存Ashmem(Anonymous Shared Memory)简要介绍和学习计划介绍的Android应用程序框架层提供MemoryFile接口开始,分别介绍Android系统匿名共享内存的创建(open)、映射(mmap)、读写(read/write)以及锁定和解锁(pin/unpin)四个使用情景。

        在进入到这个四个使用情景前,我们先来看一下Ashmem驱动程序模块的初始化函数,看看它给用户空间暴露了什么接口,即它创建了什么样的设备文件,以及提供了什么函数来操作这个设备文件。Ashmem驱动程序实现在kernel/common/mm/ashmem.c文件中,它的模块初始化函数定义为ashmem_init:


  1. static struct file_operations ashmem_fops = {  
  2.     .owner = THIS_MODULE,  
  3.     .open = ashmem_open,  
  4.     .release = ashmem_release,  
  5.     .mmap = ashmem_mmap,  
  6.     .unlocked_ioctl = ashmem_ioctl,  
  7.     .compat_ioctl = ashmem_ioctl,  
  8. };  
  9.  
  10. static struct miscdevice ashmem_misc = {  
  11.     .minor = MISC_DYNAMIC_MINOR,  
  12.     .name = "ashmem",  
  13.     .fops = &ashmem_fops,  
  14. };  
  15.  
  16. static int __init ashmem_init(void)  
  17. {  
  18.     int ret;  
  19.  
  20.     ......  
  21.  
  22.     ret = misc_register(&ashmem_misc);  
  23.     if (unlikely(ret)) {  
  24.         printk(KERN_ERR "ashmem: failed to register misc device!\n");  
  25.         return ret;  
  26.     }  
  27.  
  28.     ......  
  29.  
  30.     return 0;  

 

       这里,我们可以看到,Ahshmem驱动程序在加载时,会创建一个/dev/ashmem的设备文件,这是一个misc类型的设备。注册misc设备是通过misc_register函数进行的,关于这个函数的详细实现,可以参考前面Android日志系统驱动程序Logger源代码分析一文,调用这个函数成功后,就会在/dev目录下生成一个ashmem设备文件了。同时,我们还可以看到,这个设备文件提供了open、mmap、release和ioctl四种操作。为什么没有read和write操作呢?这是因为读写共享内存的方法是通过内存映射地址来进行的,即通过mmap系统调用把这个设备文件映射到进程地址空间中,然后就直接对内存进行读写了,不需要通过read 和write文件操作,后面我们将会具体分析是如何实现的。
       有了这个基础之后,下面我们就分四个部分来分别介绍匿名共享内存的创建(open)、映射(mmap)、读写(read/write)以及锁定和解锁(pin/unpin)使用情景。

 

        一. 匿名共享内存的创建操作

        在Android应用程序框架层提供MemoryFile类的构造函数中,进行了匿名共享内存的创建操作,我们先来看一下这个构造函数的实现,它位于frameworks/base/core/java/android/os/MemoryFile.java文件中:


  1. public class MemoryFile  
  2. {  
  3.     ......  
  4.  
  5.     private static native FileDescriptor native_open(String name, int length) throws IOException;  
  6.       
  7.     ......  
  8.  
  9.     private FileDescriptor mFD;        // ashmem file descriptor  
  10.     ......  
  11.     private int mLength;    // total length of our ashmem region  
  12.       
  13.     ......  
  14.  
  15.     /**  
  16.     * Allocates a new ashmem region. The region is initially not purgable.  
  17.     *  
  18.     * @param name optional name for the file (can be null).  
  19.     * @param length of the memory file in bytes.  
  20.     * @throws IOException if the memory file could not be created.  
  21.     */ 
  22.     public MemoryFile(String name, int length) throws IOException {  
  23.         mLength = length;  
  24.         mFD = native_open(name, length);  
  25.         ......  
  26.     }  
  27.  
  28.     ......  

 

        这里我们看到,这个构造函数最终是通过JNI方法native_open来创建匿名内存共享文件。这个JNI方法native_open实现在frameworks/base/core/jni/adroid_os_MemoryFile.cpp文件中:


  1. static jobject android_os_MemoryFile_open(JNIEnv* env, jobject clazz, jstring name, jint length)  
  2. {  
  3.     const char* namestr = (name ? env->GetStringUTFChars(nameNULL) : NULL);  
  4.  
  5.     int result = ashmem_create_region(namestr, length);  
  6.  
  7.     if (name)  
  8.         env->ReleaseStringUTFChars(name, namestr);  
  9.  
  10.     if (result < 0) {  
  11.         jniThrowException(env, "java/io/IOException""ashmem_create_region failed");  
  12.         return NULL;  
  13.     }  
  14.  
  15.     return jniCreateFileDescriptor(env, result);  

        这个函数又通过运行时库提供的接口ashmem_create_region来创建匿名共享内存,这个函数实现在system/core/libcutils/ashmem-dev.c文件中:


  1. /*  
  2.  * ashmem_create_region - creates a new ashmem region and returns the file  
  3.  * descriptor, or <0 on error  
  4.  *  
  5.  * `nameis an optional label to give the region (visible in /proc/pid/maps)  
  6.  * `sizeis the size of the region, in page-aligned bytes  
  7.  */  
  8. int ashmem_create_region(const char *name, size_t size)  
  9. {  
  10.     int fd, ret;  
  11.  
  12.     fd = open(ASHMEM_DEVICE, O_RDWR);  
  13.     if (fd < 0)  
  14.         return fd;  
  15.  
  16.     if (name) {  
  17.         char buf[ASHMEM_NAME_LEN];  
  18.  
  19.         strlcpy(buf, name, sizeof(buf));  
  20.         ret = ioctl(fd, ASHMEM_SET_NAME, buf);  
  21.         if (ret < 0)  
  22.             goto error;  
  23.     }  
  24.  
  25.     ret = ioctl(fd, ASHMEM_SET_SIZE, size);  
  26.     if (ret < 0)  
  27.         goto error;  
  28.  
  29.     return fd;  
  30.  
  31. error:  
  32.     close(fd);  
  33.     return ret;  

        这里,一共通过执行三个文件操作系统调用来和Ashmem驱动程序进行交互,分虽是一个open和两个ioctl操作,前者是打开设备文件ASHMEM_DEVICE,后者分别是设置匿名共享内存的名称和大小。

        在介绍这三个文件操作之前,我们先来了解一下Ashmem驱动程序的一个相关数据结构struct ashmem_area,这个数据结构就是用来表示一块共享内存的,它定义在kernel/common/mm/ashmem.c文件中:


  1. /*  
  2.  * ashmem_area - anonymous shared memory area  
  3.  * Lifecycle: From our parent file's open() until its release()  
  4.  * Locking: Protected by `ashmem_mutex'  
  5.  * Big Note: Mappings do NOT pin this structure; it dies on close()  
  6.  */  
  7. struct ashmem_area {  
  8.     char name[ASHMEM_FULL_NAME_LEN];/* optional name for /proc/pid/maps */  
  9.     struct list_head unpinned_list; /* list of all ashmem areas */  
  10.     struct file *file;      /* the shmem-based backing file */  
  11.     size_t size;            /* size of the mapping, in bytes */  
  12.     unsigned long prot_mask;    /* allowed prot bits, as vm_flags */  
  13. }; 

        域name表示这块共享内存的名字,这个名字会显示/proc/<pid>/maps文件中,<pid>表示打开这个共享内存文件的进程ID;域unpinned_list是一个列表头,它把这块共享内存中所有被解锁的内存块连接在一起,下面我们讲内存块的锁定和解锁操作时会看到它的用法;域file表示这个共享内存在临时文件系统tmpfs中对应的文件,在内核决定要把这块共享内存对应的物理页面回收时,就会把它的内容交换到这个临时文件中去;域size表示这块共享内存的大小;域prot_mask表示这块共享内存的访问保护位。

 

        在Ashmem驱动程中,所有的ashmem_area实例都是从自定义的一个slab缓冲区创建的。这个slab缓冲区是在驱动程序模块初始化函数创建的,我们来看一个这个初始化函数的相关实现:


  1. static int __init ashmem_init(void)  
  2. {  
  3.     int ret;  
  4.  
  5.     ashmem_area_cachep = kmem_cache_create("ashmem_area_cache",  
  6.         sizeof(struct ashmem_area),  
  7.         0, 0, NULL);  
  8.     if (unlikely(!ashmem_area_cachep)) {  
  9.         printk(KERN_ERR "ashmem: failed to create slab cache\n");  
  10.         return -ENOMEM;  
  11.     }  
  12.  
  13.     ......  
  14.  
  15.     return 0;  

        全局变量定义在文件开头的地方:


  1. static struct kmem_cache *ashmem_area_cachep __read_mostly; 

       它的类型是struct kmem_cache,表示这是一个slab缓冲区,由内核中的内存管理系统进行管理。

 

        这里就是通过kmem_cache_create函数来创建一个名为"ashmem_area_cache"、对象大小为sizeof(struct ashmem_area)的缓冲区了。缓冲区创建了以后,就可以每次从它分配一个struct ashmem_area对象了。关于Linux内核的slab缓冲区的相关知识,可以参考前面Android学习启动篇一文中提到的一本参考书籍《Understanding the Linux Kernel》的第八章Memory Managerment。
 

        有了这些基础知识后,我们回到前面的ashmem_create_region函数中。

        首先是执行打开文件的操作:


  1. fd = open(ASHMEM_DEVICE, O_RDWR); 

        ASHMEM_DEVICE是一个宏,定义为:


  1. #define ASHMEM_DEVICE   "/dev/ashmem" 

         这里就是匿名共享内存设备文件/dev/ashmem了。

 

        从上面的描述我们可以知道,调用这个open函数最终会进入到Ashmem驱动程序中的ashmem_open函数中去:


  1. static int ashmem_open(struct inode *inode, struct file *file)  
  2. {  
  3.     struct ashmem_area *asma;  
  4.     int ret;  
  5.  
  6.     ret = nonseekable_open(inode, file);  
  7.     if (unlikely(ret))  
  8.         return ret;  
  9.  
  10.     asma = kmem_cache_zalloc(ashmem_area_cachep, GFP_KERNEL);  
  11.     if (unlikely(!asma))  
  12.         return -ENOMEM;  
  13.  
  14.     INIT_LIST_HEAD(&asma->unpinned_list);  
  15.     memcpy(asma->name, ASHMEM_NAME_PREFIX, ASHMEM_NAME_PREFIX_LEN);  
  16.     asma->prot_mask = PROT_MASK;  
  17.     file->private_data = asma;  
  18.  
  19.     return 0;  

        首先是通过nonseekable_open函数来设备这个文件不可以执行定位操作,即不可以执行seek文件操作。接着就是通过kmem_cache_zalloc函数从刚才我们创建的slab缓冲区ashmem_area_cachep来创建一个ashmem_area结构体了,并且保存在本地变量asma中。再接下去就是初始化变量asma的其它域,其中,域name初始为ASHMEM_NAME_PREFIX,这是一个宏,定义为:


  1. #define ASHMEM_NAME_PREFIX "dev/ashmem/" 
  2. #define ASHMEM_NAME_PREFIX_LEN (sizeof(ASHMEM_NAME_PREFIX) - 1) 

        函数的最后是把这个ashmem_area结构保存在打开文件结构体的private_data域中,这样,Ashmem驱动程序就可以在其它地方通过这个private_data域来取回这个ashmem_area结构了。

 

        到这里,设备文件/dev/ashmem的打开操作就完成了,它实际上就是在Ashmem驱动程序中创建了一个ashmem_area结构,表示一块新的共享内存。

        再回到ashmem_create_region函数中,又调用了两次ioctl文件操作分别来设备这块新建的匿名共享内存的名字和大小。在kernel/comon/mm/include/ashmem.h文件中,ASHMEM_SET_NAME和ASHMEM_SET_SIZE的定义为:


  1. #define ASHMEM_NAME_LEN     256  
  2.  
  3. #define __ASHMEMIOC     0x77  
  4.  
  5. #define ASHMEM_SET_NAME     _IOW(__ASHMEMIOC, 1, char[ASHMEM_NAME_LEN])  
  6. #define ASHMEM_SET_SIZE     _IOW(__ASHMEMIOC, 3, size_t) 

      先来看ASHMEM_SET_NAME命令的ioctl调用,它最终进入到Ashmem驱动程序的ashmem_ioctl函数中:


  1. static long ashmem_ioctl(struct file *file, unsigned int cmd, unsigned long arg)  
  2. {  
  3.     struct ashmem_area *asma = file->private_data;  
  4.     long ret = -ENOTTY;  
  5.  
  6.     switch (cmd) {  
  7.     case ASHMEM_SET_NAME:  
  8.         ret = set_name(asma, (void __user *) arg);  
  9.         break;  
  10.     ......  
  11.     }  
  12.  
  13.     return ret;  

       这里通过set_name函数来进行实际操作:


  1. static int set_name(struct ashmem_area *asma, void __user *name)  
  2. {  
  3.     int ret = 0;  
  4.  
  5.     mutex_lock(&ashmem_mutex);  
  6.  
  7.     /* cannot change an existing mapping's name */  
  8.     if (unlikely(asma->file)) {  
  9.         ret = -EINVAL;  
  10.         goto out;  
  11.     }  
  12.  
  13.     if (unlikely(copy_from_user(asma->name + ASHMEM_NAME_PREFIX_LEN,  
  14.                     name, ASHMEM_NAME_LEN)))  
  15.         ret = -EFAULT;  
  16.     asma->name[ASHMEM_FULL_NAME_LEN-1] = '\0';  
  17.  
  18. out:  
  19.     mutex_unlock(&ashmem_mutex);  
  20.  
  21.     return ret;  

        这个函数实现很简单,把用户空间传进来的匿名共享内存的名字设备到asma->name域中去。注意,匿名共享内存块的名字的内容分两部分,前一部分是前缀,这是在open操作时,由驱动程序默认设置的,固定为ASHMEM_NAME_PREFIX,即"dev/ashmem/";后一部分由用户指定,这一部分是可选的,即用户可以不调用ASHMEM_SET_NAME命令来设置匿名共享内存块的名字。

 

        再来看ASHMEM_SET_SIZE命令的ioctl调用,它最终也是进入到Ashmem驱动程序的ashmem_ioctl函数中:


  1. static long ashmem_ioctl(struct file *file, unsigned int cmd, unsigned long arg)  
  2. {  
  3.     struct ashmem_area *asma = file->private_data;  
  4.     long ret = -ENOTTY;  
  5.  
  6.     switch (cmd) {  
  7.     ......  
  8.     case ASHMEM_SET_SIZE:  
  9.         ret = -EINVAL;  
  10.         if (!asma->file) {  
  11.             ret = 0;  
  12.             asma->size = (size_t) arg;  
  13.         }  
  14.         break;  
  15.     ......  
  16.     }  
  17.  
  18.     return ret;  

        这个实现很简单,只是把用户空间传进来的匿名共享内存的大小值保存在对应的asma->size域中。

 

        这样,ashmem_create_region函数就执先完成了,层层返回,最后回到应用程序框架层提供的接口Memory的构造函数中,整个匿名共享内存的创建过程就完成了。前面我们说过过,Ashmem驱动程序不提供read和write文件操作,进程若要访问这个共享内存,必须要把这个设备文件映射到自己的进程空间中,然后进行直接内存访问,这就是我们下面要介绍的匿名共享内存设备文件的内存映射操作了。

        二. 匿名共享内存设备文件的内存映射操作

        在MemoryFile类的构造函数中,进行了匿名共享内存的创建操作后,下一步就是要把匿名共享内存设备文件映射到进程空间来了:


  1. public class MemoryFile  
  2. {  
  3.     ......  
  4.  
  5.     // returns memory address for ashmem region  
  6.     private static native int native_mmap(FileDescriptor fd, int length, int mode)  
  7.         throws IOException;  
  8.       
  9.     ......  
  10.  
  11.     private int mAddress;   // address of ashmem memory  
  12.       
  13.     ......  
  14.  
  15.     /**  
  16.     * Allocates a new ashmem region. The region is initially not purgable.  
  17.     *  
  18.     * @param name optional name for the file (can be null).  
  19.     * @param length of the memory file in bytes.  
  20.     * @throws IOException if the memory file could not be created.  
  21.     */ 
  22.     public MemoryFile(String name, int length) throws IOException {  
  23.         ......  
  24.         mAddress = native_mmap(mFD, length, PROT_READ | PROT_WRITE);  
  25.         ......  
  26.     }  

         映射匿名共享内存设备文件到进程空间是通过JNI方法native_mmap来进行的。这个JNI方法实现在frameworks/base/core/jni/adroid_os_MemoryFile.cpp文件中:


  1. static jint android_os_MemoryFile_mmap(JNIEnv* env, jobject clazz, jobject fileDescriptor,  
  2.         jint length, jint prot)  
  3. {  
  4.     int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);  
  5.     jint result = (jint)mmap(NULL, length, prot, MAP_SHARED, fd, 0);  
  6.     if (!result)  
  7.         jniThrowException(env, "java/io/IOException""mmap failed");  
  8.     return result;  

        这里的文件描述符fd是在前面open匿名设备文件/dev/ashmem获得的,有个这个文件描述符后,就可以直接通过mmap来执行内存映射操作了。这个mmap系统调用最终进入到Ashmem驱动程序的ashmem_mmap函数中:


  1. static int ashmem_mmap(struct file *file, struct vm_area_struct *vma)  
  2. {  
  3.     struct ashmem_area *asma = file->private_data;  
  4.     int ret = 0;  
  5.  
  6.     mutex_lock(&ashmem_mutex);  
  7.  
  8.     /* user needs to SET_SIZE before mapping */  
  9.     if (unlikely(!asma->size)) {  
  10.         ret = -EINVAL;  
  11.         goto out;  
  12.     }  
  13.  
  14.     /* requested protection bits must match our allowed protection mask */  
  15.     if (unlikely((vma->vm_flags & ~asma->prot_mask) & PROT_MASK)) {  
  16.         ret = -EPERM;  
  17.         goto out;  
  18.     }  
  19.  
  20.     if (!asma->file) {  
  21.         char *name = ASHMEM_NAME_DEF;  
  22.         struct file *vmfile;  
  23.  
  24.         if (asma->name[ASHMEM_NAME_PREFIX_LEN] != '\0')  
  25.             name = asma->name;  
  26.  
  27.         /* ... and allocate the backing shmem file */  
  28.         vmfile = shmem_file_setup(name, asma->size, vma->vm_flags);  
  29.         if (unlikely(IS_ERR(vmfile))) {  
  30.             ret = PTR_ERR(vmfile);  
  31.             goto out;  
  32.         }  
  33.         asma->file = vmfile;  
  34.     }  
  35.     get_file(asma->file);  
  36.  
  37.     if (vma->vm_flags & VM_SHARED)  
  38.         shmem_set_file(vma, asma->file);  
  39.     else {  
  40.         if (vma->vm_file)  
  41.             fput(vma->vm_file);  
  42.         vma->vm_file = asma->file;  
  43.     }  
  44.     vma->vm_flags |= VM_CAN_NONLINEAR;  
  45.  
  46. out:  
  47.     mutex_unlock(&ashmem_mutex);  
  48.     return ret;  

        这个函数的实现也很简单,它调用了Linux内核提供的shmem_file_setup函数来在临时文件系统tmpfs中创建一个临时文件,这个临时文件与Ashmem驱动程序创建的匿名共享内存对应。函数shmem_file_setup是Linux内核中用来创建共享内存文件的方法,而Linux内核中的共享内存机制其实是一种进程间通信(IPC)机制,它的实现相对也是比较复杂,Android系统的匿名共享内存机制正是由于直接使用了Linux内核共享内存机制,它才会很小巧,它站在巨人的肩膀上了。关于Linux内核中的共享内存的相关知识,可以参考前面Android学习启动篇一文中提到的一本参考书籍《Linux内核源代码情景分析》的第六章传统的Unix进程间通信第七小节共享内存。
 

 

        通过shmem_file_setup函数创建的临时文件vmfile最终就保存在vma->file中了。这里的vma是由Linux内核的文件系统层传进来的,它的类型为struct vm_area_struct,它表示的是当前进程空间中一块连续的虚拟地址空间,它的起始地址可以由用户来指定,也可以由内核自己来分配,这里我们从JNI方法native_mmap调用的mmap的第一个参数为NULL可以看出,这块连续的虚拟地址空间的起始地址是由内核来指定的。文件内存映射操作完成后,用户访问这个范围的地址空间就相当于是访问对应的文件的内容了。有关Linux文件的内存映射操作,同样可以参考前面Android学习启动篇一文中提到的一本参考书籍《Linux内核源代码情景分析》的第二章内存管理第十三小节系统调用mmap。从这里我们也可以看出,Android系统的匿名共享内存是在虚拟地址空间连续的,但是在物理地址空间就不一定是连续的了。

        同时,这个临时文件vmfile也会保存asma->file域中,这样,Ashmem驱动程序后面就可以通过在asma->file来操作这个匿名内存共享文件了。

        函数ashmem_mmap执行完成后,经过层层返回到JNI方法native_mmap中去,就从mmap函数的返回值中得到了这块虚拟空间的起始地址了,这个起始地址最终返回到应用程序框架层的MemoryFile类的构造函数中,并且保存在成员变量mAddress中,后面,共享内存的读写操作就是对这个地址空间进行操作了。

        三. 匿名共享内存的读写操作

        因为前面对匿名共享内存文件进行内存映射操作,这里对匿名内存文件内容的读写操作就比较简单了,就像访问内存变量一样就行了。

        我们来看一下MemoryFile类的读写操作函数:


  1. public class MemoryFile  
  2. {  
  3.     ......  
  4.  
  5.     private static native int native_read(FileDescriptor fd, int address, byte[] buffer,  
  6.         int srcOffset, int destOffset, int count, boolean isUnpinned) throws IOException;  
  7.     private static native void native_write(FileDescriptor fd, int address, byte[] buffer,  
  8.         int srcOffset, int destOffset, int count, boolean isUnpinned) throws IOException;  
  9.       
  10.     ......  
  11.  
  12.     private FileDescriptor mFD;        // ashmem file descriptor  
  13.     private int mAddress;   // address of ashmem memory  
  14.     private int mLength;    // total length of our ashmem region  
  15.     private boolean mAllowPurging = false;  // true if our ashmem region is unpinned  
  16.  
  17.     ......  
  18.  
  19.     /**  
  20.     * Reads bytes from the memory file.  
  21.     * Will throw an IOException if the file has been purged.  
  22.     *  
  23.     * @param buffer byte array to read bytes into.  
  24.     * @param srcOffset offset into the memory file to read from.  
  25.     * @param destOffset offset into the byte array buffer to read into.  
  26.     * @param count number of bytes to read.  
  27.     * @return number of bytes read.  
  28.     * @throws IOException if the memory file has been purged or deactivated.  
  29.     */  
  30.     public int readBytes(byte[] buffer, int srcOffset, int destOffset, int count)   
  31.     throws IOException {  
  32.         if (isDeactivated()) {  
  33.             throw new IOException("Can't read from deactivated memory file.");  
  34.         }  
  35.         if (destOffset < 0 || destOffset > buffer.length || count < 0  
  36.             || count > buffer.length - destOffset  
  37.             || srcOffset < 0 || srcOffset > mLength  
  38.             || count > mLength - srcOffset) {  
  39.                 throw new IndexOutOfBoundsException();  
  40.         }  
  41.         return native_read(mFD, mAddress, buffer, srcOffset, destOffset, count, mAllowPurging);  
  42.     }  
  43.  
  44.     /**  
  45.     * Write bytes to the memory file.  
  46.     * Will throw an IOException if the file has been purged.  
  47.     *  
  48.     * @param buffer byte array to write bytes from.  
  49.     * @param srcOffset offset into the byte array buffer to write from.  
  50.     * @param destOffset offset  into the memory file to write to.  
  51.     * @param count number of bytes to write.  
  52.     * @throws IOException if the memory file has been purged or deactivated.  
  53.     */  
  54.     public void writeBytes(byte[] buffer, int srcOffset, int destOffset, int count)  
  55.         throws IOException {  
  56.             if (isDeactivated()) {  
  57.                 throw new IOException("Can't write to deactivated memory file.");  
  58.             }  
  59.             if (srcOffset < 0 || srcOffset > buffer.length || count < 0  
  60.                 || count > buffer.length - srcOffset  
  61.                 || destOffset < 0 || destOffset > mLength  
  62.                 || count > mLength - destOffset) {  
  63.                     throw new IndexOutOfBoundsException();  
  64.             }  
  65.             native_write(mFD, mAddress, buffer, srcOffset, destOffset, count, mAllowPurging);  
  66.     }  
  67.  
  68.     ......  

        这里,我们可以看到,MemoryFile的匿名共享内存读写操作都是通过JNI方法来实现的,读操作和写操作的JNI方法分别是native_read和native_write,它们都是定义在frameworks/base/core/jni/adroid_os_MemoryFile.cpp文件中:


  1. static jint android_os_MemoryFile_read(JNIEnv* env, jobject clazz,  
  2.         jobject fileDescriptor, jint address, jbyteArray buffer, jint srcOffset, jint destOffset,  
  3.         jint count, jboolean unpinned)  
  4. {  
  5.     int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);  
  6.     if (unpinned && ashmem_pin_region(fd, 0, 0) == ASHMEM_WAS_PURGED) {  
  7.         ashmem_unpin_region(fd, 0, 0);  
  8.         jniThrowException(env, "java/io/IOException""ashmem region was purged");  
  9.         return -1;  
  10.     }  
  11.  
  12.     env->SetByteArrayRegion(buffer, destOffset, count, (const jbyte *)address + srcOffset);  
  13.  
  14.     if (unpinned) {  
  15.         ashmem_unpin_region(fd, 0, 0);  
  16.     }  
  17.     return count;  
  18. }  
  19.  
  20. static jint android_os_MemoryFile_write(JNIEnv* env, jobject clazz,  
  21.         jobject fileDescriptor, jint address, jbyteArray buffer, jint srcOffset, jint destOffset,  
  22.         jint count, jboolean unpinned)  
  23. {  
  24.     int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);  
  25.     if (unpinned && ashmem_pin_region(fd, 0, 0) == ASHMEM_WAS_PURGED) {  
  26.         ashmem_unpin_region(fd, 0, 0);  
  27.         jniThrowException(env, "java/io/IOException""ashmem region was purged");  
  28.         return -1;  
  29.     }  
  30.  
  31.     env->GetByteArrayRegion(buffer, srcOffset, count, (jbyte *)address + destOffset);  
  32.  
  33.     if (unpinned) {  
  34.         ashmem_unpin_region(fd, 0, 0);  
  35.     }  
  36.     return count;  

        这里的address参数就是我们在前面执行mmap来映射匿名共享内存文件到内存中时,得到的进程虚拟地址空间的起始地址了,因此,这里就直接可以访问,不必进入到Ashmem驱动程序中去,这也是为什么Ashmem驱动程序没有提供read和write文件操作的原因。

 

        这里我们看到的ashmem_pin_region和ashmem_unpin_region两个函数是系统运行时库提供的接口,用来执行我们前面说的匿名共享内存的锁定和解锁操作,它们的作用是告诉Ashmem驱动程序,它的哪些内存块是正在使用的,需要锁定,哪些内存是不需要使用了,可以它解锁,这样,Ashmem驱动程序就可以辅助内存管理系统来有效地管理内存了。下面我们就看看Ashmem驱动程序是如果辅助内存管理系统来有效地管理内存的。





本文转自 Luoshengyang 51CTO博客,原文链接:http://blog.51cto.com/shyluo/965462,如需转载请自行联系原作者

上一篇:Android系统匿名共享内存Ashmem(Anonymous Shared Memory)驱动程序源代码分析(下)


下一篇:使用springMVC实现文件上传和下载之环境配置与上传