CS 1550: Introduction to Operating Systems

Prof. Ahmed Amer

[email protected] http://www.cs.pitt.edu/~amer/cs1550

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
2

CS 1550, cs.pitt.edu (originaly modified by Ethan

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

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

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 Each program gets time with the resource Each program gets space on the resource Use hardware efficiently Give maximum performance to each user

Manages the hardware resources

May have potentially conflicting goals:

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

Operating system timeline

First generation: 1945 1955

Vacuum tubes Plug boards Transistors Batch systems Integrated circuits Multiprogramming Large scale integration Personal computers Systems connected by high-speed networks? Wide area resource management?
Chapter 1
5

Second generation: 1955 1965

Third generation: 1965 1980

Fourth generation: 1980 present

Next generation: ???

CS 1550, cs.pitt.edu (originaly modified by Ethan

First generation: direct input

Run one job at a time

Enter it into the computer (might require rewiring!) Run it Record the results
Computer was idle during first and last steps Computers were very expensive!

Problem: lots of wasted computer time!

Goal: make better use of an expensive commodity: computer time

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

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
7

CS 1550, cs.pitt.edu (originaly modified by Ethan

Structure of a typical 2nd generation job

Data for program

FORTRAN program
$RUN $LOAD

$END

$FORTRAN $JOB, 10,6610802, ETHAN MILLER

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

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 online (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
9

CS 1550, cs.pitt.edu (originaly modified by Ethan

Third generation: multiprogramming

Multiple jobs in memory

Protected from one another

Job 3 Job 2

Memory partitions

Job 1 Operating system

Operating system protected from each job as well Resources (time, hardware) split between jobs Still not interactive

User submits job Computer runs it User gets results minutes (hours, days) later

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

10

Timesharing

Multiprogramming allowed several jobs to be active at one time

Initially used for batch systems Cheaper hardware terminals -> interactive use No more priesthood Quick turnaround meant quick fixes for problems

Computer use got much cheaper and easier

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

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

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

12

Components of a simple PC
Outside world

Video controller

Hard drive controller

USB controller

Network controller

CPU Memory
CS 1550, cs.pitt.edu (originaly modified by Ethan

Computer internals (inside the box)

Chapter 1

13

CPU internals
Execute unit Execute unit Execute unit

Fetch unit Fetch unit Decode unit Execute unit Fetch unit

Decode unit

Buffer
Decode unit

Pipelined CPU

Superscalar CPU

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

14

Storage pyramid
Capacity < 1 KB 1 MB 256 MB Registers Cache (SRAM) Main memory (DRAM) Access latency 1 ns 25 ns 50 ns
Better

40 GB
Better

Magnetic disk
Magnetic tape

5 ms
50 sec

> 1 TB

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
15

CS 1550, cs.pitt.edu (originaly modified by Ethan

Disk drive structure

Data stored on surfaces

head

Up to two surfaces per platter One or more platters per disk Tracks broken into sectors

sector

Data in concentric tracks

platter track cylinder

256B-1KB per sector

Cylinder: corresponding tracks on all surfaces

Data read and written by heads

Actuator moves heads Heads move in unison

surfaces

spindle

actuator
16

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

Memory
Address
0x2ffff

Address User program and data User program and data

Limit Base 0x2ffff 0x2d000

User data User data User program

Limit2 Base2 Limit1 Base1

0x2b000
0x27fff 0x23000 0x1dfff

0x2bfff 0x29000
0x24fff 0x23000 0x1dfff

Operating system
0 0

Operating system

Single base/limit pair: set for each process Two base/limit registers: one for program, one for data
Chapter 1
17

CS 1550, cs.pitt.edu (originaly modified by Ethan

Anatomy of a device request

3
CPU 1 5 Interrupt controller 6

1: Interrupt

Instructionn Instructionn+1

Disk controller 4

Operating system Interrupt handler 2: Process interrupt

3: Return

Left: sequence as seen by hardware

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)

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

18

Operating systems concepts

Many of these should be familiar to Unix users Processes (and trees of processes) Deadlock File systems & directory trees Pipes Well cover all of these in more depth later on, but its useful to have some basic definitions now

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

19

Processes

Process: program in execution

Address space (memory) the program can use State (registers, including program counter & stack pointer)

OS keeps track of all processes in a process table Processes can create other processes

CS 1550, cs.pitt.edu (originaly modified by Ethan

Process tree tracks these 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
20

Chapter 1

Inside a (Unix) process

0x7fffffff

Stack

Processes have three segments

Text: program code Data: program data

Statically declared variables Areas allocated by malloc() or new Automatic variables Procedure call information

Stack

Data Data

Address space growth

Text 0
CS 1550, cs.pitt.edu (originaly modified by Ethan

Text: doesnt grow Data: grows up Stack: grows down

21

Chapter 1

Deadlock

Potential deadlock
CS 1550, cs.pitt.edu (originaly modified by Ethan

Actual deadlock
Chapter 1
22

Hierarchical file systems

Root directory

bin

cse

faculty ls ps cp csh elm sbrandt kag

grads

amer4

classes stuff

research stuff

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

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

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

24

System calls

Programs want the OS to perform a service

Access a file Create a process Others

Program passes relevant information to OS OS performs the service if

Accomplished by system call

The OS is able to do so The service is permitted for this program at this time Dont want programs reading data into other programs memory!

OS checks information passed to make sure its OK

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

25

Making a system call

0xffffffff Library (read call) Return to caller Trap to kernel User space 4 3 Trap code in register 2 Increment SP Call read 1 Push arguments User code 9

System call:
read(fd,buffer,length)

Program pushes arguments, calls library Library sets up trap, calls OS OS handles system call Control returns to library Library returns to user program

Kernel space (OS)

Dispatch

6 Sys call handler

0
CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

26

System calls for files & directories

Call
fd = open(name,how) s = close(fd) n = read(fd,buffer,size) n = write(fd,buffer,size) s = lseek(fd,offset,whence) s = stat(name,&buffer) s = mkdir(name,mode) s = rmdir(name) s = link(name1,name2) s = unlink(name)

Description
Open a file for reading and/or writing Close an open file Read data from a file into a buffer Write data from a buffer into a file Move the current pointer for a file Get a files status information (in buffer) Create a new directory Remove a directory (must be empty) Create a new entry (name2) that points to the same object as name1 Remove name as a link to an object (deletes the object if name was the only link to it)
Chapter 1
27

CS 1550, cs.pitt.edu (originaly modified by Ethan

More system calls

Call
pid = fork()
pid=waitpid(pid,&statloc,options) s = execve(name,argv,environp)

Description
Create a child process identical to the parent
Wait for a child to terminate Replace a process core image

exit(status)
s = chdir(dirname) s = chmod(name,mode)

Terminate process execution and return status

Change the working directory Change a files protection bits

s = kill(pid,signal)
seconds = time(&seconds)

Send a signal to a process

Get the elapsed time since 1 Jan 1970

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

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 */ } }

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

29

Monolithic OS structure
Main procedure

Service routines

Utility routines

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

30

Virtual machines
App1 App2 App3

System calls
I/O instructions Calls to simulate I/O Real I/O instructions

Linux
VMware

Windows NT
VMware Linux Bare hardware

FreeBSD
VMware

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 Only virtual machine failsrest of underlying OS is fine Virtual machine keeps things separated
Chapter 1
31

Guest OS can crash without harming underlying OS

Guest OS can even use raw hardware

CS 1550, cs.pitt.edu (originaly modified by Ethan

Microkernels (client-server)
Client process Client process Process server Terminal server

File server

Memory server

User mode
Kernel mode

Microkernel

Processes (clients and OS servers) dont share memory

Communication via message-passing Separation reduces risk of byzantine failures

Examples include Mach

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

32

Metric units

Exp.
10-3 10-6 10-9 10-12 10-15 10-18
0.001

Number
0.000001 0.000000001 0.000000000001 0.000000000000001 0.000000000000000001

Prefix
milli micro nano pico femto atto

Exp.
103 106 109 1012 1015 1018

Number
1,000 1,000,000 1,000,000,000 1,000,000,000,000 1,000,000,000,000,000 1,000,000,000,000,000,000

Prefix
Kilo Mega Giga Tera Peta Exa

CS 1550, cs.pitt.edu (originaly modified by Ethan

Chapter 1

33