Understanding the posix interprocess semaphore

According to m开发者_如何学JAVAy understanding, a semaphore should be usable across related processes without it being placed in shared memory. If so, why does the following code deadlock?

#include <iostream>
#include <semaphore.h>
#include <sys/wait.h>

using namespace std;

static int MAX = 100;

int main(int argc, char* argv[]) {
  int retval;
  sem_t mutex;

  cout << sem_init(&mutex, 1, 0) << endl;

  pid_t pid = fork();

  if (0 == pid) {
    //     sem_wait(&mutex);
    cout << endl;
    for (int i = 0; i < MAX; i++) {
      cout << i << ",";
    }
    cout << endl;
    sem_post(&mutex);

  } else if(pid > 0) {
    sem_wait(&mutex);
    cout << endl;
    for (int i = 0; i < MAX; i++) {
      cout << i << ",";
    }
    cout << endl;
    //     sem_post(&mutex);
    wait(&retval);

  } else {
    cerr << "fork error" << endl;
    return 1;
  }

//   sem_destroy(&mutex);

  return 0;
}

When I run this on Gentoo/Ubuntu Linux, the parent hangs. Apparently, it did not receive the post by child. Uncommenting sem_destroy won't do any good. Am I missing something?

Update 1: This code works

mutex = (sem_t *) mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_SHARED, 0, 0);
if (!mutex) {
  perror("out of memory\n");
  exit(1);
}

Thanks, Nilesh.

The wording in the manual page is kind of ambiguous.

If pshared is nonzero, then the semaphore is shared between processes, and should be located in a region of shared memory.

Since a child created by fork(2) inherits its parent's memory mappings, it can also access the semaphore.

Yes, but it still has to be in a shared region. Otherwise the memory simply gets copied with the usual CoW and that's that.

You can solve this in at least two ways:

• Use sem_open("my_sem", ...)
• Use shm_open and mmap to create a shared region

An excellent article on this topic, for future passers-by:

http://blog.superpat.com/2010/07/14/semaphores-on-linux-sem_init-vs-sem_open/