C++中的`mmap`/`mprotect`系统调用：实现自定义内存保护与权限管理

C++ 中的 mmap/mprotect 系统调用：实现自定义内存保护与权限管理

大家好，今天我们来深入探讨 C++ 中与内存管理相关的两个强大的系统调用：mmap 和 mprotect。这两个函数允许我们在用户空间对虚拟内存进行细粒度的控制，实现自定义的内存保护和权限管理。理解并掌握它们，能帮助我们构建更安全、更高效的应用程序。

1. 虚拟内存基础

在深入 mmap 和 mprotect 之前，我们需要先了解一些关于虚拟内存的基本概念。

• 虚拟地址空间： 操作系统为每个进程提供一个独立的虚拟地址空间。这个地址空间是对物理内存的抽象，进程只能通过虚拟地址访问内存，而不能直接访问物理地址。

• 页（Page）： 虚拟地址空间被划分成固定大小的块，称为页。通常，页的大小为 4KB。

• 页表： 操作系统维护一个页表，用于将虚拟地址映射到物理地址。

• 内存保护： 操作系统可以为每个页设置不同的访问权限，例如只读、只写、可执行等。

• 分页机制： 当进程访问一个虚拟地址时，CPU 的内存管理单元（MMU）会查找页表，将虚拟地址转换为物理地址。如果虚拟地址没有映射到物理地址（例如，该页未被分配），或者进程试图以不允许的方式访问该页（例如，向只读页写入数据），则会触发一个缺页异常。

2. mmap：将文件或设备映射到内存

mmap（memory map）系统调用允许我们将文件或设备映射到进程的虚拟地址空间。这使得我们可以像访问内存一样访问文件或设备的内容。

2.1 函数原型

#include <sys/mman.h>

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

int munmap(void *addr, size_t length); //取消映射

• addr: 映射区的起始地址。通常设置为 NULL，让系统自动选择一个合适的地址。
• length: 映射区的长度，以字节为单位。
• prot: 映射区的保护权限，可以是以下标志的组合：
  • PROT_READ: 允许读取。
  • PROT_WRITE: 允许写入。
  • PROT_EXEC: 允许执行。
  • PROT_NONE: 禁止访问。
• flags: 映射区的标志，影响映射的行为，常见的标志包括：
  • MAP_SHARED: 对映射区的修改会反映到文件中，并且可以被其他映射同一文件的进程看到。
  • MAP_PRIVATE: 对映射区的修改不会反映到文件中，其他映射同一文件的进程也看不到这些修改。
  • MAP_ANONYMOUS: 创建一个匿名映射，不与任何文件关联。常与MAP_SHARED或MAP_PRIVATE结合使用。
  • MAP_FIXED: 强制系统使用addr指定的地址进行映射。 不推荐使用，因为它可能导致不可预测的行为，如果指定的地址不可用，mmap 将失败。
• fd: 要映射的文件描述符。如果使用 MAP_ANONYMOUS，则设置为 -1。
• offset: 文件映射的起始偏移量，以字节为单位。必须是页大小的整数倍。

2.2 用法示例：映射文件

#include <iostream>
#include <fstream>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <cerrno>
#include <cstring>

