cs 471 operating systems jim x. chen, ph.d. george mason university summer 2009

CS 471

Operating Systems

Jim X. Chen, Ph.D.

George Mason University

Summer 2009

1.2GMU – CS 471

Overview Textbook

• Required: Operating System Concepts (7th edition or latest), by Silberschatz, Galvin and Gagne. John Wiley & Sons.

• Recommended: Distributed Systems: Concept and Design (4th Edition, 2005), by

Coulouris, Dollimore and Kindberg. Modern Operating Systems (2nd Edition, 2001), by A. S. Tanenbaum

Prerequisites• Computer Architecture (CS 365)

• Working knowledge of C/C++/Java Grading

• Midterm (25%), Final exam (35 %)

• Programming projects/Assignments (3 or 4) (30 %)

• Homeworks (10%)

1.3

Operational Information

Office: Engineering, Room 4446 Office Hours:

• Office hour: M 5:00pm-6:00pm; F: 4:30pm-5:30pm

• E-mail: jchen@gmu.edu

Teaching Assistant (TA): Changwei Liu(Coco) <cliu6@gmu.edu> TA Office Hours: Tuesday, 2:00– 4:00pm; Thursday, 3:00 –

5:00pm, in Room 4456.

Computer Accounts on mason.gmu.edu or zeus.ite.gmu.edu Class Web Page: http://cs.gmu.edu/~jchen/cs471 Slides available at

• http://www.cs.gmu.edu/~jchen/cs471/

1.4

Course Objectives

Understand the principles behind the design of centralized and distributed operating systems

Observe how these principles are put into practice in real operating systems

Gain experience in• Multithreaded programming• Distributed system programming and design

1.5

Topics

Introduction, Threads and Processes Inter-process Communication, Synchronization,

Deadlocks CPU Scheduling Memory Management File and I/O Systems Protection and Security Distributed System Structures, Communication Distributed Coordination Fault Tolerance and Real-Time Computing

1.6GMU – CS 571

Lecture 1 (Ch 1, Ch 2)

Introduction• What is an Operating System?

• Co-evolution of Computer Systems and Operating System Concepts

Computer System Structures

Operating System Structures

1.7GMU – CS 571

What is an Operating System?

A program that acts as an intermediary between the user of a computer and the computer hardware.

Operating system goals• Convenience: Make the computer system convenient to use.• Efficiency: Manage the computer system resources in an

efficient manner

“Everything a vendor ships when you order an operating system” is good approximation• But varies wildly

“The one program running at all times on the computer” is the kernel. Everything else is either a system program (ships with the operating system) or an application program

1.8GMU – CS 571

Computer System Components

1. Hardware – provides basic computing resources (CPU, memory, I/O devices).

2. Operating system – controls and coordinates the use of the hardware among the various application programs for the various users.

3. Application programs – define the ways in which the system resources are used to solve the computing problems of the users (compilers, database systems, video games, business programs).

4. Users – people, other computers

1.9GMU – CS 571

Computer System Components

User 1 User 2 User 3 User n. . .

System and Application Programs

compiler assembler Text editor Database system

Operating System

Hardware

1.10GMU – CS 571

Operating System Definitions:System View

Resource allocator – manages and allocates resources.

Control program – controls the execution of user programs and operations of I/O devices.

Kernel – the one program running at all times (all else being application programs).

1.11GMU – CS 571

Co-evolution of Computer Systems and Operating System Concepts

Mainframe Systems• Batch Systems

• Multi-programmed Systems

• Time-sharing Systems Desktop Systems Modern Variants

• Parallel Systems

• Distributed Systems

• Real-time and Embedded Systems

• Handheld Systems

1.12GMU – CS 571

Operating Systems Evolution

1.13GMU – CS 571

Mainframe Systems First computers to tackle many commercial and scientific

applications Mainframes evolved through batch, multiprogrammed and time-

shared systems

