Unit 9: Inter Process Communication (IPC)

Opening Hook — Indian Railways: The World's Largest IPC System

Learning Outcomes — Bloom's Taxonomy Mapped

Concept Explanation — Inter Process Communication from Scratch

1. IPC Need and Overview

In an operating system, processes are isolated by design — each has its own address space, its own stack, its own data. This isolation is great for security and stability (a crash in one process doesn't kill another). But real applications need processes to cooperate. A web server process needs to talk to a database process. A print spooler needs to accept jobs from multiple applications. A payment gateway needs its fraud-detection module to communicate with its transaction processor.

Why do processes need to communicate?

• Data sharing: Multiple processes working on the same dataset (e.g., IRCTC reservation + waitlist processes sharing seat data)
• Computation speedup: Divide a task among multiple processes and combine results
• Modularity: Break a large system into smaller, independent processes (microservices at Razorpay)
• Convenience: A user may run multiple tasks simultaneously — editor, compiler, browser — that need to share clipboard data

2. Shared Memory (System V IPC)

Plain English: Imagine two roommates sharing a whiteboard in their room. Either roommate can write on it or read from it at any time — no messenger needed. It's the fastest way to exchange information because the data is just there, in a memory region accessible to both processes.

Technical Definition: Shared memory is a region of memory that is mapped into the address space of two or more processes. Once set up, processes can read and write to this memory directly, without any kernel intervention for data transfer. This makes it the fastest IPC mechanism.

Key System Calls

C Code — Shared Memory Writer Process

C
/* shm_writer.c — Writes data to shared memory segment */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main() {
    // Generate a unique key using ftok
    key_t key = ftok("shmfile", 65);

    // Create shared memory segment of 1024 bytes
    int shmid = shmget(key, 1024, 0666 | IPC_CREAT);
    if (shmid == -1) {
        perror("shmget failed");
        return 1;
    }

    // Attach to shared memory
    char *str = (char *)shmat(shmid, NULL, 0);
    if (str == (char *)-1) {
        perror("shmat failed");
        return 1;
    }

    // Write data to shared memory
    printf("Write data: ");
    fgets(str, 1024, stdin);

    printf("Data written to shared memory: %s\n", str);

    // Detach from shared memory
    shmdt(str);

    return 0;
}

C Code — Shared Memory Reader Process

C
/* shm_reader.c — Reads data from shared memory segment */
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main() {
    // Generate the SAME key as writer
    key_t key = ftok("shmfile", 65);

    // Get the existing shared memory segment
    int shmid = shmget(key, 1024, 0666);
    if (shmid == -1) {
        perror("shmget failed");
        return 1;
    }

    // Attach to shared memory
    char *str = (char *)shmat(shmid, NULL, 0);
    if (str == (char *)-1) {
        perror("shmat failed");
        return 1;
    }

    // Read data from shared memory
    printf("Data read from shared memory: %s\n", str);

    // Detach from shared memory
    shmdt(str);

    // Destroy the shared memory segment
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

Compilation & Execution

Bash
# First, create the key file
$ touch shmfile

# Compile both programs
$ gcc shm_writer.c -o shm_writer
$ gcc shm_reader.c -o shm_reader

# Run writer first (in Terminal 1)
$ ./shm_writer

# Run reader second (in Terminal 2)
$ ./shm_reader

3. Message Passing

Plain English: Instead of sharing a whiteboard, imagine two people exchanging letters. The sender writes a message, puts it in an envelope, and sends it. The receiver opens the envelope and reads it. There's no shared space — the message is copied from sender to receiver through the kernel.

Technical Definition: Message passing is an IPC mechanism where processes communicate by explicitly sending and receiving messages through the operating system kernel. The kernel manages the message buffer and ensures delivery.

4. Pipes (Unnamed Pipes)

Plain English: A pipe is like a water pipe — data flows in one direction. One process pours data in at one end, another process drinks from the other end. It's the simplest IPC mechanism in Unix/Linux.

Technical Definition: A pipe is a unidirectional communication channel that connects the standard output of one process to the standard input of another. It uses two file descriptors: fd[0] for reading and fd[1] for writing.

How pipe() Works

C
int fd[2];
pipe(fd);
// fd[0] = read end  (mouth of the pipe — drink from here)
// fd[1] = write end (top of the pipe — pour data here)

C Code — Parent Writes, Child Reads via Pipe

C
/* pipe_demo.c — Parent sends message to child via pipe */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    int fd[2];        // fd[0]=read, fd[1]=write
    pid_t pid;
    char write_msg[] = "Train 12301 Rajdhani: Platform 5 Ready!";
    char read_msg[100];

    // Create the pipe
    if (pipe(fd) == -1) {
        perror("Pipe creation failed");
        return 1;
    }

    pid = fork();   // Create child process

    if (pid < 0) {
        perror("Fork failed");
        return 1;
    }

    if (pid > 0) {
        // ===== PARENT PROCESS (Station Master) =====
        close(fd[0]);    // Close unused read end

        printf("[Station Master] Sending: %s\n", write_msg);
        write(fd[1], write_msg, strlen(write_msg) + 1);

        close(fd[1]);    // Close write end after writing
        wait(NULL);       // Wait for child to finish
    }
    else {
        // ===== CHILD PROCESS (Platform Announcer) =====
        close(fd[1]);    // Close unused write end

        read(fd[0], read_msg, sizeof(read_msg));
        printf("[Announcer] Received: %s\n", read_msg);
        printf("[Announcer] 📢 Attention passengers...\n");

        close(fd[0]);    // Close read end
    }

    return 0;
}

Shell Pipe Operator |

The shell pipe operator | is the most common use of unnamed pipes. When you type:

Bash
$ ls -l | grep ".c" | wc -l

The shell creates two pipes:

• Pipe 1: Connects ls -l (stdout) → grep ".c" (stdin). Lists all files, grep filters only .c files.
• Pipe 2: Connects grep ".c" (stdout) → wc -l (stdin). Counts the number of .c files.

Result: You get the count of C source files in the current directory. Three processes, two pipes, zero temporary files.

Limitations of Unnamed Pipes

5. Named Pipes (FIFOs)

Plain English: A named pipe is like a pipe with a name tag on it, placed in a public area. Any process — not just parent-child — can use it, as long as they know the name. It appears as a special file in the filesystem.

Technical Definition: A FIFO (First In, First Out) is a special type of file that provides a named, persistent pipe. Unlike unnamed pipes, FIFOs have a name in the filesystem and can be used by unrelated processes. Created with the mkfifo() system call or the mkfifo command.

C Code — FIFO Writer (Unrelated Process 1)

C
/* fifo_writer.c — Writes to a named pipe (FIFO) */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>

int main() {
    char *fifo_path = "/tmp/railway_fifo";
    char message[256];

    // Create the FIFO (named pipe) if it doesn't exist
    mkfifo(fifo_path, 0666);

    printf("[Signal Room] FIFO Writer ready. Type messages:\n");

    // Open FIFO for writing
    int fd = open(fifo_path, O_WRONLY);

    printf("Enter message: ");
    fgets(message, 256, stdin);

    write(fd, message, strlen(message) + 1);
    printf("[Signal Room] Message sent: %s", message);

    close(fd);
    return 0;
}

C Code — FIFO Reader (Unrelated Process 2)

C
/* fifo_reader.c — Reads from a named pipe (FIFO) */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>

int main() {
    char *fifo_path = "/tmp/railway_fifo";
    char buffer[256];

    // Open FIFO for reading (blocks until writer opens it)
    printf("[Station Master] Waiting for signal room message...\n");
    int fd = open(fifo_path, O_RDONLY);

    read(fd, buffer, 256);
    printf("[Station Master] Received: %s", buffer);

    close(fd);

    // Remove the FIFO file
    unlink(fifo_path);

    return 0;
}

Compilation & Execution

Bash
$ gcc fifo_writer.c -o fifo_writer
$ gcc fifo_reader.c -o fifo_reader

# Terminal 1: Start the reader first (it will block waiting)
$ ./fifo_reader
[Station Master] Waiting for signal room message...

# Terminal 2: Start the writer
$ ./fifo_writer
[Signal Room] FIFO Writer ready. Type messages:
Enter message: Track 3 clear for departure
[Signal Room] Message sent: Track 3 clear for departure

# Back in Terminal 1:
[Station Master] Received: Track 3 clear for departure

Unnamed Pipes vs Named Pipes (FIFOs)

6. popen() and pclose()

Plain English: popen() is a convenience function that does three things in one call: creates a pipe, forks a child process, and execs a shell command. It's like having a helper who runs a command for you and hands you the output through a pipe. pclose() waits for the command to finish and cleans up.

Technical Definition: popen() opens a process by creating a pipe, forking, and invoking the shell. It returns a FILE pointer that can be used for reading (capturing command output) or writing (sending input to command).

C Code — Using popen() to Capture Command Output

C
/* popen_demo.c — Execute a command and read its output */
#include <stdio.h>
#include <stdlib.h>

int main() {
    FILE *fp;
    char buffer[256];

    printf("=== System Information via popen() ===\n\n");

    // Execute "uname -a" and read output
    fp = popen("uname -a", "r");
    if (fp == NULL) {
        perror("popen failed");
        return 1;
    }

    printf("OS Info: ");
    while (fgets(buffer, sizeof(buffer), fp) != NULL) {
        printf("%s", buffer);
    }
    pclose(fp);

    // Execute "ls -la *.c" and read output
    fp = popen("ls -la *.c 2>/dev/null", "r");
    if (fp != NULL) {
        printf("\nC source files:\n");
        while (fgets(buffer, sizeof(buffer), fp) != NULL) {
            printf("  %s", buffer);
        }
        pclose(fp);
    }

    // Execute "date" to get current time
    fp = popen("date", "r");
    if (fp != NULL) {
        printf("\nCurrent time: ");
        fgets(buffer, sizeof(buffer), fp);
        printf("%s", buffer);
        pclose(fp);
    }

    return 0;
}

7. Message Queues (POSIX)

Plain English: A message queue is like a post office box system. Process A drops a letter (message) into a specific numbered box. Process B opens that box and picks up the letter whenever it's ready. Messages have priorities — urgent telegrams get picked up before regular letters.

Technical Definition: POSIX message queues provide a prioritized, asynchronous messaging mechanism between processes. Messages are stored in the kernel and can be retrieved by priority. Unlike pipes, message queues preserve message boundaries — each message is an independent unit.

Key System Calls

C Code — Message Queue Sender

C
/* mq_sender.c — Sends messages to a POSIX message queue */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mqueue.h>
#include <fcntl.h>
#include <sys/stat.h>

#define QUEUE_NAME  "/railway_queue"
#define MAX_SIZE    1024
#define MSG_STOP    "exit"

int main() {
    mqd_t mq;
    char buffer[MAX_SIZE];

    // Set queue attributes
    struct mq_attr attr;
    attr.mq_flags   = 0;
    attr.mq_maxmsg  = 10;       // Max 10 messages in queue
    attr.mq_msgsize = MAX_SIZE;  // Max message size
    attr.mq_curmsgs = 0;

    // Create the message queue
    mq = mq_open(QUEUE_NAME, O_CREAT | O_WRONLY, 0644, &attr);
    if (mq == (mqd_t)-1) {
        perror("mq_open failed");
        return 1;
    }

    printf("[Ticket Counter] Message Queue Sender ready.\n");
    printf("Type messages (type 'exit' to quit):\n\n");

    do {
        printf("Send> ");
        fgets(buffer, MAX_SIZE, stdin);
        buffer[strcspn(buffer, "\n")] = 0;  // Remove newline

        // Send with priority 0
        if (mq_send(mq, buffer, strlen(buffer) + 1, 0) == -1) {
            perror("mq_send failed");
        }
    } while (strcmp(buffer, MSG_STOP) != 0);

    // Cleanup
    mq_close(mq);
    printf("[Ticket Counter] Sender closed.\n");

    return 0;
}

C Code — Message Queue Receiver

C
/* mq_receiver.c — Receives messages from a POSIX message queue */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mqueue.h>
#include <fcntl.h>

#define QUEUE_NAME  "/railway_queue"
#define MAX_SIZE    1024
#define MSG_STOP    "exit"

int main() {
    mqd_t mq;
    char buffer[MAX_SIZE + 1];
    unsigned int priority;
    ssize_t bytes_read;

    // Open existing message queue for reading
    mq = mq_open(QUEUE_NAME, O_RDONLY);
    if (mq == (mqd_t)-1) {
        perror("mq_open failed");
        return 1;
    }

    printf("[Display Board] Receiver ready. Waiting for messages...\n\n");

    do {
        bytes_read = mq_receive(mq, buffer, MAX_SIZE + 1, &priority);
        if (bytes_read >= 0) {
            buffer[bytes_read] = '\0';
            printf("Recv [priority=%u]: %s\n", priority, buffer);
        }
    } while (strcmp(buffer, MSG_STOP) != 0);

    // Cleanup
    mq_close(mq);
    mq_unlink(QUEUE_NAME);
    printf("\n[Display Board] Queue removed. Receiver closed.\n");

    return 0;
}

Compilation & Execution

Bash
# Note: POSIX message queues need -lrt flag
$ gcc mq_sender.c -o mq_sender -lrt
$ gcc mq_receiver.c -o mq_receiver -lrt

# Terminal 1: Start receiver
$ ./mq_receiver

# Terminal 2: Start sender
$ ./mq_sender

8. IPC Mechanism Comparison Table

9. IPC in Modern Systems

The IPC mechanisms we studied (pipes, shared memory, message queues) are low-level, OS-provided primitives. In modern production systems, they've evolved into high-level abstractions:

Microservices = High-Level IPC

In a microservices architecture, each service is essentially a separate process. The Payment Service at Razorpay needs to talk to the Fraud Detection Service, which needs to talk to the Bank Gateway Service, which needs to talk to the Notification Service. This is IPC at scale — across machines, across data centres, across continents.

Learn by Doing — 3-Tier Lab Structure

Bash
$ mkdir -p ~/ipc_labs && cd ~/ipc_labs
$ nano pipe_lab.c

C
/* pipe_lab.c — Bidirectional parent-child communication */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    int pipe1[2];  // Parent → Child
    int pipe2[2];  // Child → Parent
    pid_t pid;
    char parent_msg[] = "Station Master: Is Platform 3 clear?";
    char child_msg[]  = "Signal Room: Yes, Platform 3 is clear!";
    char buffer[256];

    // Create both pipes
    if (pipe(pipe1) == -1 || pipe(pipe2) == -1) {
        perror("Pipe creation failed");
        return 1;
    }

    pid = fork();

    if (pid > 0) {
        // PARENT (Station Master)
        close(pipe1[0]);  // Close read end of pipe1
        close(pipe2[1]);  // Close write end of pipe2

        // Send question to child
        write(pipe1[1], parent_msg, strlen(parent_msg) + 1);
        printf("[Parent] Sent: %s\n", parent_msg);

        // Read reply from child
        read(pipe2[0], buffer, 256);
        printf("[Parent] Received reply: %s\n", buffer);

        close(pipe1[1]);
        close(pipe2[0]);
        wait(NULL);
    }
    else {
        // CHILD (Signal Room)
        close(pipe1[1]);  // Close write end of pipe1
        close(pipe2[0]);  // Close read end of pipe2

        // Read question from parent
        read(pipe1[0], buffer, 256);
        printf("[Child] Received: %s\n", buffer);

        // Send reply to parent
        write(pipe2[1], child_msg, strlen(child_msg) + 1);
        printf("[Child] Sent reply: %s\n", child_msg);

        close(pipe1[0]);
        close(pipe2[1]);
    }

    return 0;
}

