PREV_LECNEXT_LEC

What You Will Learn

Prerequisites

Why Share Memory At All

Copy-based IPC is simple precisely because the kernel does all the hard work of keeping data consistent — a message is either fully delivered or not delivered at all, and the kernel serializes access for you. Shared memory removes that safety net. Once two processes can both write to the same bytes at the same time, you are responsible for making sure they don’t step on each other, and that a reader never sees a half-written update.

The payoff is speed: for large or frequent transfers — video frames, audio buffers, large sensor batches — avoiding the double-copy of FIFO/socket/queue IPC can matter a great deal on a resource-constrained embedded board.

The Three-Step Workflow

Setting up POSIX shared memory always follows the same three calls:

Segment names follow the same rule as message queue names: they must begin with exactly one leading / and contain no further slashes, for example /ep-shm-demo. Under the hood, these objects typically live in tmpfs, visible at /dev/shm on most distributions:

$ ls -la /dev/shm
-rw-r--r-- 1 ravi ravi 4096 Aug 27 10:15 ep-shm-demo

Synchronizing Access

Shared memory tells you nothing about when the other side has finished writing. You need an explicit signal. A POSIX named semaphore (sem_open(3)) is the standard tool: the writer posts the semaphore after finishing a write, and the reader waits on it before reading. For a simple one-writer, one-reader demo, a single semaphore initialized to zero is enough to hand off each update.

Hands-On: A Shared Memory Writer/Reader Demo

This demo has two original programs, both prefixed ep_: ep_shm_writer creates a shared segment holding a small sensor-style struct, writes a few updates, and signals a semaphore after each; ep_shm_reader waits on that semaphore and prints each update as it arrives.

/* ep_shm_common.h */
#ifndef EP_SHM_COMMON_H
#define EP_SHM_COMMON_H

#define EP_SHM_NAME  "/ep-shm-demo"
#define EP_SEM_NAME  "/ep-shm-demo-sem"

typedef struct {
    int   sample_id;
    float temperature_c;
} ep_reading_t;

#endif

/* ep_shm_writer.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <semaphore.h>
#include "ep_shm_common.h"

int main(void)
{
    int fd = shm_open(EP_SHM_NAME, O_CREAT | O_RDWR, 0644);
    if (fd == -1) { perror("shm_open"); return 1; }

    if (ftruncate(fd, sizeof(ep_reading_t)) == -1) {
        perror("ftruncate");
        return 1;
    }

    ep_reading_t *shared = mmap(NULL, sizeof(ep_reading_t),
                                 PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (shared == MAP_FAILED) { perror("mmap"); return 1; }

    sem_t *sem = sem_open(EP_SEM_NAME, O_CREAT, 0644, 0);
    if (sem == SEM_FAILED) { perror("sem_open"); return 1; }

    for (int i = 1; i sample_id     = i;
        shared->temperature_c = 25.0f + i;
        printf("ep_shm_writer: wrote sample %d (%.1fC)\n",
               shared->sample_id, shared->temperature_c);
        sem_post(sem);
        sleep(1);
    }

    munmap(shared, sizeof(ep_reading_t));
    close(fd);
    sem_close(sem);
    return 0;
}

/* ep_shm_reader.c */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <semaphore.h>
#include "ep_shm_common.h"

int main(void)
{
    int fd = shm_open(EP_SHM_NAME, O_RDONLY, 0644);
    if (fd == -1) { perror("shm_open"); return 1; }

    ep_reading_t *shared = mmap(NULL, sizeof(ep_reading_t),
                                 PROT_READ, MAP_SHARED, fd, 0);
    if (shared == MAP_FAILED) { perror("mmap"); return 1; }

    sem_t *sem = sem_open(EP_SEM_NAME, 0);
    if (sem == SEM_FAILED) { perror("sem_open"); return 1; }

    for (int i = 0; i sample_id, shared->temperature_c);
    }

    munmap(shared, sizeof(ep_reading_t));
    close(fd);
    sem_close(sem);

    shm_unlink(EP_SHM_NAME);
    sem_unlink(EP_SEM_NAME);
    return 0;
}

Build and Run

$ gcc -o ep_shm_writer ep_shm_writer.c -lrt -lpthread
$ gcc -o ep_shm_reader ep_shm_reader.c -lrt -lpthread

# start the reader first in one terminal
$ ./ep_shm_reader

# then the writer in another terminal
$ ./ep_shm_writer
ep_shm_writer: wrote sample 1 (26.0C)
ep_shm_writer: wrote sample 2 (27.0C)
ep_shm_writer: wrote sample 3 (28.0C)

Reader terminal output:

ep_shm_reader: sample 1 = 26.0C
ep_shm_reader: sample 2 = 27.0C
ep_shm_reader: sample 3 = 28.0C

The reader blocks on sem_wait until the writer calls sem_post, so the two processes stay correctly synchronized without either one busy-polling or reading a half-updated struct.

Real-World Use Cases

Common Mistakes and Troubleshooting

Best Practices

Performance Considerations

Shared memory’s whole value proposition is avoiding copies, so measure whether that copy avoidance actually matters for your workload before adding the synchronization complexity. For small, infrequent messages, the two-copy cost of a message queue or socket is usually cheaper in engineering time than a hand-rolled shared memory protocol, even if it’s technically slower in raw throughput. Reach for shared memory when profiling shows the copy overhead is real — large buffers, high frequency, or tight latency budgets.

Security Considerations

A shared memory segment’s permissions are set at shm_open time via the mode argument, exactly like a regular file. Any process with sufficient permission to open the segment can read or write it — there’s no built-in access control beyond that, so avoid world-writable segments on any system where untrusted local processes might run, and consider a dedicated group for processes that legitimately need access.

Summary and Key Takeaways

Conclusion

Between this lecture and the previous one, you now have the full picture of Linux IPC’s two fundamental strategies: copy-based mechanisms that trade a small performance cost for kernel-managed safety, and shared memory that trades that safety for raw speed. Most real embedded systems end up using both — a message queue or socket for control and signalling, and shared memory for the bulk data path. Understanding when each is the right tool is one of the most transferable skills in systems programming, on embedded Linux or anywhere else.

Frequently Asked Questions

PREV_LECNEXT_LEC`