Shared Memory - Learning Module

Loading content...

0/227

POSIX Shared Memory

The Modern Shared Memory API

POSIX shared memory represents a cleaner, more modern approach to inter-process memory sharing than System V IPC. Introduced in POSIX.1b (1993), it addresses many of the awkwardness of System V shared memory while integrating naturally with the Unix file system model and the standard mmap() memory mapping interface.

Where System V uses opaque numeric keys and dedicated system calls, POSIX shared memory uses named objects that appear in the filesystem namespace, behave like files, and are manipulated with familiar file-like operations. This design philosophy—treating everything as a file—makes POSIX shared memory more intuitive, more inspectable, and easier to manage.

This page provides a comprehensive exploration of POSIX shared memory: the complete API, its integration with mmap(), practical patterns for robust implementation, and clear guidance on when to choose POSIX over System V.

What You Will Learn

By the end of this page, you will understand: (1) The complete POSIX shared memory API (shm_open, shm_unlink, ftruncate), (2) Integration with mmap() for memory mapping, (3) The /dev/shm filesystem and its administration, (4) Naming conventions and portability considerations, (5) Complete producer-consumer implementation patterns, and (6) When to choose POSIX vs System V shared memory.

POSIX Shared Memory Overview

POSIX shared memory is built on a simple conceptual model: shared memory objects are memory-backed files that exist in a special namespace. Unlike regular files, they don't persist to disk storage—they exist only in RAM (and swap).

The POSIX Shared Memory Model:

Create or open a named shared memory object with shm_open() → returns a file descriptor
Set the size with ftruncate() (required for new objects)
Map into address space with mmap() → returns a pointer
Use the memory through normal pointer operations
Unmap with munmap() when done
Remove the object with shm_unlink() when no longer needed

This design mirrors the standard file workflow (open → read/write → close → unlink), making it intuitive for developers already familiar with Unix file operations.

POSIX Shared Memory API
Function	Purpose	Header
shm_open()	Create/open shared memory object	<sys/mman.h>, <fcntl.h>
shm_unlink()	Remove shared memory object	<sys/mman.h>
ftruncate()	Set object size	<unistd.h>
fstat()	Get object information	<sys/stat.h>
mmap()	Map object into address space	<sys/mman.h>
munmap()	Unmap from address space	<sys/mman.h>
close()	Close file descriptor	<unistd.h>

Key Differences from System V:

•Named objects — Uses string names (e.g., "/myshm") instead of numeric keys
•File descriptor semantics — Returns fd, works with ftruncate(), fstat(), close()
•Standard memory mapping — Uses mmap()/munmap() instead of shmat()/shmdt()
•Visible in filesystem — Objects appear in /dev/shm on Linux
•Reference counting — Object is removed after shm_unlink() when all fd's are closed
•No key generation — No need for ftok() with its associated pitfalls

Compiling POSIX Shared Memory Programs

On Linux, link with -lrt (real-time library) to use shm_open() and shm_unlink(). Example: gcc program.c -o program -lrt -lpthread. Modern systems may not require -lrt as these functions are now typically in libc.

shm_open(): Creating and Opening Shared Memory

The shm_open() function creates a new shared memory object or opens an existing one:

#include <sys/mman.h>
#include <fcntl.h>

int shm_open(const char *name, int oflag, mode_t mode);

Parameters:

shm_open() Parameters
Parameter	Type	Description
name	const char*	Object name, must start with '/' followed by non-slash characters
oflag	int	Flags controlling open behavior (O_RDONLY, O_RDWR, O_CREAT, O_EXCL, O_TRUNC)
mode	mode_t	Permission bits (e.g., 0666) - only used with O_CREAT

Flag Combinations:

