3

当我这样做时：

myProgram.h
myProgram.c

    struct PipeShm
    {
    // all my fields
    // more 
    // ...

    };



    struct PipeShm myPipe = { /* initialization for all fields */ };
    struct PipeShm * sharedPipe = &myPipe;

void func()
{
 sharedPipe = mmap (NULL, sizeof * sharedPipe, PROT_READ | PROT_WRITE,MAP_SHARED | MAP_ANONYMOUS, -1, 0);

}

当我mmap使用指针sharedPipe时，如果我main()从代码中的任何方法调用，所有进程是否会共享我与structmyProgram共享的确切共享内存？myPipe

或者每个被创造出来的新孩子，都会有myPipe他自己的新孩子？

问候

编辑：

这是在我阅读评论和答案之后：现在进行了更改，并且仅在分配段后才初始化段的值：

#include "my_pipe.h"

struct PipeShm * sharedPipe = NULL;



int shm_pipe_init()
{
    if (!sharedPipe)
    {
        int myFd = shm_open ("/myregion", O_CREAT | O_TRUNC | O_RDWR, 0600);

        if (myFd == -1)
            error_out ("shm_open");

        // Allocate some memory in the region - We use ftruncate, write(2) would work just as well
        int retAlloc = ftruncate (myFd, sizeof * sharedPipe);
        if (retAlloc < 0)
            error_out("ftruncate");


        sharedPipe = mmap (NULL, sizeof * sharedPipe,
                PROT_READ | PROT_WRITE,MAP_SHARED | MAP_ANONYMOUS, myFd, 0);

        if (!sem_init (&sharedPipe->semaphore, 1, 0))
        {
            sharedPipe->init = TRUE;
            sharedPipe->flag = FALSE;
            sharedPipe->ptr1 = NULL;
            sharedPipe->ptr2 = NULL;
            sharedPipe->status1 = -10;
            sharedPipe->status2 = -10;
            sharedPipe->semaphoreFlag = FALSE;
            sharedPipe->currentPipeIndex = 0;

        }
        else
            perror ("shm_pipe_init");
    }
    return 1;   // always successful
}

然而，问题仍然存在，共享内存似乎在进程之间没有如此共享，因为在运行和分叉该 main 时：

int main()
{
    int spd, pid, rb;
    char buff[4096];

    fork();
    shm_pipe_init();

        // more
        return 0;
}

我仍然得到输出，模拟只有一个进程正在运行的行为（而不是多个输出，我只得到一个或几个，取决于进程之间的竞争条件）。

4

3 回答 3

7

如果你打算多次调用这个程序，答案是“不”。如果您打算在创建映射后分叉，答案是“是”。

匿名映射没有基础文件。因此，创建匿名映射的进程无法指定它想要的现有映射（这也不是预期的用途，您应该获得一个新的、独立的映射）。因此对第一种情况说“不”。

共享映射允许拥有相同映射的所有进程访问相同的物理内存。这意味着，如果您fork在创建映射后，fork将主要以通常的方式工作，将进程拥有的所有页面标记为写时复制，除了映射中的页面。父母和孩子都将保留映射的页面，并且能够通过指针访问相同的物理内存（顺便说一下，这意味着页面甚至也将具有相同的虚拟地址 - 这通常不是您可以依赖的映射文件时打开，但在这种情况下，操作系统别无选择，只能确保是这种情况）。

联机帮助页对匿名和共享映射的组合或究竟应该发生什么仍然含糊不清，但 TLPI 第 49.7 章明确提到MAP_SHARED|MAP_ANONYMOUS：

[...] 然后调用 fork()，然后，由于 fork() 生成的子进程继承了映射，两个进程共享内存区域。

因此，对于第二种情况“是”。

回复：编辑后的
错误顺序：

fork();
shm_pipe_init();

这首先分叉，然后初始化共享内存。这只会为每个进程分别创建一个共享的（读作可共享的，如果进程再次分叉，它可能在未来被共享，但它不会神奇地与父进程共享！）映射。

然后，您有两个映射，每个进程中都有一个，它们将由各自的子进程和孙子进程（如果有）共享，但这无助于实现您想要的。它们是“共享”的事实并不重要，它们是不同的映射，并且对于各自的其他进程来说是未知的。

首先创建映射，然后分叉。这将创建一个共享映射，两个进程确实拥有/共享并可以用于预期目的。

（此外，您的使用fork并没有完全错误，但有点奇怪......您通常应该检查返回值，所以您知道哪个是父级，哪个是子级。这不像forkcan'不会失败。当然，如果这根本不重要，因为父母和孩子总是 100% 相同，而且你不关心失败，那很好。通常，人们通常想知道。）

于 2012-07-31T11:59:23.123 回答
2

每个都有自己的，因为对指针的 sharedPipe更改不会影响myPipe.

于 2012-07-31T11:08:41.297 回答
2

让我们逐步了解您在这里所做的事情

struct PipeShm myPipe = { /* initialization for all fields */ };

这将PipeShm结构分配为全局变量

struct PipeShm * sharedPipe = &myPipe;

这将创建一个指向先前创建的结构的指针。

现在您正在修改指向返回sharedPipe内容的指针mmap（可能是共享内存区域的地址），而不是您之前分配的结构（注意：myPipe仍然存在 - 只是没有指向）。

sharedPipe = mmap (NULL, sizeof * sharedPipe, PROT_READ | PROT_WRITE,MAP_SHARED | MAP_ANONYMOUS, -1, 0);

据我所知，您也没有尝试访问sharedPipe. 所以现在，你基本上有一个全局变量和一段共享内存（两者都似乎未使用）。

这就是我不太确定您要做什么的地方。

如果要访问共享内存，则需要在返回sharedPipe后取消引用指针mmap（如果是，全局变量的意义何在？）。

如果你想访问全局变量，只需访问它myPipe（如果是这样，是mmap为了什么？）。

如果您想同时访问两者，请结合使用上述方法（如果是，这样做的意义struct PipeShm * sharedPipe = &myPipe;何在？）

于 2012-07-31T11:47:48.263 回答