3.7. Shared Memory¶

3.7.1. POSIX Shared Memory¶

The POSIX interface for shared memory is very simple, consisting of two primary functions. The shm_open() takes the POSIX IPC object name, a bit-mask of flags (oflag) and a permission mode to apply new objects. [1] Similarly, shm_unlink() deletes the shared memory object.

C library functions – <sys/mman.h>

---

int shm_open (const char *name, int oflag, mode_t mode);

Open a connection to a POSIX shared memory object.

int shm_unlink (const char *name);

Delete a POSIX shared memory object.

The following code sample uses a struct declared as follows:

1
2
3
4
5

struct permission {
  int user;
  int group;
  int other;
};

Code Listing 3.10 sets up a POSIX shared memory object, which is identified by a given name. Note that the call to shm_open() creates the object but does not specify a size; instead, ftruncate() resizes the object to be large enough to store one instance of the struct permission. Next, the process maps the shared memory object into memory with mmap() before using fork() to create a child process (which inherits both the shared memory identifier and the memory mapped region). The child writes to the region before exiting; the parent waits until the child exits and reads the data.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

/* Code Listing 3.10:
   Using POSIX shared memory to exchange data between processes
 */

/* Create unsized shared memory object;
   return value is a file descriptor */
int shmfd = shm_open ("/OpenCSF_SHM", O_CREAT | O_EXCL | O_RDWR, S_IRUSR | S_IWUSR);
assert (shmfd != -1);

/* Resize the region to store 1 struct instance */
assert (ftruncate (shmfd, sizeof (struct permission)) != -1);

/* Map the object into memory so file operations aren't needed */
struct permission *perm = mmap (NULL, sizeof (struct permission),
                                PROT_READ | PROT_WRITE, MAP_SHARED, shmfd, 0);
assert (perm != MAP_FAILED);

/* Create a child process and write to the mapped/shared region */
pid_t child_pid = fork();
if (child_pid == 0)
  {
    perm->user = 6;
    perm->group = 4;
    perm->other = 0;

    /* Unmap and close the child's shared memory access */
    munmap (perm, sizeof (struct permission));
    close (shmfd);
    return 0;
  }

/* Make the parent wait until the child has exited */
wait (NULL);

/* Read from the mapped/shared memory region */
printf ("Permission bit-mask: 0%d%d%d\n", perm->user, perm->group, perm->other);

/* Unmap, close, and delete the shared memory object */
munmap (perm, sizeof (struct permission));
close (shmfd);
shm_unlink ("/OpenCSF_SHM");

Combining shm_open() and mmap() in this way is a common technique that often confuses novices. Specifically, it seems redundant to use both IPC mechanisms, because the same task could be accomplished with either shm_open() or mmap() (not both). While it is true that both are not required, combining them leads to certain advantages:

• The shm_open() parameters adhere to the standard POSIX IPC conventions. This allows the processes to use POSIX names to identify the objects, rather than creating files in arbitrary locations.
• Using shm_unlink() provides a safety check that is not guaranteed with creating and mapping arbitrary files. Specifically, shm_unlink() will not delete the object immediately if any other process also has an open connection; this delay allows decreases the likelihood of other processes experiencing random and unexpected failures. In contrast, if an arbitrary non-IPC file was used for the mmap(), the timing of the deletion would be determined by the underlying file system; this introduces unnecessary maintenance and possibly restricts the portability of the program.
• Using mmap() allows the developer to cast the shared memory object to a more meaningful data structure type and to avoid using file operations. Specifically, observe that the return type from shm_open() is a file descriptor, which does not provide any information about the type of data stored in the object. By mapping it into memory, we can cast the pointer returned and access the user, group, and other fields contained in the struct.