[PPT] - CS 1550: Introduction to Operating Systems Prof. Ahmed Amer PowerPoint Presentation

SLIDE 1

Chapter 1

CS 1550: Introduction to Operating Systems

Prof. Ahmed Amer

amer@cs.pitt.edu http://www.cs.pitt.edu/~amer/cs1550

SLIDE 2

Chapter 1

2 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

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)

SLIDE 3

Chapter 1

3 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

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

SLIDE 4

Chapter 1

4 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

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

SLIDE 5

Chapter 1

5 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

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?

SLIDE 6

Chapter 1

6 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

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

SLIDE 7

Chapter 1

7 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

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

SLIDE 8

Chapter 1

8 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

$END $RUN $LOAD

Structure of a typical 2nd generation job

$FORTRAN $JOB, 10,6610802, ETHAN MILLER

FORTRAN program Data for program

SLIDE 9

Chapter 1

9 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

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

SLIDE 10

Chapter 1

10 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

Operating system

Third generation: multiprogramming

Multiple jobs in memory

Protected from one another

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

Job 1 Job 2 Job 3 Memory partitions

SLIDE 11

Chapter 1

11 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

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

SLIDE 12

Chapter 1

12 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

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

Components of a simple PC

Hard drive controller Video controller Memory USB controller Network controller

Outside world

CPU

Computer internals (inside the “box”)

SLIDE 14

Chapter 1

14 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

Execute unit Execute unit Execute unit Execute unit

Buffer

Fetch unit Decode unit Fetch unit Decode unit Fetch unit Decode unit

CPU internals

Pipelined CPU Superscalar CPU

SLIDE 15

Chapter 1

15 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

Access latency 1 ns 2–5 ns 50 ns 5 ms 50 sec < 1 KB 1 MB 256 MB 40 GB > 1 TB Capacity

Storage pyramid

Registers Cache (SRAM) Main memory (DRAM) Magnetic disk Magnetic tape

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

Better Better

SLIDE 16

Chapter 1

16 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

Disk drive structure

sector cylinder platter spindle track head actuator surfaces

Data stored on surfaces

Up to two surfaces per platter One or more platters per disk

Data in concentric tracks

Tracks broken into sectors

256B-1KB per sector

Cylinder: corresponding

tracks on all surfaces

Data read and written by

heads

Actuator moves heads Heads move in unison

SLIDE 17

Chapter 1

17 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

Memory

User program and data User program and data Operating system Address

0x1df f f 0x23000 0x27f f f 0x2b000 0x2f f f f

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

Base Limit

User data User program Operating system User data

Base1 Limit2 Limit1 Base2

Address

0x1df f f 0x23000 0x29000 0x2bf f f 0x2f f f f 0x2d000 0x24f f f

SLIDE 18

Chapter 1

18 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

Anatomy of a device request

Interrupt controller CPU 5 Disk controller 3 2 6 1 4

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)

Instructionn Operating system Instructionn+1 Interrupt handler 1: Interrupt 2: Process interrupt 3: Return

SLIDE 19

Chapter 1

19 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

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

SLIDE 20

Chapter 1

20 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

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

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

A B E F C D G

SLIDE 21

Chapter 1

21 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

Inside a (Unix) process

Processes have three

segments

Text: program code Data: program data

Statically declared variables Areas allocated by malloc()

r new

Stack

Automatic variables Procedure call information

Address space growth

Text: doesn’t grow Data: grows “up” Stack: grows “down”

Stack Data Text 0x7fffffff Data

SLIDE 22

Chapter 1

22 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

Deadlock

Potential deadlock Actual deadlock

SLIDE 23

Chapter 1

23 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

Root directory bin cse faculty grads ls ps cp csh

Hierarchical file systems

elm sbrandt kag amer4 stuff classes research stuff

SLIDE 24

Chapter 1

24 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

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

SLIDE 25

Chapter 1

25 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

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!

SLIDE 26

Chapter 1

26 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

Making a system call

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

Return to caller Trap to kernel Trap code in register Increment SP Call read Push arguments Dispatch Sys call handler Kernel space (OS) User space 0xffffffff 1 2 3 4 5 6 7 8 9 Library (read call) User code

SLIDE 27

Chapter 1

27 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

System calls for files & directories

Remove name as a link to an object (deletes the object if name was the only link to it)

s = unlink(name)