Early systems were afforded only by major government agencies or universities:• physically enormous machines run from a console.• the user submitted the job to the human operator in the form of

punched cards. • The operator collects the output and returns it to the user.

Batch systems: To speed up processing, operators batched together jobs with similar needs and ran them through the computer as a group.

1.14GMU – CS 571

Batch Systems

1.15GMU – CS 571

Multiprogrammed Systems

Several (and not necessarily similar) jobs are kept in the main memory at the same time, and the CPU is switched to another job when I/O takes place.Objective: Avoid CPU idle time

1.16GMU – CS 571

OS Features Needed for Multiprogramming

Job Scheduling – must choose the processes that will be brought to memory

Memory Management – must allocate the memory to several jobs

CPU Scheduling – must choose among several jobs ready to run

OS/360, developed by IBM to run on its System/360 series, was the first multiprogrammed operating system.

1.17GMU – CS 571

Time-Sharing Systems:Interactive Computing

Extension of multiprogrammed systems to allow on-line interaction with users.

Each user is provided with an on-line terminal. Objective: Response time for each user should be

short.

The CPU is multiplexed among several jobs that are kept in memory and on disk.

A job swapped in and out of memory to the disk.

CPU is allocated to another job when I/O takes place. All active users must have a fair share of the CPU

time (e.g. 10 ms for each user).

1.18GMU – CS 571

Desktop Systems Personal computers – computer system originally

dedicated to a single user. I/O devices – keyboard, mouse, printers, … Objective: User convenience and responsiveness.

• Individuals have sole use of computers

• A single user may not need advanced features of mainframe OS (maximize utilization, protection).

Today, may run several different types of operating systems (Windows, MacOS, Linux)

1.19GMU – CS 571

Parallel Systems

Multiprocessor systems with more than one CPU in close communication.

Tightly coupled system – processors share memory and a clock; communication usually takes place through the shared memory.

Advantages of parallel system• Increased throughput

• Economy of scale

• Increased reliability graceful degradation fault-tolerant systems

1.20GMU – CS 571

Parallel Systems (Cont.) Symmetric multiprocessing (SMP)

• Each processor runs an identical copy of the operating system.

• All processors are peers

Asymmetric multiprocessing

1.21GMU – CS 571

Distributed Systems

Distribute the computation among several physical processors.

Loosely coupled system – each processor has its own local memory; processors communicate with one another through various communications lines

Advantages of distributed systems• Resource and Load Sharing

• Reliability

• Communications

1.22GMU – CS 571

Real-Time and Embedded Systems A real-time system is used when rigid time

requirements have been placed on the operation of a processor or the flow of data.

An embedded system is a component of a more complex system• Control of a nuclear plant• Missile guidance• Control of home and car appliances (microwave oven,

DVD players, car engines, …)

Real-time systems • have well-defined time constraints.• may be either hard or soft real-time.

1.23GMU – CS 571

Real-Time Systems (Cont.)

Hard real-time• Critical tasks must be completed on time

• Secondary storage limited or absent, data stored in short term memory, or read-only memory (ROM)

Soft real-time• No absolute timing guarantees (e.g. “best-effort

scheduling”)

• Limited utility in industrial control of robotics

• Useful in applications (multimedia, virtual reality) requiring advanced operating-system features.

1.24GMU – CS 571

Handheld Systems

Personal Digital Assistants (PDAs) Cellular telephones Issues

• Limited memory

• Limited battery power

• Slow processors

• Small display screens

1.25GMU – CS 571

Computer-System Structures

Computer System Organization Instruction Execution Computer System Operation Interrupt Processing Storage Structure Storage Hierarchy

1.26GMU – CS 571

Computer-System Organization

1.27GMU – CS 571

Instruction Execution While executing a program, the CPU:

• fetches the next instruction from memory (loading into IR)• decodes it to determine its type and operands• executes it

May take multiple clock cycles to execute an instruction Examples:

• LOAD R1, #3• LOAD R2, M2• STORE M3, R4• ADD R1, R2, R3

