Inter process communication using Linux System Calls
-
Upload
jyoti9vssut -
Category
Documents
-
view
12.453 -
download
2
description
Transcript of Inter process communication using Linux System Calls
Inter-Process Communication us ing
Linux System Cal l API and Standard API
Jyoti Prakash6th Semester , Information Technology
Inter Process Communication
● Ability to communicate between two cooperating process
● Used in many contexts , such as a producer – consumer problem
Process A(Producer)
Process B1(Consumer)Process B4
(Consumer)
Process B2(Consumer)
Process B3(Consumer)
PassesInformation
Passes Information
Passes Information
PRODUCER CONSUMER
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
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
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])
High Level Implementation
● A simple implementation of high level pipes
Low Level Implementation
A naive implementation of pipe – passing data in the same process (complete useless , no IPC)
Another Low Level Implementation
Use fork() and pipe() -- The logical implementation of pipe
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
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)
Process A Process B
FIFO Queue File stored in
Somelocation
Implementation using mkfifo syscall
FIFO Producer
Contd ...
FIFO Client
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
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 1 Process 2Message Queue
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 ...
Producer – Consumer Implementation
Contd ...
Producer Program Implementing message queue
Implementation (... contd)
Producer Program Implementing message queue
Implementation
Consumer for Message Queue
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
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
Visual Representation of Shared Memory
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
Implementation
Shared memory header file shm_com.h
Implementation - Producer
Implementation - Consumer
Consumer Process Code for Shared Memory
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
Any Queries ???
Thank you