Chapter 2: Using the Operating System

1
Chapter 2 Using the Operating System
2
The Airplane Pilots Abstract Machine
3
Basic Abstractions
Program
Result


Program
Result
4
Basic Abstractions(2)
Abstract Machine
Program
Result
Abstract Machine
Program
Result


Abstract Machine
Program
Result
5
Abstract Machine Entities

• Process A sequential program in execution
• Resource Any abstract resource that a process
  can request, and which may can cause the process
  to be blocked if the resource is unavailable.
• File A special case of a resource. A
  linearly-addressed sequence of bytes. A byte
  stream.

6
Algorithms, Programs, and Processes
Idea
Execution Engine
Algorithm
Stack
Status
Data
Source Program
Binary Program
Other Resources
Process
7
Classic Process

• OS implements abstract machine one per task
• Multiprogramming enables N programs to be
  space-muxed in executable memory, and time-muxed
  across the physical machine processor.
• Result Have an environment in which there can be
  multiple programs in execution concurrently,
  each as a processes

Concurrently Programs appear to execute
simultaneously
8
Process Abstraction
Data
Process
Stack
Program
Operating System
Processor
Hardware
Executable Memory
9
Processes Sharing a Program
P1
P2
P3
P1
P2
P3
Shared Program Text
10
Multithreaded Accountant
Invoice
First Accountant
Invoice
Purchase Orders
Invoice
Accountant Clone
Purchase Orders
Second Accountant
(b) Double Threaded Process
(a) Separate Processes
11
Modern Process Thread

• Divide classic process
• Process is an infrastructure in which execution
  takes place address space resources
• Thread is a program in execution within a process
  context each thread has its own stack

Stack
Data
Thread
Thread
Stack
Process

Program
Stack
Thread
Operating System
12
A Process with Multiple Threads
Thread (Execution Engine)
Data
Other Resources
Binary Program
Process
13
More on Processes

• Abstraction of processor resource
• Programmer sees an abstract machine environment
  with spectrum of resources and a set of resource
  addresses (most of the addresses are memory
  addresses)
• User perspective is that its program is the only
  one in execution
• OS perspective is that it runs one program with
  its resources for a while, then switches to a
  different process (context switching)
• OS maintains
• A process descriptor data structure to implement
  the process abstraction
• Identity, owner, things it owns/accesses, etc.
• Tangible element of a process
• Resource descriptors for each resource

14
Address Space

• Process must be able to reference every resource
  in its abstract machine
• Assign each unit of resource an address
• Most addresses are for memory locations
• Abstract device registers
• Mechanisms to manipulate resources
• Addresses used by one process are inaccessible to
  other processes
• Say that each process has its own address space

15
Shared Address Space

• Classic processes sharing program ? shared
  address space support
• Thread model simplifies the problem
• All threads in a process implicitly use that
  processs address space , but no unrelated
  threads have access to the address space
• Now trivial for threads to share a program and
  data
• If you want sharing, encode your work as threads
  in a process
• If you do not want sharing, place threads in
  separate processes

16
Process Address Space
Data
Code
Stack
Abstract Machine Environment
Address Space
17
Creating a Process

• Here is the classic model for creating processes

FORK(label) Create another process in the same
address space beginning execution at instruction
label QUIT() Terminate the process. JOIN(count)
disableInterrupts() count--
if(count gt 0) QUIT() enableInterrupts()
18
Example
procA() while(TRUE) ltcompute section
A1gt update(x) ltcompute section A2gt
retrieve(y)
procB() while(TRUE) retrieve(x)
ltcompute section B1gt update(y) ltcompute
section B2gt
x
Process A
Process B
y
19
UNIX Processes
Stack Segment
Status
Data Segment
Text Segment
Other Resources
Process
20
UNIX Processes

• Each process has its own address space
• Subdivided into text, data, stack segment
• a.out file describes the address space
• OS kernel creates descriptor to manage process
• Process identifier (PID) User handle for the
  process (descriptor)
• Try ps and ps -aux (read man page)

21
Creating/Destroying Processes

• UNIX fork() creates a process
• Creates a new address space
• Copies text, data, stack into new adress space
• Provides child with access to open files
• UNIX wait() allows a parent to wait for a child
  to terminate