Each CPU has a specific set of instructions that it can execute (instruction-set architecture).

1.28GMU – CS 571

Instruction Execution

Registers• General registers (data/address)• Program Counter (PC): contains the memory address of

the next instruction to be fetched. • Stack Pointer (SP): points to the top of the current stack

in memory. The stack contains one frame for each procedure that has been entered but not yet exited.

• Program Status Word (PSW): contains the condition code bits and various other control bits.

• …

When time multiplexing the CPU, the operating system will often stop the running program to (re)start another one. In these cases, it must save the “state information” (e.g. values of the registers).

1.29GMU – CS 571

Computer-System Operation

I/O devices and CPU can execute concurrently. Each device controller has local buffer(s). CPU moves data from/to main memory to/from local

buffers I/O is from/to the device to/from local buffer of

controller. The device driver is special operating system

software that interacts with the device controller. Typically, the device controller informs CPU that it

has finished its operation by causing an interrupt. The Device Controller has an equivalent device driver

through which the device controller communicates with the Operating Systems through Interrupts.

1.30GMU – CS 571

Classes of Interrupts

I/O Interrupts: Generated by an I/O controller, to signal normal completion of an operation or to signal a variety of error conditions.

Timer Interrupts: Generated by a timer within the processor. This allows the operating system to perform certain functions on a regular basis.

Hardware Failure Interrupts: Generated by a failure (e.g. power failure or memory parity error).

Traps (Software Interrupts): Generated by some condition that occurs as a result of an instruction execution• Errors

• User request for an operating system service

1.31GMU – CS 571

Interrupt Mechanism Interrupt transfers control to the interrupt service routine

generally through the interrupt vector which contains the addresses of all the service routines.

Interrupt Service Routines (ISRs): Different segments of code determine what action should be taken for each type of interrupt.

Once the interrupt has been serviced by the ISR, the control is returned to the interrupted program. Need to save the “process state” (registers, PC, …) before ISR takes over.

A trap is a software-generated interrupt caused either by an error or a user request.

Modern operating systems are interrupt-driven.

1.32GMU – CS 571

Interrupt Timeline (single process doing output)

User processISR move data from buffer to user process

----------------Data xfr

1.33GMU – CS 571

Basic Interrupt Processing

1. The interrupt is issued 2. Processor finishes execution of current instruction3. Processor signals acknowledgement of interrupt4. Processor pushes PSW (Program Status Word) and PC

(Program Counter) onto control stack5. Processor loads new PC value through the interrupt vector6. ISR (Interrupt Service Routine) saves the process state

information7. ISR executes8. ISR restores process state information9. Old PSW and PC values are restored from the control stack What if another interrupt occurs during interrupt processing?Incoming interrupts are disabled while another interrupt is being

processed to prevent a lost interrupt.

1.34GMU – CS 571

I/O Structure After I/O starts, control returns to user program only

upon I/O completion.• Wait instruction idles the CPU until the next interrupt• Wait loop (contention for memory access).• At most one I/O request is outstanding at a time, no

simultaneous I/O processing. After I/O starts, control returns to user program

without waiting for I/O completion.• System call – request to the operating system to allow

user to wait for I/O completion.• Device-status table contains entry for each I/O device

indicating its type, address, and state.• Operating system indexes into I/O device table to

determine device status and to modify table entry to include interrupt.

1.35GMU – CS 571

Two I/O Methods

Synchronous Asynchronous

1.36GMU – CS 571

Device-Status Table

1.37GMU – CS 571

Direct Memory Access Structure

Used for high-speed I/O devices able to transmit information at (close to) memory speeds.

Device controller transfers blocks of data from buffer storage directly to main memory without CPU intervention.

Only one interrupt is generated per block, rather than one interrupt per byte.

1.38GMU – CS 571

Dual-Mode Operation

Operating System must protect itself and all other programs (and their data) from any malfunctioning program.

