Memmap数据结构

用来管理通过系统调用mmap获得的内存段。

mmap 系统调用

https://linux.die.net/man/2/mmap

mmap（memory map）类Unix系统中的一个重要系统调用，用于在进程的地址空间中创建内存映射。它允许程序将文件或设备直接映射到内存中，从而实现高效的文件访问和内存管理。

基本概念

mmap系统调用在进程的虚拟地址空间中创建一个新的映射，可以是：

文件映射：将文件的一部分映射到内存
匿名映射：不关联任何文件的内存区域
- 匿名映射用于实现malloc的大内存分配

工作原理

建立映射：
- 内核在进程的虚拟地址空间中分配区域
- 对于文件映射，建立虚拟地址到文件块的映射关系
- 实际物理内存分配延迟到首次访问时（按需分页）
访问机制：
- 进程访问映射区域时触发缺页异常
- 内核处理异常，加载对应文件内容到物理内存
- 建立页表项，指向实际物理页
写回机制：
- MAP_SHARED：修改会写入页缓存，最终由内核写回文件
- MAP_PRIVATE：修改触发写时复制，创建私有副本

函数原型

#include <sys/mman.h>

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

参数说明

参数	说明
`addr`	建议的映射起始地址（hint）
`length`	映射区域的长度（字节数）
`prot`	内存保护标志（读/写/执行权限）
`flags`	映射类型和选项
`fd`	文件描述符（匿名映射时设为-1）
`offset`	文件映射的起始偏移量（通常为0）

保护标志（prot）

标志	说明
`PROT_READ`	页面可读
`PROT_WRITE`	页面可写
`PROT_EXEC`	页面可执行
`PROT_NONE`	页面不可访问
……	……

映射标志（flags）

| 标志 | 说明 | |——————|———————————————————————-| | MAP_SHARED | 共享映射：表示映射区域是共享的。对映射区域的修改会被写回到文件（如果是文件映射），并且其他映射了同一文件的进程可以看到这些修改（但是修改不一定会及时写回文件）。在匿名映射的情况下，MAP_SHARED可以用于实现父子进程之间的共享内存 | | MAP_PRIVATE | 私有映射：写时复制（Copy-on-Write），修改不会影响原文件 | | MAP_ANONYMOUS | 匿名映射：不关联文件（fd应为-1） | | MAP_FIXED | 使用精确指定的地址。addr 必须是页面大小的整数倍。如果由 addr 和 len 指定的内存区域与任何现有映射的页面重叠，则现有映射的重叠部分将被丢弃。如果无法使用指定地址，mmap() 将失败。由于要求固定地址的映射方式可移植性较差，不建议使用此选项。 | | …… | ……|

示例

文件映射示例

#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>

int main() {
    int fd = open("example.txt", O_RDWR);
    struct stat sb;
    fstat(fd, &sb);
    
    // 创建文件映射
    char *mem = mmap(NULL, sb.st_size, 
                    PROT_READ | PROT_WRITE,
                    MAP_SHARED, fd, 0);
    
    // 通过指针访问文件内容
    printf("First character: %c\n", mem[0]);
    
    // 修改文件内容
    mem[0] = 'A';
    
    // 同步到磁盘
    msync(mem, sb.st_size, MS_SYNC);
    
    // 解除映射
    munmap(mem, sb.st_size);
    close(fd);
    return 0;
}

匿名映射示例（进程间共享）

#include <sys/mman.h>
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>

int main() {
    // 创建共享匿名映射
    int *shared = mmap(NULL, sizeof(int),
                      PROT_READ | PROT_WRITE,
                      MAP_SHARED | MAP_ANONYMOUS,
                      -1, 0);
    
    *shared = 0;
    
    pid_t pid = fork();
    if (pid == 0) {
        // 子进程
        (*shared)++;
        _exit(0);
    } else {
        // 父进程
        wait(NULL);
        printf("Shared value: %d\n", *shared); // 输出1
        munmap(shared, sizeof(int));
    }
    return 0;
}

AOSP里的封装

void* MemMap::TargetMMap(void* start, size_t len, int prot, int flags, int fd, off_t fd_off) {
  return mmap(start, len, prot, flags, fd, fd_off);
}

int MemMap::TargetMUnmap(void* start, size_t len) {
  return munmap(start, len);
}

AOSP中的MemMap

在不支持 MAP_32BIT 的64位系统上， MemMap的实现将进行线性扫描以查找空闲页面。出于安全考虑，扫描的起始位置使用动态初始化器随机化。不能有其他静态初始化器访问MemMap，否则，调用时可能会看到未初始化的值。

宏USE_ART_LOW_4G_ALLOCATOR

