Lecture Notes for Operating Systems

14 Sept 2004 - Operating System Organization

Outline

• Responsibilities

• Design and Implementation Issues.

• OS Structures.

OS Responsibilities

An OS sits between user programs and the hardware. Downwards, the OS tames Users' access to hardware.

• Upwards, the OS tames hardware for the users.

  • And defines new hardware (abstractions).

Example Responsibilities

• Make devices look like byte-streams files.

  • read(fid,n,buff); write(fid,n,buff)

• Make remote ftp directories look like local file systems.

  $ ls /ftp/kulalalumpur/public
  Lecture-3a.mpg  Lecture-4a.mpg
  Lecture-3b.mpg  Lecture-4b.mpg
  

• Re-arrange user I-O requests to be disk friendly.

Basic OS Function

• An OS manages resources.

• Resources can be

  • internal, such as the CPU, memory, devices, and files, or

  • external, such as time, capital, and bandwidth.

• Management should be done efficiently, conveniently, and securely.

OS Design Issues

• Performance - tradeoffs among features.

• Protection and security - policy and mechanism.

• Correctness - trust, security, resilience.

• Maintainability - a complex piece of software; a changing environment.

• Commercial influence - the dead hand of the past.

• Standards and open systems - an alternative.

OS Implementation Issues

• Develop the abstractions.

• OS organization - performance vs. everything else

• Kernels are the protected part of the OS.

• OS service requests via system calls or message passing.

Monolithic OSs

A monolithic OS is one big block 'o code. Early designs; it doesn't scale. OS360, early Unix.

Layered OSs

Layered - also an early design, difficult to do. Sequences of virtual machines. The THE OS.

Networked OSs

• Networked OSs can be replicated or distributed.

• Sprite, cluster computing (Mosix), grid computing (Globus?).

Micro-Kernel OSs

A microkernel is a small monolith. Expensive boundary crossings. Mach and its follow-ons.

Modular OSs

A monolith with replaceable parts Linux, Solaris.

Results

• And the winner is: The modular monolith.

  • One big block o' code with changeable bits.

• Microkernels are too expensive

• Layered systems are hard to make and to change.

• Pure monoliths don't scale.

• There's little technology for pure module systems.

This page last modified on 14 November 2004.