使用 mmap 重叠页面 (MAP_FIXED)

由于一些与此问题无关的模糊原因，我需要诉诸使用 MAP_FIXED 来获取靠近 libc 文本部分在内存中所在位置的页面。

在阅读 mmap(2) 之前（我应该首先完成），如果我使用 MAP_FIXED 调用 mmap 且基地址与已映射的区域重叠，我预计会收到错误。

然而事实并非如此。例如，这是某些进程的 /proc/maps 的一部分

7ffff7299000-7ffff744c000 r-xp 00000000 08:05 654098                     /lib/x86_64-linux-gnu/libc-2.15.so

在进行以下 mmap 调用之后...

  mmap(0x7ffff731b000,
       getpagesize(),
       PROT_READ | PROT_WRITE | PROT_EXEC,
       MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED,
       0,
       0);

... 变成：

7ffff7299000-7ffff731b000 r-xp 00000000 08:05 654098                     /lib/x86_64-linux-gnu/libc-2.15.so
7ffff731b000-7ffff731c000 rwxp 00000000 00:00 0 
7ffff731c000-7ffff744c000 r-xp 00083000 08:05 654098                     /lib/x86_64-linux-gnu/libc-2.15.so

这意味着我已经用我自己的页面覆盖了专用于 libc 的部分虚拟地址空间。显然不是我想要的...

在mmap(2)手册的MAP_FIXED部分中，明确指出：

如果addr和len指定的内存区域与任何页面重叠 现有映射，则现有映射的重叠部分将是丢弃的.

这解释了我所看到的，但我有几个问题：

1. 有没有办法检测某些内容是否已经映射到某个地址？不访问/proc/maps？
2. 有没有办法在发现重叠页面的情况下强制 mmap 失败？

1. Use page = sysconf(SC_PAGE_SIZE)找出页面大小，然后扫描您想要检查的每个页面大小的块msync(addr, page, 0) http://www.kernel.org/doc/man-pages/online/pages/man2/msync.2.html (with (unsigned long)addr % page == 0, i.e. addr与页面对齐）。如果返回的话-1 with errno == ENOMEM，该页面未映射。

   编辑：正如下面评论的那样，优于msync()。 （系统调用的实现位于mm/mincore.c在 Linux 内核源代码中，C 库通常提供更新的包装器errno。由于系统调用在确保之后立即进行映射检查addr是页面对齐的，在未映射的情况下是最佳的（ENOMEM）。如果页面已经映射，它会执行一些工作，因此如果性能至关重要，请尽量避免检查您知道已映射的页面。

   您必须针对每个页面单独执行此操作，因为对于大于单个页面的区域，ENOMEM意味着该区域尚未完全绘制；它可能仍然是部分映射的。映射始终精确到页面大小的单位。

2. 据我所知，没有办法告诉mmap()如果该区域已映射或包含已映射的页面，则会失败。 （这同样适用于mremap()，因此您无法创建映射，然后将其移动到所需的区域。）

   这意味着您面临竞争条件的风险。最好自己执行实际的系统调用，而不是 C 库包装器，以防它们在内部进行内存分配或更改内存映射：

   #define _GNU_SOURCE
   #include <unistd.h>
   #include <sys/syscall.h>
   
   static size_t page = 0;
   static inline size_t page_size(void)
   {
       if (!page)
           page = (size_t)sysconf(_SC_PAGESIZE);
       return page;
   }
   
   
   static inline int raw_msync(void *addr, size_t length, int flags)
   {
       return syscall(SYS_msync, addr, length, flags);
   }
   
   static inline void *raw_mmap(void *addr, size_t length, int prot, int flags)
   {
       return (void *)syscall(SYS_mmap, addr, length, prot, flags, -1, (off_t)0);
   }
   

然而，我怀疑无论你想做什么，你最终都需要解析/proc/self/maps anyway.

