从父进程读取子进程的 /proc/pid/mem 文件

Question

在下面的程序中，我试图导致以下情况发生：

1. 进程A为堆栈变量a分配一个值。
2. 进程A（父进程）创建进程B（子进程），PID 为child_pid。
3. 进程B调用函数func1，传递一个指向a的指针。
4. 进程B通过指针改变变量a的值。
5. 进程B打开其/proc/self/mem文件，查找包含a的页面，并打印a的新值。
6. 进程A（同时）打开/proc/child_pid/mem，寻找正确的页面，并打印 a 的新值。

问题是，在第 6 步中，父进程只能看到 /proc/child_pida 的 old 值>/mem，而子进程确实可以在其/proc/self/mem中看到新值。为什么会这样呢？有什么方法可以让父级通过 /proc 文件系统查看子级对其地址空间的更改吗？

#include <fcntl.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>

#define PAGE_SIZE 0x1000
#define LOG_PAGE_SIZE 0xc
#define PAGE_ROUND_DOWN(v) ((v) & (~(PAGE_SIZE - 1)))
#define PAGE_ROUND_UP(v) (((v) + PAGE_SIZE - 1) & (~(PAGE_SIZE - 1)))
#define OFFSET_IN_PAGE(v) ((v) & (PAGE_SIZE - 1))
# if defined ARCH && ARCH == 32
#define BP "ebp"
#define SP "esp"
#else
#define BP "rbp"
#define SP "rsp"
#endif

typedef struct arg_t {
 int a;
} arg_t;


void func1(void * data) {
 arg_t * arg_ptr = (arg_t *)data;
 printf("func1: old value: %d\n", arg_ptr->a);
 arg_ptr->a = 53;
 printf("func1: address: %p\n", &arg_ptr->a);
 printf("func1: new value: %d\n", arg_ptr->a);
}


void expore_proc_mem(void (*fn)(void *), void * data) {

 off_t frame_pointer, stack_start;
 char buffer[PAGE_SIZE];
 const char * path = "/proc/self/mem";
 int child_pid, status;
 int parent_to_child[2];
 int child_to_parent[2];
 arg_t * arg_ptr;
 off_t child_offset;

 asm volatile ("mov %%"BP", %0" : "=m" (frame_pointer));
 stack_start = PAGE_ROUND_DOWN(frame_pointer);

 printf("Stack_start: %lx\n",
        (unsigned long)stack_start);

 arg_ptr = (arg_t *)data;
 child_offset = 
  OFFSET_IN_PAGE((off_t)&arg_ptr->a);
 printf("Address of arg_ptr->a: %p\n",
        &arg_ptr->a);

 pipe(parent_to_child);
 pipe(child_to_parent);
 bool msg;
 int child_mem_fd;
 char child_path[0x20];

 child_pid = fork();
 if (child_pid == -1) {
  perror("fork");
  exit(EXIT_FAILURE);
 }
 if (!child_pid) {
  close(child_to_parent[0]);
  close(parent_to_child[1]);
  printf("CHILD (pid %d, parent pid %d).\n",
         getpid(), getppid());
  fn(data);
  msg = true;
  write(child_to_parent[1], &msg, 1);
  child_mem_fd = open("/proc/self/mem", O_RDONLY);
  if (child_mem_fd == -1) {
   perror("open (child)");
   exit(EXIT_FAILURE);
  }
  printf("CHILD: child_mem_fd: %d\n", child_mem_fd);
  if (lseek(child_mem_fd, stack_start, SEEK_SET) == (off_t)-1) {
   perror("lseek");
   exit(EXIT_FAILURE);
  }

  if (read(child_mem_fd, buffer, sizeof(buffer)) 
      != sizeof(buffer)) {
   perror("read");
   exit(EXIT_FAILURE);
  }

  printf("CHILD: new value %d\n",
         *(int *)(buffer + child_offset));

  read(parent_to_child[0], &msg, 1);
  exit(EXIT_SUCCESS);
 }
 else {
  printf("PARENT (pid %d, child pid %d)\n",
         getpid(), child_pid);
  printf("PARENT: child_offset: %lx\n",
         child_offset);
  read(child_to_parent[0], &msg, 1);
  printf("PARENT: message from child: %d\n", msg);
  snprintf(child_path, 0x20, "/proc/%d/mem", child_pid);
  printf("PARENT: child_path: %s\n", child_path);
  child_mem_fd = open(path, O_RDONLY);
  if (child_mem_fd == -1) {
   perror("open (child)");
   exit(EXIT_FAILURE);
  }
  printf("PARENT: child_mem_fd: %d\n", child_mem_fd);
  if (lseek(child_mem_fd, stack_start, SEEK_SET) == (off_t)-1) {
   perror("lseek");
   exit(EXIT_FAILURE);
  }

  if (read(child_mem_fd, buffer, sizeof(buffer)) 
      != sizeof(buffer)) {
   perror("read");
   exit(EXIT_FAILURE);
  }

  printf("PARENT: new value %d\n",
         *(int *)(buffer + child_offset));

  close(child_mem_fd);

  printf("ENDING CHILD PROCESS.\n");

  write(parent_to_child[1], &msg, 1);
  if (waitpid(child_pid, &status, 0) == -1) {
   perror("waitpid");
   exit(EXIT_FAILURE);
  }
 }

}

