0% found this document useful (0 votes)
8 views46 pages

09 Processes

The document discusses processes as an important abstraction in computer systems. It covers control flow and exceptional control flow, including interrupts and exceptions. It also discusses how processes are created and how a process can create new processes using fork and wait.

Uploaded by

oreh2345
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
8 views46 pages

09 Processes

The document discusses processes as an important abstraction in computer systems. It covers control flow and exceptional control flow, including interrupts and exceptions. It also discusses how processes are created and how a process can create new processes using fork and wait.

Uploaded by

oreh2345
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 46

University of Washington

Roadmap Data & addressing


Integers & floats
Machine code & C
C: Java:
x86 assembly
car *c = malloc(sizeof(car)); Car c = new Car(); Procedures & stacks
c->miles = 100; c.setMiles(100);
Arrays & structs
c->gals = 17; c.setGals(17);
float mpg = get_mpg(c); float mpg =
Memory & caches
free(c); c.getMPG(); Processes
Virtual memory
Assembly get_mpg: Memory allocation
language: pushq %rbp Java vs. C
movq %rsp, %rbp
...
popq %rbp
ret
OS:
Machine 0111010000011000
100011010000010000000010
code: 1000100111000010
110000011111101000011111

Computer
system:

Autumn 2013 Processes 1


University of Washington

Processes – another important abstraction


¢ First some preliminaries
§ Control flow
§ Exceptional control flow
§ Asynchronous exceptions (interrupts)
¢ Processes
§ Creating new processes
§ Fork and wait
§ Zombies

Autumn 2013 Processes 2


University of Washington

Control Flow
¢ So far, we’ve seen how the flow of control changes as a single
program executes
¢ A CPU executes more than one program at a time though – we
also need to understand how control flows across the many
components of the system

¢ Exceptional control flow is the basic mechanism used for:


§ Transferring control between processes and OS
§ Handling I/O and virtual memory within the OS
§ Implementing multi-process applications like shells and web servers
§ Implementing concurrency

Autumn 2013 Processes 3


University of Washington

Control Flow
¢ Processors do only one thing:
§ From startup to shutdown, a CPU simply reads and executes
(interprets) a sequence of instructions, one at a time
§ This sequence is the CPU’s control flow (or flow of control)

Physical control flow


<startup>
inst1
inst2
time
inst3

instn
<shutdown>
Autumn 2013 Processes 4
University of Washington

Altering the Control Flow


¢ Up to now: two ways to change control flow:
§ Jumps (conditional and unconditional)
§ Call and return
Both react to changes in program state
¢ Processor also needs to react to changes in system state
§ user hits “Ctrl-C” at the keyboard
§ user clicks on a different application’s window on the screen
§ data arrives from a disk or a network adapter
§ instruction divides by zero
§ system timer expires
¢ Can jumps and procedure calls achieve this?
§ Jumps and calls are not sufficient – the system needs mechanisms for
“exceptional” control flow!

Autumn 2013 Processes 5


University of Washington

Exceptional Control Flow


¢ Exists at all levels of a computer system
¢ Low level mechanisms
§ Exceptions
§change processor’s in control flow in response to a system event
(i.e., change in system state, user-generated interrupt)
§ Combination of hardware and OS software
¢ Higher level mechanisms
§ Process context switch
§ Signals – you’ll hear about these in CSE451 and CSE466
§ Implemented by either:
§ OS software
§ C language runtime library

Autumn 2013 Processes 6


University of Washington

Exceptions
¢ An exception is transfer of control to the operating system (OS)
in response to some event (i.e., change in processor state)
User Process OS

event current_instr exception


next_instr exception processing
by exception
handler
• return to current_instr
• return to next_instr
• abort

¢ Examples:
div by 0, page fault, I/O request completes, Ctrl-C
¢ How does the system know where to jump to in the OS?

Autumn 2013 Processes 7


University of Washington

Interrupt Vectors
Exception
numbers

code for ¢ Each type of event has a


exception handler 0 unique exception number k
Exception code for
Table exception handler 1 ¢ k = index into exception table
0 (a.k.a. interrupt vector)
1 code for
2 exception handler 2
... ¢ Handler k is called each time
n-1 ... exception k occurs

code for
exception handler n-1

basically a jump table for exceptions…


Autumn 2013 Processes 8
University of Washington

Asynchronous Exceptions (Interrupts)