• 我建议避免标准 I/Ostdio.h完全（因为各种操作将动态分配内存，从而更改映射），而使用较低级别的unistd.h接口，这不太可能影响映射。这是一组简单、粗略的函数，您可以使用它们来找出每个映射区域以及该区域中启用的保护（并丢弃其他信息）。在实践中，它使用大约 1 KB 的代码，比堆栈中的代码少，因此即使在有限的体系结构（例如嵌入式设备）上它也非常有用。

  #include <unistd.h>
  #include <fcntl.h>
  #include <errno.h>
  #include <string.h>
  
  #ifndef   INPUT_BUFFER
  #define   INPUT_BUFFER   512
  #endif /* INPUT_BUFFER */
  
  #ifndef   INPUT_EOF
  #define   INPUT_EOF     -256
  #endif /* INPUT_EOF */
  
  #define   PERM_PRIVATE  16
  #define   PERM_SHARED    8
  #define   PERM_READ      4
  #define   PERM_WRITE     2
  #define   PERM_EXEC      1
  
  typedef struct {
      int            descriptor;
      int            status;
      unsigned char *next;
      unsigned char *ends;
      unsigned char  buffer[INPUT_BUFFER + 16];
  } input_buffer;
  
  /* Refill input buffer. Returns the number of new bytes.
   * Sets status to ENODATA at EOF.
  */
  static size_t input_refill(input_buffer *const input)
  {
      ssize_t n;
  
      if (input->status)
          return (size_t)0;
  
      if (input->next > input->buffer) {
          if (input->ends > input->next) {
              memmove(input->buffer, input->next,
                      (size_t)(input->ends - input->next));
              input->ends = input->buffer + (size_t)(input->ends - input->next);
              input->next = input->buffer;
          } else {
              input->ends = input->buffer;
              input->next = input->buffer;
          }
      }
  
      do {
          n = read(input->descriptor, input->ends,
                   INPUT_BUFFER - (size_t)(input->ends - input->buffer));
      } while (n == (ssize_t)-1 && errno == EINTR);
      if (n > (ssize_t)0) {
          input->ends += n;
          return (size_t)n;
  
      } else
      if (n == (ssize_t)0) {
          input->status = ENODATA;
          return (size_t)0;
      }
  
      if (n == (ssize_t)-1)
          input->status = errno;
      else
          input->status = EIO;
  
      return (size_t)0;
  }
  
  /* Low-lever getchar() equivalent.
  */
  static inline int input_next(input_buffer *const input)
  {
      if (input->next < input->ends)
          return *(input->next++);
      else
      if (input_refill(input) > 0)
          return *(input->next++);
      else
          return INPUT_EOF;
  }
  
  /* Low-level ungetc() equivalent.
  */
  static inline int input_back(input_buffer *const input, const int c)
  {
      if (c < 0 || c > 255)
          return INPUT_EOF;
      else
      if (input->next > input->buffer)
          return *(--input->next) = c;
      else
      if (input->ends >= input->buffer + sizeof input->buffer)
          return INPUT_EOF;
  
      memmove(input->next + 1, input->next, (size_t)(input->ends - input->next));
      input->ends++;
      return *(input->next) = c;
  }
  
  /* Low-level fopen() equivalent.
  */
  static int input_open(input_buffer *const input, const char *const filename)
  {
      if (!input)
          return errno = EINVAL;
  
      input->descriptor = -1;
      input->status = 0;
      input->next = input->buffer;
      input->ends = input->buffer;
  
      if (!filename || !*filename)
          return errno = input->status = EINVAL;
  
      do {
          input->descriptor = open(filename, O_RDONLY | O_NOCTTY);
      } while (input->descriptor == -1 && errno == EINTR);
      if (input->descriptor == -1)
          return input->status = errno;
  
      return 0;
  }
  
  /* Low-level fclose() equivalent.
  */
  static int input_close(input_buffer *const input)
  {
      int result;
  
      if (!input)
          return errno = EINVAL;
  
      /* EOF is not an error; we use ENODATA for that. */
      if (input->status == ENODATA)
          input->status = 0;
  
      if (input->descriptor != -1) {
          do {
              result = close(input->descriptor);
          } while (result == -1 && errno == EINTR);
          if (result == -1 && !input->status)
              input->status = errno;
      }
  
      input->descriptor = -1;
      input->next = input->buffer;
      input->ends = input->buffer;
  
      return errno = input->status;
  }
  
  /* Read /proc/self/maps, and fill in the arrays corresponding to the fields.
   * The function will return the number of mappings, even if not all are saved.
  */
  size_t read_maps(size_t const n,
                   void **const ptr, size_t *const len,
                   unsigned char *const mode)
  {
      input_buffer    input;
      size_t          i = 0;
      unsigned long   curr_start, curr_end;
      unsigned char   curr_mode;
      int             c;
  
      errno = 0;
  
      if (input_open(&input, "/proc/self/maps"))
          return (size_t)0; /* errno already set. */
  
      c = input_next(&input);
      while (c >= 0) {
  
          /* Skip leading controls and whitespace */
          while (c >= 0 && c <= 32)
              c = input_next(&input);
  
          /* EOF? */
          if (c < 0)
              break;
  
          curr_start = 0UL;
          curr_end = 0UL;
          curr_mode = 0U;
  
          /* Start of address range. */
          while (1)
              if (c >= '0' && c <= '9') {
                  curr_start = (16UL * curr_start) + c - '0';
                  c = input_next(&input);
              } else
              if (c >= 'A' && c <= 'F') {
                  curr_start = (16UL * curr_start) + c - 'A' + 10;
                  c = input_next(&input);
              } else
              if (c >= 'a' && c <= 'f') {
                  curr_start = (16UL * curr_start) + c - 'a' + 10;
                  c = input_next(&input);
              } else
                  break;
          if (c == '-')
              c = input_next(&input);
          else {
              errno = EIO;
              return (size_t)0;
          }
  
          /* End of address range. */
          while (1)
              if (c >= '0' && c <= '9') {
                  curr_end = (16UL * curr_end) + c - '0';
                  c = input_next(&input);
              } else
              if (c >= 'A' && c <= 'F') {
                  curr_end = (16UL * curr_end) + c - 'A' + 10;
                  c = input_next(&input);
              } else
              if (c >= 'a' && c <= 'f') {
                  curr_end = (16UL * curr_end) + c - 'a' + 10;
                  c = input_next(&input);
              } else
                  break;
          if (c == ' ')
              c = input_next(&input);
          else {
              errno = EIO;
              return (size_t)0;
          }
  
          /* Permissions. */
          while (1)
              if (c == 'r') {
                  curr_mode |= PERM_READ;
                  c = input_next(&input);
              } else
              if (c == 'w') {
                  curr_mode |= PERM_WRITE;
                  c = input_next(&input);
              } else
              if (c == 'x') {
                  curr_mode |= PERM_EXEC;
                  c = input_next(&input);
              } else
              if (c == 's') {
                  curr_mode |= PERM_SHARED;
                  c = input_next(&input);
              } else
              if (c == 'p') {
                  curr_mode |= PERM_PRIVATE;
                  c = input_next(&input);
              } else
              if (c == '-') {
                  c = input_next(&input);
              } else
                  break;
          if (c == ' ')
              c = input_next(&input);
          else {
              errno = EIO;
              return (size_t)0;
          }
  
          /* Skip the rest of the line. */
          while (c >= 0 && c != '\n')
              c = input_next(&input);
  
          /* Add to arrays, if possible. */
          if (i < n) {
              if (ptr) ptr[i] = (void *)curr_start;
              if (len) len[i] = (size_t)(curr_end - curr_start);
              if (mode) mode[i] = curr_mode;
          }
          i++;
      }
  
      if (input_close(&input))
          return (size_t)0; /* errno already set. */
  
      errno = 0;
      return i;
  }
  

  The read_maps()函数读取到n区域，起始地址为void *进入ptr数组，长度为len数组和权限mode数组，返回地图总数（可能大于n)，或为零errno如果发生错误则设置。

  很有可能将系统调用用于上面的低级 I/O，这样您就不会使用任何 C 库功能，但我认为完全没有必要。 （据我所知，C 库在实际系统调用周围使用了非常简单的包装器。）

希望这个对你有帮助。