Master Linux Interprocess Communication and End Process Isolation Issues

Why Processes Need Communication

In a Linux system each process runs in its own user‑space, isolated from others. When multiple processes must cooperate—such as in distributed data collection, processing, or storage—they need a way to exchange information. The kernel provides a shared kernel space that acts as a bridge, allowing processes to communicate via system calls.

IPC Framework

The IPC mechanism consists of a kernel‑level communication core and user‑space interfaces. The core is analogous to a post office, while the interfaces are the letters or phones that applications use to send and receive data.

Types of IPC

Shared‑memory style : After the kernel creates a shared region, the communicating processes can read and write directly without further kernel mediation, but they must synchronize (e.g., with semaphores) to avoid data races.

Message‑passing style : Every message passes through the kernel, similar to a courier delivering letters. It can be bounded (fixed‑size messages) or unbounded (byte streams) and is suitable for asymmetric client‑server interactions.

Interface Design

IPC interfaces are classified as symmetric (peers have equal roles, often using shared memory) or asymmetric (client‑server, typically using message passing). Three main interface functions are:

Creating a communication channel (e.g., shmget, msgget, pipe).

Joining an existing channel (using a known name or handle).

Reading from and writing to the channel according to its semantics.

Linux IPC Mechanisms

1. Pipe Communication (Anonymous and Named)

Anonymous pipes are created with pipe() after a fork(); the parent and child inherit file descriptors and must close the unused ends to enforce unidirectional flow.

#include<iostream>
#include<unistd.h>
int main(){
    int pipefd[2];
    pipe(pipefd);
    pid_t pid=fork();
    if(pid==0){
        close(pipefd[0]);
        write(pipefd[1],"child",5);
        close(pipefd[1]);
    }else{
        close(pipefd[1]);
        char buf[10];
        read(pipefd[0],buf,5);
        close(pipefd[0]);
    }
}

Named pipes (FIFOs) use mkfifo() and can connect unrelated processes via a filesystem pathname.

2. Signals

Signals are software interrupts. A process registers a handler with signal() and the kernel delivers the signal when an event occurs.

#include <signal.h>
void handler(int s){ printf("signal %d
",s); }
int main(){ signal(SIGINT,handler); while(1)sleep(10); }

3. Files

Processes can use regular files as a persistent communication medium: one writes, another reads.

#include <stdio.h>
int main(){ FILE*fp=fopen("data.txt","w"); fputs("msg",fp); fclose(fp);
 fp=fopen("data.txt","r"); char buf[20]; fgets(buf,20,fp); printf("%s",buf); fclose(fp); }

4. Semaphores

Semaphores act as traffic lights for shared resources, ensuring exclusive access when multiple processes manipulate the same memory.

#include <sys/sem.h>
union semun{int val;};
int semid=semget(1234,1,0666|IPC_CREAT);
union semun su; su.val=1; semctl(semid,0,SETVAL,su);

5. Shared Memory

Processes attach to a common memory segment with shmget() and shmat(), then read/write directly.

#include <sys/shm.h>
int shmid=shmget(1234,2048,0666|IPC_CREAT);
char*addr=shmat(shmid,NULL,0);
strcpy(addr,"hello");
shmdt(addr);
shmctl(shmid,IPC_RMID,NULL);

6. Message Queues

Message queues provide asynchronous communication; processes send with msgsnd() and receive with msgrcv().

#include <sys/msg.h>
int qid=msgget(key,0666|IPC_CREAT);
struct {long mtype; char txt[100];}msg={1,"hi"};
msgsnd(qid,&msg,sizeof(msg),0);
msgrcv(qid,&msg,sizeof(msg),1,0);
msgctl(qid,IPC_RMID,NULL);

7. Sockets

Sockets enable both local and network IPC. A typical server creates a socket, binds, listens, accepts a client, then exchanges data.

#include <sys/socket.h>
int s=socket(AF_INET,SOCK_STREAM,0);
bind(s,(struct sockaddr*)&addr,sizeof(addr));
listen(s,3);
int c=accept(s,NULL,NULL);
read(c,buf,1024); send(c,"ok",2,0);
close(c); close(s);

Application Scenarios

IPC is used for data pipelines (e.g., ls | grep), database coordination, multimedia processing, device sharing (printers), file locking, process state notifications, distributed task distribution, multithreaded synchronization, client‑server architectures, and micro‑service communication.

Case Analyses

Pipe Example

Parent creates a pipe, forks a child, writes a string, child reads and prints it.

#include <unistd.h>
int main(){int p[2];pipe(p);if(fork()==0){close(p[1]);char buf[20];read(p[0],buf,20);printf("%s",buf);}else{close(p[0]);write(p[1],"msg",4);}}

Message Queue Example

One process sends "Hello" to a queue; another receives and prints it.

#include <sys/msg.h>
int q=msgget(key,0666|IPC_CREAT);
struct {long t; char m[100];}msg={1,"Hello"};
msgsnd(q,&msg,sizeof(msg),0);
msgrcv(q,&msg,sizeof(msg),1,0);
printf("%s",msg.m);
msgctl(q,IPC_RMID,NULL);

Shared Memory Example

Process writes "Hello" into shared memory; another maps the segment and reads it.

#include <sys/shm.h>
int id=shmget(key,1024,0666|IPC_CREAT);
char*addr=shmat(id,NULL,0);
strcpy(addr,"Hello");
shmdt(addr);
shmctl(id,IPC_RMID,NULL);

Signal Example

A process registers a handler for SIGUSR1 and waits; another process can send the signal to trigger the handler.

#include <signal.h>
void h(int s){printf("got %d
",s);}int main(){signal(SIGUSR1,h);while(1)sleep(1);}

Socket Example

Simple TCP server echoes a message back to the client.

#include <sys/socket.h>
int s=socket(AF_INET,SOCK_STREAM,0); /* bind, listen, accept … */

The diagram illustrates how isolated processes connect to the shared kernel space, which mediates all IPC operations.