Shared Memory

Chapter 1: shmget() — Creating a Segment

Just like message queues and semaphores, shared memory uses the same System V pattern: ftok() for the key, then a get function to create or connect.

c
#include <sys/shm.h>

int shmget(key_t key, size_t size, int shmflg);

c
key_t key;
int shmid;

key = ftok("/home/beej/somefile3", 'R');
shmid = shmget(key, 1024, 0644 | IPC_CREAT);

This creates a 1K shared memory segment with rw-r--r-- permissions. The shmid is just a handle — you can't use it as a pointer yet. For that, you need shmat().

Chapter 2: shmat() — Getting a Pointer

This is the magic step. shmat() takes your segment ID and returns an actual pointer you can use like any other C pointer:

c
void *shmat(int shmid, void *shmaddr, int shmflg);

c
char *data;

data = shmat(shmid, (void *)0, 0);
if (data == (char *)(-1))
    perror("shmat");

Once you have the pointer, you can read and write to it like any memory. The pointer is just a char * (or whatever type you cast it to). You're directly touching the shared segment.

Chapter 3: Reading and Writing

Once you have the pointer from shmat(), reading and writing is trivially easy. It's just normal C pointer operations:

c
char *data = shmat(shmid, (void *)0, 0);

/* Write to the segment */
printf("Enter a string: ");
fgets(data, 1024, stdin);

/* Read from the segment */
printf("Segment contains: %s\n", data);

That's it. No special system calls for reading or writing. data behaves exactly like any other pointer. You can treat it as a char *, a pointer to a struct, an array — whatever you need.

Chapter 4: Detaching and Deleting

When you're done with the shared memory segment, there are two separate steps: detach (disconnect your process) and delete (remove the segment from the system).

c
/* Detach: disconnect from the segment */
shmdt(data);    /* pass the pointer from shmat() */

/* Delete: remove the segment from the kernel */
shmctl(shmid, IPC_RMID, NULL);

After shmdt(), any access through the old pointer will cause a segmentation fault. The pointer is dangling.

Chapter 5: Concurrency Dangers

Here's the elephant in the room: shared memory has no built-in synchronization. If two processes write to the same address at the same time, you get a data race. The result is undefined — corrupted data, partial writes, nonsense values.

The solution: use semaphores (from Chapter 8) to protect access:

c
/* Lock the semaphore before writing */
sb.sem_op = -1;
semop(semid, &sb, 1);

/* Write to shared memory (critical section) */
strcpy(data, "Hello World");

/* Unlock the semaphore */
sb.sem_op = 1;
semop(semid, &sb, 1);

Chapter 6: shmdemo.c — The Full Program

Beej's demo program reads or writes to a shared memory segment depending on command-line arguments. Run it with an argument to store data, without to read it:

c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#define SHM_SIZE 1024

int main(int argc, char *argv[]) {
    key_t key;
    int shmid;
    char *data;

    key = ftok("shmdemo.c", 'R');
    shmid = shmget(key, SHM_SIZE, 0644 | IPC_CREAT);

    data = shmat(shmid, (void *)0, 0);
    if (data == (char *)(-1)) {
        perror("shmat");
        exit(1);
    }

    if (argc == 2) {
        printf("writing to segment: \"%s\"\n", argv[1]);
        strncpy(data, argv[1], SHM_SIZE);
    } else {
        printf("segment contains: \"%s\"\n", data);
    }

    shmdt(data);
    return 0;
}

Chapter 7: Shared Memory Simulator

Watch two processes read and write to the same memory region. Without synchronization, simultaneous writes can corrupt data.

Chapter 8: Beyond Shared Memory

Shared memory is the fastest IPC because there's no kernel involvement for actual data transfer. But it requires careful synchronization.

"The cool thing about shared memory segments is that they are what they sound like: a segment of memory that is shared between processes." — Beej