[OS Linux] explain Linux Process 1 in detail (process concept, PCB, process creation, process status, zombie process, orphan process)

Posted by fansa on Fri, 01 Oct 2021 21:18:50 +0200

Based on CentOS, this paper deeply explains the process concept, PCB, process creation, process status, zombie process and orphan process by von Neumann system and operating system concept.

catalogue

1, Von Neumann system

2, Operating system  

3, Basic concepts of process

4, Description process - PCB

1.task_ struct

5, Organizational process

6, View process

7, Get process identifier through system call  

8, Create process - fork-1 through system call

9, Process status

10, Zombie process

11, Orphan process

1, Von Neumann system

Most of our common computers follow the von Neumann system.

2, Operating system  

Any computer system contains a basic set of programs called the operating system (OS). In general, the operating system includes:

         Kernel (process management, memory management, file management, driver management)

         Other programs (such as function libraries, shell programs, etc.)

The purpose of designing OS is to interact with hardware, manage all software and hardware resources, and provide a good execution environment for user programs (Applications).

It is a software for integrated software and hardware management.

  Computer management hardware: describe first and then organize

         1. Describe it with struct structure

         2. Organize and use linked lists or other efficient data structures

3, Basic concepts of process

An execution instance of a program, the program being executed, etc,

From the perspective of kernel: the entity that allocates system resources (CPU time, memory).

4, Description process - PCB

Process information is placed in a data structure called process control block, which can be understood as a collection of process attributes, called PCB (process control block). The PCB under Linux operating system is task_struct. It is a part of the process entity and the most important record data structure in the operating system. PCB is the only sign of the existence of a process. The system can and can only control and schedule the process through PCB. PCB records all the information required by the operating system to describe the current situation of the process and control the operation of the process.

1.task_ struct

In Linux, the structure describing a process is called task_struct. task_struct is a data structure of Linux kernel. It will be loaded into RAM (memory) and contain process information.

Content classification:

         Identifier: the unique identifier describing this process, which is used to distinguish other processes.

         Status: task status, exit code, exit signal, etc.

         Priority: the priority relative to other processes.

         Program counter: the address of the next instruction to be executed in a program.

         Memory pointers: including pointers to program code and process related data, as well as pointers to memory blocks shared with other processes

         Context data: data in the processor's registers when the process executes.

         I/O status information: including the displayed I/O requests, the I/O devices assigned to the process and the list of files used by the process.

         Accounting information: may include the total processor time, the total number of clocks used, time limit, accounting number, etc.

         Other information

5, Organizational process

You can find it in the kernel source code. All processes running in the system use task_ The form of struct linked list exists in the kernel.

6, View process

Process information can be viewed through the / proc system folder

 

You can use user level tools such as top and ps to get

 

7, Get process identifier through system call  

Process id (PID) parent process id (PPID)

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main()
{
     printf("pid: %d\n", getpid());
     printf("ppid: %d\n", getppid());
     return 0;
}

8, Create process - fork-1 through system call

fork has two return values

The parent and child processes share the code, and the data opens up space respectively. One copy is private (copy on write)

if is usually used for shunting after fork:

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main()
{
     int ret = fork();

     if(ret < 0){
         perror("fork");

         return 1;
     }
     else if(ret == 0)
     { //child
        printf("I am child : %d!, ret: %d\n", getpid(), ret);
     }else
     { //father
         printf("I am father : %d!, ret: %d\n", getpid(), ret);
     }

     sleep(1);

     return 0;
}

9, Process status

1. Type of status

A process can have several states (in the Linux kernel, a process is sometimes called a task).

The status is defined in the kernel source code:

/*
* The task state array is a strange "bitmap" of
* reasons to sleep. Thus "running" is zero, and
* you can test for combinations of others with
* simple bit tests.
*/


static const char * const task_state_array[] = {
    "R (running)", /* 0 */
    "S (sleeping)", /* 1 */
    "D (disk sleep)", /* 2 */
    "T (stopped)", /* 4 */
    "t (tracing stop)", /* 8 */
    "X (dead)", /* 16 */
    "Z (zombie)", /* 32 */
};

Of which:

R running: it does not mean that the process must be running. It indicates that the process is either running or in the running queue.

S sleep state: it means that the process is waiting for the event to complete (sleep here is sometimes called interruptible sleep).

D Disk sleep: sometimes called non interruptible sleep. Processes in this state usually wait for the end of IO.

T stopped: the (T) process can be stopped by sending SIGSTOP signal to the process. The suspended process can continue to run by sending SIGCONT signal.

X dead state: this state is just a return state. You won't see this state in the task list.

10, Zombie process

Zombies is a special state. Zombies will occur when the process exits and the parent process does not read the return code of the child process exit.

The dead process will remain in the process table in the termination state, and will always wait for the parent process to read the exit state code. Therefore, as long as the child process exits, the parent process is still running, but the parent process does not read the child process state, and the child process enters the Z state.

For example:

#include <stdio.h>
#include <stdlib.h>

int main()
{
 pid_t id = fork();

 if(id < 0){

 perror("fork");

 return 1;

 }
 else if(id > 0){ //parent

     printf("parent[%d] is sleeping...\n", getpid());

     sleep(30);
 }else{
     printf("child[%d] is begin Z...\n", getpid());

     sleep(5);
     exit(EXIT_SUCCESS);
  }
 return 0;
}

 

Zombie process harm: the exit state of the process must be maintained. But if the parent process does not read all the time, the child process will always be in Z state.

Maintaining the exit status itself is data maintenance, which also belongs to the basic process information. Therefore, in the saved task_struct(PCB), the Z status does not exit and the PCB must be maintained all the time.

A parent process creates many child processes, which will cause a waste of memory resources. Because the data structure object itself will occupy memory, think about defining a structure variable in C to open up space at a certain location in memory, which will cause memory leakage.

11, Orphan process

The parent process exits first, and the child process is called "orphan process". The orphan process is adopted by init process 1, and the init process recycles it.

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>

int main ()
{
     int ret = fork();                                                  
      while(1)
      {
       if(ret > 0)       //Description is the parent process
       {
           printf("father : %d, ret : %d\n", getpid(), ret);
           sleep(3);
            exit(0);                                                
        }
       else if(ret == 0) {
            printf("child : %d, ret : %d\n", getpid(), ret);
            sleep(5);
        }
         else
         {
            printf("fork\n");
            return 1;
         }
      }
   return 0;
   }

Topics: C++ Linux CentOS Process