Operating Systems 1 (6/12) - Processes

Processes

Beuth HochschuleSummer Term 2014!Pictures (C) W. Stallings, if not stated otherwise

Operating Systems I PT / FF 14

Operating System Concepts

• Computer platform as collection of hardware resources

• Applications are executed to perform some task

• Developing for one hardware platform is inefficient - portability through abstraction

• Resources are made available to multiple applications

• Multi-processing and multi-tasking

• Processor is switched among multiple applications to allow progress for all of them

• Shared memory is made available to all processes in an ordered fashion

2

Computer Hardware

Operating System

Utilities

Application Programs

End User

Programmer

OS Designer

(C) Stallings 2004


Basic Concept: Process

• Unit of execution in operating system is traditionally a process

• Term introduced with MULTICS in the 60‘s to generalize job concept

• Instance of an executed program binary

• Management of multiple running processes is a core operating system task

• Concurrent utilization of resources demands some management

• Operating system must prevent independent processes from mutual code and data access (isolation)

• Sharing should be explicitly allowable under given security constraints

• Same holds for devices offering resources (storage, communication, ...)

3


Process Image• Collection of process information is often called image

• Context / execution state

• Status information in the CPU for time sharing

• Management information, such as priority, security tokens and call stacks

• Program code

• Potentially shared between running processes(e.g. libraries)

• Associated system resources

• Must be subject to security checks

• Data

4


Life of a Process• Reasons for process creation

• New application / job start

• Interactive logon by a user

• Operating system service is started (e.g. printer spooler)

• Spawned by an existing process - parent process vs. child process

• Reasons for process termination

• Completion signaled by process itself - HALT instruction, system call, return jump

• Indication from the user in an interactive process

• Request from parent process or administrator

• Failure condition - execution time limits, lack of memory, protection error, arithmetic error, I/O failure, invalid instruction, privileged instruction, parent termination, ...

5


Process Control Block

• A process is internally characterized by a process control block

• Unique identifier

• Execution state (e.g. running, suspended, terminated)

• Priority level in comparison to other processes

• CPU context state related to this process, such as the program counter

• Memory regions for code and data used by the process

• I/O status information, such as outstanding requests, devices and open files

• Accounting information: time limits, clock time used, ...

• Security information, e.g. process owner6


Process Control Block

• Contains all the process information needed by the operating system

• Is read and / or modified by many parts of the kernel

• Protection of these structures is crucial, but fast access must still be possible

• Process creation involves:

• Assignment of a new unique process identifier

• Allocation of memory for the process

• Initialization of a new process control block

• Adding the control block into management structures, e.g. for dispatching

• Loading necessary data (code, libraries) into the allocated memory space

7


Processes and Resources

• Operating system manages the use of system resources by processes(processor cycles, main memory, I/O devices)

• Resource allocation is permanently changing, system needs management tables

• Handles and identifiers work as indexin the management tables

8


Resource Tables

• Memory tables

• Keep track of physical memory and virtual memory per process

• Allocation of swapping space to processes

• Protection attributes

• I/O tables

• Status of current I/O operation

• Memory location being used as source or destination of the operation

• File tables

• Information about location and attributes of files may be managed by the kernel

• All operating system resource tables are subject to memory management too !

9


Dispatching

• Process control block

• Information allows the interruption and continuation of any given process at any given time

• Interruption is not directly visible to the application

• Multi-tasking is managed by the operating system

• Dispatcher

• Code that switches a processor from one process to another

• Relies on queue of ready-to-be-executed processes

• Most simple process state model:running vs. not running

10


Dispatching

• Process dispatching relies on some kind of execution interruption

• Interrupt: An external event triggers the execution of a handler function

• Clock interrupt, I/O interrupt, memory controller interrupt

• Trap: An error or exception condition occurred within the running process

• Typically noticed by hardware itself, such as the memory controller

• Operating system trap handler decides on necessary activity

• Processor hardware detects pending interrupt / trap

• Sets the program counter to the starting address of the interrupt handler

• Leads to switch from user to kernel mode, in order to allow privileged instructions

• Handler for the clock interrupt typically activates the dispatcher code

11


Dispatching

• Several steps for a process switch

• Save the context of the processor

• Update the control block of the running process to reflect the state change

• Add a reference to this control block in the appropriate queue

• Select another process for execution

• Update the control block of the selected process

• Update memory management data structures

• Restored the saved processor context of the selected process,including program counter

12


Five-State Process Model

13