Bash
$ gcc pipe_lab.c -o pipe_lab
$ ./pipe_lab

C
/* fifo_lab_writer.c */
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>

int main() {
    char *fifo = "/tmp/ipc_lab_fifo";
    char msg[200];

    mkfifo(fifo, 0666);
    printf("[Writer] Opening FIFO for writing...\n");
    int fd = open(fifo, O_WRONLY);

    printf("Enter train announcement: ");
    fgets(msg, 200, stdin);

    write(fd, msg, strlen(msg) + 1);
    printf("[Writer] Sent!\n");

    close(fd);
    return 0;
}

C
/* fifo_lab_reader.c */
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    char *fifo = "/tmp/ipc_lab_fifo";
    char buf[200];

    printf("[Reader] Waiting for announcement...\n");
    int fd = open(fifo, O_RDONLY);

    read(fd, buf, 200);
    printf("[Reader] Announcement: %s", buf);

    close(fd);
    unlink(fifo);
    return 0;
}

Bash
$ gcc fifo_lab_writer.c -o fifo_writer
$ gcc fifo_lab_reader.c -o fifo_reader

# Terminal 1:
$ ./fifo_reader

# Terminal 2:
$ ./fifo_writer

Python
# queue_demo.py — Basic multiprocessing Queue demo
from multiprocessing import Process, Queue
import time

