Unix/Linux编程：虚拟内存操作

怼烎@ 2022-10-18 01:39 103阅读 0赞

# API #

下面介绍在进程的虚拟内存空间上执行操作的各个系统调用

## 改变内存保护：mprotect() ##

mprotect()修改起始位置为addr长度为length字节的虚拟内存区域中分页上的保护。

NAME
           mprotect - set protection on a region of memory
    
    SYNOPSIS
           #include <sys/mman.h>
    
           int mprotect(void *addr, size_t len, int prot);

addr 的取值必须是系统分页大小（sysconf(\_SC\_PAGESIZE)的返回值）的整数倍。由于保护是设置在整个分页上的，因此实际上 length 会被向上舍入到系统分页大小的下一个整数倍。

prot 参数是一个位掩码，它指定了这块内存区域上的新保护，其取值是 PROT\_NONE 或PROT\_READ、PROT\_WRITE、以及 PROT\_EXEC 这三个值中的一个或多个取 OR。所有这些值的含义与它们在 [mmap()][mmap]中的含义是一样的

如果一个进程在访问一块内存区域时违背了内存保护，那么内核就会向该进程发送一个SIGSEGV 信号。

mprotect()的一个用途是修改原先通过 mmap()调用设置的映射内存区域上的保护，如下面程序所示。