• Waiting for something renders a process unusable for dispatching

• Examples: Blocking system call, synchronization primitives

• Single queue approach is inappropriatein practice

• Extension of state model

• Dispatch queue contains only processes in „ready“ state

• Explicit consideration of preparation phase in the operating system kernel(code loading, memory allocation, ...)

• Explicit consideration of blocked (not-runnable) processes


Operating System within the User Process

• Separation between user stack and kernel stack for different modes

• Mode switch happens within the same process

• Dispatching may take place during user mode or kernel mode operation

• Wake-up after event wait (e.g. system call) does not demand additional context switch activities

• Even though operating system code is executed in the user‘s process environment, isolation is still guaranteed

• Distribution of processes over multiple processors effectively distributes the operating system activities

• Became default for Unix since SVR4, meanwhile also for all other modern operating systems

14


Unix SVR4: Process States

15

User Running Executing, in user mode

Kernel Running Executing, in kernel mode

Ready to Run, in Memory Ready to run as soon as being chosen

Asleep in Memory Waiting for an event, unable to execute

Ready to Run, Swapped Ready to run, but still not in memory

Sleeping, Swapped Waiting for an event, unable to execute, swapped out

Preempted Returning from kernel mode, but the kernel switched to another one

Created Process is newly created, not ready to run so far

Zombie Process is gone with his resource allocations, but record is left for parent process

Same dispatch queue


Unix SVR4: Process States

16


Linux: Process Control Block

• include/sched.h

• Relevant data structure task_struct for process management

• Status and execution information, files being used, information about interprocess communication, signal handlers, ...

• List of possible task states

• TASK_RUNNING, TASK_STOPPED, TASK_ZOMBIE

• TASK_INTERRUPTIBLE: Waits for an event, can be interrupted by a signal

• TASK_UNINTERRUPTIBLE: Suspended by kernel, no wakeup from signals

• Typically stucked in a system call that cannot be interrupted by a signal handler in user mode

17


Windows: Process Control Block

18

Quota&Block&

Exit&Status&

Primary&Access&Token&

Process&ID&

Parent&Process&ID&

Excep;on&Port&

Debugger&Port&

Handle&Table&

Process&Environment&Block&

Create&and&Exit&Time&

Next&Process&Block&

Image&File&Name&

Process&Priority&Class&

Memory&Management&Informa;on&

EPROCESS&

Kernel&Process&Block&(or&PCB)&

Image&Base&Address&

Win32&Process&Block&

Dispatcher&Header&

Processor&Affinity&

Kernel&Time&

User&Time&

Inwwap/Outswap&List&Entry&

Process&Spin&Lock&

Resident&Kernel&Stack&Count&

Process&Base&Priority&

Default&Thread&Quantum&

Process&State&

Thread&Seed&

Disable&Boost&Flag&

Process&Page&Directory&

KTHREAD& ."."."

(C) Russinovich et al.


Unix: Process Creation

• Forking: Fundamental Unix concept, difference to VMS / Windows

• Child processes come to live as copy of their parent processes

• A new unique ID is created

• The operating system adds the new process to the management tables

• The process image of the parent is copied

• Shared memory regions are always left out

• Modern fork() variations can copy only parts of it

• Reference counters for parent-owned resources are increased

• Child process state is changed to ready to run

• fork() system call returns the process ID of the newly created child to the parent

19

20 Process Tree in Unix

21

#include <stdio.h>!#include <unistd.h>!#include <stdlib.h> !int main ()!{! int pid, j, i; ! pid = fork();! if (pid == 0)! {! /* child */! for (j=0; j < 10; j++) {! printf ("Child process: %d (PID: %d)\n", j, getpid());! sleep (1);! }! exit (0);! } else if (pid > 0) { ! /* parent */! for (i=0; i < 10; i++) {! printf ("Parent process: %d (PID: %d)\n", i, getpid());! sleep (1);! }! } else { ! /* Negative result means we have a problem */! fprintf (stderr, "Error");! exit (1);! }! return 0;!}


Unix: Process Creation

• vfork() system call

• Lazy copy mechanism, intended for the case where the child calls exec immediately after forking

• clone() system call (e.g. in Linux)

• Child process can share configurable amount of resources with parent

• Used to implement a thread concept without changing the kernel

• execve() system call

• Transforms the calling process into a new process

• File descriptors, security descriptors and signal configuration is inherited

• fork / exec is an established pattern for process creation in Unix systems


Windows: Process Creation