¢ Caused by events external to the processor
§ Indicated by setting the processor’s interrupt pin(s) (wire into CPU)
§ Handler returns to “next” instruction
¢ Examples:
§ I/O interrupts
§ hitting Ctrl-C on the keyboard
§ clicking a mouse button or tapping a touchscreen
§ arrival of a packet from a network
§ arrival of data from a disk
§ Hard reset interrupt
§ hitting the reset button on front panel
§ Soft reset interrupt
§ hitting Ctrl-Alt-Delete on a PC

Autumn 2013 Processes 9


University of Washington

Synchronous Exceptions
¢ Caused by events that occur as a result of executing an
instruction:
§ Traps
§Intentional: transfer control to OS to perform some function
§ Examples: system calls, breakpoint traps, special instructions
§ Returns control to “next” instruction
§ Faults
§ Unintentional but possibly recoverable
§ Examples: page faults (recoverable), segment protection faults
(unrecoverable), integer divide-by-zero exceptions (unrecoverable)
§ Either re-executes faulting (“current”) instruction or aborts
§ Aborts
§ Unintentional and unrecoverable
§ Examples: parity error, machine check (hardware failure detected)
§ Aborts current program
Autumn 2013 Processes 10
University of Washington

Trap Example: Opening File


¢ User calls: open(filename, options)
¢ Function open executes system call instruction int
0804d070 <__libc_open>:
. . .
804d082: cd 80 int $0x80
804d084: 5b pop %ebx
. . .

User Process OS

int exception
pop
open file
returns

¢ OS must find or create file, get it ready for reading or writing


¢ Returns integer file descriptor
Autumn 2013 Processes 11
University of Washington

Fault Example: Page Fault


int a[1000];
¢ User writes to memory location main ()
{
¢ That portion (page) of user’s memory a[500] = 13;
is currently on disk }

80483b7: c7 05 10 9d 04 08 0d movl $0xd,0x8049d10

User Process OS

exception: page fault


movl
Create page and
returns load into memory

¢ Page handler must load page into physical memory


¢ Returns to faulting instruction: mov is executed again!
¢ Successful on second try
Autumn 2013 Processes 12
University of Washington

Fault Example: Invalid Memory Reference


int a[1000];
main ()
{
a[5000] = 13;
}

80483b7: c7 05 60 e3 04 08 0d movl $0xd,0x804e360

User Process OS

exception: page fault


movl
detect invalid address
signal process

¢ Page handler detects invalid address


¢ Sends SIGSEGV signal to user process
¢ User process exits with “segmentation fault”
Autumn 2013 Processes 13
University of Washington

Exception Table IA32 (Excerpt)

Exception Number Description Exception Class


0 Divide error Fault
13 General protection fault Fault
14 Page fault Fault
18 Machine check Abort
32-127 OS-defined Interrupt or trap
128 (0x80) System call Trap
129-255 OS-defined Interrupt or trap

http://download.intel.com/design/processor/manuals/253665.pdf

Autumn 2013 Processes 14


University of Washington

Summary
¢ Exceptions
§ Events that require non-standard control flow
§ Generated externally (interrupts) or internally (traps and faults)
§ After an exception is handled, one of three things may happen:
§ Re-execute the current instruction
§ Resume execution with the next instruction
§ Abort the process that caused the exception

Autumn 2013 Processes 15


University of Washington

What is a process?

¢ What is a program? A processor? A process?

Autumn 2013 Processes 16


University of Washington

What is a process?
¢ Why are we learning about processes?
§ Processes are another abstraction in our computer system – the
process abstraction provides an interface between the program and the
underlying CPU + memory.
¢ What do processes have to do with exceptional control flow
(previous lecture)?
§ Exceptional control flow is the mechanism that the OS uses to enable
multiple processes to run on the same system.

Autumn 2013 Processes 17


University of Washington

Processes
¢ Definition: A process is an instance of a running program
§ One of the most important ideas in computer science
§ Not the same as “program” or “processor”

¢ Process provides each program with two key abstractions:


§ Logical control flow
§ Each process seems to have exclusive use of the CPU
§ Private virtual address space
§ Each process seems to have exclusive use of main memory

¢ Why are these illusions important?


¢ How are these illusions maintained?
§ Process executions interleaved (multi-tasking)
§ Address spaces managed by virtual memory system – next course topic
Autumn 2013 Processes 18
University of Washington

Concurrent Processes
¢ Two processes run concurrently (are concurrent) if their
instruction executions (flows) overlap in time
¢ Otherwise, they are sequential
¢ Examples:
§ Concurrent: A & B, A & C
§ Sequential: B & C
Process A Process B Process C

time