/*
 * 内存分配器架构选择逻辑：
 * 
 * 在64位系统（非Fuchsia）且满足以下条件时启用低4G内存分配器：
 * 1. ARM64架构（__aarch64__）或
 * 2. RISC-V架构（__riscv）或 
 * 3. Apple平台（__APPLE__）
 * 
 */

#if defined(__LP64__) && !defined(__Fuchsia__) && \
    (defined(__aarch64__) || defined(__riscv) || defined(__APPLE__))
#define USE_ART_LOW_4G_ALLOCATOR 1
#else
#if defined(__LP64__) && !defined(__Fuchsia__) && !defined(__x86_64__)
// 如果遇到未识别的64位架构（非x86_64），编译时报错
#error "Unrecognized 64-bit architecture."
#endif
#define USE_ART_LOW_4G_ALLOCATOR 0
#endif

// Linux系统特有优化：
// 1. 支持madvise(MADV_DONTNEED)清零内存页
// 2. 提供mremap系统调用支持内存区域替换
#ifdef __linux__
static constexpr bool kMadviseZeroes = true;
#define HAVE_MREMAP_SYSCALL true
#else
static constexpr bool kMadviseZeroes = false;
// We cannot ever perform MemMap::ReplaceWith on non-linux hosts since the syscall is not present.
#define HAVE_MREMAP_SYSCALL false
#endif

成员变量

class MemMap {
......
  std::string name_;
  uint8_t* begin_ = nullptr;    // Start of data. May be changed by AlignBy.
  size_t size_ = 0u;            // Length of data.

  void* base_begin_ = nullptr;  // Page-aligned base address. May be changed by AlignBy.
  size_t base_size_ = 0u;       // Length of mapping. May be changed by RemapAtEnd (ie Zygote).
  int prot_ = 0;                // Protection of the map.

  // When reuse_ is true, this is a view of a mapping on which
  // we do not take ownership and are not responsible for
  // unmapping.
  bool reuse_ = false;

  // When already_unmapped_ is true the destructor will not call munmap.
  bool already_unmapped_ = false;

  size_t redzone_size_ = 0u;

#if USE_ART_LOW_4G_ALLOCATOR
  static uintptr_t next_mem_pos_;   // Next memory location to check for low_4g extent.

  static void* TryMemMapLow4GB(void* ptr,
                               size_t page_aligned_byte_count,
                               int prot,
                               int flags,
                               int fd,
                               off_t offset);
#endif

  static void TargetMMapInit();
  static void* TargetMMap(void* start, size_t len, int prot, int flags, int fd, off_t fd_off);
  static int TargetMUnmap(void* start, size_t len);

  static std::mutex* mem_maps_lock_;

#ifdef ART_PAGE_SIZE_AGNOSTIC
  static size_t page_size_;
#endif

  friend class MemMapTest;  // To allow access to base_begin_ and base_size_.
};
......
}

成员函数

MapAnonymousPreferredAddress

non_moving_space_mem_map = MapAnonymousPreferredAddress(
          space_name, request_begin, non_moving_space_capacity, &error_str);

 main_mem_map_1 = MapAnonymousPreferredAddress(
          kMemMapSpaceName[0], request_begin, capacity_, &error_str);

在heap初始化流程中，使用MapAnonymousPreferredAddress尝试紧接着request_begin之后分配页面（request_begin如果LoadImage成功则会设置为image space的末尾）

方法实现：

MemMap Heap::MapAnonymousPreferredAddress(const char* name,
                                          uint8_t* request_begin,
                                          size_t capacity,
                                          std::string* out_error_str) {
  while (true) {
    MemMap map = MemMap::MapAnonymous(name,
                                      request_begin,
                                      capacity,
                                      PROT_READ | PROT_WRITE,
                                      /*low_4gb=*/ true,
                                      /*reuse=*/ false,
                                      /*reservation=*/ nullptr,
                                      out_error_str);
    if (map.IsValid() || request_begin == nullptr) {
      return map;
    }
    // Retry a  second time with no specified request begin.
    request_begin = nullptr;
  }
}

该方法其实就是第一次尝试一下在request_begin的位置MapAnonymous，如果失败了则清空request_begin，然后再调用一次MapAnonymous。所以并不能保证一定能在request_begin拿到mmap。

MapAnonymous

main_mem_map_1 = MemMap::MapAnonymous(
          kMemMapSpaceName[0],
          request_begin,
          capacity_,
          PROT_READ | PROT_WRITE,
          /* low_4gb= */ true,
          /* reuse= */ false,
          heap_reservation.IsValid() ? &heap_reservation : nullptr,
          &error_str);

也会直接使用MapAnonymous方法。