• The Windows subsystem has no understanding of parent / child relationship

• But the operating system kernel has !!!

• CreateProcess() system call

• Similar to fork() / execve()combination

• No process group concept

• Since processes are objects,they have handles

• Universal waiting functionfor all Windows handlesallows to wait for process termination - WaitForSingleObject()

23

BOOL$CreateProcess($$$$$LPCSTR$lpApplica6onName,$$$$$LPSTR$lpCommandLine,$$$$$LPSECURITY_ATTRIBUTES$lpProcessAAributes,$$$$$LPSECURITY_ATTRIBUTES$lpThreadAAributes,$$$$$BOOL$bInheritHandles,$$$$$DWORD$dwCrea6onFlags,$$$$$LPVOID$lpEnvironment,$$$$$LPCSTR$lpCurrentDirectory,$$$$$LPSTARTUPINFO$lpStartupInfo,$$$$$LPPROCESS_INFORMATION$lpProcessInforma6on)$


Windows: Why Do Processes Exit ?

• Application normally decides to terminate (ExitProcess)

• Request from graphical user interface

• Windows C library calls ExitProcess() when the main() function returns

• Desktop can request an orderly exit

• Task manager sends WM_CLOSE message to the window‘s message loop

• Forced termination by TerminateProcess() system call

• 5 seconds after an orderly exit request, the Desktop asks the user for allowance

• Task manager: „End Process“

• Unhandled exceptions catched by the operating system itself

24


Windows: Processes during System Start

25

Process'Based+Windows+Code:

System+Startup+Processes+(cont.)smss.exe Session+Manager

�� Takes+parameters+from+\HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session+Manager

Launches+required+subsystems+(csrss)+and+then+winlogoncsrss.exe Windows+subsystemwinlogon.exe Logon+process:+Launches+services.exe+&+lsass.exe;+presents+first+login+

promptWhen+someone+logs+in,+launches+apps+in+\Software\Microsoft\Windows+NT\WinLogon\Userinit

services.exe Service+Controller;+also,+home+for+many+Windows'supplied+servicesStarts+processes+for+services+not+part+of+services.exe+(driven+by+\Registry\Machine\System\CurrentControlSet\Services+)

lsass.exe Local+Security+Authentication+Serveruserinit.exe Started+after+logon;+starts+Explorer.exe+(see+

\Software\Microsoft\Windows+NT\CurrentVersion\WinLogon\Shell)+and+exits+(hence+Explorer+appears+to+be+an+orphan)

explorer.exe and+its+children+are+the+creators+of+all+interactive+apps58(C) Russinovich et al.


Jobs / Process Groups• Jobs in Windows are collections of processes

• Can be used to enable control over some unique settings (total CPU time, memory usage, run-time restrictions, security restrictions, scheduling settings, ...)

• How do processes become part of a job?

• Job object has to be created (CreateJobObject)

• Then processes are explicitly added (AssignProcessToJob)

• Processes created by processes in a job automatically are part of the job

• Unless restricted, processes can “break away” from a job

• Counter part in Unix are process groups, traditional and feature-rich concept

• Process groups are grouped into sessions

• exec() system calls inherit process group and session membership

26


Services and Daemons

• Operating system code running in user processes is default

• Still demands permanently running (operating system) activities

• Windows: Core system processes (e.g. csrss.exe, lsass.exe), service processes

• Unix: Daemons

• Services and daemons haveno direct user interface

• Executed with specializedsecurity credentials,independent from currentuser

• Managed by operatingsystem mechanisms

27

Life%of%a%Service

� Install%time� Setup%application%tells%Service%Controller%

about%the%service

� System%boot/initialization� SCM%reads%registry,%starts

services%as%directed

� Management/maintenance� Control%panel%can%start%and%stop%services%

and%change%startup%parameters

52

ServiceController/Manager

(Services.Exe)

SetupApplication

CreateServiceRegistry

ServiceProcesses

ControlPanel (C) Russinovich et al.


Summary

• Processes are the traditional foundation for operating systems

• Representation of a running application

• Kernel performs dispatching between multiple running processes

• Process creation and termination are complex tasks

• Kernel manages the resources available to the processes

• Unix systems have the process tree concept

• fork() / exec() programming model

• NT kernel has also parent / child notion for processes

• Not reflected in Windows subsystem, therefore not part of the programming model

• Today, processes mainly provide a capsule for multiple execution threads

28

Education

Operating Systems 1 (6/12) - Processes