Autumn 2013 Processes 19


University of Washington

User View of Concurrent Processes


¢ Control flows for concurrent processes are physically disjoint
in time
§ CPU only executes instructions for one process at a time
¢ However, we can think of concurrent processes as executing
in parallel

Process A Process B Process C

time

Autumn 2013 Processes 20


University of Washington

Context Switching
¢ Processes are managed by a shared chunk of OS code
called the kernel
§ Important: the kernel is not a separate process, but rather runs as part
of a user process
¢ Control flow passes from one process to another via a context
switch… (how?)
Process A Process B

user code

kernel code context switch


time user code

kernel code context switch

user code

Autumn 2013 Processes 21


University of Washington

Creating New Processes & Programs


¢ fork-exec model:
§ fork() creates a copy of the current process
§ execve() replaces the current process’ code & address space with
the code for a different program

¢ fork() and execve() are system calls


§ Note: process creation in Windows is slightly different from Linux’s
fork-exec model

¢ Other system calls for process management:


§ getpid()
§ exit()
§ wait() / waitpid()

Autumn 2013 Processes 22


University of Washington

fork: Creating New Processes


¢ pid_t fork(void)
§ creates a new process (child process) that is identical to the calling
process (parent process), including all state (memory, registers, etc.)
§ returns 0 to the child process
§ returns child’s process ID (pid) to the parent process
pid_t pid = fork();
if (pid == 0) {
printf("hello from child\n");
} else {
printf("hello from parent\n");
}

¢ fork is unique (and often confusing) because it is called once


but returns twice

Autumn 2013 Processes 23


University of Washington

Understanding fork
Process n
pid_t pid = fork();
if (pid == 0) {
printf("hello from child\n");
} else {
printf("hello from parent\n");
}

Autumn 2013 Processes 24


University of Washington

Understanding fork
Process n Child Process m
pid_t pid = fork(); pid_t pid = fork();
if (pid == 0) { if (pid == 0) {
printf("hello from child\n"); printf("hello from child\n");
} else { } else {
printf("hello from parent\n"); printf("hello from parent\n");
} }

Autumn 2013 Processes 25


University of Washington

Understanding fork
Process n Child Process m
pid_t pid = fork(); pid_t pid = fork();
if (pid == 0) { if (pid == 0) {
printf("hello from child\n"); printf("hello from child\n");
} else { } else {
printf("hello from parent\n"); printf("hello from parent\n");
} }

pid_t pid = fork(); pid_t pid = fork();


if (pid == 0) { if (pid == 0) {
pid = m printf("hello from child\n"); pid = 0 printf("hello from child\n");
} else { } else {
printf("hello from parent\n"); printf("hello from parent\n");
} }

Autumn 2013 Processes 26


University of Washington

Understanding fork
Process n Child Process m
pid_t pid = fork(); pid_t pid = fork();
if (pid == 0) { if (pid == 0) {
printf("hello from child\n"); printf("hello from child\n");
} else { } else {
printf("hello from parent\n"); printf("hello from parent\n");
} }

pid_t pid = fork(); pid_t pid = fork();


if (pid == 0) { if (pid == 0) {
pid = m printf("hello from child\n"); pid = 0 printf("hello from child\n");
} else { } else {
printf("hello from parent\n"); printf("hello from parent\n");
} }

pid_t pid = fork(); pid_t pid = fork();


if (pid == 0) { if (pid == 0) {
printf("hello from child\n"); printf("hello from child\n");
} else { } else {
printf("hello from parent\n"); printf("hello from parent\n");
} }

hello from parent Which one is first? hello from child


Autumn 2013 Processes 27
University of Washington

Fork Example
¢ Parent and child both run the same code
§ Distinguish parent from child by return value from fork()
§ Which runs first after the fork() is undefined
¢ Start with same state, but each has a private copy
§ Same variables, same call stack, same file descriptors, same register
contents, same program counter…
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);
}
Autumn 2013 Processes 28
University of Washington

Exec-ing a new program


Stack

Very high-level diagram of what


happens when you run the
Heap command ”ls” in a Linux shell:
Data
Code: /usr/bin/bash
fork():
parent child child
Stack
Stack Stack

exec():

Heap Heap
Data Data Data
Code: /usr/bin/bash Code: /usr/bin/bash Code: /usr/bin/ls
Autumn 2013 Processes 29
University of Washington

execve: Loading and Running Programs


