Exceptions and Processes!

Jennifer Rexford!

The material for this lecture is drawn from!

Computer Systems: A Programmerʼs Perspective (Bryant & OʼHallaron) Chapter 8!
1
Goals of this Lecture!
• Help you learn about:!
•  Exceptions!
•  The process concept!
… and thereby…!
•  How operating systems work!
•  How applications interact with OS and hardware!

The process concept is one of the most

important concepts in systems programming!

2
Context of this Lecture!
Second half of the course!
Previously! Starting Now!

C Language! Application Program!

language! service!
levels! levels!
Assembly Language! Operating System!
tour! tour!

Machine Language! Hardware!

Application programs, OS,!

and hardware interact!
via exceptions! 3
Motivation!
Question:!
•  How does a program get input from the keyboard?!
•  How does a program get data from a (slow) disk?!
Question:!
•  Executing program thinks it has exclusive control of CPU!
•  But multiple programs share one CPU (or a few CPUs)!
•  How is that illusion implemented?!
Question:!
•  Executing program thinks it has exclusive use of memory!
•  But multiple programs must share one memory!
•  How is that illusion implemented?!
Answers: Exceptions…!
4
Exceptions!
•  Exception!
•  An abrupt change in control flow in response to a change in
processor state!

•  Examples:!
•  Application program:!
•  Requests I/O!
•  Requests more heap memory!
•  Attempts integer division by 0!
•  Attempts to access privileged memory! Synchronous!
•  Accesses variable that is not

in real memory (see upcoming 

“Virtual Memory” lecture)!
•  User presses key on keyboard!
•  Disk controller finishes reading data!
Asynchronous!

5
Exceptions Note!

•  Note:!
! !Exceptions in OS ≠ exceptions in Java!

Implemented using!
try/catch!
and throw statements!

6
Exceptional Control Flow!

Application! Exception handler!

program! in operating system!

exception!

exception!
processing!
exception!
return!
(optional)!

7
Exceptions vs. Function Calls!
•  Exceptions are similar to function calls!
•  Control transfers from original code to other code!
•  Other code executes!
•  Control returns to original code!

•  Exceptions are different from function calls!

•  Processor pushes additional state onto stack!
•  E.g. values of all registers (including EFLAGS)!
•  Processor pushes data onto OSʼs stack, not applicationʼs stack!
•  Handler runs in privileged mode, not in user mode!
•  Handler can execute all instructions and access all memory!
•  Control might return to next instruction!
•  Control sometimes returns to current instruction!
•  Control sometimes does not return at all!!

8
Classes of Exceptions!

•  There are four classes of exceptions…!

•  Interrupts!
•  Traps!
•  Faults!
•  Aborts!

9
(1) Interrupts!
Application! Exception!
program! handler!

(2) After current instr !

finishes, control passes!
(1) CPU interrupt! to handler!
pin goes high!
(3) Handler runs!

(4) Handler returns!

control to next instr!

Cause: Signal from I/O device!

Examples:! An alternative to
User presses key!
Disk controller finishes reading/writing data!
wasteful polling!
Timer to trigger another application to run! 10
(2) Traps!
Application! Exception!
program! handler!

(2) Control passes to!

handler!
(1) Application!
pgm traps!
(3) Handler runs!

(4) Handler returns!

control to next instr!

Cause: Intentional (application program requests OS service)!

Examples:!
Application program requests more heap memory!
Application program requests I/O!

Traps provide a function-call-like interface between application and OS! 11

(3) Faults!
Application! Exception!
program! handler!

(2) Control passes!

to handler!
(1) Current instr!
causes a fault!
(3) Handler runs!

(4) Handler returns!

control to current instr,!
or aborts!

Cause: Application program causes (possibly) recoverable error!

Examples:!
Application program accesses privileged memory (segmentation fault)!
Application program accesses data that is not in real memory (page fault)!
12
(4) Aborts!
Application! Exception!
program! handler!

(2) Control passes!

to handler!
(1) Fatal hardware!
error occurs!
(3) Handler runs!