int main(void) {

 arg_t arg;
 arg.a = 42;
 printf("In main: address of arg.a: %p\n", &arg.a);
 explore_proc_mem(&func1, &arg.a);

 return EXIT_SUCCESS;
}

该程序产生以下输出。请注意，父级和子级读取 /proc/child_pid/mema 值（粗体）不同> 文件。

在main中：arg.a的地址：0x7ffffe1964f0
堆栈开始：7ffffe196000
arg_ptr->a的地址：0x7ffffe1964f0
父级（pid 20376，子级 pid 20377）
父级：child_offset：4f0
子级（pid 20377，父级 pid 20376）。
func1：旧值：42
func1：地址：0x7ffffe1964f0
func1：新值：53
家长：来自孩子的消息：1
孩子：child_mem_fd：4
父级：child_path：/proc/20377/mem
孩子：新值53
父级：child_mem_fd：7
父级：新值42
结束子进程。

Answer 1

这段代码中有一个愚蠢的错误：

const char * path = "/proc/self/mem";
...
snprintf(child_path, 0x20, "/proc/%d/mem", child_pid);
printf("PARENT: child_path: %s\n", child_path);
child_mem_fd = open(path, O_RDONLY);

所以你总是最终在这里读取父母的记忆。然而，更改此设置后，我得到：

CHILD: child_mem_fd: 4
CHILD: new value 53
read (parent): No such process

我不知道为什么会发生这种情况 - 也许 /proc 刷新条目太慢？ （它来自父级中的 perror("read") - 必须添加注释来查看哪一个失败）但这看起来很奇怪，因为 seek 也有效作为 open 本身。

这个问题似乎也不是新问题：http://lkml。 indiana.edu/hypermail/linux/kernel/0007.1/0939.html （ESRCH 是“没有这样的过程”）

实际上更好的链接是： http://www.webservertalk.com/archive242-2004-7-295131.html - 标记进程 pthread-attach 时出现问题 -安全的。你可以在那里找到 Alan Cox 派人去 Solar Designer...对我来说，这意味着“这里有龙”，如果你不在睡梦中破解内核，它是无法解决的:(

也许你检查一下 gdb 是什么就足够了在这种情况下做什么并复制它？（可能只是通过 ptrace(PTRACE_PEEKDATA,...) 进行）

Answer 2

解决方案是使用ptrace来同步父级和子级。即使我已经在父进程和子进程之间进行通信（并且 ptrace 的手册页说这会导致两个进程的行为就像它们是父进程和子进程一样），并且即使子进程正在阻塞在 read 调用中，子进程显然没有足够“停止”到 Linux 允许父进程读取子进程的 /proc/child_pid/mem 文件。但是，如果父级首先使用 PTRACE_ATTACH 调用ptrace（在通过管道接收到消息之后），那么它就可以打开文件 - 并获取正确内容！然后，父进程使用 PTRACE_DETACH 再次调用 ptrace，然后将消息发送回子进程以终止。