Study Guide for CS414 Final

Posted: Sunday Dec 9 2007

• Your experience and learning in our OS class is meant to be "holistic" in nature -- that is, a well-qualified student of CS414 should be able to integrate the course material into one seamless, end-to-end collection of knowledge regarding operating systems. Therefore, ALL the material that we have covered is fair game for appearing on the final (i.e., the book, the programming assignments, the homeworks, and especially the class discussions). Note: approximately 25% of the exam will be from material prior to the midterm exam.
• In addition to the class notes, the following material from the book should be studied for the final:

1. If you have the 6^th edition,

1. Chapter 7: Synchronization

1. NOT 7.6 (“Critical Regions”)

2. NOT 7.8 (“OS Synchronization”)

3. NOT 7.9 (“Atomic Transactions”)

2. Chapter 8: Deadlock

3. Chapter 9: Memory Management

4. Chapter 10: Virtual Memory

5. Chapter 11: File System Interface

6. Chapter 12: File System Implementation

1. NOT 12.8 (“Log-structured file system”)

2. NOT 12.9 (“NFS”)

7. Chapter 13: I/O Systems

1. NOT 13.6 (“Streams”)

8. Chapter 14: Mass-Storage Structure

1. NOT 14.7 ("Stable-Storage Implementation")

2. NOT 14.8 ("Tertiary-Storage Structure")

9. Chapter 18: Protection

1. NOT 18.6 (“Capability-Based Systems”)

2. NOT 18.7 (“Language-Based Protection”)

10. Chapter 19: Security

1. NOT 19.8 (“Computer-Security Classifications”)

2. NOT 19.9 (“An Example: Windows NT”)

2. If you have the 7^th edition,

1. Chapter 6: Synchronization

1. NOT 6.8 (“Synchronization Examples”)

2. NOT 6.9 (“Atomic Transactions”)

2. Chapter 7: Deadlock

3. Chapter 8: Main Memory

1. NOT 8.7 (“The Intel Pentium”)

4. Chapter 9: Virtual Memory

1. NOT 9.7 (“Memory-mapped files”)

2. NOT 9.8 (“Allocating Kernel Memory”)

3. NOT 9.10 (“Operating-System Examples”)

5. Chapter 10: File System Interface

1. NOT 10.5 (“File sharing")

6. Chapter 11: File System Implementation

1. NOT 11.8 (“Log-structured file system”)

2. NOT 11.9 (“NFS”)

3. NOT 11.10 (“WAFL”)

7. Chapter 12: Mass-Storage Structure

1. NOT 12.8 ("Stable-Storage Implementation")

2. NOT 12.9 ("Tertiary-Storage Structure")

8. Chapter 13: I/O Systems

1. NOT 13.6 ("Streams”)

9. Chapter 14: Protection

1. NOT 14.8 (“Capability-Based Systems”)

2. NOT 14.9 (“Language-Based Protection”)

10. Chapter 15: Security

1. NOT 15.8 (“Computer-Security Classifications”)

2. NOT 15.9 (“An Example: Windows XP”)

• As a general rule, the importance of a particular topic can be determined by the amount of time I spent in class discussing it.
• Note that in general I will not ask you how a particular OS (e.g., Linux, WinXP, etc.) does something (e.g., "How does Linux do memory management?"). Rather, I will ask you about how a generic OS does something or might do something.

1. NOTE: the clear exception to this "rule" is with regard to Linux/UNIX file systems (inodes, VFS, etc.)

Material to Know (in addition to the material for the midterm)

Process synchronization
    producer/consumer problems, race conditions
    critical section problem
        solution characteristics: mutual exclusion, progress, bounded waiting (no starvation)
        hardware support for synchronization
        semaphores, busy waiting vs. blocking
        monitors
 
Deadlock
 necessary conditions: mutual exclusion, hold&wait, no preemption, circular wait
 system resource allocation graph
 prevention: difficult/costly in practice, circular wait best candidate
 avoidance: safe state, safe sequence
 resource allocation graph algorithm (if one of each resource)
 Banker's algorithm (if multiple resource instances)
 detection: wait-for graph (if one of each resource)
 deadlock detection algorithm (if multiple resource instances)
 recovery: either preempt resources or abort processes 

Memory Management
 Address binding 
 Logical (virtual) versus physical address space
 Swapping
 Contiguous Memory Allocation (fixed-sized partitions)
 External vs. internal fragmentation
 Paging (not in the context of Virtual Memory)
 Translation look-aside buffer (TLB)
 Shared pages
 Segmentation
 
Virtual Memory
 Demand paging
 Mechanism of the page-fault trap (e.g., p. 326)
 Locality of reference
 Performance (effective access time)
 Memory-mapped files
 Page-replacement (FIFO, Optimal, LRU, LFU, MFU)
 LRU Approximation
 Allocation of Frames (equal allocation, proportional allocation, global vs. local replacement)
  Thrashing (and working-set model)
 Small vs. Large page size
 
File-System Interface
 File concept
 Access Methods (sequential, direct)
 Directory structure
 File System Mounting
 File sharing
 Protection
 
File-System Implementation
 File-system structure
 File-system implementation
 Directory implementation
 Allocation methods (contiguous, linked allocation, indexed allocation)
 Indexed allocation: linked vs. multi-level vs. combined scheme
 Free-space management (bit vector, linked list, grouping, counting)
 Efficiency and Performance (e.g., on-board cache, disk cache, page cache
 
I/O Systems
 I/O Hardware (port registers: status, control, data-in, data-out)
 Polling vs. Interrupts
 Direct Memory Access (e.g., Figure 13.5)
 Application I/O interface
 Kernel I/O Subsystem (buffering, caching, spool)
 Transforming I/O to Hardware Operations (e.g., Figure 13.10)
 
Mass-Storage Structure
 Disk structure
 Disk scheduling (seek time, rotational latency, bandwidth)
 FCFS, SSTF, SCAN. C-SCAN, LOOK, C-LOOK
 Disk management
 Swap-Space management
 RAID Structure (basic concepts; not necessary to memorize the levels)
 Tertiary-Storage Structure (e.g., performance)

Protection

Goals

Domain of Protection

Access Matrix

Implementation (Global table, access lists, capability lists)

Revocation of Access Rights

Security

Security Problem

User Authentication

Program Threats (Trojan horse, trap door, stack/buffer overflow)

System Threats (Worms, Viruses, Denial of Service)

Securing Systems and Facilities (e.g., firewall, intrusion detection, auditing, tripwire,

System-call monitoring)

Cryptography (as covered in class)