System V shared memory (covered in Chapter 48) works, but it has two well-known friction points:

Section 49.4.2 of TLPI showed that two processes can share memory by mapping the same file with MAP_SHARED. This works, but it has one annoying requirement: you must create an actual disk file even if you never want persistent storage. Creating a disk file means:

• Extra step of creating and naming a backing file
• File I/O overhead (disk reads/writes during setup)
• Cleanup burden — you must delete the file when done

POSIX shared memory eliminates the disk file entirely. It lives in a RAM-based filesystem called tmpfs.

The table below maps corresponding calls between the two APIs:

The POSIX standard does not specify how shared memory objects should be stored internally. Linux uses a dedicated tmpfs filesystem mounted at /dev/shm.

Below is a minimal complete example showing the two-step process. We create a 4096-byte shared memory object, map it, write a string, then read it back.

/*
 * posix_shm_intro.c
 * Demonstrates the two-step POSIX shm pattern:
 *   Step 1: shm_open()  - get a file descriptor
 *   Step 2: mmap()      - map into address space
 *
 * Compile: gcc posix_shm_intro.c -o posix_shm_intro -lrt
 * Run:     ./posix_shm_intro
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>          /* O_CREAT, O_RDWR */
#include <sys/mman.h>       /* shm_open, mmap  */
#include <sys/stat.h>       /* mode constants  */
#include <unistd.h>         /* ftruncate       */

#define SHM_NAME   "/ep_demo"
#define SHM_SIZE   4096

int main(void)
{
    int fd;
    void *addr;

    /* ---- STEP 1: shm_open() ---- */
    /* Create (O_CREAT) and open for read-write (O_RDWR).
     * O_EXCL would fail if it already exists — omitted here for simplicity.
     * 0600 = owner read+write permissions.
     */
    fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0600);
    if (fd == -1) {
        perror("shm_open");
        exit(EXIT_FAILURE);
    }
    printf("shm_open() succeeded. fd = %d\n", fd);

    /* A new object starts at zero length.
     * We must call ftruncate() to set the desired size BEFORE mmap().
     */
    if (ftruncate(fd, SHM_SIZE) == -1) {
        perror("ftruncate");
        exit(EXIT_FAILURE);
    }
    printf("ftruncate() set size to %d bytes\n", SHM_SIZE);

    /* ---- STEP 2: mmap() ---- */
    /* MAP_SHARED means writes are visible to other processes
     * that map the same object.
     */
    addr = mmap(NULL, SHM_SIZE, PROT_READ | PROT_WRITE,
                MAP_SHARED, fd, 0);
    if (addr == MAP_FAILED) {
        perror("mmap");
        exit(EXIT_FAILURE);
    }
    printf("mmap() succeeded. Mapped at %p\n", addr);

    /* The file descriptor can be closed after mmap().
     * The mapping stays valid.
     */
    close(fd);

    /* Write to shared memory like normal memory */
    snprintf((char *)addr, SHM_SIZE, "Hello from EmbeddedPathashala!");
    printf("Wrote: %s\n", (char *)addr);

    /* Read it back */
    printf("Read back: %s\n", (char *)addr);

    /* Cleanup */
    munmap(addr, SHM_SIZE);
    shm_unlink(SHM_NAME);   /* Remove the shared memory object */

    printf("Done. Shared memory removed.\n");
    return 0;
}

shm_open() succeeded. fd = 3
ftruncate() set size to 4096 bytes
mmap() succeeded. Mapped at 0x7f3a2b000000
Wrote: Hello from EmbeddedPathashala!
Read back: Hello from EmbeddedPathashala!
Done. Shared memory removed.