What is process?

Running instance of program. All processes are decedents of swapper process(PID=0). Both(threads, processes) are independent sequence of operations

Memory Layout of a Process

After compilation obj file is created ELF(Executable and linking format) format. This ELF file has (.text=CS, .data & .rodata = DS and others) This file is loaded in memory which creates Memory layout of the process.

                                Heap [                   ]
                                            /\
                                             |
                   |                         |<------DATA SEGMENT (static, global) ----------->                    |
[Kernel] Process-2 |[STACK] shared_libraries {PTR-To-HEAP} {Uninitialized_BSS} {Initialized DS} [TEXT/CODE SEGMENT]|
                   | ----->                                BlockStartedBySymbol <-RW--><--RO-->              0x0000|
                
Object/ELF File ===> |ELF Header|.data Header|.rodata Header|.text Header |.data|.rodata|.text|
                                                                          /             /       \                         
                                                                        /              /         \
Memory Layout ==>                                                      | Data Segment |Code Segment| Stack |
            

char s[] = "test";  //Initialized Globals
int a = 1;        
static int b = 1;

extern int a;     //Extern variable

static int a;     //Local static
                                                

int a;
static int b;
                    

malloc()->brk()
realloc()->sbrk()
                                    

add(int a, int b){          //0x33
    int c;               //Local
}
main(int argc, char *argv[]){   //0x22
    int a ,b;
    add(a,b);
}   
From OS:Call to main()      //0x11

--------stack allocated in this direction---->
[ argv[] argc | 0x11 | b a ]  [ | b a | 0x22+offset | c | ]     //Input parameters are pushed in reverse order
/\<--- sf of main()  ----->  <------ sf of add()     ---->/\
|                                                         |
|                                                         rsp Stack pointer(Points to the top of the stack)
|
rbp Base pointer(Points to the base of the current stack frame. Remains fixed)
                        

fun() {
    fun();
}
                        

8 MB(Default)  #cat /proc/pid/limits     //Linux
1 MB(Default)                            //Windows

$ ulimit -u unlimited                    //Changing stack size
                        

while(1){ 
    char *p = (char *) malloc(12); 
}                            
                        

Process States

When a process executes, it passes through different states.
a. Start: Initial state when a process is first started/created.
b. Ready: The process is waiting to be assigned to a processor.
c. Running(Flag R): Once the process has been assigned to a processor by the OS scheduler state changes to running.
d. Waiting/Sleeping(Flag S): Process moves into the waiting state if it needs to wait for a resource, eg: waiting for user input or file.
e. Terminated or Exit: Once the process finishes its execution, or it is terminated by the OS. Here it waits to be removed from main memory.

Process Table

What is Process Table?
Process Table is Array of structures (called Process Control Blocks), one entry per process.
Entry contains important information about the process's state:
  Its Program counter: Store address from where to start again
  stack pointer
  memory allocation
  the status of its open files
  Process's accounting and scheduling information
  And everything else about the process that must be saved when the process is switched from running to ready or blocked state so that it can be restarted later

Why Process Table?
The main objective of process table entry is to restart process from state where it left off, as it had never stopped.
Process state which is interrupted using Interrupt is also saved on process table for later resumption.

Process Control Block struct task_struct { long priority; //DOUBLY LL struct task_struct *next_task, *prev_task; //Process PID int pid; //Process Group int pgrp; //Pointers to parent, youngest child, silbilings etc struct task_struct *p_opptr, *p_pptr, *p_cptr, //UID,GID unsigned short uid,suid,gid,sgid..; //File system information struct fs_struct *fs; //IPC Information struct sem_queue *semsleeping; //memory management info struct mm_struct *mm; //signal handlers struct signal_struct *sig; //Register information. };

PCB / Process Control Block / Process Context

PCB is a data structure(struct task_struct) for storing all information of a process inside process table

Why needed? When process changes state (ie switched from running to waiting/sleeping state(due to context switch or interrupt)) kernel stores info in PCB, so that process can resumed later from same point using this information.
Information of child processes is stored in PCB of parent process etc.

Information stored in PCB

Ways of Process Creation, Terminaton

Process Creation Ways

1. System initialization: At boot numerous processes are created.
2. Execution of a process-creation system call by a running process. fork(), CreateProcess()=Windows
3. A user request to create a new process.
4. Initiation of a batch job.

Process Termination ways