Provide hardware support to differentiate between at least two modes of operations.1. User mode – execution done on behalf of a user.

2. Kernel mode (also monitor mode or system mode) – execution done on behalf of operating system.

1.39GMU – CS 571

Dual-Mode Operation (Cont.)

Mode bit added to computer hardware to indicate the current mode: kernel (0) or user (1).

When an interrupt occurs hardware switches to kernel mode.

Privileged instructions can be issued only in kernel mode.

kernel user

Interrupt

set user mode

1.40GMU – CS 571

Transition From User to Kernel Mode

The system call can be executed by a generic trap instruction (or in some systems, by an instruction such as syscall).

1.41GMU – CS 571

Storage Structure

Main memory – only large storage media that the CPU can access directly.

Secondary storage – extension of main memory that provides large nonvolatile storage capacity.

Magnetic disks – rigid metal or glass platters covered with magnetic recording material • Disk surface is logically divided into tracks, which are

subdivided into sectors.

• The disk controller determines the logical interaction between the device and the computer.

1.42GMU – CS 571

Memory Protection

1.43GMU – CS 571

Storage Hierarchy

Storage systems organized in hierarchy• Speed

• Cost

• Volatility

Faster access time, greater cost per bit Greater capacity, lower cost per bit Greater capacity, slower access speed

1.44GMU – CS 571

Storage-Device Hierarchy

1.45GMU – CS 571

Performance of Various Levels of Storage

Movement between levels of storage hierarchy can be explicit or implicit

1.46GMU – CS 571

Caching

Important principle, performed at many levels in a computer (in hardware, operating system, software)

Information in use copied from slower to faster storage temporarily

Faster storage (cache) checked first to determine if information is there• If it is, information used directly from the cache (fast)

• If not, data copied to cache and used there Cache smaller than storage being cached

• Cache management important design problem

• Cache size and replacement policy

1.47GMU – CS 571

Migration of Integer A from Disk to Register

Multitasking environments must be careful to use most recent value, no matter where it is stored in the storage hierarchy

Multiprocessor environment must provide cache coherency in hardware such that all CPUs have the most recent value in their cache

Distributed environment situation even more complex• Several copies of a datum can exist

• Various solutions covered in Chapter 17

1.48GMU – CS 571

Operating-System Structures

System Components• Process Management

• Main Memory Management

• File Management

• Secondary-Storage Management

• I/O System Management

• Protection and Security

• User Operating-System Interface System Calls System Programs Operating System Design Approaches

1.49GMU – CS 571

Process Management

A process is a program in execution. It is a unit of work within the system. Program is a passive entity, process is an active entity.

Process needs resources to accomplish its task• CPU, memory, I/O, files• Initialization data

Process termination requires reclaim of any reusable resources

Single-threaded process has one program counter specifying location of next instruction to execute• Process executes instructions sequentially, one at a time, until

completion Multi-threaded process has one program counter per thread Typically system has many processes, some user, some

operating system running concurrently on one or more CPUs• Concurrency by multiplexing the CPUs among the processes /

threads

1.50GMU – CS 571

Process Management

A process tree A created two child

processes, B and C B created three child

processes, D, E, and F

1.51GMU – CS 571

Process Management

The operating system is responsible for the following activities in connection with process management:

Creating and deleting both user and system processes

Suspending and resuming processes Providing mechanisms for process synchronization Providing mechanisms for process communication Providing mechanisms for deadlock handling

1.52GMU – CS 571

Memory Management

All data in memory before and after processing All instructions in memory in order to execute Memory management determines what is in memory

when• Optimizing CPU utilization and computer response to

users Memory management activities

• Keeping track of which parts of memory are currently being used and by whom

• Deciding which processes (or parts thereof) and data to move into and out of memory

• Allocating and deallocating memory space as needed

1.53GMU – CS 571

Storage Management

OS provides uniform, logical view of information storage• Abstracts physical properties to logical storage unit - file• Each medium is controlled by device (i.e., disk drive, tape

drive) Varying properties include access speed, capacity, data-