(4) Handler aborts!

execution!

Cause: Non-recoverable error!

Example:!
Parity check indicates corruption of memory bit (overheating, cosmic ray!, etc.)!

13
Summary of Exception Classes!

Class! Cause! Asynch/Synch! Return Behavior!

Interrupt! Signal from I/O
 Asynch! Return to next instr!
device!

Trap! Intentional! Sync! Return to next instr!

Fault! (Maybe) recoverable Sync! (Maybe) return to

error! current instr!
Abort! Non-recoverable Sync! Do not return!
error!

14
Exceptions in Intel Processors!
Each exception has a number!
Some exceptions in Intel processors:!

Exception #! Exception!
0! Fault: Divide error!
13! Fault: Segmentation fault!
14! Fault: Page fault (see “Virtual Memory” lecture)!
18! Abort: Machine check!
32-127! Interrupt or trap (OS-defined)!
128! Trap!
129-255! Interrupt or trap (OS-defined)!

15
Traps in Intel Processors!
•  To execute a trap, application program should:!
•  Place number in EAX register indicating desired functionality!
•  Place parameters in EBX, ECX, EDX registers!
•  Execute assembly language instruction “int 128”!

•  Example: To request more heap memory…!

In Linux, 45 indicates request!
for more heap memory!

movl $45, %eax

movl $1024, %ebx
int $128

Request is for 1024 bytes!

Causes trap!
16
System-Level Functions!
•  For convenience, traps are wrapped in system-level
functions!
•  Example: To request more heap memory…!
/* unistd.h */ sbrk() is a!
void *sbrk(intptr_t increment); system-level!
…
function!
/* unistd.s */
Defines sbrk() in assembly lang
Executes int instruction
…

/* client.c */
… A call of a system-level function,!
sbrk(1024); that is, a system call!
…

See Appendix for list of some Linux system-level functions!17

Processes!
•  Program!
•  Executable code!

•  Process!
•  An instance of a program in execution!

•  Each program runs in the context of some process!

•  Context consists of:!
•  Process ID!
•  Address space!
•  TEXT, RODATA, DATA, BSS, HEAP, and STACK!
•  Processor state!
•  EIP, EFLAGS, EAX, EBX, etc. registers!
•  Etc.!

18
Significance of Processes!

•  Process is a profound abstraction in computer

science!
•  The process abstraction provides application pgms
with two key illusions:!

•  Private control flow!

•  Private address space!

19
Private Control Flow: Illusion!

Process 1! Process 2!

Time!

Hardware and OS give each application process the!

illusion that it is the only process running on the CPU!
20
Private Control Flow: Reality!
Process 1! OS! Process 2!

Exception!
Return from exception!

Exception! Time!
Return from exception!

Exception!
Return from exception!

All application processes -- and the OS process --!

share the same CPU(s)!

21
Context Switches!
•  Context switch!
•  The activity whereby the OS assigns the CPU to a
different process!
•  Occurs during exception handling, at discretion of OS!

•  Exceptions can be caused:!

•  Synchronously, by application pgm (trap, fault, abort)!
•  Asynchronously, by external event (interrupt)!
•  Asynchronously, by hardware timer!
•  So no process can dominate the CPUs!

•  Exceptions are the mechanism that enables the

illusion of private control flow! 22
Context Switch Details!
•  Context! Process 1! Process 2!
•  State the OS needs to
restart a preempted
process! Running! Waiting!
Save context!
.!
.!
•  Context switch! .!
•  Save the context of Load context!
current process!
•  Restore the saved Waiting! Running!
context of some
previously preempted
Save context!
process! .!
•  Pass control to this
.!
.!
newly restored process! Running! Load context! Waiting!

23
When Should OS Do Context Switch?!
•  When a process is stalled waiting for I/O!
•  Better utilize the CPU, e.g., while waiting for disk access!

CPU I/O CPU I/O CPU I/O

1:
CPU I/O CPU I/O CPU I/O
2:

•  When a process has been running for a while!