int main() {
    const char* filename = "test.txt";
    size_t filesize = 1024; // 1KB

    // Create a dummy file for testing
    std::ofstream outfile(filename);
    if (outfile.fail()) {
        std::cerr << "Error creating file: " << strerror(errno) << std::endl;
        return 1;
    }
    outfile.seekp(filesize - 1);  // Create a file with the desired size
    outfile << '';           // Ensure the file has the specified size
    outfile.close();

    int fd = open(filename, O_RDWR);
    if (fd == -1) {
        std::cerr << "Error opening file: " << strerror(errno) << std::endl;
        return 1;
    }

    void* mapped_region = mmap(NULL, filesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (mapped_region == MAP_FAILED) {
        std::cerr << "mmap failed: " << strerror(errno) << std::endl;
        close(fd);
        return 1;
    }

    // Now we can access the file content through the mapped_region pointer
    char* data = static_cast<char*>(mapped_region);
    data[0] = 'H';
    data[1] = 'e';
    data[2] = 'l';
    data[3] = 'l';
    data[4] = 'o';
    data[5] = '';

    std::cout << "File content: " << data << std::endl;

    // Unmap the region
    if (munmap(mapped_region, filesize) == -1) {
        std::cerr << "munmap failed: " << strerror(errno) << std::endl;
    }

    close(fd);

    // Verify the changes are reflected in the file
    std::ifstream infile(filename);
    std::string file_content;
    std::getline(infile, file_content);
    std::cout << "File content after unmapping: " << file_content << std::endl;

    return 0;
}

这个例子创建了一个名为 test.txt 的文件，然后使用 mmap 将其映射到内存。我们可以通过 mapped_region 指针直接修改文件的内容。由于使用了 MAP_SHARED 标志，这些修改会立即反映到文件中。最后，我们使用 munmap 取消映射，并关闭文件描述符。

2.3 用法示例：匿名映射

#include <iostream>
#include <sys/mman.h>
#include <unistd.h>
#include <cerrno>
#include <cstring>

int main() {
    size_t region_size = 4096; // 4KB

    void* mapped_region = mmap(NULL, region_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_SHARED, -1, 0);
    if (mapped_region == MAP_FAILED) {
        std::cerr << "mmap failed: " << strerror(errno) << std::endl;
        return 1;
    }

    // Initialize the mapped region
    char* data = static_cast<char*>(mapped_region);
    strcpy(data, "Hello, anonymous memory!");

    std::cout << "Mapped region content: " << data << std::endl;

    // Create a child process to share the memory
    pid_t pid = fork();
    if (pid == -1) {
        std::cerr << "fork failed: " << strerror(errno) << std::endl;
        munmap(mapped_region, region_size);
        return 1;
    }

    if (pid == 0) {
        // Child process
        std::cout << "Child process, content: " << data << std::endl;
        strcpy(data, "Modified by child!");
        std::cout << "Child process, modified content: " << data << std::endl;
    } else {
        // Parent process
        wait(NULL); // Wait for the child process to finish
        std::cout << "Parent process, content after child modification: " << data << std::endl;
    }

    // Unmap the region
    if (munmap(mapped_region, region_size) == -1) {
        std::cerr << "munmap failed: " << strerror(errno) << std::endl;
    }

    return 0;
}

这个例子创建了一个匿名映射区域，不与任何文件关联。我们使用 MAP_ANONYMOUS 标志来创建匿名映射。然后，我们fork一个子进程，由于使用了MAP_SHARED标志，父子进程共享该内存区域，因此子进程可以修改父进程映射区域的内容，并且修改对父进程可见。

3. mprotect：修改内存保护权限

mprotect 系统调用允许我们修改进程的虚拟地址空间中某个区域的内存保护权限。

3.1 函数原型

#include <sys/mman.h>

int mprotect(void *addr, size_t len, int prot);

• addr: 要修改保护权限的内存区域的起始地址。必须是页大小的整数倍。
• len: 要修改保护权限的内存区域的长度，以字节为单位。必须是页大小的整数倍。
• prot: 新的保护权限，可以是以下标志的组合：
  • PROT_READ: 允许读取。
  • PROT_WRITE: 允许写入。
  • PROT_EXEC: 允许执行。
  • PROT_NONE: 禁止访问。

3.2 用法示例：防止缓冲区溢出

#include <iostream>
#include <sys/mman.h>
#include <unistd.h>
#include <cerrno>
#include <cstring>

int main() {
    size_t page_size = sysconf(_SC_PAGE_SIZE);
    size_t buffer_size = page_size; // Make the buffer one page in size.

    // Allocate a buffer using mmap
    void* buffer = mmap(NULL, buffer_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (buffer == MAP_FAILED) {
        std::cerr << "mmap failed: " << strerror(errno) << std::endl;
        return 1;
    }

    // Make the last page read-only
    if (mprotect(static_cast<char*>(buffer) + (buffer_size - page_size), page_size, PROT_READ) == -1) {
        std::cerr << "mprotect failed: " << strerror(errno) << std::endl;
        munmap(buffer, buffer_size);
        return 1;
    }

    // Try to write beyond the buffer (overflow)
    char* data = static_cast<char*>(buffer);
    try {
        strncpy(data, "This is a test string that will cause a buffer overflow", buffer_size);  // Intentionally causing overflow
        std::cout << "Write successful (should not happen)" << std::endl; // This shouldn't print
    } catch (const std::exception& e) {
        std::cerr << "Exception caught: " << e.what() << std::endl;
    }

    // Clean up
    if (munmap(buffer, buffer_size) == -1) {
        std::cerr << "munmap failed: " << strerror(errno) << std::endl;
    }

    return 0;
}

在这个例子中，我们使用 mmap 分配了一个缓冲区，然后使用 mprotect 将缓冲区的最后 4KB 设置为只读。如果我们尝试向这个只读区域写入数据，将会触发一个段错误(Segmentation Fault)，从而防止缓冲区溢出。注意，上面的代码实际上不会抛出C++异常，而是会导致程序崩溃，因为访问受保护的内存会触发操作系统信号，默认情况下会导致程序终止。我们需要设置信号处理程序来捕获这些信号，并将其转换为C++异常（但这超出了本示例的范围）。为了更清晰地展示mprotect的效果，我简化了异常处理部分。

3.3 用法示例：实现写时复制(Copy-on-Write)

#include <iostream>
#include <sys/mman.h>
#include <unistd.h>
#include <cerrno>
#include <cstring>
#include <signal.h>

// Global variables for the shared memory region
void* shared_memory = nullptr;
size_t memory_size;

// Signal handler for SIGSEGV (segmentation fault)
void signal_handler(int signum, siginfo_t* info, void* context) {
    if (signum == SIGSEGV) {
        // Get the address that caused the fault
        void* fault_address = info->si_addr;

        // Calculate the page boundary that contains the fault address
        size_t page_size = sysconf(_SC_PAGE_SIZE);
        void* page_boundary = (void*)((uintptr_t)fault_address & ~(page_size - 1));

        // Check if the fault address is within our shared memory region
        if (page_boundary >= shared_memory && page_boundary < (char*)shared_memory + memory_size) {
            // Allocate a new page of memory
            void* new_page = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
            if (new_page == MAP_FAILED) {
                std::cerr << "mmap failed in signal handler: " << strerror(errno) << std::endl;
                exit(1); // Or handle the error appropriately
            }

            // Copy the contents of the old page to the new page
            memcpy(new_page, page_boundary, page_size);

            // Remap the new page to the original address
            if (mmap(page_boundary, page_size, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED | MAP_ANONYMOUS, -1, 0) == MAP_FAILED) {
                std::cerr << "mmap (MAP_FIXED) failed in signal handler: " << strerror(errno) << std::endl;
                munmap(new_page, page_size);
                exit(1); // Or handle the error appropriately
            }

            // Unmap the old read-only page
            //munmap(page_boundary, page_size); //Don't unmap, since we remapped to the same location

            // Remove the read-only protection from the new page
            if (mprotect(page_boundary, page_size, PROT_READ | PROT_WRITE) == -1) {
                std::cerr << "mprotect failed in signal handler: " << strerror(errno) << std::endl;
                munmap(new_page, page_size);
                exit(1); // Or handle the error appropriately
            }

            std::cout << "Copy-on-write triggered at address " << fault_address << std::endl;
            return; // Signal handled
        }
    }

    // If the signal is not handled, restore the default behavior
    std::cerr << "Unhandled signal, exiting." << std::endl;
    signal(signum, SIG_DFL);
    raise(signum); // Re-raise the signal
}

int main() {
    memory_size = sysconf(_SC_PAGE_SIZE) * 2; // Two pages

    // Allocate shared memory
    shared_memory = mmap(NULL, memory_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if (shared_memory == MAP_FAILED) {
        std::cerr << "mmap failed: " << strerror(errno) << std::endl;
        return 1;
    }

    // Initialize the shared memory
    strcpy((char*)shared_memory, "Initial data");
    std::cout << "Initial data: " << (char*)shared_memory << std::endl;

    // Set the first page to read-only
    size_t page_size = sysconf(_SC_PAGE_SIZE);
    if (mprotect(shared_memory, page_size, PROT_READ) == -1) {
        std::cerr << "mprotect failed: " << strerror(errno) << std::endl;
        munmap(shared_memory, memory_size);
        return 1;
    }

    // Install signal handler for SIGSEGV
    struct sigaction sa;
    sa.sa_sigaction = signal_handler;
    sa.sa_flags = SA_SIGINFO;
    sigemptyset(&sa.sa_mask);
    if (sigaction(SIGSEGV, &sa, NULL) == -1) {
        std::cerr << "sigaction failed: " << strerror(errno) << std::endl;
        munmap(shared_memory, memory_size);
        return 1;
    }

    // Attempt to write to the read-only page (this will trigger the signal handler)
    strcpy((char*)shared_memory, "Modified data");
    std::cout << "Modified data: " << (char*)shared_memory << std::endl;

    // Restore the second page to read-write
    if (mprotect((char*)shared_memory + page_size, page_size, PROT_READ | PROT_WRITE) == -1) {
        std::cerr << "mprotect failed: " << strerror(errno) << std::endl;
        munmap(shared_memory, memory_size);
        return 1;
    }

    // Clean up
    munmap(shared_memory, memory_size);

    return 0;
}

此示例展示了如何使用 mprotect 实现写时复制 (Copy-on-Write, COW)。 COW 是一种优化技术，用于延迟或避免复制资源，直到真正需要进行写入操作时才进行复制。 在这个例子中，我们首先分配一个共享内存区域并将其初始化为某个字符串。 然后，我们将该内存区域的第一页设置为只读。 当我们尝试写入只读内存时，会触发一个 SIGSEGV 信号。 信号处理程序会捕获此信号，分配一个新的内存页，将原始数据复制到新页，然后将新页映射到原始地址。 最后，它会取消原始页面的只读保护。 这样，我们就可以修改内存，而无需一开始就复制整个内存区域。 COW 对于在进程之间共享数据非常有用，因为它允许进程共享相同的内存区域，直到其中一个进程需要修改数据。

注意: 这个例子中使用了MAP_FIXED标志，虽然前面说过不推荐使用它，但为了实现COW，我们需要把新分配的页面映射到原来的地址。 使用 MAP_FIXED 需要非常小心，因为如果指定的地址不可用，mmap 将失败，可能会导致程序崩溃。

4. 常见应用场景

mmap 和 mprotect 在许多场景下都非常有用：

• 共享内存： mmap 可以用于在进程之间共享内存，实现进程间通信。
• 加载大型文件： mmap 可以将大型文件映射到内存，避免一次性读取整个文件，提高效率。
• 内存保护： mprotect 可以用于保护敏感数据，防止恶意代码修改。
• 动态代码生成： mprotect 可以用于将内存区域设置为可执行，实现动态代码生成。
• 数据库系统： 数据库系统使用mmap来将数据库文件映射到内存，从而提高数据访问速度。
• 游戏开发： 游戏开发中，可以使用mmap来加载大型游戏资源，如纹理和模型。

5. 注意事项

• mmap 和 mprotect 操作的地址和长度必须是页大小的整数倍。
• 修改内存保护权限可能会影响程序的安全性，需要谨慎使用。
• 使用 MAP_FIXED 标志需要非常小心，因为它可能导致不可预测的行为。
• munmap 用于取消映射，必须与 mmap 配对使用，否则可能导致内存泄漏。
• 处理SIGSEGV信号需要非常小心，错误的信号处理程序可能会导致程序崩溃。
• 在高并发环境下，需要考虑线程安全问题。

6. 与 new/delete 的比较

Feature	mmap	new/delete
Level	System call, direct interaction with OS	C++ language feature, uses memory management provided by the standard library
Granularity	Page level	Object level
Use Cases	File mapping, shared memory, custom memory management, COW	Object allocation, dynamic memory management for C++ objects
Control	Fine-grained control over memory region attributes (protection, sharing)	Limited control, primarily manages object lifecycle
Overhead	Lower overhead for large contiguous blocks, potential overhead for small allocations due to page alignment	Potential overhead for small allocations due to memory management metadata
Error Handling	Returns MAP_FAILED on error, requires manual error checking	Throws exceptions on allocation failure
Memory Management	Requires explicit munmap to release memory	Automatic memory management through RAII and destructors

7. 提升程序性能与安全性

mmap和mprotect为C++程序员提供了在内存管理方面更精细的控制，允许我们构建高性能，更安全的应用程序。通过映射文件到内存，我们可以避免传统I/O操作的开销，从而显著提升程序性能。此外，通过使用mprotect，我们可以动态地修改内存区域的权限，从而增强程序的安全性，防止恶意代码的攻击。

8. 最后的一些想法

今天我们学习了 mmap 和 mprotect 这两个强大的系统调用。 通过掌握它们，我们可以更好地控制进程的虚拟地址空间，实现自定义的内存保护和权限管理，构建更安全、更高效的应用程序。 希望今天的讲解对大家有所帮助！

更多IT精英技术系列讲座，到智猿学院