具体来说，fork() 如何处理 Linux 中从 malloc() 动态分配的内存？

Question

我有一个带有父进程和子进程的程序。在 fork() 之前，父进程调用 malloc() 并用一些数据填充数组。在 fork() 之后，子进程需要该数据。我知道我可以使用管道，但以下代码似乎可以工作：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int main( int argc, char *argv[] ) {
    char *array;
    array = malloc( 20 );
    strcpy( array, "Hello" );
    switch( fork() ) {
    case 0:
        printf( "Child array: %s\n", array );
        strcpy( array, "Goodbye" );
        printf( "Child array: %s\n", array );
        free( array );
        break;
    case -1:
        printf( "Error with fork()\n" );
        break;
    default:
        printf( "Parent array: %s\n", array );
        sleep(1);
        printf( "Parent array: %s\n", array );
        free( array );
    }
    return 0;
}

输出是：

Parent array: Hello
Child array: Hello
Child array: Goodbye
Parent array: Hello

我知道在堆栈上分配的数据在子级中可用，但似乎在堆上分配的数据也可供子级使用。同样，子进程不能修改父进程在栈上的数据，子进程也不能修改父进程在堆上的数据。所以我假设子进程获得自己的堆栈和堆数据副本。

Linux 中总是这样吗？如果是这样，支持这一点的文档在哪里？我检查了 fork() 手册页，但它没有具体提到堆上动态分配的内存。

Answer 1

为进程分配的每个页面（无论是具有堆栈还是堆的虚拟内存页面）都会被复制，以便分叉进程能够访问它。

实际上，它不是从一开始就复制的，它被设置为“写入时复制”，这意味着一旦其中一个进程（父进程或子进程）尝试修改页面，它就会被复制，这样它们就不会互相伤害，并且仍然可以访问 fork() 点的所有数据。

例如，代码页（实际可执行文件映射到内存中的代码页）通常是只读的，因此在所有分叉进程之间重用 - 它们不会再次复制，因为没有人在那里写入，只能读取，等等永远不需要写时复制。

更多信息请参见此处和此处。

Answer 2

分叉后，子级完全独立于父级，但可以继承父级的某些副本。对于堆来说，子进程在概念上将在分叉时拥有父堆的副本。然而，对子地址空间中的头的修改只会修改子地址的副本（例如通过写时复制）。

至于文档：我注意到文档通常会声明所有内容都被复制，除了等等等等。

Answer 3

简短的答案是“写时脏” - 较长的答案是..更长。

但对于所有意图和目的 - 在 C 级别可以安全地假设的工作模型是，在 fork() 之后，两个进程是绝对相同的 - 即子进程获得 100% 精确的副本 - （但对于一小段时间）位围绕 fork()) 的返回值 - 然后随着双方修改其内存、堆栈和堆而开始发散。

因此，您的结论略有偏差 - 子级开始时将与父级相同的数据复制到自己的空间中 - 然后对其进行修改 - 并将其视为已修改的 - 而父级继续使用自己的副本。

事实上，事情要复杂一些——因为它试图通过做一些肮脏的事情来避免完整的副本；除非必要，否则避免复制。

深度。

Answer 4

该示例不起作用，因为子级未更新父级。这是一个解决方案：

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>

typedef struct
{
  int id;
  size_t size;
} shm_t;

shm_t *shm_new(size_t size)
{
  shm_t *shm = calloc(1, sizeof *shm);
  shm->size = size;

  if ((shm->id = shmget(IPC_PRIVATE, size, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR)) < 0)
  {
    perror("shmget");
    free(shm);
    return NULL;
  }

  return shm;
}

void shm_write(shm_t *shm, void *data)
{
  void *shm_data;

  if ((shm_data = shmat(shm->id, NULL, 0)) == (void *) -1)
  {
    perror("write");
    return;
  }

  memcpy(shm_data, data, shm->size);
  shmdt(shm_data);
}

void shm_read(void *data, shm_t *shm)
{
  void *shm_data;

  if ((shm_data = shmat(shm->id, NULL, 0)) == (void *) -1)
  {
    perror("read");
    return;
  }
  memcpy(data, shm_data, shm->size);
  shmdt(shm_data);
}

void shm_del(shm_t *shm)
{
  shmctl(shm->id, IPC_RMID, 0);
  free(shm);
}

int main()
{
  void *array = malloc(20);
  strcpy((char *) array, "Hello");
  printf("parent: %s\n", (char *) array);
  shm_t *shm = shm_new(sizeof array);

  int pid;
  if ((pid = fork()) == 0)
  { /* child */
    strcpy((char *) array, "Goodbye");
    shm_write(shm, array);
    printf("child: %s\n", (char *) array);
    return 0;
  }
  /* Wait for child to return */
  int status;
  while (wait(&status) != pid);
  /* */
  shm_read(array, shm);
  /* Parent is updated by child */
  printf("parent: %s\n", (char *) array);
  shm_del(shm);
  free(array);
  return 0;
}