This document discusses various methods of inter-process communication (IPC) in Linux using system calls and standard APIs. It describes pipes, FIFOs, message queues, and shared memory as common IPC methods. For each method, it provides details on the relevant system calls and functions, and includes code examples of producer-consumer implementations using message queues and shared memory.

1. Inter-Process Communication
using
Linux System Call API and Standard API
Jyoti Prakash
6th Semester , Information Technology

2. Inter Process Communication
● Ability to communicate between two cooperating
process
● Used in many contexts , such as a producer –
consumer problem
Process B1
Process B4 (Consumer)
(Consumer) Passes
Information
Passes Process A
Information (Producer)
Process B3 Passes Information Process B2
(Consumer) (Consumer)
PRODUCER CONSUMER

3. Methods of Inter-Process
Communication
● Methods of IPC
– Pipes
– FIFO
– Message Queues
– Shared Memory
● There's another method SOCKETS!!! .... But not
that used in this context as the others above

4. Pipes
● A pseudofile which redirects data from one process
to other.
● Below the “cmd1” and “cmd2” takes input from
stdin and outputs to stdout , but a pipe in-between
passes information from “stdout of cmd1” to “stdin
of cmd2” which outputs to stdin i.e monitor
● e.g. ls -aRl home | less ; cat file1 file2 file3 | grep
sample
● Simplest of all the IPCs

5. Pipes Implementation using Linux
SysCall and Standard API
● High Level
– User level implementation , end-user not required to
interact with the kernel
– Two functions defined in stdio.h
● FILE *popen(const char *command, const char
*open_mode)
● int pclose(FILE *stream_to_close)
● Low – Level
– Kernel level implementation, end-user required to
interact with the kernel
– System call available in unistd.h
● int pipe(int file_descriptor[2])

6. High Level Implementation
● A simple implementation of high level pipes

7. Low Level Implementation
A naive implementation of pipe – passing data in the same
process (complete useless , no IPC)

8. Another Low Level Implementation
Use fork() and pipe() -- The logical implementation of pipe

9. Methods of Inter-Process
Communication
● Methods of IPC
– Pipes
– FIFO
– Message Queues
– Shared Memory
● There's another method SOCKETS!!! .... But not
that used in this context as the others above

10. FIFO
● Stands for First In First Out (obvious in CS)
● A named pipe implementation on Linux
● Unidirectional in nature (Simplex Communication)
● Two system calls available in sys/types.h
– int mkfifo(const char *pathname, mode_t mode)
– int mknod(const char *path, mode_t mode, dev_t dev)
FIFO Queue
File stored in
Process A
Some Process B
location

11. Implementation using mkfifo syscall
FIFO Producer
Contd ...

12. FIFO Client

13. Methods of Inter-Process
Communication
● Methods of IPC
– Pipes
– FIFO
– Message Queues
– Shared Memory
● There's another method SOCKETS!!! .... But not
that used in this context as the others above

14. Message Queues
● Released in AT & T System V.2 ( a release of Unix)
● Part of System V IPC, the other being Shared
Memory and Semaphores
● Implementation of Message Passing IPC
● Message queue will remain (until deleted) , even if
the process have existed
● Can be made unidirectional or bidirectional
Process 2
Process 1 Message Queue

15. Implementation in Linux
● Uses four functions , defined in msg.h on Unix or a
Linux distro
– int msgctl(int msqid, int cmd, struct msqid_ds *buf)
● Control the message queue, by specifying
command in cmd
– int msgget(key_t key, int msgflg)
● Get a queue with the key specified
– int msgsnd(int msqid, const void *msgp, size_t msgsz, int
msgflg)
● Sends the message to the queue
– ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long
msgtyp,int msgflg)
● Receives a message from the queue
Contd ...

16. Producer – Consumer Implementation
Producer Program Implementing message queue
Contd ...

17. Implementation (... contd)
Producer Program Implementing message queue

18. Implementation
Consumer for Message Queue

19. Methods of Inter-Process
Communication
● Methods of IPC
– Pipes
– FIFO
– Message Queues
– Shared Memory
● There's another method SOCKETS!!! .... But not
that used in this context as others

20. Shared Memory
● One of the AT & T System V IPC
● Simple concept, keep a memory segment , which can
be shared by two or more processes
● Real Implementation : A process creates a memory
segment for IPC from its logical address space and
appears in that. Other process can attach that
available space for communication.
● One of the most simplest and logical
implementation of IPC

21. Visual Representation of Shared Memory

22. Implementation
● There are four functions available in sys/shm.h
– void *shmat(int shm_id, const void *shm_addr, int shmflg);
● Attached the memory segment (pointed by shm_id) to the
memory space of calling process
– int shmctl(int shm_id, int cmd, struct shmid_ds *buf)
● Performs the control operation, specified by cmd)
– int shmdt(const void *shm_addr)
●Detaches the memory segment
– int shmget(key_t key, size_t size, int shmflg)
● Allocates a shared memory segment

23. Implementation
Shared memory header file shm_com.h

24. Implementation - Producer

25. Implementation - Consumer
Consumer Process Code for Shared Memory

26. References
● Modern Operating Systems
– Andrew S. Tanenbaum
● Operating Systems Design and Implementation
– Andrew S. Tanenbaum
● Operating System Concepts
– Bear, Galvin and Silberschatz
● Beginning Linux Programming
– Neil Matthew and Richard Stones
● Beej's Guide to IPC
● MIT OCW on Operating System Engineering
– www.ocw.mit.edu/6-828-fall-2006/6-828-fall-2006/contents/index.htm

27. Any Queries ???

28. Thank you