Trying to create a shared memory segment between processes in client-server program

was kind of curious around this question so I wanted to put together a proof of concept of the forking / shared memory as well as the semaphore to guard against reading an incomplete write.

There's a few takeaways for me:

• mmap seems an easiser and more modern implementation of shared memory than the sysv shared memory segments.
• semaphore or other coordination is required to make sure the read is finished and the write is not.
• data in mmap is shared, but if that data is a pointer, it has to point to an mmap segment or it won't work in each fork ... I am pretty sure. So make sure to put all your shared data in shared memory, not just its address.

A note on using shared memory: I created 2 different mmap-shared memory, one for the semaphore and one for the data itself. But I could have instead created a struct and put both variables in that, which probably makes more sense because mmaped memory has to be page-aligned and therefore I think every new memory map requires at least 1 full page of memory. There's definitely some thinking you need to do about how to expose the state you want between the processes.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <errno.h>
#include <unistd.h>
#include <semaphore.h>

#define BUFSIZE 20480

int main(int argc, char**argv){
  int protection = PROT_READ | PROT_WRITE;
  int visibility = MAP_SHARED | MAP_ANONYMOUS;
  // we need shared memory for our semaphore
  sem_t* sem = mmap(NULL, sizeof(sem_t), protection, visibility, -1, 0);
  if(sem == MAP_FAILED) {
    perror("Couldn't create memory map");
    exit(errno);
  }
  if( sem_init(sem, 1, 0) != 0 ){
    perror("couldn't init shared memory");
    exit(errno);
  }
  // now shared memory for the data we care about, which is just a string up to BUFSIZE len including termination
  void* shmem = mmap(NULL, BUFSIZE, protection, visibility, -1, 0);
  if(shmem == MAP_FAILED) {
    perror("Couldn't create memory map");
    exit(errno);
  }
  // let's make sure there's a '\0' at the end for the string functions by copying an empty string in.  
  strncpy(shmem, "" , BUFSIZE-1);
  pid_t cpid = fork();
  if(cpid < 0){
    perror("Couldn't fork");
    exit(errno);
  }
  else if( cpid == 0 ){ // child!  
    char* msg = malloc(sizeof(char)*BUFSIZE);
    *msg = '\0';
    while( strlen(msg) == 0 ){
      printf("What would you like the message to be? ");
      fflush(stdout);
      fgets(msg, BUFSIZE, stdin);
    }
    printf("%lu character string input\n", strlen(msg));
    strncpy(shmem, msg, BUFSIZE-1);
    sem_post(sem);
  }
  else {
    int sig;
    if( sem_wait(sem) ){
      perror("couldn't wait for semaphore in parent");
      exit(errno);
    }
    printf("%lu character string input\n", strlen(shmem));
  }
}