transfer rate, access method (sequential or random) File-System management

• Files usually organized into directories• Access control on most systems to determine who can

access what• OS activities include

Creating and deleting files and directories Primitives to manipulate files and dirs Mapping files onto secondary storage Backup files onto stable (non-volatile) storage media

1.54GMU – CS 571

File Management

A file is a collection of related information defined by its creator

Commonly, files represent programs (both source and object forms) and data

The operating system responsibilities• File creation and deletion

• Directory creation and deletion

• Support of primitives for manipulating files and directories

• Mapping files onto secondary storage

• File backup on stable (non-volatile) storage media

1.55GMU – CS 571

File Systems Management

1.56GMU – CS 571

Secondary-Storage Management

The secondary storage backs up main memory and provides additional storage.

Most common secondary storage type: disks The operating system is responsible for

• Free space management

• Storage allocation

• Disk scheduling

1.57GMU – CS 571

Mass-Storage Management

Usually disks used to store data that does not fit in main memory or data that must be kept for a “long” period of time.

Proper management is of central importance Entire speed of computer operation hinges on disk

subsystem and its algorithms OS activities

• Free-space management

• Storage allocation

• Disk scheduling Some storage need not be fast

• Tertiary storage includes optical storage, magnetic tape

• Still must be managed

• Varies between WORM (write-once, read-many-times) and RW (read-write)

1.58GMU – CS 571

I/O System Management

The Operating System will hide the peculiarities of specific hardware from the user.

In Unix, the I/O subsystem consists of:• A buffering, caching and spooling system

• A general device-driver interface

• Drivers for specific hardware devices

Interrupt handlers and device drivers are crucial in the design of efficient I/O subsystems.

1.59GMU – CS 571

I/O Subsystem

One purpose of OS is to hide peculiarities of hardware devices from the user

I/O subsystem responsible for• Memory management of I/O including buffering (storing

data temporarily while it is being transferred), caching (storing parts of data in faster storage for performance), spooling (the overlapping of output of one job with input of other jobs)

• General device-driver interface

• Drivers for specific hardware devices

1.60GMU – CS 571

Protection and Security

Protection – any mechanism for controlling access of processes or users to resources defined by the OS

Security – defense of the system against internal and external attacks• Huge range, including denial-of-service, worms, viruses,

identity theft, theft of service Systems generally first distinguish among users, to

determine who can do what• User identities (user IDs, security IDs) include name and

associated number, one per user• User ID then associated with all files, processes of that user to

determine access control• Group identifier (group ID) allows set of users to be defined and

controls managed, then also associated with each process, file• Privilege escalation allows user to change to effective ID with

more rights

1.61GMU – CS 571

User Operating-System Interface

Two main approaches• Command-line interpreter (a.k.a command interpreter,

or shell)• Graphical User Interfaces (GUI)

The shell • allows users to directly enter commands that are to be

performed by the operating system• is usually a system program (not part of the kernel)

GUI allows a mouse-based window-and-menu system

Some systems allow both (e.g. X-Windows in Unix)

1.62GMU – CS 571

System Calls System calls provide the interface between a running

program and the operating system.• Generally available in routines written in C and C++ • Certain low-level tasks may have to be written using

assembly language.

Typically, application programmers design programs using an application programming interface (API).

The run-time support system (run-time libraries) provides a system-call interface, that intercepts function calls in the API and invokes the necessary system call within the operating system.

1.63GMU – CS 571

Example System-Call Processing

1.64GMU – CS 571

Major System Calls in Unix :Process Management

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 = kill (pid, signal)• Send a signal to a process

1.65GMU – CS 571

Major System Calls in Unix :File Management

fd = open (file, how, …) • Open a file for reading, writing or both

s = close (fd)• Close an open file

n = read (fd, buffer, nbytes)• Read data from a file into a buffer

