6a:T7f8,#include #include #include #include #include #include #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; }6b:T814,#include #include #include #include #include /** * 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; }6c:Tc92,#include #include #include #include #include #include #include #include #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; }6d:Tf8b,#include #include #include #include #include #include #include #include /** * 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); } }6e:T14b4,#include #include #include #include #include #include /** * 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 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; }63:{"json":{"id":"seed_5740a417d9aa79ab3f9a0dbad688bf78","slug":"shared-memory","category":"Operating Systems","topic":"Shared Memory","title":"Shared Memory: The Fastest IPC Mechanism","description":"Master shared memory—the highest-performance inter-process communication mechanism. Learn to create, attach, synchronize, and manage shared memory regions using both System V and POSIX APIs, understanding the architectural foundations that enable microsecond-level data transfer between processes.","difficulty":"INTERMEDIATE","estimatedMinutes":75,"pages":[{"id":"seed_a4f9b83ca7cf8f4ca36c59f18f8717ba","title":"Creating Shared Memory","order":0,"content":[{"id":"opening-hook","title":"The Ultimate Performance Primitive","content":[{"data":{"content":"In the landscape of inter-process communication, one mechanism stands apart in raw performance: **shared memory**. While pipes, message queues, and sockets require the kernel to copy data between processes—a costly operation measured in microseconds—shared memory eliminates this overhead entirely. When two processes share a memory region, writing to an address in one process makes that data instantaneously visible to another. There is no system call, no context switch, no data copying.\n\nThis architectural elegance comes with a price: **complexity**. Shared memory provides raw, unmediated access to bytes in memory. The kernel offers no built-in ordering, no synchronization, no protection against simultaneous access. These responsibilities fall entirely on the programmer.\n\nThis page explores the foundations: how shared memory regions are created, how the operating system manages them, and the critical design decisions you must understand before using this powerful primitive."},"type":"text"},{"data":{"icon":"Target","title":"What You Will Learn","content":"By the end of this page, you will understand: (1) The memory architecture that enables shared memory, (2) System V shared memory creation with shmget(), (3) POSIX shared memory creation with shm_open(), (4) Key generation and naming conventions, (5) Permission models and security considerations, and (6) Common pitfalls in shared memory allocation.","variant":"info"},"type":"callout"}]},{"id":"memory-architecture","title":"Memory Architecture Foundations","content":[{"data":{"content":"To understand shared memory, we must first understand how operating systems manage process memory. Each process operates in its own **virtual address space**—a contiguous range of addresses (e.g., 0 to 2⁴⁸ on 64-bit systems) that appears private to that process. The hardware **Memory Management Unit (MMU)** translates these virtual addresses to physical addresses in RAM.\n\nThe key insight is that virtual-to-physical mappings are maintained in **page tables**—data structures controlled by the kernel. Two processes can have different virtual addresses that map to the **same physical page**. When this happens, both processes are literally reading and writing the same bytes in RAM.\n\n**Shared memory exploits this mechanism intentionally.** The kernel allocates a region of physical memory and maps it into the virtual address spaces of multiple processes. From the hardware's perspective, there's nothing special about these pages—they're ordinary RAM. The magic is entirely in the page table configuration."},"type":"text"},{"data":{"height":"350px","mermaidSyntax":"graph TB\n subgraph \"Process A Virtual Space\"\n VA1[\"Virtual Address 0x7000\"]\n end\n subgraph \"Process B Virtual Space\"\n VB1[\"Virtual Address 0x9000\"]\n end\n subgraph \"Page Tables\"\n PT1[\"Process A Page Table\"]\n PT2[\"Process B Page Table\"]\n end\n subgraph \"Physical Memory\"\n PM1[\"Physical Frame 0x5000\n(Shared Memory Region)\"]\n end\n \n VA1 --> PT1\n VB1 --> PT2\n PT1 --> PM1\n PT2 --> PM1\n \n style PM1 fill:#22c55e,stroke:#16a34a,color:#fff"},"type":"mermaid-excalidraw"},{"data":{"icon":"Lightbulb","title":"Why This Matters","content":"Understanding the page table mechanism clarifies why shared memory is so fast: there is literally no copying. Both processes access the same physical bytes. It also explains why synchronization is mandatory—without it, you have two CPUs potentially racing on the same cache lines, with all the hazards that entails.","variant":"tip"},"type":"callout"},{"data":{"content":"**Physical vs. Virtual Address Considerations:**\n\nWhen process A maps shared memory at virtual address 0x7000 and process B maps it at 0x9000, the **pointers are not interchangeable**. A pointer stored in shared memory by process A (pointing to 0x7020) means something entirely different to process B. This is a common source of bugs.\n\n**Rule:** Never store absolute pointers in shared memory. Use **offsets from the base address** or **position-independent data structures** instead.\n\n**Page Alignment:**\n\nShared memory regions are always allocated in units of the system page size (typically 4KB on x86, 4KB or 64KB on ARM depending on configuration). Requesting 100 bytes of shared memory actually allocates at least one full page. Understanding this prevents memory waste and explains certain size restrictions in the APIs."},"type":"text"}],"titleType":"number","titleNumber":1},{"id":"system-v-shared-memory","title":"System V Shared Memory: shmget()","content":[{"data":{"content":"The System V IPC family—originating in Unix System V during the 1980s—provides shared memory through the `shmget()` system call. Despite its age, System V shared memory remains widely used due to its universal availability and rich feature set.\n\n**The shmget() System Call:**\n\n```c\n#include \n\nint shmget(key_t key, size_t size, int shmflg);\n```\n\nThis call either creates a new shared memory segment or obtains an identifier for an existing one. Let's examine each parameter in depth."},"type":"text"},{"data":{"rows":[["key","key_t","Unique identifier for the segment","Processes use the same key to access the same segment. Use ftok() or IPC_PRIVATE."],["size","size_t","Segment size in bytes","Rounded up to page boundary. When accessing existing segment, can be 0 or ≤ original size."],["shmflg","int","Flags controlling creation and permissions","Bitwise OR of IPC_CREAT, IPC_EXCL, and permission bits (e.g., 0666)."]],"caption":"shmget() Parameters Explained","headers":["Parameter","Type","Purpose","Critical Details"]},"type":"table"},{"data":{"content":"**Understanding the Return Value:**\n\nOn success, `shmget()` returns a **shared memory identifier** (shmid)—a non-negative integer that uniquely identifies the segment within the system. This identifier is used in subsequent calls to `shmat()`, `shmdt()`, and `shmctl()`. On failure, it returns -1 and sets `errno`.\n\n**Flag Combinations:**"},"type":"text"},{"data":{"items":["**IPC_CREAT | 0666** — Create if doesn't exist, otherwise attach. Standard pattern for shared services.","**IPC_CREAT | IPC_EXCL | 0666** — Create exclusively; fail if segment already exists. Used when segment creator must be known.","**0** — Attach to existing segment only. Fails if segment doesn't exist.","**IPC_PRIVATE** (as key, not flag) — Create a private segment not accessible via key lookup. Parent-child communication pattern."],"title":{"icon":"Code2","text":"Common shmflg Patterns","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"fileName":"system_v_shm_create.c","languages":[{"code":"$6a","label":"C","value":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"icon":"AlertCircle","title":"Kernel Persistence","content":"System V shared memory segments persist in the kernel until explicitly removed with shmctl(shmid, IPC_RMID, NULL) or system reboot—even if all processes detach. Use 'ipcs -m' to view existing segments and 'ipcrm -m shmid' to remove orphaned ones. Leaked segments consume kernel memory indefinitely.","variant":"warning"},"type":"callout"}],"titleType":"number","titleNumber":2},{"id":"key-generation","title":"Key Generation: The ftok() Function","content":[{"data":{"content":"For unrelated processes to access the same shared memory segment, they need a common key. The `ftok()` function generates a key from a pathname and a project identifier:\n\n```c\nkey_t ftok(const char *pathname, int proj_id);\n```\n\n**How ftok() Works:**\n\nftok() combines three pieces of information:\n1. The **inode number** of the file at pathname\n2. The **device ID** (st_dev) of the filesystem containing the file\n3. The least significant 8 bits of **proj_id**\n\nThese are combined algorithmically to produce a key_t value (typically 32 bits). The exact algorithm is implementation-defined but guarantees that different (pathname, proj_id) pairs produce different keys."},"type":"text"},{"data":{"items":["**File Must Exist** — ftok() calls stat() on the pathname. If the file doesn't exist, ftok() fails with errno ENOENT.","**Same Inode, Same Key** — If you delete and recreate a file, it may get a different inode, producing a different key. Processes launched before/after the recreation will disagree on the key.","**Only 8 Bits of proj_id Used** — proj_id values 0x00 and 0x100 produce the same key. Choose values between 1-255.","**Symbolic Links Followed** — ftok() uses stat(), not lstat(), so it follows symlinks. Ensure all processes see the same target.","**Not Portable Across Systems** — The same file on different machines (e.g., NFS) may have different inodes, producing different keys."],"title":{"icon":"AlertCircle","text":"Critical ftok() Pitfalls","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"fileName":"ftok_deep_dive.c","languages":[{"code":"$6b","label":"C","value":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"content":"**Alternative Key Strategies:**\n\nGiven ftok()'s limitations, production systems often use alternative approaches:\n\n1. **Hardcoded Keys:** Define keys as constants in a shared header file. Simple but requires careful management to avoid collisions.\n\n2. **IPC_PRIVATE:** Creates a unique, unkeyed segment. The shmid must be communicated out-of-band (e.g., environment variable, file, inherited across fork()). Useful for parent-child communication.\n\n3. **Configuration Files:** Store the key or shmid in a well-known configuration file. More flexible than hardcoding but adds file I/O overhead.\n\n4. **Migrate to POSIX:** POSIX shared memory uses filenames instead of numeric keys, avoiding ftok() entirely."},"type":"text"}],"titleType":"number","titleNumber":3},{"id":"posix-shared-memory","title":"POSIX Shared Memory: shm_open()","content":[{"data":{"content":"POSIX shared memory, introduced in POSIX.1b-1993, provides a cleaner, file-oriented API that avoids many System V pitfalls. Instead of numeric keys, POSIX shared memory uses **named objects** that appear in a virtual filesystem (typically mounted at `/dev/shm` on Linux).\n\n**The shm_open() System Call:**\n\n```c\n#include \n#include \n\nint shm_open(const char *name, int oflag, mode_t mode);\n```\n\nshm_open() behaves similarly to open() for regular files, returning a file descriptor that can be used with ftruncate(), fstat(), and mmap()."},"type":"text"},{"data":{"rows":[["Identifier","Numeric key (key_t)","String name (e.g., \"/my_shm\")"],["Return Type","Segment ID (int)","File descriptor (int)"],["Size Control","Set in shmget()","Set via ftruncate()"],["Memory Mapping","shmat() / shmdt()","mmap() / munmap()"],["Persistence","Kernel-managed, survives crash","/dev/shm filesystem"],["Visibility","ipcs -m","ls /dev/shm/"],["Removal","shmctl(IPC_RMID)","shm_unlink()"],["Portability","All Unix systems","POSIX-compliant systems"]],"caption":"shm_open() vs shmget() Comparison","headers":["Aspect","System V (shmget)","POSIX (shm_open)"]},"type":"table"},{"data":{"fileName":"posix_shm_create.c","languages":[{"code":"$6c","label":"C","value":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"icon":"Lightbulb","title":"The /dev/shm Filesystem","content":"On Linux, POSIX shared memory objects appear as files in /dev/shm/. This is a tmpfs filesystem stored in RAM (and swap if necessary). You can use standard file commands: 'ls -la /dev/shm/' to list objects, 'rm /dev/shm/my_shm' to delete them, 'cat /dev/shm/my_shm | xxd' to view contents. This visibility makes debugging much easier than System V's opaque segments.","variant":"tip"},"type":"callout"},{"data":{"content":"**Naming Conventions:**\n\nPOSIX shared memory names must follow specific rules:\n\n1. **Must start with a forward slash** (`/my_shm`)\n2. **No additional slashes allowed** (`/dir/shm` is invalid on many systems)\n3. **Reasonable length limits** (NAME_MAX, typically 255 characters minus the leading slash)\n4. **Case-sensitive** (`/Shm` and `/shm` are different objects)\n\n**Best Practice:** Use a consistent prefix incorporating your application name:\n```c\n#define SHM_PREFIX \"/myapp_\"\n#define SHM_BUFFER SHM_PREFIX \"buffer\"\n#define SHM_CONFIG SHM_PREFIX \"config\"\n```"},"type":"text"}],"titleType":"number","titleNumber":4},{"id":"permissions-security","title":"Permissions and Security Considerations","content":[{"data":{"content":"Shared memory provides direct access to process memory—a powerful capability that demands careful security consideration. Both System V and POSIX shared memory use Unix permission models, but the implications of misconfiguration are severe.\n\n**Permission Bits:**\n\nBoth APIs use the familiar Unix permission model (owner/group/other × read/write/execute). For shared memory, the relevant permissions are:\n\n- **Read (r):** Can attach/map the segment for reading\n- **Write (w):** Can attach/map the segment for writing\n- **Execute (x):** Generally ignored for shared memory"},"type":"text"},{"data":{"rows":[["Owner RW only","0600","Private process communication (same user)","High"],["Owner+Group RW","0660","Processes in same group need access","Medium"],["World readable","0644","Read-only data shared system-wide","Low"],["World RW","0666","Any process can read/write","Dangerous"]],"caption":"Common Permission Configurations","headers":["Mode","Octal","Use Case","Security Level"]},"type":"table"},{"data":{"items":["**Privilege Escalation Risks:** If a privileged process shares memory with an unprivileged one, the unprivileged process may be able to inject malicious data or corrupt state.","**Race Conditions:** Even with proper permissions, improper synchronization can lead to TOCTOU (time-of-check-time-of-use) vulnerabilities.","**Information Leakage:** Shared memory segments may contain sensitive data. Ensure segments are properly cleaned before reuse or removal.","**Denial of Service:** A malicious process with write access can corrupt shared data, causing all dependent processes to fail.","**Persistence After Crash:** System V segments persist across crashes. Sensitive data may remain accessible longer than intended."],"title":{"icon":"AlertCircle","text":"Security Considerations","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"fileName":"secure_shm_creation.c","languages":[{"code":"$6d","label":"C","value":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"icon":"Info","title":"Defense in Depth","content":"Shared memory security should be part of a layered defense strategy. Combine restrictive permissions with validation (magic numbers, checksums), proper synchronization, input sanitization, and clear ownership semantics. No single measure is sufficient on its own.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":5},{"id":"size-considerations","title":"Size Considerations and System Limits","content":[{"data":{"content":"Shared memory allocation is subject to both kernel limits and practical considerations. Understanding these constraints is essential for designing robust systems.\n\n**Page Alignment:**\n\nAll shared memory allocations are rounded up to the system page size. On most x86_64 systems, pages are 4KB:\n\n```\nRequested: 100 bytes → Allocated: 4096 bytes (1 page)\nRequested: 4097 bytes → Allocated: 8192 bytes (2 pages)\nRequested: 1MB → Allocated: 1MB (256 pages, exact)\n```\n\nThis has implications for memory efficiency and layout design."},"type":"text"},{"data":{"rows":[["Max segment size","SHMMAX","~8GB (varies)","sysctl kernel.shmmax"],["Min segment size","SHMMIN","1 byte","sysctl kernel.shmmin"],["Max segments system-wide","SHMMNI","4096","sysctl kernel.shmmni"],["Max total shared memory","SHMALL","~8GB in pages","sysctl kernel.shmall"],["Max segments per process","SHMSEG","128-256","Rarely needs adjustment"],["POSIX shm max size","/dev/shm size","50% of RAM","Mount option for tmpfs"]],"caption":"System Limits for Shared Memory","headers":["Limit","Parameter","Typical Default","How to Check/Change"]},"type":"table"},{"data":{"fileName":"check_shm_limits.sh","languages":[{"code":"#!/bin/bash\n# Script to check and display shared memory limits\n\necho \"=== System V Shared Memory Limits ===\"\necho \"SHMMAX (max segment size): $(cat /proc/sys/kernel/shmmax) bytes\"\necho \"SHMMIN (min segment size): $(cat /proc/sys/kernel/shmmin) bytes\"\necho \"SHMMNI (max segments): $(cat /proc/sys/kernel/shmmni)\"\necho \"SHMALL (total pages): $(cat /proc/sys/kernel/shmall) pages\"\n\nPAGE_SIZE=$(getconf PAGE_SIZE)\nSHMALL=$(cat /proc/sys/kernel/shmall)\necho \"Total shared memory limit: $((SHMALL * PAGE_SIZE / 1024 / 1024)) MB\"\n\necho \"\"\necho \"=== POSIX Shared Memory (/dev/shm) ===\"\ndf -h /dev/shm\n\necho \"\"\necho \"=== Current Shared Memory Usage ===\"\necho \"System V segments:\"\nipcs -m | tail -n +4 | head -n -1 | wc -l\necho \"\"\necho \"POSIX objects in /dev/shm:\"\nls -la /dev/shm/ 2>/dev/null || echo \"(empty or not accessible)\"\n\necho \"\"\necho \"=== Detailed System V Segment Info ===\"\nipcs -m -l","label":"Bash","value":"bash"}],"showLineNumbers":true},"type":"code"},{"data":{"content":"**Huge Pages for Large Segments:**\n\nFor very large shared memory segments (hundreds of MB or GB), standard 4KB pages become inefficient—each page requires a TLB (Translation Lookaside Buffer) entry, and TLBs are limited. Huge pages (2MB or 1GB on x86_64) reduce TLB pressure significantly.\n\n**To use huge pages with System V:**\n```c\nint shmid = shmget(key, size, IPC_CREAT | 0600 | SHM_HUGETLB);\n```\n\n**To use huge pages with POSIX (Linux-specific):**\n```c\nvoid *ptr = mmap(NULL, size, PROT_READ | PROT_WRITE,\n MAP_SHARED | MAP_HUGETLB, shm_fd, 0);\n```\n\nHuge pages must be pre-allocated by the system administrator. Check `/proc/meminfo` for `HugePages_Total` and `HugePages_Free`."},"type":"text"},{"data":{"icon":"Lightbulb","title":"Sizing Strategy","content":"For performance-critical applications, align your shared memory structures to cache line boundaries (typically 64 bytes) to prevent false sharing. Design your total size to accommodate future growth—resizing shared memory is complex and often requires careful coordination between all attached processes.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":6},{"id":"error-handling","title":"Comprehensive Error Handling","content":[{"data":{"content":"Shared memory operations can fail in numerous ways. Robust error handling is essential—a failure to create or attach shared memory is typically fatal to your application's functionality.\n\n**Common Error Codes:**"},"type":"text"},{"data":{"rows":[["EEXIST","Segment exists with IPC_EXCL","shmget/shm_open","Remove IPC_EXCL or delete existing segment"],["ENOENT","Segment doesn't exist (no IPC_CREAT)","shmget/shm_open","Add IPC_CREAT or wait for creator"],["EACCES","Permission denied","shmget/shm_open/shmat/mmap","Check uid/gid and segment permissions"],["EINVAL","Invalid size or segment removed","shmget/shmat","Verify parameters; segment may be deleted"],["ENOMEM","Insufficient memory","shmget/mmap","Reduce size or free system memory"],["ENOSPC","Limit exceeded (SHMMNI/SHMALL)","shmget","Increase system limits or clean up segments"],["ENFILE","Too many open files system-wide","shm_open","Increase system file descriptor limit"],["EMFILE","Too many open files for process","shm_open","Close unused FDs or increase ulimit"],["EFAULT","Invalid address for attachment","shmat","Let kernel choose address (NULL)"]],"caption":"Shared Memory Error Codes and Remediation","headers":["errno","Cause","Function","Remediation"]},"type":"table"},{"data":{"fileName":"robust_error_handling.c","languages":[{"code":"$6e","label":"C","value":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"icon":"Info","title":"Production Patterns","content":"In production systems, wrap shared memory operations in abstraction layers that handle retries, logging, and metrics. Log every failure with full context (key, size, errno, surrounding state) to aid debugging. Consider circuit-breaker patterns for recovery from persistent failures.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":7},{"id":"summary","title":"Summary: Creating Shared Memory","content":[{"data":{"content":"We've covered the foundational concepts and practical techniques for creating shared memory regions. Let's consolidate the key takeaways:"},"type":"text"},{"data":{"type":"ordered","items":["**Shared memory enables zero-copy IPC** — Multiple processes map the same physical memory pages, eliminating kernel-mediated data transfer.","**Two API families exist** — System V (shmget/shmat) uses numeric keys; POSIX (shm_open/mmap) uses named objects in /dev/shm.","**Key generation requires care** — ftok() has pitfalls with inode changes; consider POSIX naming or explicit configuration.","**Permissions control access** — Use minimal permissions (0600) and validate segment ownership for security.","**Size is page-aligned** — All allocations round up to system page size; plan structure layouts accordingly.","**Robust error handling is essential** — Handle race conditions, permission issues, and resource limits gracefully.","**Segments persist beyond process lifetime** — System V segments survive until explicit removal; POSIX objects persist in /dev/shm."],"title":{"icon":"CheckCircle","text":"Key Takeaways","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**What's Next:**\n\nCreating shared memory is only the beginning. In the next page, we explore **attaching and detaching** shared memory regions—how processes map segments into their address spaces, the nuances of address selection, and patterns for clean detachment when work is complete."},"type":"text"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now understand the mechanisms for creating shared memory segments using both System V and POSIX APIs. You've learned about key generation, permissions, size constraints, and robust error handling. Next, we'll explore how processes attach to and detach from these shared regions.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":8}],"isLocked":false},{"id":"seed_6cd0d82667257a67a4c7262632f1dbcb","title":"Attaching and Detaching Shared Memory","order":1,"content":null,"isLocked":true},{"id":"seed_32a7ac1cdd2636669dbf3fb01b5242f0","title":"Synchronization Requirements","order":2,"content":null,"isLocked":true},{"id":"seed_392b25adb8b835ef3004a6f7c226da91","title":"Performance Benefits","order":3,"content":null,"isLocked":true},{"id":"seed_732f1812188a6b4585f1a500aab6cd15","title":"POSIX Shared Memory","order":4,"content":null,"isLocked":true}]}}