The diagram below shows why shared memory is faster than pipes and message queues.

Every shared memory usage follows this sequence. Each step maps to a specific system call.

This skeleton shows the overall flow — create, attach, use, detach, delete. Details of each call are covered in the following parts.

/* shm_skeleton.c — Minimal System V shared memory lifecycle */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>

#define SHM_SIZE 4096   /* 4 KB — kernel rounds up to page size anyway */

int main(void)
{
    int    shmid;
    char  *shmptr;

    /* STEP 1: Create a shared memory segment.
       IPC_PRIVATE means only this process (and its children) will use it.
       0600 = owner can read+write */
    shmid = shmget(IPC_PRIVATE, SHM_SIZE, IPC_CREAT | 0600);
    if (shmid == -1) {
        perror("shmget");
        exit(EXIT_FAILURE);
    }
    printf("Segment created, shmid = %d\n", shmid);

    /* STEP 2: Attach — map segment into our address space.
       NULL means: let the kernel pick the address (recommended). */
    shmptr = shmat(shmid, NULL, 0);
    if (shmptr == (void *) -1) {
        perror("shmat");
        exit(EXIT_FAILURE);
    }
    printf("Attached at address: %p\n", (void *)shmptr);

    /* STEP 3: Use — read/write like normal memory */
    strcpy(shmptr, "Hello from shared memory!");
    printf("Written: %s\n", shmptr);

    /* STEP 4: Detach */
    if (shmdt(shmptr) == -1) {
        perror("shmdt");
        exit(EXIT_FAILURE);
    }
    printf("Detached\n");

    /* STEP 5: Delete */
    if (shmctl(shmid, IPC_RMID, NULL) == -1) {
        perror("shmctl IPC_RMID");
        exit(EXIT_FAILURE);
    }
    printf("Segment deleted\n");

    return 0;
}

Compile and run:

gcc -o shm_skeleton shm_skeleton.c
./shm_skeleton

Because the kernel does not intervene on every read/write, two processes can simultaneously modify the same location — a race condition. The classic example:

Solution: protect accesses with a semaphore, mutex, or other locking primitive. System V semaphores (Chapter 47) are the traditional companion to System V shared memory.

/* Pattern: use a semaphore to protect shared memory access */
sem_wait(&sem);          /* lock */
shared_data->counter++;  /* safe — only one process at a time */
sem_post(&sem);          /* unlock */

You will encounter both terms when reading Linux IPC documentation.

The underlying operation is identical — both modify the process’s page table to point virtual addresses at physical RAM pages. The terminology difference is purely historical.