22
Creating a UNIX Process
int pidValue ... pidValue fork() /
Creates a child process / if(pidValue 0)
/ pidValue is 0 for child, nonzero for parent
/ / The child executes this code concurrently
with parent / childsPlay() / A
procedure linked into a.out / exit(0) /
The parent executes this code concurrently with
child / parentsWork(..) wait() ...
23
Child Executes aDifferent Program
int pid ... / Set up the argv array for the
child / ... / Create the child / if((pid
fork()) 0) / The child executes its own
absolute program / execve(childProgram.out,
argv, 0) / Only return from an execve call if
it fails / printf(Error in the exec
terminating the child ) exit(0)
... wait() / Parent waits for child to
terminate / ...
24
Example Parent
include ltsys/wait.hgt define NULL
0 int main (void) if (fork() 0) /
This is the child process /
execve("child",NULL,NULL) exit(0)
/ Should never get here, terminate / /
Parent code here / printf("Processd
Parent in execution ...\n", getpid())
sleep(2) if(wait(NULL) gt 0) / Child
terminating / printf("Processd
Parent detects terminating child \n",
getpid()) printf("Processd
Parent terminating ...\n", getpid())
25
Example Child
int main (void) / The child process's new
program This program replaces the parent's
program / printf("Processd child in
execution ...\n", getpid()) sleep(1)
printf("Processd child terminating ...\n",
getpid()) sys_wait in another word file
26
Threads -- The NT Model
Thread (Execution Engine)
Data
Other Resources
Binary Program
Process
27
Resources

• Anything that a process requests from an OS
• Available ? allocated
• Not available ? process is blocked
• Examples
• Files
• Primary memory address space (virtual memory)
• Actual primary memory (physical memory)
• Devices (e.g., window, mouse, kbd, serial port,
  )
• Network port
• many others

28
Files

• Data must be read into (and out of) the machine
  I/O devices
• Storage devices provide persistent copy
• Need an abstraction to make I/O simple the file
• A file is a linearly-addressed sequence of bytes
• From/to an input device
• Including a storage device

29
The File Abstraction
Data
File
Process
Stack
Program
Operating System
File Descriptor
Processor
Storage Device
Hardware
Executable Memory
30
UNIX Files

• UNIX and NT try to make every resource (except
  CPU and RAM) look like a file
• Then can use a common interface

open Specifies file name to be used close
Release file descriptor read Input a block of
information write Output a block of
information lseek Position file for
read/write ioctl Device-specific operations
31
UNIX File Example
include ltstdio.hgt include ltfcntl.hgt int
main() int inFile, outFile char
inFileName in_test char outFileName
out_test int len char c inFile
open(inFileName, O_RDONLY) outFile
open(outFileName, O_WRONLY) / Loop through the
input file / while ((len read(inFile, c,
1)) gt 0) write(outFile, c, 1) / Close
files and quite / close(inFile)
close(outFile)
32
Shell Command Line Interpreter
Interactive User
Application System Software
Shell Program
OS System Call Interface
OS
33
The Shell Strategy
grep first f3
fork a process
read keyboard
Shell Process
Process to execute command
f3
read file
34
Bootstrapping

• Computer starts, begins executing a bootstrap
  program -- initial process
• Loads OS from the disk (or other device)
• Initial process runs OS, creates other processes

35
Bootstrap Program

• This appendix describes the Bootstrap Program,
  also known as the ROM Monitor.
• The Bootstrap Program can help you isolate or
  rule out hardware problems encountered when
  installing your router.
• A summary of the bootstrap diagnostic tests and
  command options is provided.

36
The ROM program varies in length, but basically
performs the following

• Diagnostics, usually called Power On Self Test
  (POST)
• Location, loading, and execution of a larger
  bootstrap program from the bootable drive
• Loading and execution of the kernel by the
  bootstrap program

37
The ROM bootstrap program does the following,
though not necessarily in this order

• Performs POST, including testing memory,
  keyboard, and console.
• Polls all addresses where a device can reside,
  and either runs diagnostics in the ROM or asks
  the device to run a self-diagnostic and report
  the results.
• Finds the device that is bootable, usually the
  first drive.

38

• Determines whether that device has a program in
  its own ROM that needs to be loaded in order to
  control the device, then loads it.
• Jumps to the now-loaded device control program
  that lets you load the disk bootstrap program,
  and loads it. The program resides in the boot
  block or boot sector of a disk. That sector has
  become a favorite target area for virus writers,
  because it's very hard to boot a computer without
  loading and executing the boot sector.
• Jumps to the beginning of the now-loaded disk
  bootstrap program and executes it.

39
The origin of Bootstrapping

• Booting is a shortened version of bootstrapping,
  which comes from the expression "to lift yourself
  up by your own bootstraps."
• Oddly enough, that would be impossible, but the
  expression means "to help yourself."

40
A typical Unix boot sequence is

• Power-on
• ROM boot starts and runs POST
• ROM boot loads and executes the boot sector or
  boot block (commonly called primary boot)
• Boot block executes by loading and executing the
  secondary boot program, which does a local or
  network boot
• Unix kernel is loaded from a local disk drive or
  over the network, then executed

41
Initializing a UNIX Machine
Serial Port A
login
Serial Port B
login
Serial Port C
login
Serial Port Z
login
getty
/etc/passwd
42
Objects

• A recent trend is to replace processes by objects
• Objects are autonomous
• Objects communicate with one another using
  messages
• Popular computing paradigm
• Too early to say how important it will be ...

43
Interrupt

• CLI
• STI

44
(No Transcript)
45
(No Transcript)
46
Be careful about CLI and STI

• Unix-like systems have used the functions cli and
  sti to disable and enable interrupts for many
  years.
• In modern Linux systems, however, using them
  directly is discouraged.
• It is increasingly impossible for any routine to
  know whether interrupts are enabled when it is
  called thus, simply enabling interrupts with sti
  before return is a bad practice.
• Your function may be returning to a function that
  expects interrupts to be still disabled.

47
Thus, if you must disable interrupts, it is
better to use the following calls

• unsigned long flags
• save_flags(flags)
• cli()
• / This code runs with interrupts disabled /
  restore_flags(flags)

48
Enabling and Disabling Interrupts

• We have already seen the sti and cli functions,
  which can enable and disable all interrupts.
  Sometimes, however, it's useful for a driver to
  enable and disable interrupt reporting for its
  own IRQ line only. The kernel offers three
  functions for this purpose, all declared in
  ltasm/irq.hgt
• void disable_irq(int irq) void
  disable_irq_nosync(int irq)
• void enable_irq(int irq)