#include <sys/mman.h>

void *mmap(void   *addr,    /* Suggested address (usually NULL) */
           size_t  length,  /* Number of bytes to map           */
           int     prot,    /* Protection flags: PROT_READ etc  */
           int     flags,   /* MAP_SHARED or MAP_PRIVATE etc    */
           int     fd,      /* File descriptor from shm_open()  */
           off_t   offset); /* Offset into object (usually 0)   */

/* Returns: mapped address on success, MAP_FAILED on error */

The prot argument controls what operations are allowed on the mapped region. The protection you request must be compatible with the access mode used in shm_open().

When two processes call mmap() with MAP_SHARED on the same object, the kernel arranges their page tables to point at the same physical pages:

When you are done with the shared memory, call munmap() to release the mapping from the process’s virtual address space.

#include <sys/mman.h>

int munmap(void *addr, size_t length);
/* Returns: 0 on success, -1 on error */

A common real-world pattern is to cast the mapped address to a pointer to a struct that defines the shared data layout. Both processes use the same struct definition.

/*
 * shared_struct.h — Shared data layout used by writer and reader
 * Both processes include this header.
 */
#ifndef SHARED_STRUCT_H
#define SHARED_STRUCT_H

#include <stdint.h>

#define SHM_NAME  "/ep_struct_demo"
#define SHM_SIZE  sizeof(struct SharedData)

/* Data layout in shared memory */
struct SharedData {
    int32_t  counter;          /* Incremented by writer     */
    int32_t  ready;            /* 1 = new data available    */
    char     message[128];     /* Text message from writer  */
};

#endif

/*
 * shm_writer.c — Writes to shared memory via mmap()
 * Compile: gcc shm_writer.c -o shm_writer -lrt
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include "shared_struct.h"

int main(void)
{
    int fd;
    struct SharedData *shdata;

    /* Create shared memory object */
    fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0660);
    if (fd == -1) { perror("shm_open"); exit(EXIT_FAILURE); }

    if (ftruncate(fd, SHM_SIZE) == -1) { perror("ftruncate"); exit(EXIT_FAILURE); }

    /* Map and cast to struct pointer */
    shdata = mmap(NULL, SHM_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (shdata == MAP_FAILED) { perror("mmap"); exit(EXIT_FAILURE); }
    close(fd);  /* fd not needed after mmap */

    /* Initialize */
    shdata->counter = 0;
    shdata->ready   = 0;
    memset(shdata->message, 0, sizeof(shdata->message));

    printf("[Writer] Shared memory ready. Writing 5 messages...\n");

    for (int i = 1; i <= 5; i++) {
        shdata->counter = i;
        snprintf(shdata->message, sizeof(shdata->message),
                 "Message #%d from writer (pid=%d)", i, (int)getpid());
        shdata->ready = 1;    /* Signal reader */

        printf("[Writer] counter=%d  message='%s'\n",
               shdata->counter, shdata->message);
        sleep(1);
        shdata->ready = 0;    /* Reset */
    }

    printf("[Writer] Done. Press Enter to cleanup and exit...\n");
    getchar();

    munmap(shdata, SHM_SIZE);
    shm_unlink(SHM_NAME);
    return 0;
}

/*
 * shm_reader.c — Reads from shared memory via mmap()
 * Compile: gcc shm_reader.c -o shm_reader -lrt
 * Run in a second terminal while writer is running.
 */

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include "shared_struct.h"

int main(void)
{
    int fd;
    struct SharedData *shdata;

    /* Open existing object — reader doesn't create */
    fd = shm_open(SHM_NAME, O_RDONLY, 0);
    if (fd == -1) { perror("shm_open"); exit(EXIT_FAILURE); }

    /* Map read-only */
    shdata = mmap(NULL, SHM_SIZE, PROT_READ, MAP_SHARED, fd, 0);
    if (shdata == MAP_FAILED) { perror("mmap"); exit(EXIT_FAILURE); }
    close(fd);

    printf("[Reader] Watching for messages (Ctrl+C to stop)...\n");

    int last_counter = 0;
    while (1) {
        /* Spin-wait for new data (simple polling — in production use semaphore) */
        if (shdata->ready == 1 && shdata->counter != last_counter) {
            printf("[Reader] counter=%d  message='%s'\n",
                   shdata->counter, shdata->message);
            last_counter = shdata->counter;
        }
        usleep(10000);  /* 10ms poll interval */
    }

    munmap(shdata, SHM_SIZE);
    return 0;
}