1. Overview of today’s lecture 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

2. Suspending Processes 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

3. Unix SVR4 Processes 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

4. Modes of Execution User mode  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

5. Operating System Control Structures Information about the current status of each process and resource Tables are constructed for each entity the operating system manages

6. Memory Tables 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

7. I/O Tables 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

8. File Tables Existence of files Location on secondary memory Current Status Attributes Sometimes this information is maintained by a file management system

9. Process Control Block Process identification  Identifiers Numeric identifiers that may be stored with the process control block include  Identifier of this process  Identifier of the process that created this process (parent process)  User identifier

10. Process Control Block 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.

11. Process Control Block 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

12. Process Control Block 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.

13. Process Control Block 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

14. Process Control Block Process Control Information  Data Structuring A process may be linked to other process in a queue, ring, or some other structure. For example, all processes in a waiting state for a particular priority level may be linked in a queue. A process may exhibit a parent-child (creator-created) relationship with another process. The process control block may contain pointers to other processes to support these structures.

15. Process Control Block Process Control Information  Inter-process Communication Various flags, signals, and messages may be associated with communication between two independent processes. Some or all of this information may be maintained in the process control block.  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.

16. fork : Creating new processes 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 if (fork() == 0) { printf("hello from child\n"); } else { printf("hello from parent\n"); } Fork is interesting (and often confusing) because it is called once but returns twice

17. Fork Example #1 void fork1() { int x = 1; pid_t pid = fork(); if (pid == 0) { printf("Child has x = %d\n", ++x); } else { printf("Parent has x = %d\n", --x); } printf("Bye from process %d with x = %d\n", getpid(), x); } Key Points  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

18. Fork Example #2 void fork2() { printf("L0\n"); fork(); printf("L1\n"); fork(); printf("Bye\n"); } Key Points  Both parent and child can continue forking L0 L1 Bye

19. Fork Example #3 void fork3() { printf("L0\n"); fork(); printf("L1\n"); fork(); printf("L2\n"); fork(); printf("Bye\n"); } Key Points  Both parent and child can continue forking L1L2 Bye L1L2 Bye L0

20. Fork Example #4 void fork4() { printf("L0\n"); if (fork() != 0) { printf("L1\n"); if (fork() != 0) { printf("L2\n"); fork(); } printf("Bye\n"); } Key Points  Both parent and child can continue forking L0 L1 Bye L2 Bye

21. Fork Example #5 void fork5() { printf("L0\n"); if (fork() == 0) { printf("L1\n"); if (fork() == 0) { printf("L2\n"); fork(); } printf("Bye\n"); } Key Points  Both parent and child can continue forking L0 Bye L1 Bye L2

22. exit : Destroying Process 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); }

23. Zombies 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

24. linux>./forks 7 & [1] 6639 Running Parent, PID = 6639 Terminating Child, PID = 6640 linux> ps PID TTY TIME CMD 6585 ttyp9 00:00:00 tcsh 6639 ttyp9 00:00:03 forks 6640 ttyp9 00:00:00 forks 6641 ttyp9 00:00:00 ps linux> kill 6639 [1] Terminated linux> ps PID TTY TIME CMD 6585 ttyp9 00:00:00 tcsh 6642 ttyp9 00:00:00 ps Zombie Example  ps shows child process as “defunct”  Killing parent allows child to be reaped void fork7() { if (fork() == 0) { /* Child */ printf("Terminating Child, PID = %d\n", getpid()); exit(0); } else { printf("Running Parent, PID = %d\n", getpid()); while (1) ; /* Infinite loop */ }

25. linux>./forks 8 Terminating Parent, PID = 6675 Running Child, PID = 6676 linux> ps PID TTY TIME CMD 6585 ttyp9 00:00:00 tcsh 6676 ttyp9 00:00:06 forks 6677 ttyp9 00:00:00 ps linux> kill 6676 linux> ps PID TTY TIME CMD 6585 ttyp9 00:00:00 tcsh 6678 ttyp9 00:00:00 ps Non-terminating Child Example Child process still active even though parent has terminated  Must kill explicitly, or else will keep running indefinitely void fork8() { if (fork() == 0) { /* Child */ printf("Running Child, PID = %d\n", getpid()); while (1) ; /* Infinite loop */ } else { printf("Terminating Parent, PID = %d\n", getpid()); exit(0); }

26. wait : Synchronizing with children int wait(int *child_status)  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

27. wait : Synchronizing with children void fork9() { int child_status; if (fork() == 0) { printf("HC: hello from child\n"); } else { printf("HP: hello from parent\n"); wait(&child_status); printf("CT: child has terminated\n"); } printf("Bye\n"); exit(); } HP HCBye CTBye

28. Wait Example  If multiple children completed, will take in arbitrary order  Can use macros WIFEXITED and WEXITSTATUS to get information about exit status void fork10() { pid_t pid[N]; int i; int child_status; for (i = 0; i < N; i++) if ((pid[i] = fork()) == 0) exit(100+i); /* Child */ 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); }

29. Waitpid  waitpid(pid, &status, options) Can wait for specific process Various options void fork11() { pid_t pid[N]; int i; int child_status; for (i = 0; i < N; i++) if ((pid[i] = fork()) == 0) exit(100+i); /* Child */ 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); }

30. Wait/Waitpid Example Outputs 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 )

31. exec : Running new programs 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! main() { if (fork() == 0) { execl("/usr/bin/cp", "cp", "foo", "bar", 0); } wait(NULL); printf("copy completed\n"); exit(); }