Advanced Operating Systems: Lecture 5 - Mr. Farhan Zaidi

Advanced Operating Systems - Lecture 5: Suspending processes. This lecture will cover the following: process management models and state machines (cont’d from the previous lecture); what is in a process control block; operating system calls for process management in UNIX family of systems;...

 Re-view of the previous lecture

 Process management models and state machines (cont’d from the previous lecture)

 What is in a process control block

 Operating system calls for process management in UNIX family of systems

 Example programs invoking OS services for process management

 Re-cap of lecture

 May suspend a process by swapping part or all of it to disk

 Most useful if we are waiting for an event that will not arrive soon (printer, keyboard)

 If not done well, can slow system down by increasing disk I/O activity

 State Transition Diagram

 Key States:

 Ready – In memory, ready to execute

 Blocked – In memory, waiting for an event

 Blocked Suspend – On disk, waiting for an event

 Ready Suspend – On disk, ready to execute

 Uses 9 processes states

 Preempted and Ready to run, in memory are nearly identical

 A process may be preempted for a higher-priority process at the end of a system call

 Zombie – Saves information to be passed to the parent of this process

 Process 0 – Swapper, created at boot

 Process 1 – Init, creates other processes

 Less-privileged mode

 User programs typically execute in this mode

 System mode, control mode, or kernel mode

 More-privileged mode

 Kernel of the operating system

 Allocation of main memory to processes

 Allocation of secondary memory to processes

 Protection attributes for access to shared memory regions

 Information needed to manage virtual memory

 I/O device is available or assigned

 Status of I/O operation

 Location in main memory being used as the source or destination of the I/O transfer

 Sometimes this information is maintained by

a file management system

 Identifier of this process

 Identifier of the process that created this process (parent process)

 User identifier

 Processor State Information

 User-Visible Registers

 A user-visible register is one that may be

referenced by means of the machine language that the processor executes while in user mode Typically, there are from 8 to 32 of these

registers, although some RISC implementations have over 100

 Processor State Information

 Control and Status Registers

These are a variety of processor registers that are employed to control the operation of the processor

These include

 Program counter: Contains the address of the next

instruction to be fetched

 Condition codes: Result of the most recent arithmetic or

logical operation (e.g., sign, zero, carry, equal, overflow)

 Status information: Includes interrupt enabled/disabled

flags, execution mode

 Processor State Information

 Stack Pointers

 Each process has one or more last-in-first-out (LIFO)

system stacks associated with it A stack is used to store parameters and calling addresses for procedure and

system calls The stack pointer points to the top of the stack

 Process Control Information

 Scheduling and State Information

This is information that is needed by the operating system to perform its scheduling function Typical items of information:

Process state : defines the readiness of the process to be

scheduled for execution (e.g., running, ready, waiting, halted)

Priority : One or more fields may be used to describe the

scheduling priority of the process In some systems, several values are required (e.g., default, current, highest-allowable)

Scheduling-related information : This will depend on the

scheduling algorithm used Examples are the amount of time that the process has been waiting and the amount of time that the process executed the last time it was running

Event: Identity of event the process is awaiting before it can be resumed

processes to support these structures

 Process Privileges

 Processes are granted privileges in terms of the memory that may be accessed and the types of instructions that may be executed In addition, privileges may apply to the use of system utilities and services

 int fork(void)

 creates a new process (child process) that is identical to the

calling process (parent process)

 returns 0 to the child process

 returns child’s pid to the parent process

once but returns twice

 Parent and child both run same code

 Distinguish parent from child by return value from fork

 Start with same state, but each has private copy

 Including shared output file descriptor

 Relative ordering of their print statements undefined

Bye Bye Bye Bye

L0

fork();

} }

fork();

} }

Bye L2

 void exit(int status)

 exits a process

 Normally return with status 0

 atexit() registers functions to be executed upon exit

void cleanup(void) { printf("cleaning up\n");

}

void fork6() { atexit(cleanup);

fork();

exit(0);

}

 Idea

 When process terminates, still consumes system resources

 Various tables maintained by OS

 Called a “zombie”

 Living corpse, half alive and half dead

 Reaping

 Performed by parent on terminated child

 Parent is given exit status information

 Kernel discards process

 What if Parent Doesn’t Reap?

 If any parent terminates without reaping a child, then child will be reaped by init process

 Only need explicit reaping for long-running processes

 E.g., shells and servers

linux> /forks 7 &

[1] 6639

Running Parent, PID = 6639

Terminating Child, PID = 6640

 Killing parent allows child to be reaped

void fork7() {

} }

linux> /forks 8

Terminating Parent, PID = 6675

Running Child, PID = 6676

 Must kill explicitly, or else will keep running

indefinitely

void fork8() {

 suspends current process until one of its children terminates

 return value is the pid of the child process that terminated

 if child_status != NULL, then the object it

points to will be set to a status indicating why the child process terminated

 If multiple children completed, will take in arbitrary order

 Can use macros WIFEXITED and WEXITSTATUS to get

information about exit status

for (i = 0; i < N; i++) {

pid_t wpid = wait(&child_status);

if (WIFEXITED(child_status)) printf("Child %d terminated with exit status

%d\n",

wpid, WEXITSTATUS(child_status));

else printf("Child %d terminate abnormally\n", wpid); }

}

 waitpid(pid, &status, options)

 Can wait for specific process

for (i = 0; i < N; i++) {

pid_t wpid = waitpid(pid[i], &child_status, 0);

if (WIFEXITED(child_status)) printf("Child %d terminated with exit status %d\n",

wpid, WEXITSTATUS(child_status));

else printf("Child %d terminated abnormally\n", wpid); }

Child 3565 terminated with exit status 103 Child 3564 terminated with exit status 102 Child 3563 terminated with exit status 101 Child 3562 terminated with exit status 100 Child 3566 terminated with exit status 104

Child 3568 terminated with exit status 100 Child 3569 terminated with exit status 101 Child 3570 terminated with exit status 102 Child 3571 terminated with exit status 103 Child 3572 terminated with exit status 104

Using wait ( fork10 )

Using waitpid ( fork11 )

 int execl(char *path, char *arg0, char *arg1, …, 0)

 loads and runs executable at path with args arg0, arg1, …

 path is the complete path of an executable

 arg0 becomes the name of the process

 typically arg0 is either identical to path, or else it contains only the executable filename from path

 “real” arguments to the executable start with arg1, etc.

 list of args is terminated by a (char *)0 argument

 returns -1 if error, otherwise doesn’t return!