Shared Memory: The Fastest IPC Mechanism

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

#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <errno.h>
#include <string.h>
 
#define SHM_SIZE 4096  // 4KB segment
 
/**
 * Demonstrates robust System V shared memory creation
 * with comprehensive error handling and cleanup.
 */
int main() {
    key_t key;
    int shmid;
    
    // Generate a unique key based on file path and project ID
    // Both communicating processes must use identical arguments
    key = ftok("/tmp/myapp", 'S');
    if (key == -1) {
        perror("ftok failed");
        fprintf(stderr, "Ensure /tmp/myapp exists and is accessible
");
        exit(EXIT_FAILURE);
    }
    
    printf("Generated key: 0x%x
", key);
    
    // Attempt to create shared memory segment
    // IPC_CREAT: Create if doesn't exist
    // IPC_EXCL: Fail if already exists (we want to be the creator)
    // 0660: Owner and group read/write, others no access
    shmid = shmget(key, SHM_SIZE, IPC_CREAT | IPC_EXCL | 0660);
    
    if (shmid == -1) {
        if (errno == EEXIST) {
            // Segment already exists - attach to it instead
            printf("Segment exists, attaching...
");
            shmid = shmget(key, 0, 0660);
            if (shmid == -1) {
                perror("shmget (attach) failed");
                exit(EXIT_FAILURE);
            }
        } else {
            perror("shmget failed");
            fprintf(stderr, "Error code: %d
", errno);
            exit(EXIT_FAILURE);
        }
    } else {
        printf("Created new shared memory segment
");
    }
    
    printf("Shared memory ID: %d
", shmid);
    
    // Query segment information
    struct shmid_ds shm_info;
    if (shmctl(shmid, IPC_STAT, &shm_info) == -1) {
        perror("shmctl IPC_STAT failed");
        exit(EXIT_FAILURE);
    }
    
    printf("Segment size: %zu bytes
", shm_info.shm_segsz);
    printf("Creator PID: %d
", shm_info.shm_cpid);
    printf("Last attach PID: %d
", shm_info.shm_lpid);
    printf("Current attachments: %lu
", shm_info.shm_nattch);
    
    return 0;
}

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

#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/stat.h>
#include <errno.h>
 
/**
 * Demonstrates ftok() internals and potential issues.
 * Understanding these details prevents subtle production bugs.
 */
int main() {
    const char *path = "/tmp/myapp_shm_key";
    int proj_id = 'M';  // 0x4D - using printable char is common practice
    
    // First, let's see what ftok() uses internally
    struct stat st;
    if (stat(path, &st) == -1) {
        perror("stat failed - file must exist for ftok()");
        printf("Creating key file: %s
", path);
        FILE *f = fopen(path, "w");
        if (f) {
            fclose(f);
        } else {
            perror("Could not create key file");
            exit(EXIT_FAILURE);
        }
        stat(path, &st);
    }
    
    printf("Key file: %s
", path);
    printf("  Inode: %lu
", (unsigned long)st.st_ino);
    printf("  Device ID: %lu
", (unsigned long)st.st_dev);
    printf("  Project ID: %d (0x%02x)
", proj_id, proj_id);
    
    key_t key = ftok(path, proj_id);
    if (key == -1) {
        perror("ftok failed");
        exit(EXIT_FAILURE);
    }
    
    printf("Generated key: 0x%08x
", key);
    
    // Demonstrate proj_id collision
    printf("
--- Demonstrating proj_id collision ---
");
    key_t key1 = ftok(path, 0x01);
    key_t key2 = ftok(path, 0x101);  // Only lower 8 bits used!
    key_t key3 = ftok(path, 0x201);
    
    printf("ftok(path, 0x001) = 0x%08x
", key1);
    printf("ftok(path, 0x101) = 0x%08x
", key2);
    printf("ftok(path, 0x201) = 0x%08x
", key3);
    
    if (key1 == key2 && key2 == key3) {
        printf("WARNING: All three keys are identical! Only lower 8 bits matter.
");
    }
    
    // Best practice: use different characters for different IPC objects
    printf("
--- Recommended pattern ---
");
    printf("Shared Memory: ftok(path, 'S') = 0x%08x
", ftok(path, 'S'));
    printf("Message Queue: ftok(path, 'M') = 0x%08x
", ftok(path, 'M'));
    printf("Semaphore:     ftok(path, 'E') = 0x%08x
", ftok(path, 'E'));
    
    return 0;
}

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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
 
#define SHM_NAME "/my_app_shared"  // Must start with /
#define SHM_SIZE 4096
 
/**
 * Demonstrates POSIX shared memory creation with robust error handling.
 * POSIX approach uses familiar file-like semantics.
 */
int main() {
    int shm_fd;
    void *shm_ptr;
    
    // Create or open shared memory object
    // O_CREAT: Create if doesn't exist
    // O_RDWR: Read and write access
    // Mode 0666: Read/write for owner, group, and others
    shm_fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0666);
    if (shm_fd == -1) {
        perror("shm_open failed");
        exit(EXIT_FAILURE);
    }
    
    printf("Shared memory object created/opened: %s
", SHM_NAME);
    printf("File descriptor: %d
", shm_fd);
    
    // Get current size of the shared memory object
    struct stat shm_stat;
    if (fstat(shm_fd, &shm_stat) == -1) {
        perror("fstat failed");
        close(shm_fd);
        exit(EXIT_FAILURE);
    }
    
    printf("Current size: %ld bytes
", (long)shm_stat.st_size);
    
    // Set size of shared memory object
    // This allocates the actual memory
    // Note: Can only grow, shrinking may not release memory immediately
    if (shm_stat.st_size < SHM_SIZE) {
        printf("Resizing to %d bytes...
", SHM_SIZE);
        if (ftruncate(shm_fd, SHM_SIZE) == -1) {
            perror("ftruncate failed");
            close(shm_fd);
            exit(EXIT_FAILURE);
        }
    }
    
    // Map the shared memory into our address space
    shm_ptr = mmap(NULL,           // Let kernel choose address
                   SHM_SIZE,       // Map this many bytes
                   PROT_READ | PROT_WRITE,  // Read and write access
                   MAP_SHARED,     // Changes visible to other processes
                   shm_fd,         // From this shared memory object
                   0);             // Starting at offset 0
    
    if (shm_ptr == MAP_FAILED) {
        perror("mmap failed");
        close(shm_fd);
        exit(EXIT_FAILURE);
    }
    
    printf("Mapped at address: %p
", shm_ptr);
    
    // The file descriptor can be closed after mmap()
    // The mapping remains valid
    close(shm_fd);
    printf("Closed file descriptor (mapping still valid)
");
    
    // Write some data
    const char *message = "Hello from POSIX shared memory!";
    memcpy(shm_ptr, message, strlen(message) + 1);
    printf("Wrote message: %s
", message);
    
    // In a real application, we would synchronize access here
    // For now, just demonstrate the data is there
    printf("Read back: %s
", (char *)shm_ptr);
    
    // Unmap when done with this process
    // The shared memory object persists for other processes
    if (munmap(shm_ptr, SHM_SIZE) == -1) {
        perror("munmap failed");
    }
    printf("Unmapped shared memory
");
    
    // To remove the shared memory object entirely:
    // shm_unlink(SHM_NAME);
    // This removes the name from /dev/shm
    // Actual memory freed when all mappings are gone
    
    printf("
Shared memory persists at: /dev/shm%s
", SHM_NAME);
    
    return 0;
}

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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
 
/**
 * Demonstrates secure shared memory creation patterns.
 * Key principles: minimal permissions, exclusive creation,
 * explicit cleanup, and size validation.
 */
 
#define SECURE_SHM_NAME "/secure_app_data"
#define SECURE_SHM_SIZE (64 * 1024)  // 64KB
 
typedef struct {
    unsigned int magic;      // Validation marker
    unsigned int version;    // Protocol version
    size_t data_size;        // Actual data length
    char data[];             // Flexible array member
} SecureSharedData;
 
#define SHM_MAGIC 0xDEADBEEF
 
int create_secure_shm(void **ptr, size_t *size, int is_creator) {
    int shm_fd;
    int flags = O_RDWR;
    mode_t mode = 0600;  // Owner only - most restrictive
    
    if (is_creator) {
        // Creator uses O_EXCL to ensure we're creating, not reusing
        flags |= O_CREAT | O_EXCL;
        
        // First, try to remove any stale segment from previous crash
        shm_unlink(SECURE_SHM_NAME);  // Ignore error if doesn't exist
        
        shm_fd = shm_open(SECURE_SHM_NAME, flags, mode);
        if (shm_fd == -1) {
            perror("shm_open (creator) failed");
            return -1;
        }
        
        // Set size
        if (ftruncate(shm_fd, SECURE_SHM_SIZE) == -1) {
            perror("ftruncate failed");
            close(shm_fd);
            shm_unlink(SECURE_SHM_NAME);
            return -1;
        }
    } else {
        // Consumer: open existing only
        shm_fd = shm_open(SECURE_SHM_NAME, flags, 0);
        if (shm_fd == -1) {
            if (errno == ENOENT) {
                fprintf(stderr, "Shared memory not created yet
");
            } else {
                perror("shm_open (consumer) failed");
            }
            return -1;
        }
        
        // Verify size matches expected
        struct stat shm_stat;
        if (fstat(shm_fd, &shm_stat) == -1) {
            perror("fstat failed");
            close(shm_fd);
            return -1;
        }
        
        if (shm_stat.st_size != SECURE_SHM_SIZE) {
            fprintf(stderr, "Size mismatch: expected %d, got %ld
",
                    SECURE_SHM_SIZE, (long)shm_stat.st_size);
            close(shm_fd);
            return -1;
        }
        
        // Verify ownership (security check)
        if (shm_stat.st_uid != getuid()) {
            fprintf(stderr, "Security: SHM owned by different user
");
            close(shm_fd);
            return -1;
        }
    }
    
    // Map with minimum required permissions
    *ptr = mmap(NULL, SECURE_SHM_SIZE, PROT_READ | PROT_WRITE,
                MAP_SHARED, shm_fd, 0);
    close(shm_fd);  // No longer needed after mmap
    
    if (*ptr == MAP_FAILED) {
        perror("mmap failed");
        if (is_creator) shm_unlink(SECURE_SHM_NAME);
        return -1;
    }
    
    if (is_creator) {
        // Initialize with secure defaults
        SecureSharedData *data = (SecureSharedData *)*ptr;
        
        // Zero entire region first (prevent information leakage)
        memset(data, 0, SECURE_SHM_SIZE);
        
        // Set validation markers
        data->magic = SHM_MAGIC;
        data->version = 1;
        data->data_size = 0;
    } else {
        // Validate the segment
        SecureSharedData *data = (SecureSharedData *)*ptr;
        if (data->magic != SHM_MAGIC) {
            fprintf(stderr, "Invalid magic number - corrupted segment
");
            munmap(*ptr, SECURE_SHM_SIZE);
            *ptr = NULL;
            return -1;
        }
    }
    
    *size = SECURE_SHM_SIZE;
    return 0;
}
 
void cleanup_secure_shm(void *ptr, int is_creator) {
    if (ptr) {
        // Zero memory before unmapping (security)
        memset(ptr, 0, SECURE_SHM_SIZE);
        munmap(ptr, SECURE_SHM_SIZE);
    }
    
    if (is_creator) {
        shm_unlink(SECURE_SHM_NAME);
    }
}

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

#!/bin/bash
# Script to check and display shared memory limits
 
echo "=== System V Shared Memory Limits ==="
echo "SHMMAX (max segment size):     $(cat /proc/sys/kernel/shmmax) bytes"
echo "SHMMIN (min segment size):     $(cat /proc/sys/kernel/shmmin) bytes"
echo "SHMMNI (max segments):         $(cat /proc/sys/kernel/shmmni)"
echo "SHMALL (total pages):          $(cat /proc/sys/kernel/shmall) pages"
 
PAGE_SIZE=$(getconf PAGE_SIZE)
SHMALL=$(cat /proc/sys/kernel/shmall)
echo "Total shared memory limit:     $((SHMALL * PAGE_SIZE / 1024 / 1024)) MB"
 
echo ""
echo "=== POSIX Shared Memory (/dev/shm) ==="
df -h /dev/shm
 
echo ""
echo "=== Current Shared Memory Usage ==="
echo "System V segments:"
ipcs -m | tail -n +4 | head -n -1 | wc -l
echo ""
echo "POSIX objects in /dev/shm:"
ls -la /dev/shm/ 2>/dev/null || echo "(empty or not accessible)"
 
echo ""
echo "=== Detailed System V Segment Info ==="
ipcs -m -l

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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/shm.h>
#include <sys/ipc.h>
 
/**
 * Demonstrates comprehensive error handling for shared memory operations.
 * Each error case is handled with appropriate action and clear messaging.
 */
 
typedef enum {
    SHM_SUCCESS = 0,
    SHM_ERR_FTOK,
    SHM_ERR_SHMGET,
    SHM_ERR_SHMAT,
    SHM_ERR_SHMDT,
    SHM_ERR_SHMCTL,
    SHM_ERR_RETRY_LIMIT
} ShmError;
 
const char* shm_error_string(ShmError err) {
    switch (err) {
        case SHM_SUCCESS:        return "Success";
        case SHM_ERR_FTOK:       return "Failed to generate key";
        case SHM_ERR_SHMGET:     return "Failed to get/create segment";
        case SHM_ERR_SHMAT:      return "Failed to attach segment";
        case SHM_ERR_SHMDT:      return "Failed to detach segment";
        case SHM_ERR_SHMCTL:     return "Failed to control segment";
        case SHM_ERR_RETRY_LIMIT: return "Retry limit exceeded";
        default:                  return "Unknown error";
    }
}
 
ShmError create_shared_memory_robust(
    const char *path,
    int proj_id,
    size_t size,
    int *shmid_out,
    void **ptr_out,
    int max_retries
) {
    key_t key;
    int shmid;
    void *ptr;
    int retries = 0;
    
    // Generate key with retry logic (file might be temporarily unavailable)
    while (retries < max_retries) {
        key = ftok(path, proj_id);
        if (key != -1) break;
        
        if (errno == ENOENT) {
            fprintf(stderr, "Key file %s not found, creating...
", path);
            FILE *f = fopen(path, "w");
            if (f) fclose(f);
            retries++;
            continue;
        } else if (errno == EACCES) {
            fprintf(stderr, "No access to key file %s
", path);
            return SHM_ERR_FTOK;
        } else {
            fprintf(stderr, "ftok error: %s
", strerror(errno));
            return SHM_ERR_FTOK;
        }
    }
    if (key == -1) return SHM_ERR_RETRY_LIMIT;
    
    // Create/get shared memory with handling for race conditions
    retries = 0;
    while (retries < max_retries) {
        // First try: create exclusively
        shmid = shmget(key, size, IPC_CREAT | IPC_EXCL | 0660);
        if (shmid != -1) {
            printf("Created new segment with ID %d
", shmid);
            break;
        }
        
        // Handle specific errors
        switch (errno) {
            case EEXIST:
                // Segment exists, try to attach
                shmid = shmget(key, 0, 0660);
                if (shmid != -1) {
                    printf("Attached to existing segment %d
", shmid);
                    goto attach;
                }
                // If ENOENT here, segment was deleted between our attempts
                if (errno == ENOENT || errno == EIDRM) {
                    retries++;
                    continue;  // Race condition, retry
                }
                fprintf(stderr, "Cannot access existing segment: %s
", 
                        strerror(errno));
                return SHM_ERR_SHMGET;
                
            case ENOSPC:
                fprintf(stderr, "System limit reached (SHMMNI or SHMALL)
");
                fprintf(stderr, "Run: ipcs -m to see segments
");
                fprintf(stderr, "Run: ipcrm -m <id> to remove unused segments
");
                return SHM_ERR_SHMGET;
                
            case ENOMEM:
                fprintf(stderr, "Insufficient memory for %zu bytes
", size);
                return SHM_ERR_SHMGET;
                
            case EACCES:
                fprintf(stderr, "Permission denied for key 0x%x
", key);
                return SHM_ERR_SHMGET;
                
            default:
                fprintf(stderr, "shmget failed: %s (errno %d)
", 
                        strerror(errno), errno);
                return SHM_ERR_SHMGET;
        }
    }
    if (retries >= max_retries) return SHM_ERR_RETRY_LIMIT;
    
attach:
    // Attach with retry for transient conditions
    retries = 0;
    while (retries < max_retries) {
        ptr = shmat(shmid, NULL, 0);
        if (ptr != (void *)-1) break;
        
        if (errno == EINVAL || errno == EIDRM) {
            fprintf(stderr, "Segment %d was removed during attach
", shmid);
            return SHM_ERR_SHMAT;
        } else if (errno == ENOMEM) {
            fprintf(stderr, "No memory to map segment into address space
");
            return SHM_ERR_SHMAT;
        } else if (errno == EACCES) {
            fprintf(stderr, "Permission denied to attach segment
");
            return SHM_ERR_SHMAT;
        }
        
        retries++;
    }
    if (ptr == (void *)-1) return SHM_ERR_RETRY_LIMIT;
    
    *shmid_out = shmid;
    *ptr_out = ptr;
    return SHM_SUCCESS;
}
 
int main() {
    int shmid;
    void *ptr;
    
    ShmError result = create_shared_memory_robust(
        "/tmp/robust_shm_key",
        'R',
        4096,
        &shmid,
        &ptr,
        5  // max retries
    );
    
    if (result != SHM_SUCCESS) {
        fprintf(stderr, "Failed: %s
", shm_error_string(result));
        return EXIT_FAILURE;
    }
    
    printf("Success! shmid=%d, ptr=%p
", shmid, ptr);
    
    // Use shared memory...
    
    // Cleanup
    shmdt(ptr);
    
    return EXIT_SUCCESS;
}