•  Sharing on a fine time scale to give each process the
illusion of running on its own machine!
•  Trade-off efficiency for a finer granularity of fairness!
24
Life Cycle of a Process!
•  Running: instructions are being executed!
•  Waiting: waiting for some event (e.g., I/O finish) !
•  Ready: ready to be assigned to a processor!

Create! Ready! Running! Termination!

Waiting!
25
Context Switch: What Context to Save?!
•  Process state !
•  New, ready, waiting, terminated!

•  CPU registers !
•  EIP, EFLAGS, EAX, EBX, …!

•  I/O status information !

•  Open files, I/O requests, …!

•  Memory management information !

•  Page tables (see “Virtual Memory” lecture)!

•  Accounting information!
•  Time limits, group ID, ...!

•  CPU scheduling information !

•  Priority, queues!
26
Private Address Space: Illusion!

Process 1! Process 2!
00000000 00000000

Memory! Memory!
for! for!
Process! Process!
1! 2!

FFFFFFFF FFFFFFFF

Hardware and OS give each application process!

the illusion that it is the only process using memory!
27
Private Address Space: Reality!
Process 1 VM! Real Memory! Process 2 VM!
00000000 00000000

unused!

unused!
FFFFFFFF FFFFFFFF

Memory is divided! Disk!

into pages!

All processes use the same real memory!

Hardware and OS provide application pgms with!
a virtual view of memory, i.e. virtual memory (VM)!
28
Private Address Space Details!

•  Exceptions (specifically, page faults) are the mechanism

that enables the illusion of private address spaces!

•  See the Virtual Memory lecture for details!

29
Summary!
•  Exception: an abrupt change in control flow!
•  Interrupts: asynchronous; e.g. I/O completion, hardware
timer!
•  Traps: synchronous; e.g. app pgm requests more heap
memory, I/O!
•  Faults: synchronous; e.g. seg fault!
•  Aborts: synchronous; e.g. parity error!

•  Process: An instance of a program in execution!

•  Hardware and OS use exceptions to give each process
the illusion of:!
•  Private control flow (reality: context switches)!
•  Private address space (reality: virtual memory)!
30
Appendix: System-Level Functions!
Linux system-level functions for I/O management!

Number! Function! Description!

3! read() Read data from file descriptor

Called by getchar(), scanf(), etc.!
4! write() Write data to file descriptor

Called by putchar(), printf(), etc.!
5! open() Open file or device

Called by fopen()
6! close() Close file descriptor

Called by fclose()
8! creat() Open file or device for writing

Called by fopen(…, “w”)

Described in I/O Management lecture!

31
Appendix: System-Level Functions!
Linux system-level functions for process management!

Number! Function! Description!

1! exit() Terminate the process!
2! fork() Create a child process!
7! waitpid() Wait for process termination!
7! wait() (Variant of previous)!
11! exec() Execute a program in current process!
20! getpid() Get process id!

Described in Process Management lecture!

32
Appendix: System-Level Functions!
Linux system-level functions for I/O redirection and inter-
process communication!

Number! Function! Description!

41! dup() Duplicate an open file descriptor!
42! pipe() Create a channel of communication between
processes!
63! dup2() Close an open file descriptor, and duplicate
an open file descriptor!

Described in Process Management lecture!

33
Appendix: System-Level Functions!
Linux system-level functions for dynamic memory
management!

Number! Function! Description!

45! brk() Move the program break, thus changing the
amount of memory allocated to the HEAP!
45! sbrk() (Variant of previous)!
90! mmap() Map a virtual memory page!
91! munmap() Unmap a virtual memory page!

Described in Dynamic Memory Management lectures!

34
Appendix: System-Level Functions!
Linux system-level functions for signal handling!

Number! Function! Description!

27! alarm() Deliver a signal to a process after a
specified amount of wall-clock time!
37! kill() Send signal to a process!
67! sigaction() Install a signal handler!

104! setitimer() Deliver a signal to a process after a

specified amount of CPU time!
126! sigprocmask() Block/unblock signals!

Described in Signals lecture!

35