7a:T47f,System V message queues don't exist in isolation—they're part of a broader IPC framework that also includes shared memory segments and semaphores. Understanding this architecture provides crucial context for message queue operations. ### The System V IPC Model All System V IPC mechanisms share a common architectural pattern: 1. **Objects Exist in Kernel Space**: Unlike pipes (which are file descriptors) or files (which are filesystem entries), System V IPC objects live directly in kernel memory. They persist independently of any process's lifecycle. 2. **Key-Based Identification**: Each IPC object is identified by a numeric key (type `key_t`). Unrelated processes can connect to the same object by using the same key—without needing a parent-child relationship or a filesystem path. 3. **Permission Structure**: Each object has owner/group/other permissions similar to files, controlling which processes can access it. 4. **Explicit Lifecycle Management**: Unlike pipes that close automatically, System V objects persist until explicitly deleted—surviving process termination, system load changes, and even partial system failures.7b:T460,#include #include #include #include #include #include int main() { const char *keyfile = "/tmp/myapp_keyfile"; int proj_id = 'A'; // Using character literal (common convention) // Generate the key key_t key = ftok(keyfile, proj_id); if (key == -1) { fprintf(stderr, "ftok failed: %s ", strerror(errno)); fprintf(stderr, "Ensure %s exists and is accessible ", keyfile); return EXIT_FAILURE; } printf("Generated key: 0x%08x (%d) ", key, key); printf("This key can be used by multiple processes "); printf("using the same file and project ID. "); // Demonstrate reproducibility key_t key2 = ftok(keyfile, proj_id); printf(" Second ftok() call: 0x%08x ", key2); printf("Keys match: %s ", (key == key2) ? "YES" : "NO"); // Different project ID = different key key_t key3 = ftok(keyfile, 'B'); printf(" With proj_id 'B': 0x%08x ", key3); printf("Different from original: %s ", (key != key3) ? "YES" : "NO"); return EXIT_SUCCESS; }7c:T6ef,#include #include #include #include #include #include #include #define KEYFILE "/tmp/msgqueue_demo" #define PROJ_ID 'M' int main() { // Ensure keyfile exists FILE *fp = fopen(KEYFILE, "w"); if (fp) fclose(fp); // Generate the key key_t key = ftok(KEYFILE, PROJ_ID); if (key == -1) { perror("ftok"); return EXIT_FAILURE; } // ======================================== // Scenario 1: Create a new queue // ======================================== int msqid = msgget(key, IPC_CREAT | IPC_EXCL | 0666); if (msqid == -1) { if (errno == EEXIST) { printf("Queue already exists, opening existing... "); // Open existing queue (no IPC_EXCL) msqid = msgget(key, 0666); if (msqid == -1) { perror("msgget (open existing)"); return EXIT_FAILURE; } } else { perror("msgget (create)"); return EXIT_FAILURE; } } else { printf("Created new message queue "); } printf("Message Queue ID: %d ", msqid); printf("Key: 0x%08x ", key); // ======================================== // Scenario 2: Private queue // ======================================== int private_msqid = msgget(IPC_PRIVATE, IPC_CREAT | 0600); if (private_msqid == -1) { perror("msgget (private)"); } else { printf(" Private Queue ID: %d ", private_msqid); printf("This queue can only be shared via fork() "); // Clean up private queue immediately msgctl(private_msqid, IPC_RMID, NULL); } return EXIT_SUCCESS; }7d:T45e,System V message queues have a strict requirement for message format: every message must begin with a `long` integer representing the message type, followed by the actual data. ### The Required Structure Format ```c struct msgbuf { long mtype; // Message type (must be > 0) char mtext[1]; // Message data (flexible array) }; ``` This is a template—you define your own structure following this pattern: ```c struct my_message { long mtype; // REQUIRED: Message type // Your data follows... int command_code; char payload[256]; double values[10]; // ... any data you need }; ``` ### Why the mtype Field Matters The `mtype` field is not just metadata—it's a fundamental feature that enables: 1. **Selective Reception**: Receivers can request messages of a specific type, leaving others in the queue 2. **Priority Handling**: Lower type numbers can be treated as higher priority 3. **Message Routing**: Different receiver processes can handle different message types 4. **Protocol Design**: Type values can indicate command types, response codes, or sender IDs7e:T5b4,#include // ================================================ // Example 1: Simple command/response protocol // ================================================ #define MSG_REQUEST 1L #define MSG_RESPONSE 2L struct simple_message { long mtype; char text[128]; }; // ================================================ // Example 2: Multi-type message system // ================================================ #define MSG_LOGIN 1L #define MSG_LOGOUT 2L #define MSG_DATA 3L #define MSG_HEARTBEAT 4L struct system_message { long mtype; pid_t sender_pid; time_t timestamp; union { struct { char username[32]; char password[64]; } login; struct { int session_id; } logout; struct { size_t length; char buffer[1024]; } data; struct { int sequence; } heartbeat; } payload; }; // ================================================ // Example 3: Worker task distribution // ================================================ #define MSG_TASK_LOW 100L // Low priority #define MSG_TASK_NORMAL 50L // Normal priority #define MSG_TASK_HIGH 10L // High priority #define MSG_TASK_URGENT 1L // Urgent priority struct task_message { long mtype; // Priority encoded in type int task_id; char task_data[512]; pid_t assigned_worker; // 0 if unassigned };7f:T841,#include #include #include #include #include #include #include #define MAX_TEXT 512 struct message { long mtype; char text[MAX_TEXT]; }; int main() { key_t key = ftok("/tmp/msgdemo", 'S'); int msqid = msgget(key, IPC_CREAT | 0666); if (msqid == -1) { perror("msgget"); return EXIT_FAILURE; } struct message msg; // ======================================== // Blocking send (default behavior) // ======================================== msg.mtype = 1; snprintf(msg.text, MAX_TEXT, "Hello from PID %d", getpid()); // msgsz = size of text field only size_t msgsz = sizeof(msg.text); printf("Sending message (blocking mode)... "); if (msgsnd(msqid, &msg, msgsz, 0) == -1) { perror("msgsnd"); return EXIT_FAILURE; } printf("Message sent successfully "); // ======================================== // Non-blocking send (IPC_NOWAIT) // ======================================== msg.mtype = 2; snprintf(msg.text, MAX_TEXT, "Urgent message!"); printf(" Sending message (non-blocking mode)... "); if (msgsnd(msqid, &msg, msgsz, IPC_NOWAIT) == -1) { if (errno == EAGAIN) { printf("Queue is full, message not sent "); } else { perror("msgsnd"); } } else { printf("Message sent successfully "); } // ======================================== // Sending multiple message types // ======================================== for (int i = 1; i <= 5; i++) { msg.mtype = i; // Different types for each snprintf(msg.text, MAX_TEXT, "Message type %d content", i); if (msgsnd(msqid, &msg, msgsz, 0) == -1) { perror("msgsnd loop"); } else { printf("Sent message type %d ", i); } } printf(" Queue now contains messages of types 1-5 "); printf("Use 'ipcs -q' to view queue status "); return EXIT_SUCCESS; }80:Taa6,#include #include #include #include #include #include #include #define MAX_TEXT 512 struct message { long mtype; char text[MAX_TEXT]; }; void demonstrate_msgrcv(int msqid) { struct message msg; size_t msgsz = sizeof(msg.text); ssize_t received; // ======================================== // Pattern 1: Receive ANY message (FIFO) // ======================================== printf(" --- Pattern 1: Receive any message (msgtyp = 0) --- "); received = msgrcv(msqid, &msg, msgsz, 0, IPC_NOWAIT); if (received != -1) { printf("Received type %ld: %s ", msg.mtype, msg.text); } else if (errno == ENOMSG) { printf("Queue is empty "); } // ======================================== // Pattern 2: Receive SPECIFIC type // ======================================== printf(" --- Pattern 2: Receive specific type (msgtyp = 3) --- "); received = msgrcv(msqid, &msg, msgsz, 3, IPC_NOWAIT); if (received != -1) { printf("Received type %ld: %s ", msg.mtype, msg.text); } else if (errno == ENOMSG) { printf("No message of type 3 available "); } // ======================================== // Pattern 3: Priority-based reception // ======================================== printf(" --- Pattern 3: Priority reception (msgtyp = -5) --- "); printf("Will receive lowest type <= 5 "); received = msgrcv(msqid, &msg, msgsz, -5, IPC_NOWAIT); if (received != -1) { printf("Received type %ld: %s ", msg.mtype, msg.text); } else if (errno == ENOMSG) { printf("No message with type <= 5 available "); } // ======================================== // Pattern 4: Blocking wait for message // ======================================== printf(" --- Pattern 4: Blocking receive --- "); printf("Waiting for message of type 1 (Ctrl+C to cancel)... "); received = msgrcv(msqid, &msg, msgsz, 1, 0); // Blocks! if (received != -1) { printf("Received: %s ", msg.text); } // ======================================== // Pattern 5: Truncate long messages // ======================================== printf(" --- Pattern 5: Allow message truncation --- "); char small_buf[64]; struct { long mtype; char text[64]; } small_msg; // MSG_NOERROR: truncate if message is larger than buffer received = msgrcv(msqid, &small_msg, sizeof(small_msg.text), 0, IPC_NOWAIT | MSG_NOERROR); if (received != -1) { printf("Received %zd bytes (may be truncated) ", received); } }81:T93b,#include #include #include #include #include #include #include void print_queue_info(int msqid) { struct msqid_ds info; if (msgctl(msqid, IPC_STAT, &info) == -1) { perror("msgctl IPC_STAT"); return; } printf(" ===== Message Queue Info (ID: %d) ===== ", msqid); // Ownership and permissions struct passwd *owner = getpwuid(info.msg_perm.uid); printf("Owner: %s (UID %d) ", owner ? owner->pw_name : "unknown", info.msg_perm.uid); printf("Permissions: %03o ", info.msg_perm.mode & 0777); // Queue statistics printf(" Current messages: %lu ", info.msg_qnum); printf("Current size: %lu bytes ", info.__msg_cbytes); printf("Maximum size: %lu bytes ", info.msg_qbytes); // Process info printf(" Last send PID: %d ", info.msg_lspid); printf("Last recv PID: %d ", info.msg_lrpid); // Timestamps printf(" Last send: %s", ctime(&info.msg_stime)); printf("Last recv: %s", ctime(&info.msg_rtime)); printf("Last change: %s", ctime(&info.msg_ctime)); } void resize_queue(int msqid, size_t new_size) { struct msqid_ds info; // First get current settings if (msgctl(msqid, IPC_STAT, &info) == -1) { perror("msgctl IPC_STAT"); return; } printf("Current max size: %lu bytes ", info.msg_qbytes); // Modify the maximum size info.msg_qbytes = new_size; if (msgctl(msqid, IPC_SET, &info) == -1) { perror("msgctl IPC_SET"); printf("Note: Increasing size may require root privileges "); return; } printf("New max size: %lu bytes ", new_size); } void remove_queue(int msqid) { printf("Removing message queue %d... ", msqid); if (msgctl(msqid, IPC_RMID, NULL) == -1) { perror("msgctl IPC_RMID"); return; } printf("Queue removed successfully "); printf("All pending messages are lost! "); } int main() { // Create a queue for demonstration int msqid = msgget(IPC_PRIVATE, IPC_CREAT | 0666); if (msqid == -1) { perror("msgget"); return EXIT_FAILURE; } print_queue_info(msqid); resize_queue(msqid, 32768); // Increase to 32KB remove_queue(msqid); return EXIT_SUCCESS; }72:{"json":{"id":"seed_b71d21dcea10eb0c885c057399430acf","slug":"os-message-queues","category":"Operating Systems","topic":"Inter-Process Communication","title":"Message Queues","description":"Master the theory and practice of message queues for inter-process communication. Explore System V and POSIX message queues, message typing, priority ordering, and learn when message queues provide superior IPC solutions.","difficulty":"INTERMEDIATE","estimatedMinutes":60,"pages":[{"id":"seed_7923dc51b4e4e1e8f6c1be97989b6b79","title":"System V Message Queues","order":0,"content":[{"id":"opening-context","title":"The Evolution of Structured IPC","content":[{"data":{"content":"While pipes and FIFOs provide simple byte-stream communication between processes, they lack structure. When Process A sends data to Process B, there's no inherent way to distinguish between different types of messages, no mechanism to prioritize urgent communications, and no natural boundary between discrete messages in the stream.\n\n**Message queues** solve these limitations by providing a structured, typed, and prioritized messaging system. Unlike pipes, message queues preserve message boundaries—each message is a discrete unit that arrives intact. Unlike shared memory, message queues handle synchronization automatically—no explicit semaphores required.\n\nThe **System V IPC** suite, introduced in AT&T's Unix System V in the early 1980s, was the first standardized implementation of message queues in Unix. Despite being over four decades old, System V message queues remain widely used and form the conceptual foundation for understanding all message-based IPC."},"type":"text"},{"data":{"icon":"Target","title":"What You Will Master","content":"By the end of this page, you will understand the complete architecture of System V message queues: their kernel-level implementation, the APIs for creation, sending, receiving, and management, key-based identification, message structure requirements, and the operational characteristics that determine when System V queues are the right choice for your IPC needs.","variant":"info"},"type":"callout"}]},{"id":"sysv-ipc-architecture","title":"System V IPC Architecture","content":[{"data":{"content":"$7a"},"type":"text"},{"data":{"rows":[["Purpose","Structured message passing","Fast data sharing","Synchronization"],["Data Preservation","Kernel copies messages","Direct memory access","Counter values only"],["Synchronization","Built-in blocking","None (needs semaphores)","Core function"],["Message Boundaries","Yes, preserved","No (raw bytes)","N/A"],["Typical Use Case","Task distribution","Large data sharing","Critical sections"]],"caption":"System V IPC Objects Comparison","headers":["Feature","Message Queues","Shared Memory","Semaphores"]},"type":"table"},{"data":{"icon":"Info","title":"Kernel Persistence","content":"A critical characteristic of System V IPC: objects persist in kernel memory even after all processes using them terminate. This is both a feature (enables restart recovery) and a danger (can leak kernel resources). Always design cleanup strategies for System V IPC resources.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":1},{"id":"key-generation-ftok","title":"Key Generation with ftok()","content":[{"data":{"content":"Before creating a message queue, you need a key—a numeric identifier that allows unrelated processes to find the same queue. The `ftok()` function generates keys deterministically from a pathname and a project identifier.\n\n### The ftok() Function\n\n```c\n#include \n\nkey_t ftok(const char *pathname, int proj_id);\n```\n\n**Parameters:**\n- `pathname`: Path to an existing, accessible file (used to derive a unique key)\n- `proj_id`: A project identifier (only the low-order 8 bits are used)\n\n**Returns:**\n- A `key_t` value on success\n- `-1` on error (with `errno` set)\n\n### How ftok() Works Internally\n\nThe `ftok()` function combines three pieces of information:\n1. The inode number of the specified file\n2. The device number of the filesystem containing the file\n3. The low 8 bits of the project ID\n\nThis means:\n- **Same file + same proj_id = same key** (reliably)\n- **Different files = different keys** (almost always)\n- **Same file + different proj_id = different keys** (guaranteed)"},"type":"text"},{"data":{"fileName":"ftok_example.c","languages":[{"code":"$7b","label":"C","value":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"icon":"AlertCircle","title":"ftok() Pitfalls","content":"The ftok() function has important limitations: (1) The file must exist when ftok() is called—if deleted and recreated, the inode changes and so does the key; (2) Symbolic links are followed, so the actual file's inode is used; (3) On some systems, if the file is on a remote filesystem, results may be unpredictable. For maximum reliability, use a stable, local file that's part of your application installation.","variant":"warning"},"type":"callout"},{"data":{"content":"### The IPC_PRIVATE Alternative\n\nInstead of using `ftok()`, you can create a private queue using the special key `IPC_PRIVATE`:\n\n```c\nkey_t key = IPC_PRIVATE; // Value is 0\nint msqid = msgget(key, IPC_CREAT | 0666);\n```\n\n`IPC_PRIVATE` guarantees a new, unique message queue every time. However, there's a catch: the resulting queue ID must be communicated to other processes through some other mechanism (environment variables, file, shared memory, etc.), since they can't derive it from a shared key.\n\n**Use `IPC_PRIVATE` when:**\n- Parent creates queue before forking children (children inherit the ID)\n- Queue ID can be passed via command-line arguments\n- You need guaranteed uniqueness without race conditions\n\n**Use `ftok()` when:**\n- Unrelated processes need to find the same queue\n- Processes start independently and must rendezvous\n- You need queue persistence across process restarts"},"type":"text"}],"titleType":"number","titleNumber":2},{"id":"creating-message-queues","title":"Creating Message Queues with msgget()","content":[{"data":{"content":"The `msgget()` system call creates a new message queue or obtains the identifier of an existing queue.\n\n### The msgget() Function\n\n```c\n#include \n#include \n#include \n\nint msgget(key_t key, int msgflg);\n```\n\n**Parameters:**"},"type":"text"},{"data":{"rows":[["`key`","The key value from `ftok()` or `IPC_PRIVATE`"],["`msgflg`","Flags controlling creation behavior and permissions"]],"headers":["Parameter","Description"]},"type":"table"},{"data":{"content":"**Returns:**\n- Queue identifier (non-negative integer) on success\n- `-1` on error (with `errno` set)"},"type":"text"},{"data":{"items":["**IPC_CREAT** — Create a new queue if one doesn't exist with this key. If combined with a permission mode, the queue is created with those permissions.","**IPC_EXCL** — When combined with `IPC_CREAT`, fail if the queue already exists. This prevents race conditions when multiple processes try to create the same queue.","**Permission bits** — Standard Unix permission bits (e.g., `0666` for read/write by all). Applied to owner, group, and others."],"title":{"icon":"Code2","text":"msgget() Flags","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"fileName":"msgget_example.c","languages":[{"code":"$7c","label":"C","value":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"rows":[["`EACCES`","Queue exists but caller lacks permission","Check queue permissions with `ipcs`"],["`EEXIST`","`IPC_CREAT | IPC_EXCL` but queue exists","Remove `IPC_EXCL` or delete existing queue"],["`ENOENT`","Queue doesn't exist and `IPC_CREAT` not set","Add `IPC_CREAT` flag or verify queue was created"],["`ENOSPC`","System limit on message queues reached","Delete unused queues or increase `MSGMNI`"],["`ENOMEM`","Insufficient kernel memory","Free system memory or reduce queue sizes"]],"caption":"Common msgget() Error Codes","headers":["errno","Cause","Solution"]},"type":"table"}],"titleType":"number","titleNumber":3},{"id":"message-structure","title":"Message Structure Requirements","content":[{"data":{"content":"$7d"},"type":"text"},{"data":{"fileName":"message_structures.c","languages":[{"code":"$7e","label":"C","value":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"icon":"AlertCircle","title":"Critical Constraints","content":"The mtype value MUST be greater than 0. Using mtype ≤ 0 causes msgsnd() to fail with EINVAL. This is a common source of bugs—ensure all message types are positive integers.","variant":"warning"},"type":"callout"}],"titleType":"number","titleNumber":4},{"id":"sending-messages","title":"Sending Messages with msgsnd()","content":[{"data":{"content":"The `msgsnd()` system call adds a message to a queue.\n\n### The msgsnd() Function\n\n```c\n#include \n#include \n#include \n\nint msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);\n```\n\n**Parameters:**"},"type":"text"},{"data":{"rows":[["`msqid`","Queue identifier from `msgget()`"],["`msgp`","Pointer to message structure (must begin with `long mtype`)"],["`msgsz`","Size of message data **excluding** the `mtype` field"],["`msgflg`","Flags controlling send behavior"]],"headers":["Parameter","Description"]},"type":"table"},{"data":{"content":"**Returns:**\n- `0` on success\n- `-1` on error\n\n### The Size Parameter Subtlety\n\nA common source of bugs: `msgsz` is the size of the data portion **only**, not including the `mtype` field:\n\n```c\nstruct my_msg {\n long mtype; // NOT counted in msgsz\n char data[100]; // This IS counted\n};\n\nstruct my_msg msg;\nmsg.mtype = 1;\nstrcpy(msg.data, \"Hello\");\n\n// CORRECT: size of data only\nmsgsnd(msqid, &msg, sizeof(msg.data), 0);\n// OR: total size minus mtype\nmsgsnd(msqid, &msg, sizeof(msg) - sizeof(long), 0);\n\n// WRONG: includes mtype size\n// msgsnd(msqid, &msg, sizeof(msg), 0); // Sends extra bytes!\n```"},"type":"text"},{"data":{"fileName":"msgsnd_complete.c","languages":[{"code":"$7f","label":"C","value":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"items":["**0 (default)** — Blocking mode. If the queue is full (reached `msg_qbytes` limit), the call blocks until space becomes available or the queue is removed.","**IPC_NOWAIT** — Non-blocking mode. If the queue is full, return immediately with `errno` set to `EAGAIN`. Never blocks the caller."],"title":{"icon":"Zap","text":"msgsnd() Flags","type":"icon","color":"primary","variant":"outline-circle"},"variant":"glass"},"type":"list"}],"titleType":"number","titleNumber":5},{"id":"receiving-messages","title":"Receiving Messages with msgrcv()","content":[{"data":{"content":"The `msgrcv()` system call retrieves messages from a queue with powerful selection capabilities.\n\n### The msgrcv() Function\n\n```c\n#include \n#include \n#include \n\nssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);\n```\n\n**Parameters:**"},"type":"text"},{"data":{"rows":[["`msqid`","Queue identifier"],["`msgp`","Buffer to receive message"],["`msgsz`","Maximum data size to receive (excluding `mtype`)"],["`msgtyp`","Message type selection (see below)"],["`msgflg`","Flags controlling receive behavior"]],"headers":["Parameter","Description"]},"type":"table"},{"data":{"content":"**Returns:**\n- Number of bytes copied into `mtext` on success\n- `-1` on error\n\n### Message Type Selection\n\nThe `msgtyp` parameter provides flexible message selection:"},"type":"text"},{"data":{"rows":[["`= 0`","Receive the first message in the queue (any type)"],["`> 0`","Receive the first message with exactly this type"],["`< 0`","Receive the first message with type ≤ |msgtyp| (lowest type first)"]],"headers":["msgtyp Value","Behavior"]},"type":"table"},{"data":{"fileName":"msgrcv_patterns.c","languages":[{"code":"$80","label":"C","value":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"icon":"Lightbulb","title":"Priority Queue Pattern","content":"Using negative msgtyp values creates priority ordering: msgrcv(msqid, &msg, msgsz, -100, 0) will receive the message with the lowest type value that is ≤ 100. If you have messages of types 1, 5, 50, and 100, it receives type 1 first. This enables priority queuing without separate queues!","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":6},{"id":"queue-control","title":"Queue Control with msgctl()","content":[{"data":{"content":"The `msgctl()` system call performs various control operations on a message queue.\n\n### The msgctl() Function\n\n```c\n#include \n#include \n#include \n\nint msgctl(int msqid, int cmd, struct msqid_ds *buf);\n```\n\n**Commands:**"},"type":"text"},{"data":{"rows":[["`IPC_STAT`","Copy queue info into `buf`"],["`IPC_SET`","Apply settings from `buf` to queue"],["`IPC_RMID`","Remove the message queue immediately"]],"headers":["Command","Description"]},"type":"table"},{"data":{"fileName":"msgctl_operations.c","languages":[{"code":"$81","label":"C","value":"c"}],"showLineNumbers":true},"type":"code"},{"data":{"icon":"AlertCircle","title":"Removal Is Immediate and Destructive","content":"When IPC_RMID is issued, the queue is destroyed immediately. All messages still in the queue are lost. Any processes blocked in msgrcv() or msgsnd() are awakened and receive EIDRM. There is no way to recover the queue or its contents. Always ensure all messages are processed before removal in production systems.","variant":"warning"},"type":"callout"}],"titleType":"number","titleNumber":7},{"id":"summary","title":"Summary: System V Message Queues","content":[{"data":{"content":"We've covered the complete System V message queue API. Let's consolidate the essential concepts:"},"type":"text"},{"data":{"type":"ordered","items":["**Key-based identification** — `ftok()` generates keys from pathname + project ID, enabling unrelated processes to find the same queue.","**Kernel persistence** — Queues exist in kernel space and survive process termination. Must be explicitly removed with `msgctl(IPC_RMID)`.","**Message structure** — All messages must begin with `long mtype > 0`, followed by data. The type enables selective reception.","**Size calculation** — `msgsz` parameter is data size only, excluding the `mtype` field.","**Selective reception** — `msgrcv()` can receive any message (type=0), specific type (type>0), or priority-based (type<0).","**Blocking behavior** — Both send and receive block by default; use `IPC_NOWAIT` for non-blocking operations."],"title":{"icon":"CheckCircle","text":"Key Takeaways","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now understand System V message queues—the foundational message-passing IPC mechanism. Next, we'll explore POSIX message queues, which provide a more modern API with additional features like notification and better POSIX compliance.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":8}],"isLocked":false},{"id":"seed_bc0c2210b51587ba99beb37fd4902880","title":"POSIX Message Queues","order":1,"content":null,"isLocked":true},{"id":"seed_0e6d7e631c076dc6e9f1ccaaab99b25a","title":"Message Types","order":2,"content":null,"isLocked":true},{"id":"seed_cde9ce23c65e857e8e1e4f85fe1133ae","title":"Priority Ordering","order":3,"content":null,"isLocked":true},{"id":"seed_0e5318286e45e09ca356fc057a65c04b","title":"Advantages of Message Queues","order":4,"content":null,"isLocked":true}]}}