Process

Process Context

• The resources associated with a process managed by the OS are called the process context
• The operating system manages three types of context information:
  • User context
    • Content of the allocated address space (\(\longrightarrow\) virtual memory)
  • Hardware context
    • CPU registers
  • System context
    • Information, which stores the operating system about a process
• Typically information about the hardware and system context are stored in the process control block (PCB)

Hardware Context

System Context

Process Table and Process Control Blocks

• Each process has its own process context, which is independent of the contexts of other processes

Context Switching

• Each process is at any moment in a particular state
  \(\longrightarrow\) Process state models

Process States

• The number of different states depends on the process state model of the operating system used

Process State Model with 2 States

• In principle two process states are enough:
  • running: The CPU is allocated to a process
  • idle: The processes waits for the allocation of CPU

Process State Model with 2 States (Implementation)

• Processes in state idle are stored in a queue (\(\rightarrow\) the runqueue), in which they wait for execution

  • The list can be sorted according to the process priority or waiting time

• This model also shows the working method of the dispatcher
  • The job of the dispatcher is to carry out the state transitions
• The execution order of the processes is specified by the scheduler, which uses a scheduling algorithm

Process Priorities

• The priority of a process is proportional to its CPU time
• The process priority is typically expressed as an integer value
  • A lower value represents a higher priority
• For Linux systems:
  • Priorities between -20 and +19 are available
  • -20 is the highest priority and +19 is the lowest priority.
  • The default priority is 0
  • Normal users can assign priorities from 0 to 19
  • The super user (root) can assign negative values too
• For RIOT systems:
  • Priorities between 0 and 15 are available
  • 0 is the highest priority and 15 is the lowest priority.
  • The default priority is 7
  • Priorities are typically fixed at process creation

Two States do not suffice in Practice

Process State Model with 3 States

• ready:
  • The process is ready to run and is currently waiting for the allocation of the CPU
  • This state is sometimes also called pending
• blocked:
  • The process can currently not be executed and is waiting for the occurrence of an event or the satisfaction of a condition
  • This may be e.g., a message of another process or of an I/O device or the occurrence of a synchronization event

Process State Model with 3 States – Implementation

Process State Model with 5 States

• For many implementations the introduction of two additional states is useful:

  • new: The process (process control block) has been created by the OS but not yet in ready state

  • exit: The execution of the process has finished or was terminated but the process control block still exists

Process State Model with 6 States

• The sum of all processes may exceed the amount of physical main memory \(\Rightarrow\) memory belonging to currently not running processes is swapped out \(\Longrightarrow\) swapping

• The OS outsources processes which are in blocked state

Process State Model with 7 States

• For more efficient use of available memory or in order to reduce waiting time, processes in suspended state may be distinguished into
  • blocked suspended state
  • ready suspended state

Process State Model of Linux/UNIX (somewhat simplified)

• The state running is split into the states…
  • user running for user mode processes
  • kernel running for kernel mode processes

POSIX

• POSIX (Portable Operating System Interface) is a family of IEEE standards for operating systems
• Aims for portability and compatibility of applications between different operating systems
• Defines user and system level APIs (application programming interfaces)
• Additionally it defines command line shells and utility interfaces
• It is based on UNIX
• There are few POSIX-certified OS (e.g., macOS, VxWorks, or AIX)
• Many OS (like Linux, FreeBSD, or Minix) are mostly POSIX compliant

POSIX Process Creation via fork

• In a POSIX system the system call fork() is the only way to create a new process
• If a process calls fork(), an identical copy is started as a new process
  • The calling process is called parent process
  • The new process is called child process
• Child process and parent process both have their own process context, but …
• all assigned resources (like opened files and memory areas) of the parent process are copied for the child process and are independent from the parent process
• The child process after creation runs the exactly same code
  • Since the program counters are identical as well both processes refer to the same line of code

Code example for fork on Linux

• If a process calls fork(), an exact copy is created
  • The processes differ only in the return values of fork()

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
void main(void) {
    int return_value = fork();
    if (return_value < 0) {
        // If fork() returns -1, an error happened.
        // Memory or processes table have no more free capacity.
        ...
    }
    if (return_value > 0) {
        // If fork() returns a positive number, we are in the parent process.
        // The return value is the PID of the newly created child process.
        ...
    }
    if (return_value == 0) {
        // If fork() returns 0, we are in the child process.
        ...
    }
}

Process Hierarchy of a POSIX System

• All processes on a POSIX system are spawned via fork()
• All processes are part of the same hierarchy

Process Tree

• Processes in a system form a tree of processes (\(\longrightarrow\) process hierarchy) based on the parent-child relationship

 $ ps fax
 1   ?        Ss     0:01 /usr/lib/systemd/systemd --switched-root --system
...
1211 ?        Ss     0:00 dhcpcd: [manager] [ip4] [ip6]
1214 ?        S      0:00  \_ dhcpcd: [privileged proxy]
7775 ?        S      0:00  |   \_ dhcpcd: [BPF ARP] enp0s31f6 10.2.0.190
7778 ?        S      0:00  |   \_ dhcpcd: [BPF ARP] wlan0 10.51.134.219
1215 ?        S      0:00  \_ dhcpcd: [network proxy]
1216 ?        S      0:00  \_ dhcpcd: [control proxy]
1339 ?        Ss     0:00 /usr/lib/systemd/systemd --user
1340 ?        S      0:00  \_ (sd-pam)
1465 ?        Ss     0:00  \_ /usr/bin/dbus-daemon --session --nofork
1511 ?        Ssl    0:00  \_ /usr/lib/at-spi-bus-launcher
1519 ?        S      0:00  |   \_ /usr/bin/dbus-daemon --address=unix:path=/run/user/1000/at-spi/bus