def sender(q):
    messages = ["Train arriving", "Platform clear", "Departure in 5 min"]
    for msg in messages:
        print(f"[Sender] Sending: {msg}")
        q.put(msg)
        time.sleep(1)
    q.put("STOP")

def receiver(q):
    while True:
        msg = q.get()
        if msg == "STOP":
            break
        print(f"[Receiver] Got: {msg}")

if __name__ == "__main__":
    q = Queue()
    p1 = Process(target=sender, args=(q,))
    p2 = Process(target=receiver, args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print("Done!")

Industry Spotlight — A Day in the Life

Earn With It — Freelance & Income Roadmap

⏱️ Time to First Earning: 3–4 weeks (if you complete all 3 lab tiers and build a GitHub portfolio)

MCQ Assessment Bank — 30 Questions (Bloom's Mapped)

Remember / Identify (Q1–Q5)

Understand / Explain (Q6–Q10)

Apply / Implement (Q11–Q15)

Analyze / Compare (Q16–Q20)

Evaluate / Justify (Q21–Q25)

Create / Design (Q26–Q30)

Short Answer Questions

Diagram
Parent Process          Kernel Pipe Buffer          Child Process
┌──────────┐          ┌──────────────┐          ┌──────────┐
│ fd[1]────│─────────→│  ■ ■ ■ ■ ■   │─────────→│────fd[0] │
│ (write)  │          │  (FIFO data) │          │  (read)  │
│ fd[0] ✗  │          └──────────────┘          │  fd[1] ✗ │
└──────────┘           (kernel space)           └──────────┘

Case Studies

Chapter Summary

Earning Checkpoint

✅ Unit 9 complete. MCQs: 30. Ready for Unit 10: Capstone!

[QR: Link to EduArtha video tutorial — Inter Process Communication]