n = write (fd, buffer, nbytes) • Write data from a buffer into a file

position = lseek(fd, offset, whence)• Move the file pointer

s = stat(name, &buf)• Get a file’s status information

1.66GMU – CS 571

Major System Calls in Unix :Directory and File System Management

s = mkdir(name, mode) • Create a new directory

s = rmdir (name)• Remove an empty directory

s = link (name1, name2) • Create a new directory, name2, pointing to name1

s = unlink (name) • Remove a directory entry

s = mount (special, name, flag)• Mount a file system

s = umount(special) • Unmount a file system

1.67GMU – CS 571

System Programs System programs provide a convenient environment

for program development. They can provide various services

• Status information

• File modification

• Programming language support

• Program loading and execution

• Communications

Most users’ view of the operating system is defined by system programs, not by the actual system calls.

1.68GMU – CS 571

Operating System Design Approaches

Simple Structure Layered Approach Microkernels Modular Approach Virtual Machines

-- (July 6, 2009)

1.69GMU – CS 571

Simple System Structure

Some operating systems do not have well-defined structures. Often, these started as simple systems and grew beyond their original scope.

MS-DOS – written to provide the most functionality in the least space• not divided into modules

• Although MS-DOS has some structure, its interfaces and levels of functionality are not well separated

1.70GMU – CS 571

MS-DOS Structure

1.71GMU – CS 571

UNIX System Structure

UNIX – limited by hardware functionality, the original UNIX operating system had limited structure. The UNIX OS consists of two separable parts.• System programs

• The kernel (everything below the system-call interface and above the physical hardware)

Provides the file system, CPU scheduling, memory management, and other operating-system functions

A large number of functions for one level.

1.72GMU – CS 571

UNIX System Structure

1.73GMU – CS 571

Layered Approach

The operating system is divided into a number of layers (levels), each built on top of lower layers. The bottom layer (layer 0), is the hardware; the highest (layer N) is the user interface.

With modularity, layers are selected such that each uses functions (operations) and services of only lower-level layers.

Simplifies debugging and system verification Disadvantages?

1.74GMU – CS 571

Microkernels

Moves as much as possible from the kernel into the “user” space.

Communication takes place between user modules using message passing (e.g. Mach operating system)

1.75GMU – CS 571

Microkernels (cont.)

Benefits• easier to extend

• more reliable (less code is running in kernel mode)

• convenient for distributed architectures

Disadvantages• Increased system function overhead (message passing)

1.76GMU – CS 571

Modular Approach

Modular kernel• The kernel has a set of core components

• Dynamically links in additional services either during boot time or during run-time

• Common in modern implementations of Unix such as Linux and Solaris

1.77GMU – CS 571

Virtual Machines

Originally proposed and implemented for VM Operating System (IBM)

A virtual machine provides an interface identical to the underlying bare hardware

Each user is given its own virtual machine The operating system creates the illusion of multiple

processes, each executing on its own processor with its own (virtual) memory

1.78GMU – CS 571

Virtual Machines (Cont.)

Non-virtual Machine Virtual Machine

1.79GMU – CS 571

Virtual Machines (Evaluation)

The virtual-machine concept provides complete protection (because of complete isolation).

This isolation, however, permits no direct sharing of resources.

A virtual-machine system is a perfect vehicle for operating-systems research and development.

The virtual machine concept is difficult to implement due to the effort required to provide an exact duplicate of the underlying machine.

1.80GMU – CS 571

VMware

Abstracts Intel 80x86 hardware into multiple virtual machines

VMware is an application running on top of a host operating system (e.g. Windows or Linux).

Several different guest operating systems (e.g. Free BSD, Windows NT, Windows XP) can run on top of VMware

1.81GMU – CS 571

Java Virtual Machine

Compiled Java programs are platform-neutral bytecodes executed by a Java Virtual Machine (JVM).

JVM consists of

- class loader

- class verifier

- runtime interpreter Just-In-Time (JIT) compilers increase performance