Information about processes in Linux/UNIX

$ ps -eFw
UID    PID  PPID  C    SZ   RSS PSR STIME TTY          TIME CMD
root     1     0  0  5456 12860   2 12:06 ?     00:00:01 /usr/lib/systemd/systemd
root  1311     1  0  1998  4992   4 12:06 ?     00:00:00 login -- oleg
oleg  1339     1  0  5110 11828   4 12:07 ?     00:00:00 /usr/lib/systemd/systemd --user
oleg  1347  1311  0 1122763 171300 0 12:07 tty1 00:00:51 sway
oleg  8031     1  0 285131 31908  3 13:16 ?     00:00:02 foot
oleg  8033  8031  0  4948 15160   7 13:16 pts/2 00:00:02 /usr/bin/zsh
oleg 14043     1  3 949647 569960 4 13:26 ?     00:01:33 /usr/lib/firefox/firefox
oleg 14077     1  0 261432 165640 2 13:26 tty1  00:00:06 Xwayland :0 -rootless -core 
oleg 22367     1  0 285340 35712  3 13:54 ?     00:00:01 foot
oleg 22369 22367  0  3710  9548   2 13:54 pts/1 00:00:00 /usr/bin/zsh
root 25003     2  0     0     0   6 14:05 ?     00:00:00 [kworker/6:2-events]
root 25097     2  0     0     0   0 14:05 ?     00:00:00 [kworker/0:2-i915-unordered]
oleg 25202 22369  0  3187  4564   3 14:05 pts/1 00:00:00 ps -eFw 

Parent and Child Processes

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main(void) {
    int i;
    if (fork())
    // Parent process source code
        for (i = 0; i < 5000000; i++)
            printf("\n Parent: \%i", i);
    else
    // Child process source code
        for (i = 0; i < 5000000; i++)
            printf("\n Child : \%i", i);
    return 0;
}

Child : 0
Child : 1
...
Child : 21019
Parent: 0
...
Parent: 50148
Child : 21020
...
Child : 129645
Parent: 50149
...
Parent: 855006
Child : 129646
...  

The PID Numbers of Parent and Child Process (1/2)

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
void main(void) {
    int pid_of_child;
    pid_of_child = fork();
    // An error occured --> program abort
    if (pid_of_child < 0) {
        perror("\n fork() caused an error!");
        exit(1);
    }
    // Parent process
    if (pid_of_child > 0) {
        printf("\n Parent: PID: %i", getpid());
        printf("\n Parent: PPID: %i", getppid());
    }
    // Child process
    if (pid_of_child == 0) {
        printf("\n Child:  PID: %i", getpid());
        printf("\n Child:  PPID: %i", getppid());
    }
} 

The PID Numbers of Parent and Child Process (2/2)

Replacing Processes via exec

• The system call exec() replaces a process with another one
  • The new process gets the PID of the calling process
• To start a new process, one need to …
  • call fork(), and then
  • call exec()

Another exec Example

#include <stdio.h>
#include <unistd.h>
int main(void) {
    int pid; 
    pid = fork();
    // If PID!=0 --> Parent process
    if (pid) {
        printf("...Parent process...\n");
        printf("[Parent] Own PID:           %d\n", getpid());
        printf("[Parent] PID of the child:  %d\n", pid);
    }
    // If PID=0 --> Child process
    else {
        printf("...Child process...\n");
        printf("[Child]  Own PID:           %d\n", getpid());
        printf("[Child]  PID of the parent: %d\n", getppid());
        // Current program is replaced by "date"
        // "date" will be the process name in the process table
        execl("/bin/date", "date", "-u", NULL);
    }
    printf("[%d ]Program abort\n", getpid());
    return 0;
} 

Explanation of the exec Example

$ ./exec_example
...Parent process...
[Parent] Own PID:           25646
[Parent] PID of the child:  25647
[25646 ]Program abort
...Child process...
[Child]  Own PID:           25647
[Child]  PID of the parent: 25646
Di 24. Mai 17:25:31 CEST 2016
$ ./exec_example 
...Parent process...
[Parent] Own PID:           25660
[Parent] PID of the child:  25661
[25660 ]Program abort
...Child process...
[Child]  Own PID:           25661
[Child]  PID of the parent: 1
Di 24. Mai 17:26:12 CEST 2016

• After printing its PID via getpid() and the PID of its parent process via getppid(), the child process is replaced via date

• If the parent process of a process terminates before the child process, the child process gets init as new parent process assigned :::

3 possible Ways to create a new Process

• Process forking: A running process creates with fork() a new, identical process
• Process chaining: A running process creates with exec() a new process and terminates itself this way because it gets replaced by the new process
• Process creation: A running process creates with fork() a new, identical process, which replaces itself via exec() by a new process

Have Fun with Fork Bombs

import os

while True:
    os.fork() 

#include <unistd.h>

int main(void)
{
    while(1)
    fork();
} 

<?php
  while(true)
    pcntl_fork();
?> 

Memory Layout of a Unix Process

$ size /bin/c*
text   data    bss     dec     hex filename
46480    620   1480   48580    bdc4 /bin/cat
7619    420     32    8071    1f87 /bin/chacl
55211    592    464   56267    dbcb /bin/chgrp
51614    568    464   52646    cda6 /bin/chmod
57349    600    464   58413    e42d /bin/chown
120319    868   2696  123883   1e3eb /bin/cp
131911   2672   1736  136319   2147f /bin/cpio

Summary