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