333 CS Introduction to Operating Systems Class 1 - Introduction to OS-related Hardware and Software
Jonathan Walpole Computer Science Portland State University
About the instructor
Instructor - Jonathan Walpole
Professor at OGI 1989 2004, PSU 2004 Director of Systems Software Lab at OGI Research Interests: Operating System Design, Distributed Computing Systems, Multimedia Computing and Networking http://www.cs.pdx.edu/~walpole
About CS 333
Goals of the class
understand the basic concepts of operating systems gain some practical experience so its not just all words!
building o p e ra ting s y s te m s , no t using th e m !
Expectations
reading assignments should be read before class active participation in class discussions no cheating
Grading
Exams
Midterm 25% Final 25%
Coursework
project 40%
Quizzes
inclass quizzes and discussions 10%
Text books
"Modern Operating Systems" 2nd Edition A. Tannenbaum "The BLITZ System" Harry Porter
The project
You will read, understand and write real operating system code! We will be using the BLITZ system, written by Harry Porter About BLITZ
CPU emulator, assembler, highlevel language, operating system, and debugging environment Simple enough to understand in detail how everything works! Realistic enough to understand in detail how everything works! Runs on the departmental Sun machines (cs.pdx.edu)
Administrative
Class web site
www.c s .p d x.e d u/~wa lp o le /c la s s /c s 3 3 3 /s p ring 2 0 0 7 /h o m e .h tm l Find m y we b s ite fro m th e fa c ulty lis ting o n th e d e p a rtm e nt we b s ite . Fo llo w teaching link to Spring 2007 CS333. h ttp s ://m a ilh o s t.c e c s .p d x.e d u/c g ib in/m a ilm a n/lis tinfo /c s 3 3 3
Class mailing list
Project 0
read the class web site join the class mailing list due next week! See web site for project assignments.
Project 1
Class 1 - Introduction to OS-related Hardware and Software
Overview
What is an Operating System? A review of OS-related hardware
What is an operating system?
Operating system --"is a program that controls the execution of application programs and implements an interface between the user of a computer and the computer hardware"
Narrow view of a computer and OS
Traditional computer with applications running on it (e.g. PCs, Workstations, Servers)
Broad view of a computer and OS
Anything that needs to manage resources (e.g. router OS, embedded devices, cell phones ...)
Two key OS functions
Abstract Machine Hides details of the underlying hardware Provides common API to applications and services Simplifies application writing Resource Manager Controls accesses to shared resources
Allows for global policies to be implemented
CPU, memory, disks, network, ...
Why is abstraction important?
Without OSs and abstract interfaces, application writers
must program all device access directly
load device command codes into device registers handle initialization, recalibration, sensing, timing etc for physical devices understand physical characteristics and layout control motors interpret return codes ... etc very complicated maintenance and upgrading writing this code once, and sharing it, is how OS began!
Applications suffer severe code bloat!
Providing abstraction via system calls
Application Operating System
Video Card Monitor
CPU
Memory Disk Printer
Network
Providing abstraction via system calls
Application
System Calls: read(), open(), write(), mkdir(), kill() ...
Device Mgmt
Operating System
File System Protection Network Comm.
Process Mgmt Security
Video Card Monitor
CPU
Memory Disk Printer
Network
OS as a resource manager
Sharing resources among applications across space and time
Scheduling (time sharing a resource) Allocation (time or space sharing a resource) improving utilization minimizing overhead improving throughput/good put enforcement of boundaries
Making efficient use of limited resources
Protecting applications from each other
Problems an OS must solve
Time sharing the CPU among applications Space sharing the memory among applications Space sharing the disk among users Time sharing access to the disk Time sharing access to the network
More problems an OS must solve
Protection
of applications from each other of user data from other users of hardware/devices of the OS itself!
The OS is just a program! It needs help from the hardware to accomplish these tasks!
When an application is running, the OS is not running! When the OS is not running, it can't do anything!
Overview
What is an Operating System? A review of OS-related hardware
Instruction sets
A CPU's instruction set defines the instructions it can execute
different for different CPU architectures all have load and store instructions for moving items between memory and registers many instructions for comparing and combining values in registers and putting result into a register
Load a word located at an address in memory into a register Store the contents of a register to a word located at an address in memory
Look at the Blitz instruction set which is similar to a SUN SPARC instruction set
Basic anatomy on a CPU
Program Counter (PC)
Basic anatomy on a CPU
Program Counter (PC)
Holds the memory address of the next instruction
Basic anatomy on a CPU
Program Counter (PC)
Holds the memory address of the next instruction
Instruction Register (IR)
Basic anatomy on a CPU
Program Counter (PC)
Holds the memory address of the next instruction Holds the instruction currently being executed
Instruction Register (IR)
Basic anatomy on a CPU
Program Counter (PC)
Holds the memory address of the next instruction holds the instruction currently being executed
Instruction Register (IR)
General Registers (Reg. 1..n)
Basic anatomy on a CPU
Program Counter (PC)
Holds the memory address of the next instruction holds the instruction currently being executed hold variables and temporary results
Instruction Register (IR)
General Registers (Reg. 1..n)
Basic anatomy on a CPU
Program Counter (PC)
Holds the memory address of the next instruction holds the instruction currently being executed hold variables and temporary results
Instruction Register (IR)
General Registers (Reg. 1..n)
Arithmetic and Logic Unit (ALU)
Basic anatomy on a CPU
Program Counter (PC)
Holds the memory address of the next instruction holds the instruction currently being executed hold variables and temporary results performs arithmetic functions and logic operations
Instruction Register (IR)
General Registers (Reg. 1..n)
Arithmetic and Logic Unit (ALU)
Basic anatomy on a CPU
Stack Pointer (SP)
Basic anatomy on a CPU
Stack Pointer (SP)
holds memory address of a stack with a frame for each active procedure's parameters & local variables
Basic anatomy on a CPU
Stack Pointer (SP)
holds memory address of a stack with a frame for each active procedure's parameters & local variables
Processor Status Word (PSW)
Basic anatomy on a CPU
Stack Pointer (SP)
holds memory address of a stack with a frame for each active procedure's parameters & local variables contains various control bits including the mode bit which determines whether privileged instructions can be executed
Processor Status Word (PSW)
Basic anatomy on a CPU
Stack Pointer (SP)
holds memory address of a stack with a frame for each active procedure's parameters & local variables contains various control bits including the mode bit which determines whether privileged instructions can be executed contains address of memory to be loaded from/stored to contains memory data loaded or to be stored
Processor Status Word (PSW)
Memory Address Register (MAR)
Memory Data Register (MDR)
Program execution
The Fetch/Decode/Execute cycle
fetch next instruction pointed to by PC decode it to find its type and operands execute it repeat
At a fundamental level, fetch/decode/execute is all a CPU does
Fetch/decode/execute cycle
CPU PC IR Memory
ALU
Reg. 1 ... Reg. n
MAR MDR
Fetch/decode/execute PC cycle
CPU IR Memory
ALU
Reg. 1 ... Reg. n
MAR MDR
While (1) { Fetch instruction from memory Execute instruction (Get other operands if necessary) Store result }
Fetch/decode/execute cycle
CPU PC IR Memory
ALU
Reg. 1 ... Reg. n
MAR MDR
While (1) { Fetch instruction from memory Execute instruction (Get other operands if necessary) Store result }
Fetch/decode/execute cycle
CPU PC IR Memory
ALU
Reg. 1 ... Reg. n
MAR MDR
While (1) { Fetch instruction from memory Execute instruction (Get other operands if necessary) Store result }
Fetch/decode/execute cycle
CPU PC IR Memory
ALU
Reg. 1 ... Reg. n
MAR MDR
While (1) { Fetch instruction from memory Execute instruction (Get other operands if necessary) Store result }
Fetch/decode/execute cycle
CPU PC IR Memory
ALU
Reg. 1 ... Reg. n
MAR MDR
While (1) { Fetch instruction from memory Execute instruction (Get other operands if necessary) Store result }
Fetch/decode/execute cycle
CPU PC IR Memory
ALU
Reg. 1 ... Reg. n
MAR MDR
While (1) { Fetch instruction from memory Execute instruction (Get other operands if necessary) Store result }
Fetch/decode/execute cycle
CPU PC IR Memory
ALU
Reg. 1 ... Reg. n
MAR MDR
While (1) { Fetch instruction from memory Execute instruction (Get other operands if necessary) Store result }
Fetch/decode/execute cycle
CPU PC IR Memory
ALU
Reg. 1 ... Reg. n
MAR MDR
While (1) { Fetch instruction from memory Execute instruction (Get other operands if necessary) Store result }
The OS is just a program!
The OS is a sequence of instructions that the CPU will fetch/decode/execute
How can the OS cause application programs to run? How can the OS switch the CPU to run a different application and later resume the first one? How can the OS maintain control? In what ways can application code try to seize control indefinitely (ie. cheat)? And how can the OS prevent such cheating? How can applications programs cause the OS to run?
How can the OS invoke an application?
How can the OS invoke an application?
Somehow, the OS must load the address of the application's starting instruction into the PC
The computer boots and begins running the OS
OS code must be loaded into memory somehow fetch/decode/execute OS instructions OS requests user input to identify application "file" OS loads application file (executable) into memory OS loads the memory address of the application's starting instruction into the PC CPU fetches/decodes/executes the application's instructions
How can OS guarantee to regain control?
What if a running application doesn't make a system call back to the OS and hence hogs the CPU?
How can OS guarantee to regain control?
What if a running application doesn't make a system call and hence hogs the CPU?
OS needs interrupts from a timer device! OS must register a future timer interrupt before it hands control of the CPU over to an application When the timer interrupt goes off the interrupt hardware jumps control back into the OS at a prespecified location called an interrupt handler The interrupt handler is just a program (part of the OS) The address of the interrupt handler's first instruction is placed in the PC by the interrupt h/w
What if the application tries to cheat?
What stops the running application from disabling the future timer interrupt so that the OS can not take control back from it?
What if the application tries to cheat?
What stops the running application from disabling the future timer interrupt so that the OS can not take control back from it? Disabling interrupts must be a privileged instruction which is not executable by applications The CPU knows whether or not to execute privileged instructions based on the value of the mode bit in the PSW! Privileged instructions can only be executed when the mode bit is set disabling interrupts setting the mode bit! Attempted execution in nonprivileged mode generally causes an interrupt (trap) to occur
What other ways are there to cheat?
What other ways are there to cheat?
What stops the running application from modifying the OS?
Specifically, what stops it from modifying the timer interrupt handler to jump control back to the application?
What other ways are there to cheat?
What stops the running application from modifying the OS?
Memory protection! Memory protection instructions must be privileged They can only be executed with the mode bit set ...
Why must the OS clear the mode bit before it hands control to an application?
How can applications invoke the OS?
Why not just set PC to an OS instruction address and transfer control that way?
How can applications invoke the OS?
Special instruction causes a trap / interrupt Trap instruction changes PC to point to a predetermined OS entry point instruction and simultaneously sets the mode bit
application calls a library procedure that includes...