CS 1550:
Introduction to Operating Systems
Chapter 1
Class outline
Introduction, concepts, review & historical
perspective
Processes
Synchronization
Scheduling
Deadlock
Memory management, address translation, and
virtual memory
Operating system management of I/O
File systems
Security & protection
Distributed systems (as time permits)
Chapter 1
10/05/20 2
Overview: Chapter 1
What is an operating system, anyway?
Operating systems history
The zoo of modern operating systems
Review of computer hardware
Operating system concepts
Operating system structure
User interface to the operating system
Anatomy of a system call
Chapter 1
10/05/20 3
What is an operating system?
A program that runs on the “raw” hardware and supports
Resource Abstraction
Resource Sharing
Abstracts and standardizes the interface to the user across
different types of hardware
Virtual machine hides the messy details which must be performed
Manages the hardware resources
Each program gets time with the resource
Each program gets space on the resource
May have potentially conflicting goals:
Use hardware efficiently
Give maximum performance to each user
Chapter 1
10/05/20 4
Operating system timeline
First generation: 1945 – 1955
Vacuum tubes
Plug boards
Second generation: 1955 – 1965
Transistors
Batch systems
Third generation: 1965 – 1980
Integrated circuits
Multiprogramming
Fourth generation: 1980 – present
Large scale integration
Personal computers
Next generation: ???
Systems connected by high-speed networks?
Wide area resource management?
Chapter 1
10/05/20 5
First generation: direct input
Run one job at a time
Enter it into the computer (might require rewiring!)
Run it
Record the results
Problem: lots of wasted computer time!
Computer was idle during first and last steps
Computers were very expensive!
Goal: make better use of an expensive commodity:
computer time
Chapter 1
10/05/20 6
Second generation: batch systems
Bring cards to 1401
Read cards onto input tape
Put input tape on 7094
Perform the computation, writing results to output tape
Put output tape on 1401, which prints output
Chapter 1
10/05/20 7
Structure of a typical 2nd generation job
Data for
$END
program
$RUN
FORTRAN $LOAD
program
$FORTRAN
$JOB, 10,6610802, ETHAN MILLER
Chapter 1
10/05/20 8
Spooling
Original batch systems used tape drives
Later batch systems used disks for buffering
Operator read cards onto disk attached to the computer
Computer read jobs from disk
Computer wrote job results to disk
Operator directed that job results be printed from disk
Disks enabled simultaneous peripheral operation on-
line (spooling)
Computer overlapped I/O of one job with execution of
another
Better utilization of the expensive CPU
Still only one job active at any given time
Chapter 1
10/05/20 9
Third generation: multiprogramming
Multiple jobs in memory
Protected from one another
Job 3 Operating system protected
from each job as well
Job 2 Resources (time, hardware)
Memory split between jobs
partitions Job 1 Still not interactive
User submits job
Computer runs it
Operating User gets results minutes
system (hours, days) later
Chapter 1
10/05/20 10
Timesharing
Multiprogramming allowed several jobs to be active
at one time
Initially used for batch systems
Cheaper hardware terminals -> interactive use
Computer use got much cheaper and easier
No more “priesthood”
Quick turnaround meant quick fixes for problems
Chapter 1
10/05/20 11
Types of modern operating systems
Mainframe operating systems: MVS
Server operating systems: FreeBSD, Solaris
Multiprocessor operating systems: Cellular IRIX
Personal computer operating systems: Windows,
Unix
Real-time operating systems: VxWorks
Embedded operating systems
Smart card operating systems
Some operating systems can fit into more than one
category
Chapter 1
10/05/20 12
Components of a simple PC
Outside
world
Video Hard drive USB Network
controller controller controller controller
CPU Computer internals
(inside the “box”)
Memory
Chapter 1
10/05/20 13
CPU internals
Execute
Fetch Decode unit
unit unit
Fetch Decode Execute Execute
Buffer unit
unit unit unit
Fetch Decode
unit unit Execute
unit
Pipelined CPU Superscalar CPU
Chapter 1
10/05/20 14
Storage pyramid
Capacity Access latency
< 1 KB Registers 1 ns Better
1 MB Cache (SRAM) 2–5 ns
256 MB Main memory (DRAM) 50 ns
40 GB Magnetic disk 5 ms
Better > 1 TB Magnetic tape 50 sec
Goal: really large memory with very low latency
Latencies are smaller at the top of the hierarchy
Capacities are larger at the bottom of the hierarchy
Solution: move data between levels to create illusion of large
memory with low latency
Chapter 1
10/05/20 15
Disk drive structure
head
Data stored on surfaces
Up to two surfaces per platter sector
One or more platters per disk
Data in concentric tracks
platter
Tracks broken into sectors
256B-1KB per sector track
Cylinder: corresponding
cylinder
tracks on all surfaces
Data read and written by
heads surfaces
Actuator moves heads
Heads move in unison
spindle
actuator
Chapter 1
10/05/20 16
Memory
Address Address
0x2ffff 0x2ffff
User program User data
0x2d000
and data
0x2b000 0x2bfff Limit2
User data
0x27fff Limit 0x29000 Base2
User program
0x24fff Limit1
and data User program
0x23000 Base 0x23000 Base1
0x1dfff 0x1dfff
Operating Operating
system system
0 0
Single base/limit pair: set for each process
Two base/limit registers: one for program, one for data
Chapter 1
10/05/20 17
Anatomy of a device request
Instructionn
3 2 Instructionn+1
1: Interrupt
5 Interrupt Disk
CPU
controller controller
1 6 4
Operating
system 3: Return
Interrupt handler
Left: sequence as seen by hardware 2: Process interrupt
Request sent to controller, then to disk
Disk responds, signals disk controller which tells interrupt controller
Interrupt controller notifies CPU
Right: interrupt handling (software point of view)
Chapter 1
10/05/20 18
Operating systems concepts
Many of these should be familiar to Unix users…
Processes (and trees of processes)
Deadlock
File systems & directory trees
Pipes
We’ll cover all of these in more depth later on, but
it’s useful to have some basic definitions now
Chapter 1
10/05/20 19
Processes
Process: program in execution
Address space (memory) the
A program can use
State (registers, including
program counter & stack
pointer)
B C D OS keeps track of all processes in
a process table
Processes can create other
processes
Process tree tracks these
E F G relationships
A is the root of the tree
A created three child processes:
B, C, and D
C created two child processes: E
and F
D created one child process: G
Chapter 1
10/05/20 20
Inside a (Unix) process
0x7fffffff Processes have three
Stack segments
Text: program code
Data: program data
Statically declared variables
Areas allocated by malloc()
or new
Stack
Automatic variables
Data Procedure call information
Data
Address space growth
Text: doesn’t grow
Text Data: grows “up”
Stack: grows “down”
0
Chapter 1 21
Deadlock
Potential deadlock Actual deadlock
Chapter 1
10/05/20 22
Hierarchical file systems
Root directory
bin cse
faculty grads
ls ps cp csh
elm sbrandt kag amer4
classes research
stuff stuff
Chapter 1
10/05/20 23
Interprocess communication
Processes want to exchange information with each other
Many ways to do this, including
Network
Pipe (special file): A writes into pipe, and B reads from it
A B
Chapter 1
10/05/20 24
System calls
Programs want the OS to perform a service
Access a file
Create a process
Others…
Accomplished by system call
Program passes relevant information to OS
OS performs the service if
The OS is able to do so
The service is permitted for this program at this time
OS checks information passed to make sure it’s OK
Don’t want programs reading data into other programs’ memory!
Chapter 1
10/05/20 25
Making a system call
0xffffffff
Library
System call:
(read call) read(fd,buffer,length)
Program pushes arguments,
Return to caller
Trap to kernel
calls library
3 Trap code in register
Library sets up trap, calls
User OS
space 8
2 OS handles system call
4 Increment SP 9 7 Control returns to library
Call read
1 Push arguments
Library returns to user
program
User
Kernel code
5 6 Sys call
space Dispatch
handler
(OS)
0
Chapter 1
10/05/20 26
System calls for files & directories
Call Description
fd = open(name,how) Open a file for reading and/or writing
s = close(fd) Close an open file
n = read(fd,buffer,size) Read data from a file into a buffer
n = write(fd,buffer,size) Write data from a buffer into a file
s = lseek(fd,offset,whence) Move the “current” pointer for a file
s = stat(name,&buffer) Get a file’s status information (in buffer)
s = mkdir(name,mode) Create a new directory
s = rmdir(name) Remove a directory (must be empty)
s = link(name1,name2) Create a new entry (name2) that points to the
same object as name1
s = unlink(name) Remove name as a link to an object (deletes
the object if name was the only link to it)
Chapter 1
10/05/20 27
More system calls
Call Description
pid = fork() Create a child process identical to the
parent
pid=waitpid(pid,&statloc,options) Wait for a child to terminate
s = execve(name,argv,environp) Replace a process’ core image
exit(status) Terminate process execution and return
status
s = chdir(dirname) Change the working directory
s = chmod(name,mode) Change a file’s protection bits
s = kill(pid,signal) Send a signal to a process
seconds = time(&seconds) Get the elapsed time since 1 Jan 1970
Chapter 1
10/05/20 28
A simple shell
while (TRUE) { /* repeat forever */
type_prompt( ); /* display prompt */
read_command (command, parameters) /* input from terminal */
if (fork() != 0) { /* fork off child process */
/* Parent code */
waitpid( -1, &status, 0); /* wait for child to exit */
} else {
/* Child code */
execve (command, parameters, 0); /* execute command */
}
}
Chapter 1
10/05/20 29
Monolithic OS structure
Main
procedure
Service
routines
Utility
routines
Chapter 1
10/05/20 30
Virtual machines
App1 App2 App3
System calls Linux Windows NT FreeBSD
I/O instructions VMware VMware VMware
Calls to simulate I/O Linux
“Real” I/O instructions Bare hardware
First widely used in VM/370 with CMS
Available today in VMware
Allows users to run any x86-based OS on top of Linux or NT
“Guest” OS can crash without harming underlying OS
Only virtual machine fails—rest of underlying OS is fine
“Guest” OS can even use raw hardware
Virtual machine keeps things separated
Chapter 1
10/05/20 31
Microkernels (client-server)
Client Client Process Terminal File Memory
process process server server
… server server User mode
Microkernel Kernel mode
Processes (clients and OS servers) don’t share memory
Communication via message-passing
Separation reduces risk of “byzantine” failures
Examples include Mach
Chapter 1
10/05/20 32
Metric units
Exp. Number Prefix Exp. Number Prefix
10-3 0.001 milli 103 1,000 Kilo
10-6 0.000001 micro 106 1,000,000 Mega
10-9 0.000000001 nano 109 1,000,000,000 Giga
10-12 0.000000000001 pico 1012 1,000,000,000,000 Tera
10-15 0.000000000000001 femto 1015 1,000,000,000,000,000 Peta
10-18 0.000000000000000001 atto 1018 1,000,000,000,000,000,000 Exa
Chapter 1
10/05/20 33