Create a new entry (name2) that points to the same object as name1

s = link(name1,name2)

Remove a directory (must be empty)

s = rmdir(name)

Create a new directory

s = mkdir(name,mode)

Get a file’s status information (in buffer)

s = stat(name,&buffer)

Move the “current” pointer for a file

s = lseek(fd,offset,whence)

Write data from a buffer into a file

n = write(fd,buffer,size)

Read data from a file into a buffer

n = read(fd,buffer,size)

Close an open file

s = close(fd)

Open a file for reading and/or writing

fd = open(name,how)

Description Call

SLIDE 28

Chapter 1

28 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

Get the elapsed time since 1 Jan 1970

seconds = time(&seconds)

Change a file’s protection bits

s = chmod(name,mode)

Send a signal to a process

s = kill(pid,signal)

Change the working directory

s = chdir(dirname)

Terminate process execution and return status

exit(status)

Replace a process’ core image

s = execve(name,argv,environp)

Wait for a child to terminate

pid=waitpid(pid,&statloc,options)

Create a child process identical to the parent

pid = fork()

Description Call

More system calls

SLIDE 29

Chapter 1

29 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

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

SLIDE 30

Chapter 1

30 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

Monolithic OS structure

Main procedure Service routines Utility routines

SLIDE 31

Chapter 1

31 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

Virtual machines

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

Bare hardware Linux VMware Linux App1 App2 App3 VMware VMware Windows NT FreeBSD I/O instructions System calls Calls to simulate I/O “Real” I/O instructions

SLIDE 32

Chapter 1

32 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

Microkernel Client process Process server Terminal server Client process File server Memory server

…

User mode Kernel mode

Microkernels (client-server)

Processes (clients and OS servers) don’t share memory

Communication via message-passing Separation reduces risk of “byzantine” failures

Examples include Mach

SLIDE 33

Chapter 1

33 CS 1550, cs.pitt.edu (originaly modified by Ethan L. Miller and Scott A. Brandt)

CS 1550: Introduction to Operating Systems

amer@cs.pitt.edu http://www.cs.pitt.edu/~amer/cs1550

Class outline

Introduction, concepts, review & historical

perspective

Processes

Memory management, address translation, and

virtual memory

Operating system management of I/O File systems Security & protection Distributed systems (as time permits)

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

What is an operating system?

different types of hardware

Operating system timeline

First generation: direct input

Run one job at a time

Problem: lots of wasted computer time!

Goal: make better use of an expensive commodity:

computer time

Second generation: batch systems

Structure of a typical 2nd generation job

FORTRAN program Data for program

Spooling

Original batch systems used tape drives Later batch systems used disks for buffering

Disks enabled simultaneous peripheral operation on-

line (spooling)

another

Operating system

Third generation: multiprogramming

from each job as well

split between jobs

(hours, days) later

Job 1 Job 2 Job 3 Memory partitions

Timesharing

Multiprogramming allowed several jobs to be active

at one time

Computer use got much cheaper and easier

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

Components of a simple PC

Hard drive controller Video controller Memory USB controller Network controller

Outside world

CPU

Computer internals (inside the “box”)

Execute unit Execute unit Execute unit Execute unit

Buffer

Fetch unit Decode unit Fetch unit Decode unit Fetch unit Decode unit

CPU internals

Pipelined CPU Superscalar CPU

Access latency 1 ns 2–5 ns 50 ns 5 ms 50 sec < 1 KB 1 MB 256 MB 40 GB > 1 TB Capacity

Storage pyramid

Registers Cache (SRAM) Main memory (DRAM) Magnetic disk Magnetic tape

memory with low latency

Better Better

Disk drive structure

sector cylinder platter spindle track head actuator surfaces

tracks on all surfaces

heads

Memory

User program and data User program and data Operating system Address

0x1df f f 0x23000 0x27f f f 0x2b000 0x2f f f f

Base Limit

User data User program Operating system User data

Base1 Limit2 Limit1 Base2

Address

0x1df f f 0x23000 0x29000 0x2bf f f 0x2f f f f 0x2d000 0x24f f f

Anatomy of a device request

Interrupt controller CPU 5 Disk controller 3 2 6 1 4

Instructionn Operating system Instructionn+1 Interrupt handler 1: Interrupt 2: Process interrupt 3: Return

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

Processes

program can use

program counter & stack pointer)

a process table