How to diffrenctiate Process and Images in Linux

turned on computer monitor displaying text
Reading Time: 4 minutes

Process and images are the two important terms that describe the environment and the execution of commands in Linux.

What is an image?

The image is an environment for the execution which includes a core image, general register values, status of open files, current directory, and the like. Therefore, it depicts the entire picture of the state of the Linux kernel.  The components of the image in Linux are:

What is a process?

The process is the execution of an image. Thus, it is important for the image to be present in the core during the execution of the process. 

There are 3 segments of the user-core part of an image:

1. Program text segment

2. Data segment

3. Stack segment

All processes share a single copy of the program text segment, during the execution of an image. Data segment begins in the virtual address space at the top of the text segment. It is a non-shared writable segment whose size can be extended by a system call. The Stack segment begins at the highest address in the virtual address space which automatically increases its length as the stack pointer fluctuates.

Processes can be executed by placing a fork call as follows:

processid = fork(label)

Fork call splits into two independent processes which are commonly called, parent process and child process. Each process resides on different memory space and has a separate copy of the original core image. In the parent process, the control returns directly from the fork, whereas in the child process, the control is passed to a location label. The process id which is returned by the fork call is the identification of the other processes.  

Process in Linux: Communication

Kernel coordinates the activities of the process in Linux and is responsible for the communication between processes. Linux supports various Inter-Process Communication(IPC) mechanisms. For example:

  • Shared files
  • Shared memory
  • Pipes
  • Signals

Lets learn about these Inter-Process communication mechanisms:

1. Shared Files

They are the most basic type of sharing mechanisms offered by Linux. It comprises a producer that creates and writes to a file and a consumer that consumes or reads from that file. Shared Files is not a safe mechanism to use as the problem of race-conditioning might arise. Therefore, to avoid this problem, it can be secured by applying locks such that prevent the conflict between read and write.

2. Shared Memory

Shared memory is an extra piece of memory. It is attached to some address spaces for their owners to use. Consequently, that is how the process, sharing the same memory segment, can access it. It can too result in the race-condition if not handled properly. 

3. Pipes

A pipe is used for Inter-process communication. The call

filep = pipe()

return a file descriptor filep and create an interprocess channel called a pipe. It is passed from parent to child process in the image by a fork call. Pipe falls under the category of one-way communication. A read using a pipe file descriptor waits for the other process to complete the write. There are two types of pipes in Linux: 

(a) Ordinary Pipes or Unnamed Pipes : They are unidirectional and used for the communication between two processes, most commonly between  a parent and a child process.

(b) Named Pipes : They can be used as the bidirectional pipes as they can be written by several writers. As a result, it provides two-way communication between two unrelated processes.

4. Signals

A signal for a process in Linux is similar to an interrupt used for communication. Therefore, it notifies the occurrence of an event to the processes. Signals can be specified with a number or a name. 

The following system calls and library function allow the caller to send a signal:

Raise(3)Sends a signal to the calling thread.
Kill(2) Sends  a  signal to a specified process, to all member of a specified process group, or to  all  processes  on the system.
Killpg(3)Sends  a  signal  to  all of the members of a specified process group.
pthread_kill(3)
Sends a signal to a specified POSIX thread in the  same process as the caller.
tgkill(2)   Sends  a signal to a specified thread within a specific process.  (This is the system call  used  to  implement pthread_kill(3).)
sigqueue(3)Sends  a  real-time  signal with accompanying data to a specified process.

Execution of Programs 

The execution of a program is invoked by 

execute(file, arg1, arg2, ..., argn)

This system call will request the system to read in and execute the program named by the file along with its arguments. All the code and data in the process using execution are replaced from the file, but open files, current directory, and interprocess relationships are unaltered. For instance, if the call fails because a file could not be found or because its execute-permission bit was not set, does a return take place from the execute primitive; it resembles a “jump” machine instruction rather than a subroutine call.

Process in Linux: Synchronization

It involves a time slice for each process in Linux so that each process gets the required time for its execution. Fork() creates a child process that is a duplicate of the parent process but has a different PID. When a parent process is terminated before the termination of the child process, we call the child process as an orphaned process. 

Wait() command is used to provide the synchronization between the processes. As a result, Linux detects the deadlock between the processes and sorts it out. 

Process in Linux: Termination

It is the last condition for the process, which is called by

exit(status)

In conclusion, this deletes a process, destroys its image, and closes its open files. Termination of a child process is notified to the parent processes as well. 

References

https://tldp.org/LDP/tlk/kernel/processes.html

Written by 

Vidushi Bansal is a Software Consultant [Devops] at Knoldus Inc. She is passionate about learning and exploring new technologies.

Leave a Reply