Stack bottom
Null-terminated
¢ int execve( env var strings
char *filename,
Null-terminated
char *argv[], cmd line arg strings
char *envp[] unused
) envp[n] == NULL
¢ Loads and runs in current process: envp[n-1]
§ Executable filename …
envp[0]
§ With argument list argv
argv[argc] == NULL
§ And environment variable list envp argv[argc-1]
§ Env. vars: “name=value” strings …
(e.g. “PWD=/homes/iws/bpw”) argv[0]
¢ execve does not return (unless error) Linker vars
envp
¢ Overwrites code, data, and stack argv
§ Keeps pid, open files, a few other items argc
Stack frame for
Autumn 2013 Processes
main Stack top 30
University of Washington

execve: Example

envp[n] = NULL
envp[n-1] “PWD=/homes/iws/gaetano”
… “PRINTER=ps581”
envp[0] “USER=gaetano”

argv[argc] = NULL
argv[argc-1] “/usr/include”
… “-l”
argv[0] “ls”

Autumn 2012 Exceptional Control and Processes 31


University of Washington

exit: Ending a process


¢ void exit(int status)
§ Exits a process
§Status code: 0 is used for a normal exit, nonzero for abnormal exit
§ atexit() registers functions to be executed upon exit

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

void fork6() {
atexit(cleanup);
fork(); function pointer
exit(0);
}

Autumn 2013 Processes 32


University of Washington

Zombies
¢ Idea
§ When process terminates, it still consumes system resources
Various tables maintained by OS
§
§ Called a “zombie”
§ A 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 (pid == 1)
§ But in long-running processes we need explicit reaping
§ e.g., shells and servers
Autumn 2013 Processes 33
University of Washington

wait: Synchronizing with Children


¢ int wait(int *child_status)
§ Suspends current process (i.e. the parent) until one of its children
terminates
§ Return value is the pid of the child process that terminated
§ On successful return, the child process is reaped
§ If child_status != NULL, then the int that it points to will be set
to a status indicating why the child process terminated
§ NULL is a macro for address 0, the null pointer
§ There are special macros for interpreting this status – see wait(2)

¢ If parent process has multiple children, wait() will return


when any of the children terminates
§ waitpid() can be used to wait on a specific child process

Autumn 2013 Processes 34


University of Washington

wait Example
void fork_wait() {
int child_status;
pid_t child_pid;

if (fork() == 0) { HC Bye
printf("HC: hello from child\n");
} else {
child_pid = wait(&child_status); CT Bye
printf("CT: child %d has terminated\n”,
child_pid);
}
printf("Bye\n");
exit(0);
}

Autumn 2013 Processes 35


University of Washington

Process management summary


¢ fork gets us two copies of the same process (but fork()
returns different values to the two processes)
¢ execve has a new process substitute itself for the one that
called it
§ Two-process program:
§ First fork()
§ if (pid == 0) { /* child code */ } else { /* parent code */ }
§ Two different programs:
§ First fork()
§ if (pid == 0) { execve() } else { /* parent code */ }
§ Now running two completely different programs
¢ wait / waitpid used to synchronize parent/child execution
and to reap child process
Autumn 2013 Processes 36
University of Washington

Summary
¢ Processes
§ At any given time, system has multiple active processes
§ Only one can execute at a time, but each process appears to have total
control of the processor
§ OS periodically “context switches” between active processes
§ Implemented using exceptional control flow

¢ Process management
§ fork: one call, two returns
§ exec: one call, usually no return
§ wait or waitpid: synchronization
§ exit: one call, no return

Autumn 2013 Processes 37


University of Washington

Detailed examples

Autumn 2013 Processes 38


University of Washington

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

Autumn 2013 Processes 39


University of Washington

Fork Example #3
¢ Both parent and child can continue forking
void fork3() Bye
{
L2 Bye
printf("L0\n");
fork(); Bye
printf("L1\n"); L1 L2 Bye
fork(); Bye
printf("L2\n"); L2 Bye
fork();
Bye
printf("Bye\n");
} L0 L1 L2 Bye

Autumn 2013 Processes 40


University of Washington

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

Autumn 2013 Processes 41


University of Washington

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

Autumn 2013 Processes 42


University of Washington

Zombie void fork7()


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

Autumn 2013 Processes 43


University of Washington

void fork8()

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

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 terminated abnormally\n", wpid);
}
}
Autumn 2013 Processes 45
University of Washington

waitpid(): Waiting for a Specific Process


¢ waitpid(pid, &status, options)
§ suspends current process until specific process terminates
§ various options (that we won’t talk about)
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);
}
Autumn 2013 Processes 46

You might also like