安全地初始化共享内存

Question

我有几个进程通过 OS X 上的 POSIX 共享内存相互通信。 我的问题是这些进程可以以任何顺序生成，并尝试同时初始化共享内存段。

我尝试将咨询锁与 fcntl 和 flock 一起使用，但都失败告诉我我正在传递无效的文件描述符（我确信文件描述符不是无效的）。很明显，这是不可能的。

还有其他选择吗？或者是否有关于使用共享内存锁的任何我不知道的细节？

编辑： 我使用锁的尝试如下所示：

// Some declarations...

struct Queue {                                                                                          
    int index[ENTRIES_PER_QUEUE];                                                                       
    sem_t lock;                                                                                         
    sem_t readWait;                                                                                     
    sem_t writeSem;                                                                                     
    struct Entry slots[ENTRIES_PER_QUEUE];                                                              
};

struct ipc_t {
    int fd;
    char name[512];
    struct Queue* queue;
};

ipc_t ipc_create(const char* name, int owner) {

    int isInited = 1;                                                                                   
    struct Queue* queue;                                                                                
    struct flock lock = {                                                                               
        .l_type = F_WRLCK,                                                                              
        .l_whence = SEEK_SET,                                                                           
        .l_start = 0,                                                                                   
        .l_len = 0                                                                                      
    };

    ipc_t conn = malloc(sizeof(struct ipc_t));

    sprintf(conn->name, "/arqvenger_%s", name);

    conn->fd = shm_open(conn->name, O_CREAT | O_RDWR, 0666);
    if (conn->fd == -1) {
        free(conn);
        perror("shm_open failed");
        return NULL;
    }

    if (fcntl(conn->fd, F_SETLKW, &lock) == -1) {
        perror("Tanked...");
    }

// Do stuff with the lock & release it

我得到的输出是：

Tanked...: Bad file descriptor

Answer 1

一种常见的技术是首先使用 O_CREAT|O_EXCL 调用 shm_open。只有一个必须执行设置的进程才会成功。然后其他人必须像以前一样打开并等待一段时间（可能是轮询）以确保设置完成。

编辑：展示如何按照评论中的讨论进行操作。

struct head {
 unsigned volatile flag;
 pthread_mutex_t mut;
};

void * addr = 0;
/* try shm_open with exclusive, and then */
if (/* we create the segment */) {
  addr = mmap(something);
  struct head* h = addr;
  pthread_mutex_init(&h->mut, aSharedAttr);
  pthread_mutex_lock(&h->mut);
  h->flag = 1;
  /* do the rest of the initialization, and then */
  pthread_mutex_unlock(&h->mut);
} else {
  /* retry shm_open without exclusive, and then */
  addr = mmap(something);
  struct head* h = addr;
  /* initialy flag is guaranteed to be 0 */
  /* this will break out of the loop whence the new value is written to flag */
  while (!h->flag) sched_yield();
  pthread_mutex_lock(&h->mut);
  pthread_mutex_unlock(&h->mut);  
}

Answer 2

我已经能够重现该问题。然后我在标准中发现了一个悲伤的通知：

当文件描述符fildes引用共享内存对象时，
fcntl() 的行为应与常规文件相同，除了
参数 cmd 的以下值的效果应为
未指定：F_SETFL、F_GETLK、F_SETLK 和 F_SETLKW。

所以很可能它尚未得到支持。对于这样一个简单的设置，我将使用信号量来表示“内存已准备好”。

编辑

看来我需要提到可以使用“O_EXCL”创建信号量（因此没有竞争）。