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

迈不过友情╰ 2022-08-05 15:25 308阅读 0赞

在上一文章[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_Ashmem_Anonymous Shared Memory]介绍的Android应用程序框架层提供MemoryFile接口开始，分别介绍Android系统匿名共享内存的创建（open）、映射（mmap）、读写（read/write）以及锁定和解锁（pin/unpin）四个使用情景。

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

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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;  
31. \}

这里，我们可以看到，Ahshmem驱动程序在加载时，会创建一个/dev/ashmem的设备文件，这是一个misc类型的设备。注册misc设备是通过misc\_register函数进行的，关于这个函数的详细实现，可以参考前面 [Android日志系统驱动程序Logger源代码分析][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文件中：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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.     ......  
29. \}

这里我们看到，这个构造函数最终是通过JNI方法native\_open来创建匿名内存共享文件。这个JNI方法native\_open实现在frameworks/base/core/jni/adroid\_os\_MemoryFile.cpp文件中：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **static** jobject android\_os\_MemoryFile\_open(JNIEnv\* env, jobject clazz, jstring name, jint length)  
2.  \{  
3.      **const** **char**\* namestr = (name ? env->GetStringUTFChars(name, NULL) : 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);  
16. \}

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

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  /\* 
2.   \* ashmem\_create\_region - creates a new ashmem region and returns the file 
3.   \* descriptor, or <0 on error 
4.   \* 
5.   \* \`name' is an optional label to give the region (visible in /proc/pid/maps) 
6.   \* \`size' is 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;  
34. \}

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

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

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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缓冲区是在驱动程序模块初始化函数创建的，我们来看一个这个初始化函数的相关实现：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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;  
16. \}

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

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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学习启动篇][Android]一文中提到的一本参考书籍《Understanding the Linux Kernel》的第八章Memory Managerment。

有了这些基础知识后，我们回到前面的ashmem\_create\_region函数中。

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

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  fd = open(ASHMEM\_DEVICE, O\_RDWR);

ASHMEM\_DEVICE是一个宏，定义为：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#define ASHMEM\_DEVICE   "/dev/ashmem"

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

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

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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;  
20. \}

首先是通过nonseekable\_open函数来设备这个文件不可以执行定位操作，即不可以执行seek文件操作。接着就是通过kmem\_cache\_zalloc函数从刚才我们创建的slab缓冲区ashmem\_area\_cachep来创建一个ashmem\_area结构体了，并且保存在本地变量asma中。再接下去就是初始化变量asma的其它域，其中，域name初始为ASHMEM\_NAME\_PREFIX，这是一个宏，定义为：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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的定义为：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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函数中：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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;  
14. \}

这里通过set\_name函数来进行实际操作：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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;  
22. \}

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

再来看ASHMEM\_SET\_SIZE命令的ioctl调用，它最终也是进入到Ashmem驱动程序的ashmem\_ioctl函数中：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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;  
19. \}

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

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

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

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

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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.     \}  
27. \}

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

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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;  
9.  \}

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

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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;  
49. \}

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

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

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

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

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

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

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

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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.     ......  
69. \}

这里，我们可以看到，MemoryFile的匿名共享内存读写操作都是通过JNI方法来实现的，读操作和写操作的JNI方法分别是native\_read和native\_write，它们都是定义在frameworks/base/core/jni/adroid\_os\_MemoryFile.cpp文件中：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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;  
37. \}

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

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

四. 匿名共享内存的锁定和解锁操作  
        前面提到，Android系统的运行时库提到了执行匿名共享内存的锁定和解锁操作的两个函数ashmem\_pin\_region和ashmem\_unpin\_region，它们实现在system/core/libcutils/ashmem-dev.c文件中：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **int** ashmem\_pin\_region(**int** fd, **size\_t** offset, **size\_t** len)  
2.  \{  
3.      **struct** ashmem\_pin pin = \{ offset, len \};  
4.      **return** ioctl(fd, ASHMEM\_PIN, &pin);  
5.  \}  
6.    
7.  **int** ashmem\_unpin\_region(**int** fd, **size\_t** offset, **size\_t** len)  
8.  \{  
9.      **struct** ashmem\_pin pin = \{ offset, len \};  
10.     **return** ioctl(fd, ASHMEM\_UNPIN, &pin);  
11. \}

它们的实现很简单，通过ASHMEM\_PIN和ASHMEM\_UNPIN两个ioctl操作来实现匿名共享内存的锁定和解锁操作。

我们先看来一下ASHMEM\_PIN和ASHMEM\_UNPIN这两个命令号的定义，它们的定义可以在kernel/common/include/linux/ashmem.h文件中找到：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#define \_\_ASHMEMIOC     0x77  
2.    
3.  \#define ASHMEM\_PIN      \_IOW(\_\_ASHMEMIOC, 7, struct ashmem\_pin)  
4.  \#define ASHMEM\_UNPIN        \_IOW(\_\_ASHMEMIOC, 8, struct ashmem\_pin)

它们的参数类型为struct ashmem\_pin，它也是定义在kernel/common/include/linux/ashmem.h文件中：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **struct** ashmem\_pin \{  
2.      \_\_u32 offset;   /\* offset into region, in bytes, page-aligned \*/  
3.      \_\_u32 len;  /\* length forward from offset, in bytes, page-aligned \*/  
4.  \};

这个结构体只有两个域，分别表示要锁定或者要解锁的内块块的起始大小以及大小。

在分析这两个操作之前，我们先来看一下Ashmem驱动程序中的一个数据结构struct ashmem\_range，这个数据结构就是用来表示某一块被解锁（unpinnd）的内存：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  /\* 
2.   \* ashmem\_range - represents an interval of unpinned (evictable) pages 
3.   \* Lifecycle: From unpin to pin 
4.   \* Locking: Protected by \`ashmem\_mutex' 
5.   \*/  
6.  **struct** ashmem\_range \{  
7.      **struct** list\_head lru;       /\* entry in LRU list \*/  
8.      **struct** list\_head unpinned;  /\* entry in its area's unpinned list \*/  
9.      **struct** ashmem\_area \*asma;   /\* associated area \*/  
10.     **size\_t** pgstart;         /\* starting page, inclusive \*/  
11.     **size\_t** pgend;           /\* ending page, inclusive \*/  
12.     unsigned **int** purged;        /\* ASHMEM\_NOT or ASHMEM\_WAS\_PURGED \*/  
13. \};

域asma表示这块被解锁的内存所属于的匿名共享内存，它通过域unpinned连接在asma->unpinned\_list表示的列表中；域pgstart和paend表示这个内存块的开始和结束页面号，它们表示一个前后闭合的区间；域purged表示这个内存块占用的物理内存是否已经被回收；这块被解锁的内存块除了保存在它所属的匿名共享内存asma的解锁列表unpinned\_list之外，还通过域lru保存在一个全局的最近最少使用列表ashmem\_lru\_list列表中，它的定义如下：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  /\* LRU list of unpinned pages, protected by ashmem\_mutex \*/  
2.  **static** LIST\_HEAD(ashmem\_lru\_list);

了解了这个数据结构之后，我们就可以来看ashmem\_ioctl函数中关于ASHMEM\_PIN和ASHMEM\_UNPIN的操作了：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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\_PIN:  
9.      **case** ASHMEM\_UNPIN:  
10.         ret = ashmem\_pin\_unpin(asma, cmd, (**void** \_\_user \*) arg);  
11.         **break**;  
12.     ......  
13.     \}  
14.   
15.     **return** ret;  
16. \}

它们都是通过ashmem\_pin\_unpin来进一步处理：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **static** **int** ashmem\_pin\_unpin(**struct** ashmem\_area \*asma, unsigned **long** cmd,  
2.                  **void** \_\_user \*p)  
3.  \{  
4.      **struct** ashmem\_pin pin;  
5.      **size\_t** pgstart, pgend;  
6.      **int** ret = -EINVAL;  
7.    
8.      **if** (unlikely(!asma->file))  
9.          **return** -EINVAL;  
10.   
11.     **if** (unlikely(copy\_from\_user(&pin, p, **sizeof**(pin))))  
12.         **return** -EFAULT;  
13.   
14.     /\* per custom, you can pass zero for len to mean "everything onward" \*/  
15.     **if** (!pin.len)  
16.         pin.len = PAGE\_ALIGN(asma->size) - pin.offset;  
17.   
18.     **if** (unlikely((pin.offset | pin.len) & ~PAGE\_MASK))  
19.         **return** -EINVAL;  
20.   
21.     **if** (unlikely(((\_\_u32) -1) - pin.offset < pin.len))  
22.         **return** -EINVAL;  
23.   
24.     **if** (unlikely(PAGE\_ALIGN(asma->size) < pin.offset + pin.len))  
25.         **return** -EINVAL;  
26.   
27.     pgstart = pin.offset / PAGE\_SIZE;  
28.     pgend = pgstart + (pin.len / PAGE\_SIZE) - 1;  
29.   
30.     mutex\_lock(&ashmem\_mutex);  
31.   
32.     **switch** (cmd) \{  
33.     **case** ASHMEM\_PIN:  
34.         ret = ashmem\_pin(asma, pgstart, pgend);  
35.         **break**;  
36.     **case** ASHMEM\_UNPIN:  
37.         ret = ashmem\_unpin(asma, pgstart, pgend);  
38.         **break**;  
39.     ......  
40.     \}  
41.   
42.     mutex\_unlock(&ashmem\_mutex);  
43.   
44.     **return** ret;  
45. \}

首先是获得用户空间传进来的参数，并保存在本地变量pin中，这是一个struct ashmem\_pin类型的变量，这个结构体我们在前面已经见过了，它包括了要pin/unpin的内存块的起始地址和大小，这里的起始地址和大小都是以字节为单位的，因此，通过转换把它们换成以页面为单位的，并且保存在本地变量pgstart和pgend中。这里除了要对参数作一个安全性检查外，还要一个处理逻辑是，如果从用户空间传进来的内块块的大小值为0 ，则认为是要pin/unpin整个匿名共享内存。

函数最后根据当前要执行的是ASHMEM\_PIN操作还是ASHMEM\_UNPIN操作来分别执行ashmem\_pin和ashmem\_unpin来进一步处理。创建匿名共享内存时，默认所有的内存都是pinned状态的，只有用户告诉Ashmem驱动程序要unpin某一块内存时，Ashmem驱动程序才会把这块内存unpin，之后，用户可以再告诉Ashmem驱动程序要重新pin某一块之前被unpin过的内块，从而把这块内存从unpinned状态改为pinned状态，也就是说，执行ASHMEM\_PIN操作时，目标对象必须是一块当前处于unpinned状态的内存块。

我们先来看一下ASHMEM\_UNPIN操作，进入到ashmem\_unpin函数：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  /\* 
2.   \* ashmem\_unpin - unpin the given range of pages. Returns zero on success. 
3.   \* 
4.   \* Caller must hold ashmem\_mutex. 
5.   \*/  
6.  **static** **int** ashmem\_unpin(**struct** ashmem\_area \*asma, **size\_t** pgstart, **size\_t** pgend)  
7.  \{  
8.      **struct** ashmem\_range \*range, \*next;  
9.      unsigned **int** purged = ASHMEM\_NOT\_PURGED;  
10.   
11. restart:  
12.     list\_for\_each\_entry\_safe(range, next, &asma->unpinned\_list, unpinned) \{  
13.         /\* short circuit: this is our insertion point \*/  
14.         **if** (range\_before\_page(range, pgstart))  
15.             **break**;  
16.   
17.         /\* 
18.          \* The user can ask us to unpin pages that are already entirely 
19.          \* or partially pinned. We handle those two cases here. 
20.          \*/  
21.         **if** (page\_range\_subsumed\_by\_range(range, pgstart, pgend))  
22.             **return** 0;  
23.         **if** (page\_range\_in\_range(range, pgstart, pgend)) \{  
24.             pgstart = min\_t(**size\_t**, range->pgstart, pgstart),  
25.             pgend = max\_t(**size\_t**, range->pgend, pgend);  
26.             purged |= range->purged;  
27.             range\_del(range);  
28.             **goto** restart;  
29.         \}  
30.     \}  
31.   
32.     **return** range\_alloc(asma, range, purged, pgstart, pgend);  
33. \}

这个函数的主体就是在遍历asma->unpinned\_list列表，从中查找当前处于unpinned状态的内存块是否与将要unpin的内存块\[pgstart, pgend\]是否相交，如果相交，则要执行合并操作，即调整pgstart和pgend的大小，然后通过调用range\_del函数删掉原来的已经被unpinned过的内存块，最后再通过range\_alloc函数来重新unpinned这块调整过后的内存块\[pgstart, pgend\]，这里新的内存块\[pgstart, pgend\]已经包含了刚才所有被删掉的unpinned状态的内存。注意，这里如果找到一块相并的内存块，并且调整了pgstart和pgend的大小之后，要重新再扫描一遍asma->unpinned\_list列表，因为新的内存块\[pgstart, pgend\]可能还会与前后的处于unpinned状态的内存块发生相交。

我们来看一下range\_before\_page的操作，这是一个宏定义：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#define range\_before\_page(range, page) \\  
2.    ((range)->pgend < (page))

表示range描述的内存块是否在page页面之前，如果是，则整个描述就结束了。从这里我们可以看出asma->unpinned\_list列表是按照页面号从大到小进行排列的，并且每一块被unpin的内存都是不相交的。

再来看一下page\_range\_subsumed\_by\_range的操作，这也是一个宏定义：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#define page\_range\_subsumed\_by\_range(range, start, end) \\  
2.    (((range)->pgstart <= (start)) && ((range)->pgend >= (end)))

表示range描述的内存块是不是包含了\[start, end\]这个内存块，如果包含了，则说明当前要unpin的内存块已经处于unpinned状态，什么也不用操作，直接返回即可。

再看page\_range\_in\_range的操作，它也是一个宏定义：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#define page\_range\_in\_range(range, start, end) \\  
2.    (page\_in\_range(range, start) || page\_in\_range(range, end) || \\  
3.     page\_range\_subsumes\_range(range, start, end))

它用到的其它两个宏分别定义为：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#define page\_range\_subsumed\_by\_range(range, start, end) \\  
2.    (((range)->pgstart <= (start)) && ((range)->pgend >= (end)))  
3.    
4.  \#define page\_in\_range(range, page) \\  
5.   (((range)->pgstart <= (page)) && ((range)->pgend >= (page)))

它们都是用来判断两个内存区间是否相交的。

两个内存块相交分为四种情况：

|-------range-----|        |-------range------|       |--------range---------|                 |----range---|

|-start----end-|       |-start-----end-|                          |-start-------end-|        |-start-----------end-|  
                 (1)                                (2)                                  (3)                                            (4)  
      第一种情况，前面已经讨论过了，对于第二到第四种情况，都是需要执行合并操作的。

再来看从asma->unpinned\_list中删掉内存块的range\_del函数：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **static** **void** range\_del(**struct** ashmem\_range \*range)  
2.  \{  
3.      list\_del(&range->unpinned);  
4.      **if** (range\_on\_lru(range))  
5.          lru\_del(range);  
6.      kmem\_cache\_free(ashmem\_range\_cachep, range);  
7.  \}

这个函数首先把range从相应的unpinned\_list列表中删除，然后判断它是否在lru列表中：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#define range\_on\_lru(range) \\  
2.    ((range)->purged == ASHMEM\_NOT\_PURGED)

如果它的状态purged等于ASHMEM\_NOT\_PURGED，即对应的物理页面尚未被回收，它就位于lru列表中，通过调用lru\_del函数进行删除：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **static** **inline** **void** lru\_del(**struct** ashmem\_range \*range)  
2.  \{  
3.      list\_del(&range->lru);  
4.      lru\_count -= range\_size(range);  
5.  \}

最后调用kmem\_cache\_free将它从slab缓冲区ashmem\_range\_cachep中释放。

这里的slab缓冲区ashmem\_range\_cachep定义如下：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **static** **struct** kmem\_cache \*ashmem\_range\_cachep \_\_read\_mostly;

它和前面介绍的slab缓冲区ashmem\_area\_cachep一样，是在Ashmem驱动程序模块初始化函数ashmem\_init进行初始化的：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **static** **int** \_\_init ashmem\_init(**void**)  
2.  \{  
3.      **int** ret;  
4.    
5.      ......  
6.    
7.      ashmem\_range\_cachep = kmem\_cache\_create("ashmem\_range\_cache",  
8.          **sizeof**(**struct** ashmem\_range),  
9.          0, 0, NULL);  
10.     **if** (unlikely(!ashmem\_range\_cachep)) \{  
11.         printk(KERN\_ERR "ashmem: failed to create slab cache\\n");  
12.         **return** -ENOMEM;  
13.     \}  
14.   
15.     ......  
16.   
17.     printk(KERN\_INFO "ashmem: initialized\\n");  
18.   
19.     **return** 0;  
20. \}

回到ashmem\_unpin函数中，我们再来看看range\_alloc函数的实现：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  /\* 
2.   \* range\_alloc - allocate and initialize a new ashmem\_range structure 
3.   \* 
4.   \* 'asma' - associated ashmem\_area 
5.   \* 'prev\_range' - the previous ashmem\_range in the sorted asma->unpinned list 
6.   \* 'purged' - initial purge value (ASMEM\_NOT\_PURGED or ASHMEM\_WAS\_PURGED) 
7.   \* 'start' - starting page, inclusive 
8.   \* 'end' - ending page, inclusive 
9.   \* 
10.  \* Caller must hold ashmem\_mutex. 
11.  \*/  
12. **static** **int** range\_alloc(**struct** ashmem\_area \*asma,  
13.                **struct** ashmem\_range \*prev\_range, unsigned **int** purged,  
14.                **size\_t** start, **size\_t** end)  
15. \{  
16.     **struct** ashmem\_range \*range;  
17.   
18.     range = kmem\_cache\_zalloc(ashmem\_range\_cachep, GFP\_KERNEL);  
19.     **if** (unlikely(!range))  
20.         **return** -ENOMEM;  
21.   
22.     range->asma = asma;  
23.     range->pgstart = start;  
24.     range->pgend = end;  
25.     range->purged = purged;  
26.   
27.     list\_add\_tail(&range->unpinned, &prev\_range->unpinned);  
28.   
29.     **if** (range\_on\_lru(range))  
30.         lru\_add(range);  
31.   
32.     **return** 0;  
33. \}

这个函数的作用是从slab 缓冲区中ashmem\_range\_cachep分配一个ashmem\_range，然后对它作相应的初始化，放在相应的ashmem\_area->unpinned\_list列表中，并且还要判断这个range的purged是否是ASHMEM\_NOT\_PURGED状态，如果是，还要把它放在lru列表中：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **static** **inline** **void** lru\_add(**struct** ashmem\_range \*range)  
2.  \{  
3.      list\_add\_tail(&range->lru, &ashmem\_lru\_list);  
4.      lru\_count += range\_size(range);  
5.  \}

这样，ashmem\_unpin的源代码我们就分析完了。

接着，我们再来看一下ASHMEM\_PIN操作，进入到ashmem\_pin函数：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  /\* 
2.   \* ashmem\_pin - pin the given ashmem region, returning whether it was 
3.   \* previously purged (ASHMEM\_WAS\_PURGED) or not (ASHMEM\_NOT\_PURGED). 
4.   \* 
5.   \* Caller must hold ashmem\_mutex. 
6.   \*/  
7.  **static** **int** ashmem\_pin(**struct** ashmem\_area \*asma, **size\_t** pgstart, **size\_t** pgend)  
8.  \{  
9.      **struct** ashmem\_range \*range, \*next;  
10.     **int** ret = ASHMEM\_NOT\_PURGED;  
11.   
12.     list\_for\_each\_entry\_safe(range, next, &asma->unpinned\_list, unpinned) \{  
13.         /\* moved past last applicable page; we can short circuit \*/  
14.         **if** (range\_before\_page(range, pgstart))  
15.             **break**;  
16.   
17.         /\* 
18.          \* The user can ask us to pin pages that span multiple ranges, 
19.          \* or to pin pages that aren't even unpinned, so this is messy. 
20.          \* 
21.          \* Four cases: 
22.          \* 1. The requested range subsumes an existing range, so we 
23.          \*    just remove the entire matching range. 
24.          \* 2. The requested range overlaps the start of an existing 
25.          \*    range, so we just update that range. 
26.          \* 3. The requested range overlaps the end of an existing 
27.          \*    range, so we just update that range. 
28.          \* 4. The requested range punches a hole in an existing range, 
29.          \*    so we have to update one side of the range and then 
30.          \*    create a new range for the other side. 
31.          \*/  
32.         **if** (page\_range\_in\_range(range, pgstart, pgend)) \{  
33.             ret |= range->purged;  
34.   
35.             /\* Case \#1: Easy. Just nuke the whole thing. \*/  
36.             **if** (page\_range\_subsumes\_range(range, pgstart, pgend)) \{  
37.                 range\_del(range);  
38.                 **continue**;  
39.             \}  
40.   
41.             /\* Case \#2: We overlap from the start, so adjust it \*/  
42.             **if** (range->pgstart >= pgstart) \{  
43.                 range\_shrink(range, pgend + 1, range->pgend);  
44.                 **continue**;  
45.             \}  
46.   
47.             /\* Case \#3: We overlap from the rear, so adjust it \*/  
48.             **if** (range->pgend <= pgend) \{  
49.                 range\_shrink(range, range->pgstart, pgstart-1);  
50.                 **continue**;  
51.             \}  
52.   
53.             /\* 
54.              \* Case \#4: We eat a chunk out of the middle. A bit 
55.              \* more complicated, we allocate a new range for the 
56.              \* second half and adjust the first chunk's endpoint. 
57.              \*/  
58.             range\_alloc(asma, range, range->purged,  
59.                     pgend + 1, range->pgend);  
60.             range\_shrink(range, range->pgstart, pgstart - 1);  
61.             **break**;  
62.         \}  
63.     \}  
64.   
65.     **return** ret;  
66. \}

前面我们说过，被pin的内存块，必须是在unpinned\_list列表中的，如果不在，就什么都不用做。要判断要pin的内存块是否在unpinned\_list列表中，又要通过遍历相应的asma->unpinned\_list列表来找出与之相交的内存块了。这个函数的处理方法大体与前面的ashmem\_unpin函数是一致的，也是要考虑四种不同的相交情况，这里就不详述了，读者可以自己分析一下。

这里我们只看一下range\_shrink函数的实现：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  /\* 
2.   \* range\_shrink - shrinks a range 
3.   \* 
4.   \* Caller must hold ashmem\_mutex. 
5.   \*/  
6.  **static** **inline** **void** range\_shrink(**struct** ashmem\_range \*range,  
7.                  **size\_t** start, **size\_t** end)  
8.  \{  
9.      **size\_t** pre = range\_size(range);  
10.   
11.     range->pgstart = start;  
12.     range->pgend = end;  
13.   
14.     **if** (range\_on\_lru(range))  
15.         lru\_count -= pre - range\_size(range);  
16. \}

这个函数的实现很简单，只是调整一下range描述的内存块的起始页面号，如果它是位于lru列表中，还要调整一下在lru列表中的总页面数大小。

这样，匿名共享内存的ASHMEM\_PIN和ASHMEM\_UNPIN操作就介绍完了，但是，我们还看不出来Ashmem驱动程序是怎么样辅助内存管理系统来有效管理内存的。有了前面这些unpinned的内存块列表之后，下面我们就看一下Ashmem驱动程序是怎么样辅助内存管理系统来有效管理内存的。

首先看一下Ashmem驱动程序模块初始化函数ashmem\_init：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **static** **struct** shrinker ashmem\_shrinker = \{  
2.      .shrink = ashmem\_shrink,  
3.      .seeks = DEFAULT\_SEEKS \* 4,  
4.  \};  
5.    
6.  **static** **int** \_\_init ashmem\_init(**void**)  
7.  \{  
8.      **int** ret;  
9.    
10.     ......  
11.   
12.     register\_shrinker(&ashmem\_shrinker);  
13.   
14.     printk(KERN\_INFO "ashmem: initialized\\n");  
15.   
16.     **return** 0;  
17. \}

这里通过调用register\_shrinker函数向内存管理系统注册一个内存回收算法函数。在Linux内核中，当系统内存紧张时，内存管理系统就会进行内存回收算法，将一些最近没有用过的内存换出物理内存去，这样可以增加物理内存的供应。因此，当内存管理系统进行内存回收时，就会调用到这里的ashmem\_shrink函数，让Ashmem驱动程序执行内存回收操作：

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  /\* 
2.   \* ashmem\_shrink - our cache shrinker, called from mm/vmscan.c :: shrink\_slab 
3.   \* 
4.   \* 'nr\_to\_scan' is the number of objects (pages) to prune, or 0 to query how 
5.   \* many objects (pages) we have in total. 
6.   \* 
7.   \* 'gfp\_mask' is the mask of the allocation that got us into this mess. 
8.   \* 
9.   \* Return value is the number of objects (pages) remaining, or -1 if we cannot 
10.  \* proceed without risk of deadlock (due to gfp\_mask). 
11.  \* 
12.  \* We approximate LRU via least-recently-unpinned, jettisoning unpinned partial 
13.  \* chunks of ashmem regions LRU-wise one-at-a-time until we hit 'nr\_to\_scan' 
14.  \* pages freed. 
15.  \*/  
16. **static** **int** ashmem\_shrink(**int** nr\_to\_scan, gfp\_t gfp\_mask)  
17. \{  
18.     **struct** ashmem\_range \*range, \*next;  
19.   
20.     /\* We might recurse into filesystem code, so bail out if necessary \*/  
21.     **if** (nr\_to\_scan && !(gfp\_mask & \_\_GFP\_FS))  
22.         **return** -1;  
23.     **if** (!nr\_to\_scan)  
24.         **return** lru\_count;  
25.   
26.     mutex\_lock(&ashmem\_mutex);  
27.     list\_for\_each\_entry\_safe(range, next, &ashmem\_lru\_list, lru) \{  
28.         **struct** inode \*inode = range->asma->file->f\_dentry->d\_inode;  
29.         loff\_t start = range->pgstart \* PAGE\_SIZE;  
30.         loff\_t end = (range->pgend + 1) \* PAGE\_SIZE - 1;  
31.   
32.         vmtruncate\_range(inode, start, end);  
33.         range->purged = ASHMEM\_WAS\_PURGED;  
34.         lru\_del(range);  
35.   
36.         nr\_to\_scan -= range\_size(range);  
37.         **if** (nr\_to\_scan <= 0)  
38.             **break**;  
39.     \}  
40.     mutex\_unlock(&ashmem\_mutex);  
41.   
42.     **return** lru\_count;  
43. \}

这里的参数nr\_to\_scan表示要扫描的页数，如果是0，则表示要查询一下，当前Ashmem驱动程序有多少页面可以回收，这里就等于挂在lru列表的内块页面的总数了，即lru\_count；否则，就要开始扫描lru列表，从中回收内存了，直到回收的内存页数等于nr\_to\_scan，或者已经没有内存可回收为止。回收内存页面是通过vm\_truncate\_range函数进行的，这个函数定义在kernel/common/mm/memory.c文件中，它是Linux内核内存管理系统实现的，有兴趣的读者可以研究一下。

这样，Android系统匿名共享内存Ashmem驱动程序源代码就分析完了，在下一篇文章中，我们将继续分析Android系统的匿名共享内存机制，研究它是如何通过Binder进程间通信机制实现在不同进程程进行内存共享的，敬请关注。

**老罗的新浪微博：[http://weibo.com/shengyangluo][http_weibo.com_shengyangluo]，欢迎关注！**

**转帖：http://blog.csdn.net/luoshengyang/article/details/6664554**

[Android_Ashmem_Anonymous Shared Memory]: http://blog.csdn.net/luoshengyang/article/details/6651971
[view plain]: http://blog.csdn.net/luoshengyang/article/details/6664554#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/134055
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/134055/fork
[Android_Logger]: http://blog.csdn.net/luoshengyang/article/details/6595744
[Android]: http://blog.csdn.net/luoshengyang/article/details/6557518
[http_weibo.com_shengyangluo]: http://weibo.com/shengyangluo