#include <unistd.h>
    #include <signal.h>
    #include <stdio.h>
    #include <malloc.h>
    #include <stdlib.h>
    #include <errno.h>
    #include <sys/mman.h>
    
    #define LEN (1024 * 1024)
    
    #define SHELL_FMT "cat /proc/%ld/maps | grep zero"
    #define CMD_SIZE (sizeof(SHELL_FMT) + 20)
    
    int main(int argc, char *argv[])
    {
        
        char cmd[CMD_SIZE];
        char *addr;
    
        /* 创建一个最初拒绝所有访问（PROT_NONE）的匿名映射 */
        addr = (char * )mmap(NULL, LEN, PROT_NONE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
        if (addr == MAP_FAILED){
        
            perror("mmap");
            exit(EXIT_FAILURE);
        }
    
    
        // 打印出与该映射区域对应的/proc/PID/maps 文件中的内容，这样就能够看到内存保
        //护上发生的变更了（通过解析/proc/self/maps 就能获取映射信息)
        /* Display line from /proc/self/maps corresponding to mapping */
        printf("Before mprotect()\n");
        snprintf(cmd, CMD_SIZE, SHELL_FMT, (long) getpid());
        system(cmd);
    
        /* 将该区域上的保护修改为读加写*/
        if (mprotect(addr, LEN, PROT_READ | PROT_WRITE) == -1){
        
            perror("mprotect");
            exit(EXIT_FAILURE);
        }
    
        // 打印出与该映射区域对应的/proc/PID/maps 文件中的内容，这样就能够看到内存保
        //护上发生的变更了（通过解析/proc/self/maps 就能获取映射信息)
        printf("After mprotect()\n");
        system(cmd);                /* Review protection via /proc/self/maps */
    
        exit(EXIT_SUCCESS);
    }

效果如下：  
![在这里插入图片描述][2021060417343874.png]  
从上面输出的最后一行可以看出 mprotect()已经将内存区域上的权限修改为PROT\_READ | PROT\_WRITE

下面的程序分配了四页内存，使这些页中的第三页只读，然后执行一个循环，向上遍历分配的区域修改字节。

#include <unistd.h>
    #include <signal.h>
    #include <stdio.h>
    #include <malloc.h>
    #include <stdlib.h>
    #include <errno.h>
    #include <sys/mman.h>
    
    #define handle_error(msg) \
               do {
           perror(msg); exit(EXIT_FAILURE); } while (0)
    
    char *buffer;
    
    static void
    handler(int sig, siginfo_t *si, void *unused)
    {
        
        printf("Got SIGSEGV at address: 0x%lx\n",
               (long) si->si_addr);
        exit(EXIT_FAILURE);
    }
    
    int main(int argc, char *argv[])
    {
        
        char *p;
        int pagesize;
        struct sigaction sa;
    
        sa.sa_flags = SA_SIGINFO;
        sigemptyset(&sa.sa_mask);
        sa.sa_sigaction = handler;
        if (sigaction(SIGSEGV, &sa, NULL) == -1)
            handle_error("sigaction");
    
        pagesize = sysconf(_SC_PAGE_SIZE);
        if (pagesize == -1)
            handle_error("sysconf");
    
        /* Allocate a buffer aligned on a page boundary;
           initial protection is PROT_READ | PROT_WRITE */
    
        buffer = (char *)memalign(pagesize, 4 * pagesize);
        if (buffer == NULL)
            handle_error("memalign");
        printf("Start of region:        0x%lx\n", (long) buffer);
    
        if (mprotect(buffer + pagesize * 2, pagesize,
                     PROT_READ) == -1)
            handle_error("mprotect");
    
        for (p = buffer ; ; )
            *(p++) = 'a';
    
        printf("Loop completed\n");     /* Should never happen */
        exit(EXIT_SUCCESS);
    }

## 内存锁：mlock()和mlockall() ##

在一些应用程序中将一个进程的虚拟内存的部分或者全部锁进内存以确保它们总是位于物理内存是非常有用的。之所以需要这样做的一个原因是它可以提高性能。对被锁住的分页的访问可以确保永远不会因为分页故障而发生延迟。

给内存加锁的另一个原因是安全。如果一个包含敏感信息的虚拟内存分页永远也不会被交换出去，那么该分页的副本就不会被写入磁盘（攻击者可能会故意通过运行一个消耗大量内存的程序来构造这种场景，从而强制其他进程占据的内存被交换到磁盘上。）

### RLIMIT\_MEMLOCK 资源限制 ###

RLIMIT\_MEMLOCK为一个进程能够锁进内存的字节数设定了一个上限。

在 2.6.9 之前的 Linux 内核中，只有特权进程（CAP\_IPC\_LOCK）才能给内存加锁，RLIMIT\_MEMLOCK 软资源限制为一个特权进程能够锁住的字节数设定一个上限。

从 Linux 2.6.9 开始，内存加锁模型发生了变化，即允许非特权进程给一小段内存进行加锁。

*  特权进程能够锁住的内存数量是没有限制的（即 RLIMIT\_MEMLOCK 会被忽略）；
 *  非特权进程能够锁住的内存数量上限由软限制 RLIMIT\_MEMLOCK 定义

软和硬 RLIMIT\_MEMLOCK 限制的默认值都是 8 个分页（即在 x86-32 上是 32768 字节）。

RLIMIT\_MEMLOCK 限制影响

*  mlock()和mlockall()
 *  mmap() MAP\_LOCKED标记，该标记用来在映射被创建时将内存映射锁进内存
 *  shmctl() SHM\_LOCK 操作，该操作用来给 System V 共享内存段加锁

由于虚拟内存的管理单位是分页，因此内存加锁会应用于整个分页。在执行权限检测时，RLIMIT\_MEMLOCK 限制会被向下舍入到最近的系统分页大小的整数倍。

### 给内存区域加锁和解锁 ###

一个进程可以使用 mlock()和 munlock()来给一块内存区域加锁和解锁。

NAME
           mlock, munlock, mlockall, munlockall - lock and unlock memory
    
    SYNOPSIS
           #include <sys/mman.h>
    
           int mlock(const void *addr, size_t len);
           int munlock(const void *addr, size_t len);

mlock()系统调用会锁住调用进程的虚拟地址空间中起始地址为 addr 长度为 length 字节的区域中的所有分页

在 mlock()调用成功之后就能确保指定区域中的分页会被锁住并驻留在物理内存中。当没有足够的物理内存来锁住所有所请求的分页或请求违背 RLIMIT\_MEMLOCK 软资源限制时mlock()系统调用就会失败

由于加锁操作的单位是分页，因此被锁住的区域的结束位置为大于 length 加 addr 的下一个分页边界。例如，在一个分页大小为 4096 字节的系统上，mlock(2000, 4000)调用会将 0 到8191 之间的字节锁住

> 通过查看 Linux 特有的/proc/PID/status 文件中的 VmLck 条目能够找出一个进程当前已经锁住的内存数量

munlock()即删除之前由调用进程创建的内存锁。给一组分页解锁并不能确保它们就不会驻留在内存中了：只有在其他进程请求内存的时候才会从RAM 中删除分页。

除了显式地使用 munlock()之外，内存锁在下列情况下会被自动删除

*  在进程终止时。
 *  当被锁住的分页通过 munmap()被解除映射时。
 *  当被锁住的分页被使用 mmap() MAP\_FIXED 标记的映射覆盖时。

内存锁不会被通过 fork()创建的子进程继承，也不会在 exec()执行期间被保留。

当多个进程共享一组分页时（如 MAP\_SHARED 映射），只要还存在一个进程持有着这些分页上的内存锁，那么这些分页就会保持被锁进内存的状态。

内存锁不在单个进程上叠加。如果一个进程重复地在一个特定虚拟地址区域上调用mlock()，那么只会建立一个锁，并且只需要通过一个 munlock()调用就能够删除这个锁。另一方面，如果使用 mmap()将同一组分页（即同样的文件）映射到单个进程中的几个不同的位置，然后分别给所有这些映射加锁，那么这些分页会保持被锁进 RAM 的状态直到所有的映射都被解锁为止

### 给一个进程占据的所有内存加锁和解锁 ###

一个进程可以使用 mlockall()和 munlockall()给它占据的所有内存加锁和解锁。

NAME
           mlock, munlock, mlockall, munlockall - lock and unlock memory
    
    SYNOPSIS
           #include <sys/mman.h>
    
           int mlockall(int flags);
           int munlockall(void);

flags 参数的取值为下面这些常量中的一个或多个取 OR

*  MCL\_CURRENT：将调用进程的虚拟地址空间中当前映射的分页锁进内存，包括当前为程序文本段、数据段、内存映射以及栈分配的所有分页
 *  MCL\_FUTURE ：
    
     *  将后继映射进调用进程的虚拟地址空间的所有分页锁进内存。
     *  例如，此类分页可能是通过 mmap()或 shmat()映射的一个共享内存区域的一部分，或向上增长的堆或向下增长的栈的一部分。
     *  指定 MCL\_FUTURE 标记的结果是后续的内存分配操作（如 mmap()、sbrk()或 malloc()）可能会失败，或者栈增长可能会产生 SIGSEGV 信号，当然前提是系统已经没有 RAM 分配给进程或者已经达到了 RLIMIT\_MEMLOCK 软资源限制

通过 mlock()创建的内存锁上有关约束、生命周期以及继承性方面的规则同样也适用于通过 mlockall()创建的内存锁。

munlockall()系统调用将调用进程的所有分页解锁并撤销之前的 mlockall(MCL\_ FUTURE)调用所产生的结果。与 munlock()一样，这个调用无法保证会从 RAM 中删除被解锁的分页。

注意 shmctl() SHM\_LOCK 操作（48.7 节）的语义与 mlock()和 mlockall()的语义是不同的，具体如下。

*  在 SHM\_LOCK 操作之后，分页只有在因后续引用而发生故障时才会被锁进内存。与之相反的是，mlock()和 mlockall()调用在返回之前会将所有分页锁进内存。
 *  SHM\_LOCK 操作会设置共享内存段的一个属性，而不是进程的属性。（正因为这个原因，/proc/PID/status VmLck 字段的值中并没有包含使用 SHM\_LOCK 锁住的所有附加System V 共享内存段的大小。）这意味着分页一旦因故障被锁进了内存，那么即使所有进程都与这个共享内存段分离了，分页还是会保持驻留在内存中的状态。与之相反的是，使用 mlock()（或 mlockall()）锁进内存的区域只有在还存在进程持有该区域上的锁时才会保持被锁进内存的状态

## 确定内存驻留性：mincore() ##

mincore()系统调用是内存加锁系统调用的补充，它报告在一个虚拟地址范围中哪些分页当前驻留在RAM中，因此在访问这些分页时也不会导致分页故障

SUSv3 并没有规定 mincore()，很多 UNIX 实现都提供了这个函数，但不是所有的 UNIX实现都提供了这个函数。在 Linux 上从内核 2.4 开始提供了 mincore()。

NAME
           mincore - determine whether pages are resident in memory
    
    SYNOPSIS
           #include <unistd.h>
           #include <sys/mman.h>
    
           int mincore(void *addr, size_t length, unsigned char *vec);

mincore()返回起始地址为addr长度为length字节的虚拟地址访问中分页的内存驻留信息。addr 中的地址必须是分页对齐的，并且由于返回的信息是有关整个分页的，因此length 实际上会被向上舍入到系统分页大小的下一个整数倍。

内存驻留相关的信息会通过 vec 返回，它是一个数组，其大小为(length + PAGE\_SIZE – 1) / PAGE\_SIZE 字节。每个字节的最低有效位在相应分页驻留在内存中时会被设置，而其他位的设置在一些 UNIX 实现上是未定义的，因此可移植的应用程序应该只测试最低有效位。

mincore()返回的信息在执行调用的时刻与检查 vec 中的元素的时刻期间可能会发生变化。唯一能够确保保持驻留在内存中的分页是那些通过 mlock()或 mlockall()锁住的分页。

下面演示了如何使用 mlock()和 mincore()。这个程序首先分配并使用 mmap()  
映射了一块内存区域，然后以固定的时间间隔使用 mlock()将整个区域或一组分页锁进内存。（传给这个程序的所有命令行参数的单位是分页，程序会将这些参数转换成字节，因为 mmap()、mlock()以及 mincore()使用的是字节。）在调用 mlock()之前和之后，程序使用mincore()来获取这个区域中分页的内存驻留信息并图形化地将这些信息展现了出来。

#include <unistd.h>
    #include <signal.h>
    #include <stdio.h>
    #include <malloc.h>
    #include <stdlib.h>
    #include <errno.h>
    #include <sys/mman.h>
    #include <string.h>
    #define _BSD_SOURCE             /* Get mincore() declaration and MAP_ANONYMOUS
                                       definition from <sys/mman.h> */
    #include <sys/mman.h>
    static void displayMincore(char *addr, size_t length)
    {
        
        unsigned char *vec;
        long pageSize, numPages, j;
    
    #ifndef _SC_PAGESIZE
        pageSize = getpagesize();   /* Some systems don't have _SC_PAGESIZE */
    #else
        pageSize = sysconf(_SC_PAGESIZE);
    #endif
    
        numPages = (length + pageSize - 1) / pageSize;
        vec = (unsigned char *)malloc(numPages);
        if (vec == NULL){
        
            perror("malloc");
            exit(EXIT_FAILURE);
        }
    
    
        if (mincore(addr, length, vec) == -1){
        
            perror("mincore");
            exit(EXIT_FAILURE);
        }
    
    
        for (j = 0; j < numPages; j++) {
        
            if (j % 64 == 0)
                printf("%s%10p: ", (j == 0) ? "" : "\n", addr + (j * pageSize));
            printf("%c", (vec[j] & 1) ? '*' : '.');
        }
        printf("\n");
    
        free(vec);
    }
    int main(int argc, char *argv[])
    {
        
        char *addr;
        size_t len, lockLen;
        long pageSize, stepSize, j;
    
        if (argc != 4 || strcmp(argv[1], "--help") == 0){
        
            printf("%s num-pages lock-page-step lock-page-len\n", argv[0]);
            exit(EXIT_FAILURE);
        }
    
    
    #ifndef _SC_PAGESIZE
        pageSize = getpagesize();
        if (pageSize == -1){
        
            printf("getpagesize");
            exit(EXIT_FAILURE);
        }
    
    #else
        pageSize = sysconf(_SC_PAGESIZE);
        if (pageSize == -1){
        
            printf("sysconf(_SC_PAGESIZE)");
            exit(EXIT_FAILURE);
        }
    #endif
    
        len =      atoi(argv[1]) * pageSize;  //"num-pages"
        stepSize = atoi(argv[2]) * pageSize;  //"lock-page-step"
        lockLen =  atoi(argv[3]) * pageSize;  //"lock-page-len"
    
        addr = (char *)mmap(NULL, len, PROT_READ, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
        if (addr == MAP_FAILED){
        
            perror("mmap");
            exit(EXIT_FAILURE);
        }
    
    
        printf("Allocated %ld (%#lx) bytes starting at %p\n",
               (long) len, (unsigned long) len, addr);
        /*FIXME: above: should use %zu here, and remove (long) cast */
    
        printf("Before mlock:\n");
        displayMincore(addr, len);
    
        /* Lock pages specified by command-line arguments into memory */
    
        for (j = 0; j + lockLen <= len; j += stepSize)
            if (mlock(addr + j, lockLen) == -1){
        
                perror("mlock");
                exit(EXIT_FAILURE);
            }
    
    
        printf("After mlock:\n");
        displayMincore(addr, len);
    
        exit(EXIT_SUCCESS);
    }

下面中分配了 32 个分页，每组为 8 个分页，并给三个连续分页加锁。  
![在这里插入图片描述][20210604180749167.png]  
在程序输出中，点表示分页不在内存中，星号表示分页驻留在内存中。从最后一行输出中可以看出，每组 8 个分页中有 3 个分页是驻留在内存中的。

在这个例子中假设了超级用户特权，这样程序就能够使用 mlock()。从 Linux 2.6.9 开始就无需这种特权了，只要待加锁的内存量不超过 RLIMIT\_MEMLOCK 软资源限制即可。

## 建议后续的内存使用模式：madvise() ##

madvise() 通过通知内核调用进程对起始地址为addr长度为length字节的范围之内分页的可能的使用情况来提升应用程序的性能。内核可能会使用这种信息来提升分页之下的文件映射IO效率。

NAME
           madvise - give advice about use of memory
    
    SYNOPSIS
           #include <sys/mman.h>
    
           int madvise(void *addr, size_t length, int advice);

addr 中的值必须是分页对齐的，length 实际上会被向上舍入到系统分页大小的下一个整数倍。advice 参数的取值为下列之一

*  MADV\_NORMAL ：这是默认行为。分页是以簇的形式（较小的一个系统分页大小的整数倍）传输的。这个值会导致一些预先读和事后读。
 *  MADV\_RANDOM ：这个区域中的分页会被随机访问，这样预先读将不会带来任何好处，因此内核在每次读取时所取出的数据量应该尽可能少。
 *  MADV\_SEQUENTIAL ：在这个范围中的分页只会被访问一次，并且是顺序访问，因此内核可以激进地预先读，并且分页在被访问之后就可以将其释放了
 *  MADV\_WILLNEED ：预先读取这个区域中的分页以备将来的访问之需。MADV\_WILLNEED 操作的效果与 Linux特有的 readahead()系统调用和 posix\_fadvise() POSIX\_FADV\_WILLNEED 操作的效果类似
 *  MADV\_DONTNEED ：调用进程不再要求这个区域中的分页驻留在内存中。这个标记的精确效果在不同 UNIX 实现上是不同的。

大多数 UNIX 实现都提供了一个 madvise()，它们通常至少支持上面描述的 advice 常量。然而SUSv3 使用了一个不同的名称来标准化了这个 API，即 posix\_madvise()，并且在相应的 advice 常量  
上加上了一个前缀字符串 POSIX\_。因此，这些常量变成了POSIX\_MADV\_NORMAL、POSIX\_MADV\_RANDOM、POSIX\_MADV\_SEQUENTIAL、POSIX\_MADV\_WILLNEED等等

# 总结 #

*  mprotect()系统调用修改一块虚拟内存区域上的保护信息
 *  mlock()和mlockall()系统调用将一块虚拟内存区域锁进物理内存，从而防止它被交换出去
 *  mincore()系统调用让一个进程能够确定一块虚拟内存区域中的分页是否驻留在物理内存中
 *  madvise()系统调用让一个进程能够将其对虚拟内存区域的使用模式报告给内核

其中一些系统调用只有与共享内存区域结合起来之后才能够发挥特别的作用，但它们可以被应用于一个进程的虚拟内存中的任何区域

[mmap]: https://blog.csdn.net/zhizhengguan/article/details/89413096
[2021060417343874.png]: /images/20221014/b45db275474f430d9a45b488dceff49c.png
[20210604180749167.png]: /images/20221014/237ca80ebdf5491094da573dafff0af8.png