Common shm_open() Flag Patterns
Pattern	Flags	Behavior
Create if needed	O_CREAT \| O_RDWR	Create or open existing, read-write access
Create exclusively	O_CREAT \| O_EXCL \| O_RDWR	Fail if already exists (ensures you're the creator)
Open existing only	O_RDWR	Fail if doesn't exist
Read-only access	O_RDONLY	Open without write permission
Truncate on open	O_CREAT \| O_TRUNC \| O_RDWR	Reset size to 0 on open

shm_open_examples.c
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
 
/**
 * Demonstrates various shm_open() usage patterns.
 */
 
// Pattern 1: Creator process - create exclusively
int create_shared_memory(const char *name, size_t size) {
    // O_EXCL ensures we fail if it already exists
    // This is important for knowing who initialized the data
    int fd = shm_open(name, O_CREAT | O_EXCL | O_RDWR, 0660);
    if (fd == -1) {
        if (errno == EEXIST) {
            printf("Shared memory '%s' already exists\n", name);
            return -1;
        }
        perror("shm_open (create)");
        return -1;
    }
    
    // Set the size - REQUIRED for new objects!
    if (ftruncate(fd, size) == -1) {
        perror("ftruncate");
        close(fd);
        shm_unlink(name);
        return -1;
    }
    
    printf("Created '%s' with size %zu\n", name, size);
    return fd;
}
 
// Pattern 2: Consumer process - open existing
int open_shared_memory(const char *name, size_t *size_out) {
    int fd = shm_open(name, O_RDWR, 0);  // Mode ignored when not creating
    if (fd == -1) {
        if (errno == ENOENT) {
            printf("Shared memory '%s' doesn't exist yet\n", name);
        } else {
            perror("shm_open (open)");
        }
        return -1;
    }
    
    // Get the size set by the creator
    struct stat sb;
    if (fstat(fd, &sb) == -1) {
        perror("fstat");
        close(fd);
        return -1;
    }
    
    *size_out = sb.st_size;
    printf("Opened '%s', size is %zu\n", name, *size_out);
    return fd;
}
 
// Pattern 3: Create or open (flexible)
int create_or_open(const char *name, size_t size, int *was_created) {
    // First try to create exclusively
    int fd = shm_open(name, O_CREAT | O_EXCL | O_RDWR, 0660);
    if (fd != -1) {
        // We created it - set size
        if (ftruncate(fd, size) == -1) {
            perror("ftruncate");
            close(fd);
            shm_unlink(name);
            return -1;
        }
        *was_created = 1;
        return fd;
    }
    
    if (errno != EEXIST) {
        perror("shm_open");
        return -1;
    }
    
    // Already exists - just open it
    fd = shm_open(name, O_RDWR, 0);
    if (fd == -1) {
        perror("shm_open (existing)");
        return -1;
    }
    *was_created = 0;
    return fd;
}
 
int main() {
    const char *name = "/demo_shm";
    size_t size = 4096;
    
    // Clean up any previous run
    shm_unlink(name);
    
    // Demonstrate creation
    int fd = create_shared_memory(name, size);
    if (fd != -1) {
        printf("File descriptor: %d\n", fd);
        
        // Show that it exists in /dev/shm
        printf("Check: ls /dev/shm%s\n", name);
        
        close(fd);
    }
    
    // Demonstrate opening
    size_t retrieved_size;
    fd = open_shared_memory(name, &retrieved_size);
    if (fd != -1) {
        printf("Retrieved size matches: %s\n", 
               retrieved_size == size ? "yes" : "no");
        close(fd);
    }
    
    // Cleanup
    if (shm_unlink(name) == 0) {
        printf("Removed '%s'\n", name);
    }
    
    return 0;
}

Naming Rules

POSIX shared memory names must start with '/' and contain no other slashes. The maximum length is implementation-defined but typically NAME_MAX (255). Some systems are more restrictive. For portability, use simple names like '/myapp_data' rather than paths like '/myapp/data/buffer'.

Size Management with ftruncate()

Unlike System V shared memory where size is specified at creation, POSIX shared memory objects are created with size zero. You must call ftruncate() to allocate space before mapping.

#include <unistd.h>

int ftruncate(int fd, off_t length);

Key Points:

Required after creation: A newly created shm object has size 0. Mapping zero bytes is invalid.
Extends with zeros: Growing an object with ftruncate() fills new space with zeros.
May not shrink immediately: Shrinking an object doesn't necessarily release memory immediately. Implementations vary.
Only once (typically): Set size once at creation. Resizing a mapped object is complex and best avoided.
Page alignment: Size is rounded up to page boundaries for mapping purposes.

size_management.c
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
 
/**
 * Demonstrates size management for POSIX shared memory.
 */
 
#define SHM_NAME "/size_demo"
 
void print_shm_size(int fd, const char *label) {
    struct stat sb;
    if (fstat(fd, &sb) == 0) {
        printf("%s: size = %ld bytes\n", label, (long)sb.st_size);
    } else {
        perror("fstat");
    }
}
 
int main() {
    // Clean up previous run
    shm_unlink(SHM_NAME);
    
    // Create shared memory object
    int fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0666);
    if (fd == -1) {
        perror("shm_open");
        exit(EXIT_FAILURE);
    }
    
    // Initial size is 0
    print_shm_size(fd, "After shm_open");
    
    // Attempting to map size 0 will fail
    void *ptr = mmap(NULL, 0, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (ptr == MAP_FAILED) {
        printf("mmap with size 0 failed (expected): %s\n", strerror(errno));
    }
    
    // Set initial size
    size_t initial_size = 4096;
    if (ftruncate(fd, initial_size) == -1) {
        perror("ftruncate");
        exit(EXIT_FAILURE);
    }
    print_shm_size(fd, "After ftruncate(4096)");
    
    // Now map it
    ptr = mmap(NULL, initial_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (ptr == MAP_FAILED) {
        perror("mmap");
        exit(EXIT_FAILURE);
    }
    
    // New memory is zero-initialized
    printf("First byte after ftruncate: 0x%02x (should be 0x00)\n", 
           ((unsigned char *)ptr)[0]);
    
    // Write some data
    memset(ptr, 'A', 100);
    printf("Wrote 100 'A' characters\n");
    
    // Growing the object
    size_t new_size = 8192;
    if (ftruncate(fd, new_size) == -1) {
        perror("ftruncate (grow)");
    } else {
        print_shm_size(fd, "After ftruncate(8192)");
        printf("Note: existing mapping still only covers original 4096 bytes!\n");
    }
    
    // To access new space, need to remap
    munmap(ptr, initial_size);
    ptr = mmap(NULL, new_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (ptr != MAP_FAILED) {
        // Original data preserved
        printf("First byte after remap: '%c' (should be 'A')\n", 
               ((char *)ptr)[0]);
        
        // New space is zeroed
        printf("Byte 4100: 0x%02x (should be 0x00)\n", 
               ((unsigned char *)ptr)[4100]);
        
        munmap(ptr, new_size);
    }
    
    // Shrinking (implementation-dependent behavior)
    printf("\nShrinking is discouraged - behavior varies by implementation\n");
    
    // Cleanup
    close(fd);
    shm_unlink(SHM_NAME);
    
    return 0;
}

Why ftruncate() After shm_open()?

This two-step process (shm_open + ftruncate) allows consumers to query the size with fstat() before mapping. The creator sets the size; consumers discover it. This is cleaner than System V where you must either know the size in advance or pass it out-of-band.

The /dev/shm Filesystem

On Linux, POSIX shared memory objects are implemented using a tmpfs filesystem mounted at /dev/shm. This provides a file-like interface to shared memory while keeping everything in RAM.

tmpfs Characteristics:

Stored in RAM (and swap if memory pressure occurs)
Files appear in the filesystem namespace
Subject to filesystem permissions
Uses standard file operations (ls, cat, rm, chmod, etc.)
Contents lost on reboot (unless swap preserves them, which is system-dependent)

Visibility Advantages:

Unlike System V segments (visible only via ipcs -m), POSIX shared memory can be examined with standard Unix tools:

dev_shm_operations.sh
Bash
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#!/bin/bash
# Operations on /dev/shm
 
echo "=== POSIX Shared Memory Objects ==="
ls -la /dev/shm/
 
echo ""
echo "=== Size and Usage ==="
df -h /dev/shm/
 
echo ""
echo "=== View contents of a shared memory object ==="
# If you have a shm object named /myapp_data, view it:
# hexdump -C /dev/shm/myapp_data | head -20
 
echo ""
echo "=== Check permissions ==="
# ls -la /dev/shm/myapp_data
 
echo ""
echo "=== Delete orphaned shared memory ==="
# rm /dev/shm/myapp_data
# Or from code: shm_unlink("/myapp_data");
 
echo ""
echo "=== Monitor shared memory usage ==="
# Watch for changes in /dev/shm
# inotifywait -m /dev/shm
 
echo ""
echo "=== Typical mount options (from /proc/mounts) ==="
grep "devshm\|/dev/shm" /proc/mounts
 
echo ""
echo "=== Resize /dev/shm (requires root) ==="
echo "# Edit /etc/fstab or use:"
echo "# mount -o remount,size=4G /dev/shm"

Size Limits:

By default, /dev/shm is typically sized at 50% of physical RAM. This limits total POSIX shared memory usage. You can check and modify this:

# Check current size
df -h /dev/shm

# Resize temporarily (as root)
mount -o remount,size=8G /dev/shm

# Permanent resize via /etc/fstab:
# tmpfs /dev/shm tmpfs defaults,size=8G 0 0

Comparison: /dev/shm vs. Just Using mmap on Files:

You might wonder: "Why not just mmap() a regular file in /tmp?" The key differences:

Aspect	/dev/shm	Regular File mmap
Storage	RAM only (+ swap)	Disk (cached in RAM)
Persistence	Lost on reboot	Survives reboot
Write-back	None	Periodic flush to disk
Performance	Optimal for IPC	Disk I/O can occur
Intent	Temporary sharing	Persistent files

Debugging with /dev/shm

During development, you can inspect shared memory contents directly: 'xxd /dev/shm/myshm | less'. You can also copy a snapshot: 'cp /dev/shm/myshm /tmp/myshm_snapshot' for later analysis. This visibility is a major advantage over System V shared memory.

Complete Implementation Pattern

Let's bring together all the POSIX shared memory concepts into a complete, production-ready implementation pattern. This example demonstrates a producer-consumer system with proper initialization, synchronization, and cleanup.

posix_shm_complete.c
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
/**
 * Complete POSIX Shared Memory Example
 * 
 * Demonstrates a robust producer-consumer pattern using:
 * - POSIX shared memory (shm_open, mmap)
 * - POSIX semaphores for synchronization
 * - Proper initialization, validation, and cleanup
 * 
 * Compile: gcc -o shm_demo posix_shm_complete.c -lrt -lpthread
 * Run producer: ./shm_demo producer
 * Run consumer: ./shm_demo consumer
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <semaphore.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <time.h>
 
// Configuration
#define SHM_NAME "/messagequeue"
#define SEM_MUTEX_NAME "/mq_mutex"
#define SEM_ITEMS_NAME "/mq_items"
#define SEM_SPACES_NAME "/mq_spaces"
#define QUEUE_SIZE 10
#define MESSAGE_SIZE 256
 
// Magic number for validation
#define SHM_MAGIC 0x4D51534D  // "MQSM" - Message Queue Shared Memory
 
// Shared memory structure
typedef struct {
    uint32_t magic;
    uint32_t version;
    uint32_t head;           // Consumer reads from here
    uint32_t tail;           // Producer writes here
    uint32_t count;          // Current message count
    char messages[QUEUE_SIZE][MESSAGE_SIZE];
} SharedQueue;
 
// Global state for cleanup
static SharedQueue *g_queue = NULL;
static size_t g_shm_size = 0;
static sem_t *g_sem_mutex = NULL;
static sem_t *g_sem_items = NULL;
static sem_t *g_sem_spaces = NULL;
static int g_is_producer = 0;
volatile sig_atomic_t g_running = 1;
 
void signal_handler(int sig) {
    g_running = 0;
}
 
void cleanup(void) {
    printf("Cleaning up...\n");
    
    if (g_queue) {
        munmap(g_queue, g_shm_size);
    }
    
    if (g_sem_mutex) sem_close(g_sem_mutex);
    if (g_sem_items) sem_close(g_sem_items);
    if (g_sem_spaces) sem_close(g_sem_spaces);
    
    // Only producer removes resources
    if (g_is_producer) {
        shm_unlink(SHM_NAME);
        sem_unlink(SEM_MUTEX_NAME);
        sem_unlink(SEM_ITEMS_NAME);
        sem_unlink(SEM_SPACES_NAME);
        printf("Removed shared resources\n");
    }
}
 
int init_producer(void) {
    g_is_producer = 1;
    
    // Remove any stale resources
    shm_unlink(SHM_NAME);
    sem_unlink(SEM_MUTEX_NAME);
    sem_unlink(SEM_ITEMS_NAME);
    sem_unlink(SEM_SPACES_NAME);
    
    // Create shared memory
    int fd = shm_open(SHM_NAME, O_CREAT | O_EXCL | O_RDWR, 0666);
    if (fd == -1) {
        perror("shm_open");
        return -1;
    }
    
    g_shm_size = sizeof(SharedQueue);
    if (ftruncate(fd, g_shm_size) == -1) {
        perror("ftruncate");
        close(fd);
        return -1;
    }
    
    g_queue = mmap(NULL, g_shm_size, PROT_READ | PROT_WRITE,
                   MAP_SHARED, fd, 0);
    close(fd);
    
    if (g_queue == MAP_FAILED) {
        perror("mmap");
        return -1;
    }
    
    // Initialize queue structure
    memset(g_queue, 0, g_shm_size);
    g_queue->magic = SHM_MAGIC;
    g_queue->version = 1;
    g_queue->head = 0;
    g_queue->tail = 0;
    g_queue->count = 0;
    
    // Create semaphores
    g_sem_mutex = sem_open(SEM_MUTEX_NAME, O_CREAT | O_EXCL, 0666, 1);
    g_sem_items = sem_open(SEM_ITEMS_NAME, O_CREAT | O_EXCL, 0666, 0);
    g_sem_spaces = sem_open(SEM_SPACES_NAME, O_CREAT | O_EXCL, 0666, QUEUE_SIZE);
    
    if (g_sem_mutex == SEM_FAILED || g_sem_items == SEM_FAILED || 
        g_sem_spaces == SEM_FAILED) {
        perror("sem_open");
        return -1;
    }
    
    printf("Producer initialized. Queue capacity: %d messages\n", QUEUE_SIZE);
    return 0;
}
 
int init_consumer(void) {
    // Open existing shared memory
    int fd = shm_open(SHM_NAME, O_RDWR, 0);
    if (fd == -1) {
        if (errno == ENOENT) {
            fprintf(stderr, "Producer not running. Start producer first.\n");
        } else {
            perror("shm_open");
        }
        return -1;
    }
    
    struct stat sb;
    if (fstat(fd, &sb) == -1) {
        perror("fstat");
        close(fd);
        return -1;
    }
    g_shm_size = sb.st_size;
    
    g_queue = mmap(NULL, g_shm_size, PROT_READ | PROT_WRITE,
                   MAP_SHARED, fd, 0);
    close(fd);
    
    if (g_queue == MAP_FAILED) {
        perror("mmap");
        return -1;
    }
    
    // Validate magic number
    if (g_queue->magic != SHM_MAGIC) {
        fprintf(stderr, "Invalid shared memory magic number\n");
        return -1;
    }
    
    // Open existing semaphores
    g_sem_mutex = sem_open(SEM_MUTEX_NAME, 0);
    g_sem_items = sem_open(SEM_ITEMS_NAME, 0);
    g_sem_spaces = sem_open(SEM_SPACES_NAME, 0);
    
    if (g_sem_mutex == SEM_FAILED || g_sem_items == SEM_FAILED || 
        g_sem_spaces == SEM_FAILED) {
        perror("sem_open (existing)");
        return -1;
    }
    
    printf("Consumer connected. Queue version: %u\n", g_queue->version);
    return 0;
}
 
int enqueue(const char *message) {
    // Wait for space
    sem_wait(g_sem_spaces);
    
    // Lock queue
    sem_wait(g_sem_mutex);
    
    // Add message
    strncpy(g_queue->messages[g_queue->tail], message, MESSAGE_SIZE - 1);
    g_queue->messages[g_queue->tail][MESSAGE_SIZE - 1] = '\0';
    g_queue->tail = (g_queue->tail + 1) % QUEUE_SIZE;
    g_queue->count++;
    
    sem_post(g_sem_mutex);
    
    // Signal item available
    sem_post(g_sem_items);
    
    return 0;
}
 
int dequeue(char *buffer, size_t bufsize) {
    // Wait for item
    struct timespec timeout;
    clock_gettime(CLOCK_REALTIME, &timeout);
    timeout.tv_sec += 1;  // 1 second timeout
    
    if (sem_timedwait(g_sem_items, &timeout) == -1) {
        if (errno == ETIMEDOUT) return -1;
        perror("sem_timedwait");
        return -1;
    }
    
    // Lock queue
    sem_wait(g_sem_mutex);
    
    // Get message
    strncpy(buffer, g_queue->messages[g_queue->head], bufsize - 1);
    buffer[bufsize - 1] = '\0';
    g_queue->head = (g_queue->head + 1) % QUEUE_SIZE;
    g_queue->count--;
    
    sem_post(g_sem_mutex);
    
    // Signal space available
    sem_post(g_sem_spaces);
    
    return 0;
}
 
void run_producer(void) {
    printf("Producing messages. Press Ctrl+C to stop.\n");
    
    int msg_num = 0;
    while (g_running) {
        char message[MESSAGE_SIZE];
        snprintf(message, sizeof(message), "Message #%d from PID %d", 
                 msg_num++, getpid());
        
        enqueue(message);
        printf("Produced: %s (queue size: %u)\n", message, g_queue->count);
        
        usleep(500000);  // 500ms delay
    }
}
 
void run_consumer(void) {
    printf("Consuming messages. Press Ctrl+C to stop.\n");
    
    while (g_running) {
        char message[MESSAGE_SIZE];
        if (dequeue(message, sizeof(message)) == 0) {
            printf("Consumed: %s (queue size: %u)\n", message, g_queue->count);
        }
    }
}
 
int main(int argc, char *argv[]) {
    if (argc != 2 || (strcmp(argv[1], "producer") != 0 && 
                      strcmp(argv[1], "consumer") != 0)) {
        fprintf(stderr, "Usage: %s <producer|consumer>\n", argv[0]);
        return EXIT_FAILURE;
    }
    
    // Setup signal handlers
    signal(SIGINT, signal_handler);
    signal(SIGTERM, signal_handler);
    atexit(cleanup);
    
    int is_producer = (strcmp(argv[1], "producer") == 0);
    
    if (is_producer) {
        if (init_producer() != 0) return EXIT_FAILURE;
        run_producer();
    } else {
        if (init_consumer() != 0) return EXIT_FAILURE;
        run_consumer();
    }
    
    printf("Exiting\n");
    return EXIT_SUCCESS;
}

Production Considerations

This example demonstrates the pattern but would need enhancements for production: error recovery, metrics/logging, graceful degradation if semaphores fail, handling of process crashes, and potentially robust mutexes. The synchronization uses three semaphores: mutex for exclusive access, items to block consumers when empty, spaces to block producers when full.

POSIX vs System V: When to Choose Which

Both POSIX and System V shared memory achieve the same result—sharing memory between processes—but with different APIs and trade-offs. Here's a detailed comparison to guide your choice.

Comprehensive POSIX vs System V Comparison
Aspect	POSIX Shared Memory	System V Shared Memory
API Style	File-like (open/mmap/close)	Dedicated IPC calls (shmget/shmat)
Naming	String names (/myshm)	Numeric keys (ftok or constant)
Size Setting	ftruncate() separately	At shmget() time
Visibility	/dev/shm filesystem	ipcs -m command only
Memory Mapping	Standard mmap()	Custom shmat()
Lifetime Control	Reference counted after unlink	Persists until explicit IPC_RMID
Portability	POSIX systems (most modern Unix)	All Unix (including ancient)
Windows Equivalent	CreateFileMapping (similar)	None directly
Multiple Mappings	mmap supports partial, multiple	shmat can attach multiple times
Resize	ftruncate() (grow only reliable)	Not supported after creation
Debugging	Easy (ls, cat, rm)	Requires ipcs/ipcrm

Choose POSIX When

•Writing new code without legacy constraints
•You want file-like semantics and easier debugging
•Targeting modern Linux, macOS, or BSD systems
•You need partial mappings of large objects
•You prefer string names over numeric keys
•Administrative visibility (/dev/shm) is valuable

Choose System V When

•Maintaining legacy code that uses System V IPC
•Targeting very old Unix systems without POSIX IPC
•You need segment information (creator PID, attach times) via shmctl()
•Integration with other System V IPC (semaphores, message queues) already in use
•You prefer the segment to persist through crashes without explicit unlink

General Recommendation

For new projects, prefer POSIX shared memory. It integrates better with modern development practices, is easier to debug, and provides cleaner semantics. Only use System V if you have specific legacy compatibility requirements or need its unique features.

Portability Considerations

POSIX shared memory is standardized, but implementations vary. Understanding these differences helps write portable code.

Platform-Specific Behavior
Platform	Implementation	Notes
Linux	tmpfs at /dev/shm	Full support, objects visible as files
macOS	Kernel object	Works but no /dev/shm equivalent visible
FreeBSD	tmpfs or kernel	Configuration dependent
Solaris/illumos	tmpfs	Full POSIX compliance
Windows (via Cygwin)	File mapping	Compatible API, different mechanism
QNX	Native	Real-time OS with full POSIX support

Portability Tips:

•Name format: Always use names starting with '/' and no other slashes. Some systems are strict about this.
•Name length: Keep names short (< 32 characters). NAME_MAX varies.
•Binary layout: Ensure structures in shared memory have explicit padding for consistent layout across compilers.
•Endianness: If sharing between different architectures, handle byte order explicitly.
•Atomics: Verify lock-free atomics are truly lock-free on all target platforms.
•Size limits: Check /dev/shm size on Linux; other systems may have different limits.
•Feature testing: Use feature test macros (_POSIX_SHARED_MEMORY_OBJECTS) to detect availability.

portable_shm.h
C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
/**
 * Portable POSIX shared memory wrapper header.
 */
#ifndef PORTABLE_SHM_H
#define PORTABLE_SHM_H
 
#include <stddef.h>
#include <stdint.h>
 
/* Feature detection */
#if defined(_POSIX_SHARED_MEMORY_OBJECTS) && _POSIX_SHARED_MEMORY_OBJECTS > 0
    #define HAVE_POSIX_SHM 1
#elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
    #define HAVE_POSIX_SHM 1
#else
    #define HAVE_POSIX_SHM 0
#endif
 
#if !HAVE_POSIX_SHM
    #error "POSIX shared memory not available on this platform"
#endif
 
/* Cross-platform structure alignment */
#if defined(__GNUC__) || defined(__clang__)
    #define SHM_PACKED __attribute__((packed))
    #define SHM_ALIGNED(n) __attribute__((aligned(n)))
#elif defined(_MSC_VER)
    #define SHM_PACKED
    #define SHM_ALIGNED(n) __declspec(align(n))
#else
    #define SHM_PACKED
    #define SHM_ALIGNED(n)
#endif
 
/* Cache line size for alignment */
#define CACHE_LINE_SIZE 64
 
/* Portable shared memory structure template */
typedef struct SHM_ALIGNED(CACHE_LINE_SIZE) {
    uint32_t magic;
    uint32_t version;
    uint32_t creator_pid;
    uint32_t _reserved;
    /* Add your data fields here */
} PortableSharedData;
 
/* API functions */
int portable_shm_create(const char *name, size_t size, void **ptr_out);
int portable_shm_open(const char *name, void **ptr_out, size_t *size_out);
int portable_shm_close(void *ptr, size_t size);
int portable_shm_unlink(const char *name);
 
/* Name formatting */
static inline int shm_validate_name(const char *name) {
    if (!name || name[0] != '/') return 0;
    if (strchr(name + 1, '/') != NULL) return 0;
    if (strlen(name) > 31) return 0;  // Conservative limit
    return 1;
}
 
#endif /* PORTABLE_SHM_H */

Summary: POSIX Shared Memory

We've completed a comprehensive exploration of POSIX shared memory—the modern, file-oriented API for inter-process memory sharing. Let's consolidate the key takeaways:

Key Takeaways

•shm_open() creates or opens named objects — Uses string names (starting with /), returns file descriptor, integrates with standard file operations.
•ftruncate() sets the size — Required after creation. Size can be queried by consumers via fstat().
•mmap() maps to address space — Standard memory mapping interface, supports partial mappings and protection changes.
•/dev/shm provides visibility — On Linux, objects appear as files. Use ls, cat, rm for inspection and administration.
•shm_unlink() removes the name — Object remains valid until all file descriptors are closed. Enables deferred deletion.
•POSIX is preferred for new code — Cleaner API, better debugging, standard mmap integration. Use System V only for legacy compatibility.
•Portability requires care — Name format, structure alignment, and platform-specific limits need attention.

Module Complete:

You've now mastered shared memory—the fastest inter-process communication mechanism. From creating segments to attaching/detaching, from synchronization requirements to performance optimization, and from System V to POSIX APIs, you have the knowledge to implement high-performance shared memory systems.

Next Steps:

Practice with the producer-consumer pattern
Experiment with performance benchmarks
Explore lock-free data structures for advanced use cases
Consider shared memory for your next high-performance IPC requirement

Module Complete

Congratulations! You've completed the Shared Memory module. You understand how to create, attach, synchronize, and optimize shared memory regions using both System V and POSIX APIs. You're equipped to implement the highest-performance IPC solutions in operating systems.