C191 Study Guide:

CH 1.1: pages 1-34

Main Topics:

1. The Role of an Operating System (OS): Acts as a bridge between hardware

capabilities and user needs, providing essential support for efficient and safe
application development and use.
2. Abstraction and Virtualization: Utilized by OS to simplify and enhance the
interaction between hardware and users. Abstraction combines simpler
operations into more complex ones, hiding details. Virtualization creates illusions
of more favorable characteristics than the actual hardware.
3. The OS as a Resource Manager: Optimizes the use of computational resources
to ensure good overall performance, including CPU, memory, and I/O devices.
4. Multiprogramming and Time-sharing: Techniques to improve CPU utilization
and throughput by running multiple programs simultaneously and sharing CPU
time among multiple computations.
5. OS Structure: A hierarchical organization to manage complexity, with the kernel
providing essential services and supported by libraries and applications.
6. Interrupts and Traps: Mechanisms for handling events and errors, transferring
control to appropriate service routines in the OS.
7. Evolution and Scope of OSs: The classification of OSs over time, driven by
hardware advancements and application environments, from batch processing
systems to modern multi-user, interactive, and real-time systems.

Relevant Vocabulary and Definitions:

 CPU (Central Processing Unit): The primary component of a computer that

performs most of the processing inside a computer.
 Main Memory: The primary storage or RAM (Random Access Memory) where
programs and data are kept for quick access by the CPU.
 Secondary Storage: Non-volatile storage like HDDs (Hard Disk Drives) or SSDs
(Solid State Drives) used for long-term data storage.
 I/O Devices (Input/Output Devices): Hardware used for inputting data to or
outputting data from a computer.
 Kernel: The core part of an OS, responsible for managing system resources and
communication between hardware and software applications.
  System Calls: Requests for service from the application to the OS.
 Interrupts: Signals to the processor indicating an event that needs immediate
attention.
 Virtualization: The process of creating a virtual version of something, including
virtual computer hardware platforms, storage devices, and computer network
resources.

This summary highlights the foundational concepts and functionalities of operating

systems as described in the first part of the document. For a detailed exploration of all
topics, definitions, and further discussions present in the entire document, the complete
text should be consulted.

CH 1.2:
The document "ch1.2" covers a range of topics essential for understanding computer
storage, memory, I/O structures, computing environments, and the nuances of free and
open-source operating systems. Here is an in-depth summary of the entire document,
including key topics, vocabulary, and definitions:

Key Topics Covered:

1. Computer Storage and Measurement Units: The document begins by detailing

the units used for computer storage, such as kilobytes (KB), megabytes (MB),
gigabytes (GB), terabytes (TB), and petabytes (PB), and contrasts these with
networking measurements, which are in bits.
2. Memory Management: It explores how all forms of memory provide an array of
bytes, each with its own address, and how memory management involves load
and store instructions to specific memory addresses.
3. Secondary Storage: The necessity of secondary storage (e.g., HDDs, SSDs) due
to the volatile nature of main memory and its limited capacity is discussed,
emphasizing its role in permanently storing large quantities of data.
4. Storage Hierarchy and Technologies: A hierarchy of storage systems based on
speed, size, and volatility is presented, including volatile and nonvolatile storage,
and the transition from mechanical to electrical storage solutions.
5. I/O Structure: The document explains the structure of Input/Output in
computers, including the use of Direct Memory Access (DMA) and the efficiency
of different architectures (bus vs. switch) in handling I/O operations.
6. Computing Environments: Various computing environments are outlined,
including traditional computing, mobile computing, client-server computing,
 peer-to-peer systems, and cloud computing, each discussed with their unique
characteristics and evolution.
7. Free and Open-Source Operating Systems: An in-depth look at the benefits of
free and open-source operating systems, including their history, the difference
between free and open-source, and notable examples like GNU/Linux and BSD
UNIX.

Important Vocabulary and Definitions:

 Volatile/Nonvolatile Storage: Volatile storage loses its content when power is

turned off, whereas nonvolatile storage retains its content.
 Direct Memory Access (DMA): A method that allows an input/output (I/O)
device to send or receive data directly to or from the main memory, bypassing
the CPU to speed up memory operations.
 Client-Server System: A computing model in which server systems satisfy
requests generated by client systems, used in distributed computing
environments.
 Peer-to-Peer (P2P) System: A decentralized computing model where each
participant, or peer, acts as both a client and a server.
 Cloud Computing: The delivery of computing services over the internet ("the
cloud"), including servers, storage, databases, networking, software, analytics, and
intelligence.
 GNU General Public License (GPL): A widely used free software license that
ensures end users the freedom to run, study, share, and modify the software.

This document offers a comprehensive overview essential for understanding the

fundamentals of computer systems, storage management, and the impact of different
computing models and environments on the development and use of operating
systems.

CH 2
The document "ch2.pdf" delves into operating system services, system calls, and the
interfaces between user programs and the operating system. Here's a detailed summary
of all 35 pages, focusing on the most important topics, vocabulary, and definitions:

Main Topics:

1. Operating System Services: These include user interface options (CLI, GUI,
touchscreens), program execution, I/O operations, file-system manipulation,
 communications, error detection, resource allocation, logging, and
protection/security.
2. User and Operating-System Interface: It discusses command-line interfaces
(CLI), graphical user interfaces (GUI), and touch-screen interfaces as the means for
users to interact with the operating system.
3. System Calls: Describes system calls as the programming interface between the
user program and the operating system, detailing their use, types, and
mechanisms.
4. Types of System Calls: System calls are categorized into process control, file
management, device management, information maintenance, communications,
and protection.
5. System Services (Utilities): Covers file management, status information, file
modification, and programming-language support, providing a conducive
environment for program development and execution.

Relevant Vocabulary and Definitions:

 System Call: A software-triggered interrupt for requesting a kernel service.

 API (Application Programming Interface): A set of commands and functions
for programming applications to interact with the operating system.
 CLI (Command-Line Interface): A text-based interface for entering commands
directly to the operating system.
 GUI (Graphical User Interface): An interface featuring graphical elements like
windows, icons, and menus for user interaction.
 Process Control: System calls related to the creation, execution, and termination
of processes.
 File Management: System calls for creating, deleting, reading, writing, and
managing files.
 Device Management: System calls for managing hardware devices.
 Information Maintenance: System calls for managing and retrieving system
information.
 Communications: System calls for establishing and managing communication
between processes.
 Protection: System calls for managing access rights and permissions for system
resources.

This comprehensive summary encapsulates the foundational principles of operating

systems as discussed in the document, including the services they provide, the interfaces
they offer to users and programmers, and the system calls that facilitate these
interactions.
CH 3.1
The document "ch3.1.pdf" comprehensively covers the concepts of processes in
operating systems, including their creation, control, and management. Here's a detailed
summary along with the most important topics, vocabulary, and definitions:

Main Topics:

1. The Process Concept: Defines a process as an instance of a program being

executed. It introduces the Process Control Block (PCB), a data structure that
holds all information about a process, including its current state, memory
allocation, and execution context.
2. Process States and Transitions: Discusses various states a process can be in
(e.g., running, ready, blocked) and the transitions between these states based on
events such as resource allocation or completion of execution.
3. Process Control Block (PCB): Details the components of a PCB, including CPU
state, process state, memory pointers, scheduling and accounting information, list
of open files, and other resources. It emphasizes the PCB's role in managing and
tracking process information throughout its lifecycle.
4. Organizing PCBs: Explores methods for efficiently organizing PCBs within the
operating system, including using arrays or linked lists, to facilitate easy
allocation, tracking, and deallocation of processes.
5. Process Creation and Destruction: Explains how processes are created and
destroyed, including the allocation of a new PCB upon process creation, setting
initial state and resources, and the cleanup activities involved in process
destruction.

Relevant Vocabulary and Definitions:

 Process: An instance of a program in execution.

 Process Control Block (PCB): A data structure in the operating system that
contains all the information about a process.
 CPU State: Part of the PCB that stores the contents of CPU registers and flags for
a process.
 Process State: Indicates the current status of a process (e.g., running, ready,
blocked).
 Memory Management: Refers to the management of the primary memory or
RAM and involves keeping track of each byte of memory to decide how
allocation and deallocation occurs.
  Scheduling Information: Information used by the operating system to schedule
processes on the CPU, including process priority and CPU time used.
 Open Files: A list of files that a process has opened, maintained within the PCB.
 Process Creation (create()): The function called by the operating system to
create a new process, involving the allocation and initialization of a new PCB.
 Process Destruction (destroy()): The function called to terminate a process and
free its resources, including deallocating its PCB.

This document provides a foundational understanding of processes in operating

systems, emphasizing the importance of the PCB in process management and the
lifecycle of a process from creation to destruction.

Ch 3.2
The document "ch3.2.pdf" delves into advanced topics regarding process management
and communication in operating systems, particularly focusing on interprocess
communication (IPC), threads, and resource management. Here's a detailed summary
covering the entire document along with important topics, vocabulary, and definitions:

Interprocess Communication (IPC)

 IPC Mechanisms: The document compares two fundamental IPC models: shared
memory and message passing. Shared memory requires processes to establish a
region of memory they can both access, enabling direct data exchange. Message
passing involves sending and receiving messages through a communication link,
without sharing memory space.
 Producer-Consumer Problem: It uses the producer-consumer scenario to
illustrate IPC mechanisms. The problem highlights synchronization needs
between processes to prevent data corruption and ensure proper sequencing of
operations.

Threads

 Thread Concept: Threads allow a process to execute multiple sequences of

operations concurrently within its own context, sharing the same process
resources but operating independently.
 Thread Efficiency: Threads are more resource-efficient than full processes
because they share the same memory space and resources, reducing the
overhead required for process creation and context switching.
  User-Level vs Kernel-Level Threads: The distinction between user-level threads,
managed within user space, and kernel-level threads, managed by the operating
system. User-level threads offer fast operation but limited by single-threaded OS
views, while kernel-level threads can leverage multi-core processors but with
greater overhead.

Resource Management

 Resource Allocation and Release: Detailed discussion on how operating

systems manage resources, including the allocation to processes upon request
and release back into the system.
 Resource Control Block (RCB): A data structure analogous to the Process
Control Block (PCB) but for managing resources. It tracks the status and
allocation of system resources.

Important Vocabulary and Definitions:

 IPC: Mechanism allowing processes to communicate and synchronize their

actions.
 Shared Memory: An IPC method where a memory area is shared between
multiple processes.
 Message Passing: An IPC technique involving sending and receiving messages
between processes.
 Thread: A sequence of executable instructions within a process that can run
independently of other sequences.
 Thread Control Block (TCB): Data structure containing thread-specific
information, similar to PCB for processes.
 Direct Communication: A messaging pattern where the sender specifies the
recipient directly.
 Indirect Communication: Communication through a shared mailbox, not
specifying the recipient directly.
 Synchronization: Mechanisms ensuring that multiple processes or threads can
operate safely when accessing shared resources or communicating.

This document provides a comprehensive overview of process and thread management,

emphasizing IPC, the role of threads in modern computing, and the mechanisms for
managing system resources. It presents fundamental concepts necessary for
understanding how operating systems facilitate concurrent execution and
communication among processes.
CH 3.3

The document "ch3.3.pdf" covers various advanced concepts related to interprocess

communication (IPC), message passing mechanisms, pipes, and the intricacies of
multicore programming. Here's a summary of the first 28 pages out of 32, highlighting
the most important topics along with relevant vocabulary and definitions:

Interprocess Communication (IPC) Systems

 POSIX Shared Memory: Uses memory-mapped files for processes to access

shared memory, requiring the shm_open() system call to create a shared-memory
object.
 Mach Message Passing: Designed for distributed systems, using messages sent
to and received from mailboxes (called ports in Mach), which are finite in size and
unidirectional.

Pipes

 Ordinary Pipes (UNIX and Windows): Allow unidirectional communication

between two processes, typically between a parent and its child, using the
standard pipe() function in UNIX and CreatePipe() in Windows.
 Named Pipes: Offer a more flexible communication mechanism, allowing
bidirectional communication without a parent-child relationship and persisting
after the communicating processes have terminated.

Multicore Programming

 Concurrency vs. Parallelism: Differentiates between systems that support more

than one task by interleaving (concurrency) and systems that perform more than
one task simultaneously (parallelism).
 Programming Challenges: Identifying tasks that can run in parallel, ensuring
balance among tasks, splitting data, managing data dependencies, and the
complexities of testing and debugging multithreaded applications.
 Amdahl's Law: Illustrates potential performance gains from adding additional
computing cores to an application with both serial and parallel components.

Types of Parallelism
  Data Parallelism: Distributes subsets of the same data across multiple
computing cores and performs the same operation on each core.
 Task Parallelism: Distributes tasks (threads) across multiple computing cores,
with each task performing a unique operation.

Multithreading Models

 Many-to-One Model: Maps many user-level threads to one kernel thread,

limiting parallelism.
 One-to-One Model: Maps each user thread to a kernel thread, allowing more
concurrency but potentially burdening the system with too many kernel threads.
 Many-to-Many Model: Multiplexes many user-level threads to a smaller or
equal number of kernel threads, offering flexibility and parallelism.

Vocabulary and Definitions

 Thread: A sequence of executable instructions within a process that can run

independently.
 Process: An instance of a program in execution.
 Kernel Thread: A thread managed directly by the operating system.
 User Thread: A thread that operates in user space and is managed without
kernel support.
 IPC: Mechanisms allowing processes to communicate and synchronize their
actions.

This summary highlights key concepts related to IPC, the evolution of computing from
single-core to multicore systems, and the challenges and strategies involved in
multicore and multithreaded programming.

CH 4.1

The document "ch4.1.pdf" provides an in-depth look at the principles of process

scheduling in operating systems, focusing on long-term vs. short-term scheduling,
preemptive vs. non-preemptive scheduling, and various scheduling algorithms. Here's a
comprehensive summary along with important topics, vocabulary, and definitions:

Main Topics:

1. Long-term vs. Short-term Scheduling:

 Long-term scheduling determines when a process enters the ready state,
while short-term scheduling decides which ready process to execute next.
 Long-term scheduling affects the degree of multiprogramming; short-term
scheduling impacts the system's responsiveness.
2. Preemptive vs. Non-preemptive Scheduling:
 Non-preemptive scheduling allows a process to run until it blocks or
voluntarily releases the CPU.
 Preemptive scheduling can interrupt a running process to assign the CPU
to another process, enhancing responsiveness but increasing scheduling
complexity.
3. Scheduling Algorithms:
 FIFO (First-In-First-Out): Processes are scheduled according to their
arrival time.
 SJF (Shortest Job First): Processes with the shortest CPU burst time are
scheduled first. It's efficient but can cause starvation for longer processes.
 SRT (Shortest Remaining Time): A preemptive version of SJF, where
processes with the shortest remaining execution time are prioritized.
 RR (Round Robin): Processes are executed in a cyclic order using time
quanta, ensuring fairness among processes.
 Priority Scheduling: Processes are scheduled based on priority, with
various strategies for handling processes of the same priority.

Vocabulary and Definitions:

 Process: An instance of an executing program, including its current state and

data.
 Scheduling: The method by which work specified by some means is assigned to
resources that complete the work.
 Time Quantum: The fixed time period allocated to each process in round-robin
scheduling.
 CPU Burst: The time period for which a process is executed on the CPU in one
go.
 Starvation: A condition where a process is not given CPU time due to the
continuous execution of other processes.
 Priority Inversion: A scenario where a lower-priority process holds a resource
required by a higher-priority process, effectively inverting their priorities.

This summary encapsulates the core principles behind various scheduling strategies,
emphasizing the trade-offs between fairness, efficiency, and system responsiveness.
Each scheduling algorithm has its advantages and is suited to particular system
requirements and workloads.

CH 4.2

The document "ch4.2.pdf" covers advanced topics in CPU scheduling, focusing on real-
time operating systems, scheduling algorithms for multiprocessor systems, and priority-
based scheduling. Here's a summary of the first 28 pages out of 36, highlighting the
most important topics along with relevant vocabulary and definitions:

Main Topics:

1. Real-time Scheduling (EDF and RM): Discusses Earliest Deadline First (EDF) and
Rate Monotonic (RM) scheduling algorithms for real-time operating systems,
focusing on periodic processes with specific CPU time and deadlines.
2. Combined Approaches for OS Scheduling: Explains that a general-purpose OS
must combine different scheduling algorithms to accommodate various types of
processes, including batch, interactive, and real-time processes. A two-tier
scheduling scheme is mentioned, dividing processes into real-time and
batch/interactive groups with different priority levels.
3. Scheduling with Floating Priorities: Introduces a more flexible scheduling
approach where processes are assigned a base priority, and increments are
added based on their actions, such as returning from keyboard or disk input. This
method allows for dynamic adjustment of process priorities.
4. Scheduling Criteria: Outlines criteria for comparing CPU-scheduling algorithms,
including CPU utilization, throughput, turnaround time, waiting time, and
response time. The goal is to maximize CPU utilization and throughput while
minimizing turnaround time, waiting time, and response time.
5. Multi-processor Scheduling: Addresses the complexities of scheduling in
systems with multiple processors, including symmetric multiprocessing (SMP) and
load sharing. It mentions asymmetric multiprocessing, where only one processor
handles system activities, and symmetric multiprocessing, where each processor
is self-scheduling.
6. Multicore Processors and Multithreading: Explains how multicore processors
complicate scheduling issues and introduces the concept of multithreaded
processing cores, where if one hardware thread stalls, the core can switch to
another thread.
 7. Load Balancing: Discusses the importance of balancing the workload among
processors in an SMP system and introduces two general approaches to load
balancing: push migration and pull migration.
8. Processor Affinity: Covers the concept of processor affinity, which tries to keep
a thread running on the same processor to take advantage of a warm cache. It
differentiates between soft and hard affinity.
9. Heterogeneous Multiprocessing (HMP): Describes systems that use cores
varying in clock speed and power management, known as big.LITTLE architecture
in ARM processors, to manage power consumption efficiently.

Vocabulary and Definitions:

 Rate-Monotonic Scheduling (RM): A static-priority scheduling algorithm where

shorter period tasks have higher priority.
 Earliest Deadline First (EDF): A dynamic-priority scheduling algorithm that
prioritizes tasks closer to their deadlines.
 Symmetric Multiprocessing (SMP): A system where each processor is self-
scheduling, all processors are equal, and any processor can perform any task.
 Chip Multithreading (CMT) / Hyper-threading: Techniques allowing multiple
threads to run on a single processor core to optimize usage and avoid memory
stalls.
 Load Balancing: Techniques to distribute work evenly across all processors in a
system to ensure efficient utilization.
 Processor Affinity: A strategy to keep a process running on the same processor
to utilize the warm cache effectively.
 Heterogeneous Multiprocessing (HMP): Systems that combine high-
performance and energy-efficient processor cores to manage power
consumption effectively.

This summary covers the document's exploration of CPU scheduling, particularly in real-
time and multiprocessor systems, emphasizing the complexities and strategies involved
in efficiently managing CPU resources across various computing environments.

CH 5.1

The document "ch5.1.pdf" provides an in-depth discussion on process interactions,

focusing on concurrency, the critical section problem, and synchronization mechanisms.
Here is a summary along with the most important topics, vocabulary, and definitions:
Process Interactions and Concurrency

 Concurrency is the act of multiple processes or threads executing at the same

time, which can be achieved through parallel execution on multiple CPUs or time-
sharing on a single CPU.
 Critical Section: A segment of code that cannot be simultaneously executed by
more than one process to prevent inconsistent data states.

The Critical Section Problem

 Solutions to the critical section problem must ensure mutual exclusion (only one
process in the critical section at a time), prevent lockout (ensuring every process
gets a chance to enter the critical section), prevent starvation (making sure all
processes eventually get to enter the critical section), and prevent deadlock.
 A software approach to solving this problem involves using flags and a tie-
breaker variable to ensure that all conditions for solving the critical section
problem are met.

Synchronization Mechanisms

 Mutex Locks: Mutual exclusion locks used to protect critical sections and prevent
race conditions. Processes must acquire the lock before entering a critical section
and release it upon exiting. The document discusses the implementation and
disadvantages of mutex locks, such as busy waiting, where a process loops
continuously while waiting to acquire the lock.

Vocabulary and Definitions

 Mutex Lock: A mutual exclusion mechanism to ensure that only one process can
access a critical section at a time.
 Busy Waiting: A situation where a process continuously checks if a condition is
met, which can waste CPU resources.
 Spinlock: A lock where a process "spins" (repeatedly checks) while waiting for the
lock to become available, useful in multicore systems for short durations to avoid
the overhead of context switching.

The document emphasizes the importance of correctly managing process interactions to

ensure system reliability and efficiency. It introduces basic concepts and mechanisms to
address the critical section problem, highlighting the challenges and solutions related to
process synchronization in concurrent computing environments.
CH 5.2

The document "ch5.2.pdf" explores synchronization mechanisms in operating systems,

particularly focusing on monitors, condition variables, and the bounded-buffer
(producer-consumer) problem. It also discusses priority waits and the monitor-based
solutions to classic synchronization problems like the alarm clock, dining philosophers,
and the elevator algorithm. Here's a summary along with important topics, vocabulary,
and definitions:

Monitors and Condition Variables

 Monitors: A high-level synchronization construct that allows threads to have

both mutual exclusion and the ability to wait (block) for a certain condition to
become true.
 Condition Variables: Used within monitors to allow threads to wait for certain
conditions within the monitor. Threads can signal other threads to wake up when
conditions change.

Bounded-Buffer Problem

 Demonstrates a monitor solution for the classic producer-consumer problem,

where mutual exclusion is guaranteed, and threads wait on condition variables
notfull and notempty to produce or consume items.

Priority Waits

 Introduces a variation of wait operations where waits can have priorities, enabling
more control over the order of thread waking, useful in specific synchronization
scenarios like the alarm clock monitor.

Alarm Clock Problem

 A monitor-based solution where threads wait for a certain time before

proceeding. The monitor uses priority waits to manage waking order based on
alarm settings.

Dining Philosophers Problem

  Discusses a monitor solution to prevent deadlock and ensure that philosophers
(threads) can pick up forks (resources) to eat (execute) without causing a
deadlock.

Elevator Algorithm

 A synchronization solution for managing requests in systems like disk scheduling

or elevator control. The algorithm prioritizes requests based on their direction
and order to optimize performance and avoid starvation.

Vocabulary and Definitions

 Monitor: A synchronization construct that controls access to shared resources by

multiple threads.
 Condition Variable: A synchronization aid that allows threads to wait until a
certain condition occurs.
 Mutual Exclusion: Ensures that only one thread can access a resource or critical
section at any time.
 Deadlock: A situation where two or more threads are blocked forever, waiting for
each other to release resources.
 Starvation: A condition where a thread is perpetually denied access to resources
it needs to proceed.
 Priority Wait: A wait operation that allows threads to be prioritized based on
certain criteria when they are waiting on a condition variable.

This summary highlights the document's exploration of advanced synchronization

techniques and solutions to classic problems, emphasizing the importance of properly
managing thread execution and resource allocation in concurrent programming
environments.

CH 6

The document "ch6.pdf" delves into the intricacies of deadlock in operating systems,
focusing on concepts like resource allocation graphs, deadlock modeling, detection,
avoidance, and prevention strategies. Here's a comprehensive summary along with
important topics, vocabulary, and definitions:

Resource Allocation and Deadlocks

  Resource Allocation Graphs (RAGs): Visual representations showing processes,
resources, and their relationships. Processes are depicted as circles, resources as
rectangles, and allocations/requests by directed edges.
 Deadlock Modeling: Explains how deadlocks involve processes waiting
indefinitely for resources held by other processes, forming a cycle in the RAG.

Deadlock Detection and Avoidance

 Graph Reduction: A technique for deadlock detection by systematically

removing unblocked processes and their associated edges from the RAG. A graph
that cannot be completely reduced indicates a deadlock.
 The Banker's Algorithm: An avoidance strategy that simulates bank loan
issuance to manage resource allocation safely. It ensures that granting a resource
will not lead to a non-reducible graph, thereby avoiding deadlocks.

Deadlock Prevention

 Conditions for Deadlock: Highlights necessary conditions for a deadlock,

including mutual exclusion, hold and wait, no preemption, and circular wait.
 Eliminating Hold and Wait: Proposes strategies to prevent deadlocks by
ensuring processes do not hold onto resources while waiting for others.
 Ordered Resource Allocation: Prevents circular wait by imposing a global
ordering on resource requests, ensuring that processes request resources in a
defined sequence.

Vocabulary and Definitions

 Deadlock: A situation where a set of processes are blocked because each process
is holding a resource and waiting for another resource acquired by some other
process.
 Mutual Exclusion: Only one process can use a resource at any given time.
 Hold and Wait: A process holding at least one resource is waiting to acquire
additional resources held by other processes.
 Circular Wait: A set of processes are waiting for each other in a circular chain.
 Resource Allocation Graph (RAG): A directed graph where vertices represent
processes and resources, and edges represent allocation of resources to
processes or process requests for resources.

This document provides a thorough understanding of deadlocks in operating systems,

including their detection, avoidance, and prevention. It emphasizes the importance of
careful resource management and scheduling strategies to ensure efficient and
deadlock-free system operation.

CH 7.1

The document "ch7.1.pdf" offers an insightful exploration into memory management in

operating systems, specifically focusing on logical versus physical memory, program
transformations, and dynamic versus static relocation. Here's a concise summary along
with key topics, vocabulary, and definitions:

Logical vs. Physical Memory

 Logical Memory: An abstraction that allows programmers to view memory as a

contiguous address space without concern for the actual physical memory layout.
It simplifies programming and enhances security and isolation between
processes.
 Physical Memory (RAM): The actual hardware memory available in the system.
It's organized as a linear array of words, each with a unique physical address.

Program Transformations

 Source Module: A program written in a high-level or assembly language that

needs to be translated into machine code by a compiler or assembler.
 Object Module: The output of the compiler or assembler, which may be linked
with other object modules to form a load module.
 Load Module: The final form of a program, ready to be loaded into memory and
executed.

Dynamic vs. Static Relocation

 Static Relocation: Logical addresses are bound to physical addresses before

execution. The entire process must be relocated if moved in memory.
 Dynamic Relocation: Binding of logical addresses to physical addresses is
deferred until the time of access during execution. This allows more flexibility in
using physical memory but requires hardware support for address translation.

Key Definitions
  Relocation Register: A hardware register that holds the starting physical address
of a program in memory. It's used to translate logical addresses to physical
addresses dynamically during execution.
 Memory Compaction: The process of relocating programs in memory to
consolidate free memory space, reducing fragmentation.
 Fragmentation: The existence of unusable memory spaces between allocated
segments. External fragmentation refers to the space outside allocated regions,
while internal fragmentation refers to wasted space within allocated regions.

This document delves into the foundational concepts of memory management,

emphasizing the need for efficient handling of logical and physical memory spaces, the
process of transforming programs from source to executable form, and strategies like
dynamic relocation to optimize memory usage.

CH 7.2

The document "ch7.2.pdf" extensively discusses memory management techniques in

operating systems, focusing on paging and segmentation, their advantages, address
translation mechanisms, and the role of the Translation Lookaside Buffer (TLB). Here's a
summary of the key topics, vocabulary, and definitions:

Paging and Segmentation

 Paging: Divides memory into fixed-size units called pages, which are mapped
into frames of physical memory. Paging simplifies memory allocation and
effectively handles memory fragmentation.
 Segmentation: Divides memory into segments of variable size according to
logical divisions of a program, such as code, data, and stack segments.
Segmentation allows for more natural memory access patterns aligned with
program structure.

Address Translation

 Logical vs. Physical Address: Logical addresses are generated by the CPU
during program execution, while physical addresses refer to actual locations in
memory. Address translation maps logical to physical addresses.
 Page Table: Used in paging to store mappings from virtual pages to physical
frames. Each entry in the page table corresponds to a page in memory.
  Segment Table: Used in segmentation to store information about each segment,
including its starting address in physical memory and length.

Translation Lookaside Buffer (TLB)

 TLB: A cache that stores recent translations of virtual memory addresses to

physical addresses. The TLB speeds up the address translation process by
reducing access to the page table stored in memory.
 TLB Hit Ratio: The fraction of address translations that are found in the TLB. A
higher hit ratio means fewer accesses to the page table, improving performance.

Internal Fragmentation and External Fragmentation

 Internal Fragmentation: Occurs in paging when allocated memory blocks

(pages or frames) are partially filled, wasting memory within the blocks.
 External Fragmentation: Happens in segmentation when free memory is split
into small blocks between allocated segments, making it difficult to find
contiguous space for new segments.

Combined Paging and Segmentation

 Combines the benefits of both paging and segmentation by segmenting the

memory into logical units and further dividing each segment into pages. This
approach allows for efficient memory use and protection while minimizing
fragmentation.

Key Definitions

 Segment Number (s) and Offset (w): In segmentation, the segment number
identifies a segment, and the offset specifies the location within that segment.
 Page Number (p) and Offset (w): In paging, the page number identifies a page
within the virtual address space, and the offset specifies the location within that
page.
 Frame Number (f): Identifies a frame within physical memory.

This document highlights the complexities and intricacies of managing memory in

modern operating systems, emphasizing the need for efficient mechanisms like paging
and segmentation to optimize memory usage and access speed.
CH 8.1
The document "ch8.1.pdf" explores the concept of virtual memory (VM), detailing
demand paging, page replacement strategies, and the use of bits like the present bit
and modified bit in page table entries. Here's a comprehensive summary along with
important topics, vocabulary, and definitions:

Virtual Memory (VM) and Demand Paging

 Virtual Memory (VM): A technique that allows the execution of processes that
may not be completely in memory, creating the illusion of a large address space
that exceeds physical memory size.
 Demand Paging: Loads pages into memory only when they are needed, not in
advance, reducing memory usage and improving response time.

Present Bit and Page Faults

 Present Bit: A flag in each page table entry indicating whether the
corresponding page is in physical memory. If a page is not present (the bit is 0),
accessing it triggers a page fault.
 Page Fault: Occurs when a program tries to access a page not currently in
memory, prompting the OS to load the required page from disk into memory.

Page Replacement and Modified Bit

 Page Replacement: The process of swapping out a page from physical memory
to make room for a new page when memory is full. Strategies aim to select the
best page to replace, minimizing the number of page faults.
 Modified Bit (M-bit): Indicates whether a page has been modified (written to)
while in memory. If not modified, the page doesn't need to be written back to
disk upon replacement, saving I/O time.

Key Definitions

 Page Table: A data structure used by the VM system to store the mapping of
virtual pages to physical frames.
 Frame: A fixed-size block of physical memory. VM systems map pages to frames.
 Segmentation: Divides memory into segments of variable length, each segment
being a logical unit like a process's code, data, or stack segment.
This document highlights the mechanisms underlying VM, emphasizing the efficiency
and necessity of demand paging and page replacement in managing limited physical
memory resources.

CH 8.2

The document "ch8.2.pdf" provides an in-depth analysis of the operational aspects of

virtual memory (VM), focusing on page replacement algorithms, the working set model,
and strategies to manage page faults and memory load efficiently. Here's a detailed
summary along with the most important topics, vocabulary, and definitions:

Page Replacement Algorithms

 Third-Chance Algorithm: Refines the second-chance algorithm by utilizing both

the referenced (r-bit) and modified (m-bit) bits of pages, giving modified pages
an additional chance to remain in memory due to the higher cost of replacing
them.

Working Set Model

 Working Set: A dynamic set of pages that a process is currently using, aimed at
minimizing page faults by keeping these pages in memory. The working set
changes as the process accesses different memory locations.
 Window of Size d: The size of the working set is determined by examining the
set of pages referenced in the last d memory references.

Page Fault Frequency Control

 Page-Fault-Frequency Replacement Algorithm: Adjusts the size of the working

set based on the frequency of page faults. This algorithm aims to keep the page
fault rate within acceptable bounds to avoid thrashing.

Thrashing and Load Control

 Thrashing: Occurs when a system spends most of its time servicing page faults
rather than executing processes, leading to severely degraded performance.
 Load Control: Techniques used to prevent thrashing by limiting the number of
processes competing for memory, ensuring that each has enough frames to hold
its working set.
Key Definitions

 Virtual Memory (VM): An abstraction that allows processes to execute with the
illusion of having more memory available than is physically present.
 Page Fault: An event that occurs when a process attempts to access a page that
is not currently in physical memory, requiring the system to load the page from
disk.
 Page Replacement: The process of selecting a page in memory to be replaced
by another page that needs to be loaded, based on a specific algorithm.
 Working Set: The set of pages that a process has referenced in the recent past,
which ideally should be kept in memory to minimize page faults.

This document elaborates on the strategies and algorithms designed to efficiently

manage memory in a system using virtual memory, highlighting the balance between
maximizing CPU utilization and minimizing page fault rates to ensure optimal system
performance.

CH 9

The document "ch9.pdf" provides a comprehensive overview of swapping and its role in
managing memory in operating systems. Here are the key points, along with important
vocabulary and definitions:

Swapping

 Swapping involves moving entire processes or portions thereof between main

memory and a backing store (secondary storage) temporarily. This technique
allows the total physical address space of all processes to exceed the actual
physical memory available, thereby enhancing the degree of multiprogramming.

Standard Swapping

 Involves moving entire processes between main memory and a backing store,
typically fast secondary storage. This approach enables physical memory
oversubscription but is less commonly used in contemporary systems due to the
prohibitive time required to move entire processes.

Swapping with Paging

  Modern systems, like Linux and Windows, utilize a form of swapping where
individual pages of a process, rather than the entire process, can be swapped.
This method aligns well with virtual memory systems, allowing physical memory
to be oversubscribed without incurring the costs associated with swapping entire
processes.

Swapping on Mobile Systems

 Mobile operating systems typically do not support swapping due to limitations of

flash memory, including space constraints, limited write cycles, and poor
throughput. Instead, systems like iOS and Android may terminate processes or
ask applications to voluntarily relinquish memory to manage low-memory
situations.

System Performance Under Swapping

 While swapping pages is more efficient than swapping entire processes, frequent
swapping indicates that a system may have more active processes than available
physical memory. Solutions include terminating some processes or adding more
physical memory.

Vocabulary and Definitions

 Swapped: The action of moving processes or pages between main memory and
a backing store to manage memory resources.
 Backing Store: Secondary storage used for the temporary storage of processes
or pages that are swapped out of main memory.
 Application State: A construct used in mobile operating systems to save the
state of an application so it can be quickly restarted after being terminated due
to low memory conditions.

This document highlights the evolution of swapping strategies from standard process
swapping to more efficient page-level swapping in conjunction with virtual memory, and
the unique approaches taken by mobile operating systems to manage memory
resources.
CH 10.1

The document "ch10.1.pdf" delves into the structure and management of file systems,
detailing the concepts of files, directories, and the various operations that can be
performed on them. Here's a concise summary along with key topics, vocabulary, and
definitions:

File and Directory Concepts

 Files: Named collections of data stored persistently on secondary storage

devices. They can be viewed as unstructured byte streams or as structured series
of records.
 Directories (Folders): Special files that store information about other files,
including their names and locations, organizing them into a hierarchical structure
for easy navigation and management.

File Operations

 Operations such as create, delete, read, write, and seek allow users to manage
files effectively. These operations enable users to interact with the file system's
interface, manipulating files as needed without concerning themselves with the
underlying storage details.

File Types and File Extensions

 File types are identified either by magic numbers within file headers or by file
extensions appended to file names. Magic numbers offer a stronger form of file
typing by indicating the file's format, while file extensions provide convenient but
weaker hints about the file's intended application.

Access Methods

 Sequential Access: Reading or writing data continuously, moving through the

file from beginning to end.
 Direct Access: Randomly accessing file records without progressing through the
file linearly.

Directory Structure

 The document discusses tree-structured directory hierarchies, where

directories can contain multiple files or subdirectories, forming a navigable,
hierarchical organization of the file system.

Symbolic and Hard Links

  Symbolic Links: Pointers to files or directories, allowing multiple references to a
single file without duplicating the actual data.
 Hard Links: Direct pointers to the data within files, making the same content
accessible from multiple directory entries without occupying additional storage
space.

Operations on Directories

 Includes changing the current directory, creating and deleting directories, moving
and renaming files or directories, listing the contents of a directory, and finding
files within the directory structure.

The document emphasizes the role of file systems in abstracting the complexities of
data storage and retrieval, providing a user-friendly interface for managing files and
directories on secondary storage devices.

CH 10.2

The document "ch10.2.pdf" comprehensively covers the methods and challenges of

managing disk storage in file systems, including disk block allocation, free space
management, and memory-mapped files. Here's a summary of the critical topics,
vocabulary, and definitions:

Disk Block Allocation Strategies

 Contiguous Allocation: Stores files as contiguous blocks on the disk, simplifying

access but leading to fragmentation and compaction challenges.
 Linked Allocation: Uses pointers in each block to link to the next block,
eliminating fragmentation but complicating direct access and increasing
overhead for storing pointers.
 Indexed Allocation: Stores a file's blocks' addresses in an index block, facilitating
direct access and reducing fragmentation but requiring additional space for the
index.

Free Space Management

 Bitmaps: Use bits to represent whether a block on the disk is free or allocated,
providing an efficient way to track free space but requiring scanning for
allocation/deallocation.
  Linked Lists: Link free disk blocks, making it easy to find and allocate free space
but potentially slower due to the need to traverse the list.

Memory-Mapped Files

 Memory Mapping: A method where files or portions of files are mapped into a
process's address space, allowing file I/O operations through memory access
rather than system calls, improving performance.
 Shared Memory: Memory-mapped files can also facilitate inter-process
communication (IPC) by allowing multiple processes to access the same portion
of the memory, acting as a shared memory mechanism.

Key Definitions

 Fragmentation: Occurs when free storage space is divided into small, non-
contiguous blocks, making it inefficient to use.
 File Allocation Table (FAT): A data structure used by some file systems to keep
track of the segments of disk space used by files.
 Bitmap: A data structure representing disk space usage where each bit
corresponds to a block on the disk, indicating whether it's free or allocated.
 Memory-Mapped I/O: A technique that allows file data to be accessed directly
in memory, bypassing traditional file I/O operations for improved efficiency.

This document emphasizes the complexities and various strategies involved in disk
storage management within file systems, highlighting the trade-offs between different
allocation methods and the advantages of memory-mapped files for efficient file access
and inter-process communication.

CH 11.1

The document "ch11.1.pdf" discusses the hardware-software interface for I/O systems,
emphasizing device controllers, device drivers, and various I/O programming methods.
Here's a summary along with key topics, vocabulary, and definitions:

The I/O Hierarchy and Device Controllers

 I/O Devices: Include components for human-computer interaction, secondary

storage, and networking, all connected via controllers that operate the devices
using binary signals.
  Device Controller (Adapter): An electronic circuit that manages the operations
of a specific I/O device, interfacing with it through hardware registers and flags
set or examined by device drivers.

Device Drivers

 Device Driver: A device-specific program that performs I/O operations

requested by user applications or the OS by interacting with the device controller.
Device drivers are essential due to the wide variety in device characteristics, such
as speed, latency, and data transmission modes.

Programmed I/O

 Programmed I/O with Polling: Involves the CPU actively checking device status
through polling, transferring data between the I/O device and main memory
based on the operation status.
 Programmed I/O with Interrupts: Utilizes interrupts for I/O processing, freeing
the CPU from continuous status checks and allowing it to perform other tasks
until the I/O operation completes.

Direct Memory Access (DMA)

 Direct Memory Access (DMA): A method where an I/O device can directly
transfer data to or from memory without continuous CPU intervention,
significantly reducing CPU overhead for I/O operations.

Polling vs. Interrupts

 Polling: Suitable for dedicated systems or very fast devices, where the overhead
of context switching for interrupts would exceed the time for polling loops.
 Interrupts: Preferred in multi-process environments, minimizing CPU time
wasted on busy loops and ensuring efficient processing by reacting immediately
after an I/O operation completes.

Key Definitions

 Busy Flag: Indicates whether a device is busy or idle, used in both polling and
interrupts to determine device availability.
 Opcode Register: Specifies the operation requested by the CPU, such as reading
or writing.
  Data Buffer: Holds data being transferred between the device and main
memory.

This document highlights the importance of efficient I/O handling through various
programming techniques, emphasizing the role of device drivers in abstracting
hardware specifics and the advantages of using DMA and interrupts for reducing CPU
load during I/O operations.

CH 11.2

The document "ch11.2.pdf" focuses on disk scheduling strategies to optimize I/O

operations, addressing the need for efficient access and management of data on hard
disk drives. Here's a detailed summary along with important topics, vocabulary, and
definitions:

Disk Scheduling Algorithms

 First-Come, First-Served (FCFS): Services requests in the order they arrive.

Simple and fair but may lead to inefficient disk utilization.
 Shortest Seek Time First (SSTF): Chooses the request closest to the current
head position to minimize seek time, improving performance but risking
starvation for distant requests.
 SCAN (Elevator Algorithm): The disk arm moves in one direction, servicing
requests until it reaches the end, then reverses direction. This strategy offers a
balance between fairness and efficiency.
 C-SCAN (Circular SCAN): Similar to SCAN but only services requests in one
direction, jumping back to the start once the end is reached, ensuring more
uniform wait times across all requests.
 LOOK and C-LOOK Variants: Similar to SCAN and C-SCAN but the arm only
goes as far as the last request in each direction before reversing or looping,
potentially reducing unnecessary movement.

Performance Considerations

 The choice of disk scheduling algorithm can significantly impact system

performance, particularly in terms of access time and bandwidth.
 Algorithms like SCAN and C-SCAN tend to perform better under heavy load by
reducing the variability in wait times and optimizing head movement.
Key Definitions

 Seek Time: The time it takes for the disk arm to move the heads to the cylinder
containing the desired sector.
 Rotational Latency: The time waiting for the disk to rotate the desired sector to
the disk head.
 Bandwidth: The total amount of data transferred divided by the total time
between the first request for service and the completion of the last transfer.

This document emphasizes the importance of selecting an appropriate disk scheduling

algorithm to enhance disk performance, reduce access times, and efficiently manage I/O
operations, taking into account factors like seek time, rotational latency, and overall
system load.

CH 12.1

The document "ch12.1.pdf" provides an in-depth analysis of I/O systems in operating

systems, covering the structure of the I/O subsystem, device management, and various
I/O techniques. Here's a summary of the first 21 pages out of 29:

I/O System Overview

 The primary roles of an operating system in managing I/O are to control I/O
operations and devices efficiently. This involves understanding I/O hardware's
constraints and providing a seamless interface for applications to perform I/O
operations.

Device Drivers

 Device Drivers: Serve as the interface between the operating system and
hardware devices, presenting a uniform device-access interface to the I/O
subsystem. They manage the peculiarities of specific devices, ensuring that
applications have standardized access to hardware resources.

I/O Hardware

 I/O devices are categorized into storage, transmission, and human-interface

devices, each requiring unique control methods. Controllers and ports facilitate
 device communication with the computer system, with buses like PCIe serving as
the primary communication channels.

Memory-Mapped I/O

 This technique allows device-control registers to be mapped into the processor's

address space, enabling I/O operations via standard data-transfer instructions.
Memory-mapped I/O simplifies device control and can be more efficient than
using special I/O instructions.

Polling and Interrupts

 Polling: Involves the CPU continuously checking the device status, which can be
efficient for fast devices but may waste CPU resources.
 Interrupts: Allow devices to notify the CPU when they require attention, enabling
the CPU to perform other tasks instead of polling. Interrupt-driven I/O improves
system efficiency by allowing asynchronous event handling.

Direct Memory Access (DMA)

 DMA offloads data transfer work from the CPU to a DMA controller, allowing
large data transfers directly between devices and memory. This method improves
system performance by reducing the CPU's involvement in data movement.

Handshaking

 A protocol for coordinating actions between the host and device controllers,
typically involving busy and command-ready bits to indicate device status and
host requests.

Key Definitions

 Controller: A device that manages I/O operations for a specific device.

 Port: A connection point for devices.
 Bus: A communication system connecting various components within a
computer.
 Interrupt: A mechanism allowing a device to signal the CPU that it requires
processing.
 DMA: A system that enables direct data transfers between memory and devices
without CPU intervention.
The document emphasizes the complexity and variety of device control techniques
needed to manage the broad spectrum of I/O devices and operations, highlighting the
role of device drivers, memory-mapped I/O, polling, interrupts, and DMA in facilitating
efficient I/O processing.

CH 12.2

The document "ch12.2.pdf" elaborates on advanced I/O system concepts,

emphasizing RAID levels, performance improvement strategies, and the
integration of hardware and software in managing I/O operations. Here's a
summary of the first 20 pages out of 29, focusing on key topics and
definitions:

RAID Levels and Their Characteristics

 RAID 0 (Striping): Increases performance by distributing data across
multiple disks but offers no redundancy.
 RAID 1 (Mirroring): Provides redundancy by duplicating data across
two disks, enhancing data reliability at the cost of storage efficiency.
 RAID 4 (Block-level Striping with Parity): Uses a dedicated disk for
storing parity information, allowing data recovery in case of a single disk
failure but suffering from a write bottleneck on the parity disk.
 RAID 5 (Block-level Striping with Distributed Parity): Distributes
parity blocks among all disks, mitigating the write bottleneck of RAID 4
and providing fault tolerance with better storage efficiency.
 RAID 6 (P+Q Redundancy): Extends RAID 5 by adding an additional
level of redundancy, allowing recovery from two simultaneous disk
failures.

Performance Improvement via Parallelism

 The document discusses how RAID can improve system performance by
parallelizing disk access. This includes mirroring to double read rates
and striping to enhance both read and write speeds across multiple
drives.
I/O Performance and Efficiency
 Emphasizes reducing context switches, minimizing data copies, and
balancing system performance across CPU, memory, and I/O to optimize
overall system efficiency.

Hardware and Software in I/O

 Discusses the role of front-end processors, terminal concentrators, and
I/O channels in offloading I/O work from the main CPU, highlighting
strategies to improve I/O handling.

Key Definitions
 RAID (Redundant Array of Independent Disks): A data storage
virtualization technology that combines multiple physical disk drive
components into one or more logical units for data redundancy,
performance improvement, or both.
 Mirroring and Striping: Techniques used in RAID to either duplicate
data across disks or distribute data across disks to improve
performance.
 Parity and ECC (Error-Correcting Code): Used in certain RAID levels to
provide fault tolerance by storing additional data that can be used to
reconstruct lost or corrupted data.

This summary covers the document's insights on optimizing I/O subsystems,

particularly through RAID configurations and strategies for balancing
hardware and software roles in managing I/O operations. The emphasis on
RAID's role in enhancing data reliability and system performance highlights
the critical considerations in designing and maintaining efficient storage
solutions.
CH 13

The document "ch13.pdf" provides a comprehensive overview of mass-storage

structure, focusing on hard disk drives (HDDs) and nonvolatile memory (NVM) devices.
Here's a summary of the first 23 pages out of 25, covering the main topics along with
vocabulary and definitions:

Hard Disk Drives (HDDs)

 Concepts: HDDs store information magnetically on platters, with data organized

into concentric cylinders, tracks subdivided into sectors, and sectors having a
fixed size, commonly transitioning from 512 bytes to 4KB.
 Performance: Discussed in terms of transfer rates, positioning time (including
seek time and rotational latency), and the importance of DRAM buffers in drive
controllers for enhancing performance.

Nonvolatile Memory Devices

 Overview: NVM devices, primarily flash-memory-based, offer electrical storage

solutions with no moving parts, presenting advantages in speed, power
consumption, and reliability over HDDs.
 Flash-memory-based NVM: Includes solid-state disks (SSDs), USB drives, and
embedded storage in devices. The document elaborates on the characteristics
and challenges of NAND semiconductors, including wear leveling and over-
provisioning to manage write performance and device longevity.

Secondary Storage Connection Methods

 Discusses various buses and controllers used to connect secondary storage

devices to computers, highlighting SATA and NVM Express (NVMe) for their
relevance to modern storage solutions.

Key Definitions and Concepts

 Logical Block Addressing (LBA): Simplifies addressing by mapping logical

blocks to physical sectors or pages, irrespective of the storage device's physical
structure.
 Wear Leveling: Strategies to distribute write operations evenly across NAND
cells to prolong the lifespan of NVM devices.
 Error-correcting Codes (ECC): Used in both HDDs and NVM devices to detect
and correct errors during data reads and writes.

Volatile Memory as Mass Storage

  RAM Drives: Utilize sections of a system's DRAM as high-speed storage, acting
as secondary storage but without persistence through system restarts or
shutdowns.

Magnetic Tapes

 While not as prevalent as disk or solid-state storage for primary data storage due
to slow access times, magnetic tapes remain important for backup and archival
purposes.

This summary highlights the document's insights into the structural and operational
aspects of mass-storage devices, including HDDs and NVM, their interfaces, and the role
of system architecture in supporting efficient data storage and retrieval.

CH 14

The document "ch14.pdf" delves into file-system structure and implementation,

emphasizing how operating systems manage, access, and store files on disk. Here are
the main topics, vocabulary, and definitions covered:

File-System Structure

 I/O Control Level: Involves device drivers and interrupt handlers that transfer
information between main memory and the disk system. A device driver acts as a
translator between high-level commands and low-level, hardware-specific
instructions.
 Basic File System: Also known as the block I/O subsystem in Linux, it is
responsible for issuing generic commands to device drivers for reading and
writing blocks on the storage device and managing memory buffers and caches.
 File-Organization Module: Manages files and their logical blocks, including the
free-space manager which tracks unallocated blocks.
 Logical File System: Manages metadata information, the directory structure, and
file-control blocks (FCBs) or inodes, which contain information about the file,
such as ownership, permissions, and location of the file contents.

File-Control Block (FCB) / Inode

 Contains metadata about a file, facilitating access and management. In UNIX

systems, this is known as an inode.
Key Concepts

 Boot Control Block: Contains information necessary for booting an operating

system from a volume.
 Volume Control Block: Holds volume details, such as block size and the number
and location of free blocks.
 Directory Structure: Organizes files and includes file names and associated
inode numbers.
 Mount Table: An in-memory structure containing information about each
mounted volume.

File-System Operations

 Detailed structures and operations for implementing file-system operations,

including the creation of new files, the allocation of new FCBs, and the updating
of directory structures with new file names and FCBs.

Efficiency and Performance

 Discusses the impact of block-allocation and directory-management options on

storage efficiency and performance. Techniques like UNIX inodes preallocation
and clustering schemes are explored to optimize performance and reduce
fragmentation.

Unified Buffer Cache

 A caching mechanism that avoids double caching by using the same cache for
memory-mapped I/O and direct file I/O, enhancing system performance by
optimizing memory usage and minimizing data movement within system
memory.

This summary encapsulates the document's exploration of the mechanisms behind file
system structure and implementation, highlighting the complexities of managing file
metadata, directory structures, and optimizing file system performance.

CH 15

The document "ch15.pdf" explores the structure and management of disk partitions,
boot processes, and the concept of mounting in file systems, providing insights into
how operating systems interact with storage devices. Here are the summarized points
along with key vocabulary and definitions:

Disk Partitions and Mounting

 Partitions: Disks can be divided into multiple partitions, with each partition being
either "raw" (without a file system) or "cooked" (containing a file system). Raw
partitions might be used for UNIX swap space or by databases that format the
data according to their specific needs.
 Mounting: The process of making a file system available to the operating
system. The root partition, containing the operating system kernel, is mounted at
boot time, while other partitions can be mounted automatically or manually later.

Boot Process

 Bootstrap Loader: A small program that loads the kernel into memory as part of
the boot process. It knows enough about the file system to find and load the
kernel, starting the operating system.
 Dual-Booted Systems: Systems that can boot one of two or more installed
operating systems. A boot loader capable of understanding multiple operating
systems and file systems is required to choose between them.

Key Definitions

 Raw Disk: Direct access to a secondary storage device as an array of blocks with
no file system, used for specific applications that manage data in custom formats.
 Dual-Booted: Describes a computer that can boot one of two or more installed
operating systems.
 Root Partition: The storage partition that contains the kernel and the root file
system; the one mounted at boot.

File System Types and Mount Points

 Microsoft Windows-based systems use a separate namespace for each volume,

denoted by a letter and a colon (e.g., C:). File systems can also be mounted at any
point within the directory structure in later versions of Windows.
 UNIX systems allow file systems to be mounted at any directory, using a flag in
the inode for the directory to indicate it is a mount point. This enables seamless
traversal across file systems of varying types.
This document emphasizes the importance of partitions, boot processes, and mounting
in managing and accessing disk storage, detailing the mechanisms operating systems
use to boot from and interact with different storage partitions and file systems.

CH 16.1

The document "ch16.1.pdf" comprehensively addresses computer security, detailing

security goals, threats, and protective mechanisms against various forms of security
violations. Here's a detailed summary covering all 35 pages:

Security Goals and Threats

 Computer Security: Defined as the safeguard against theft or damage to

hardware, software, or information, and from disruption or misdirection of
services.
 Protection: Involves mechanisms and policies that ensure the confidentiality,
integrity, availability, and authenticity of all data and services.

Types of Security Violations

1. Information Disclosure: Unauthorized release or dissemination of information,

leading to violations of confidentiality and/or privacy.
2. Information Modification: Unauthorized alteration of data or programs,
resulting in loss of information and/or the ability to carry out subsequent security
violations.
3. Information Destruction: Deliberate or accidental deletion of data or damage to
hardware, causing loss of information or access to services.
4. Unauthorized Use: Circumvention of system's user authentication to make
unauthorized use of a service, leading to loss of revenue for the service provider.
5. Denial of Service: Preventing a legitimate user from employing a service in a
timely manner, resulting in financial loss or unavailability of critical systems.
6. User Deception: Causing a legitimate user to receive and believe false
information.

Insider Attacks

 Insiders, such as legitimate users, can easily compromise security, motivated by

financial gain, revenge, or malice. Examples include logic bombs, back doors
(trapdoors), information leaking, and login spoofing.
Mechanisms for Protection

1. Logic Bombs: Unauthorized code inserted to perform destructive actions at a

specified time, used for blackmail or revenge.
2. Back Doors (Trapdoors): Mechanisms that bypass user authentication,
potentially inserted by systems programmers for unauthorized access.
3. Information Leaking: Disclosure of confidential information by a legitimate user
to an unauthorized user.
4. Login Spoofing: Deceiving a legitimate user with a fake login screen to steal
login credentials.

Exploiting Human Weaknesses

 Intrusions often exploit human behaviors through deception or carelessness,

involving Trojan horses, viruses, and phishing.
 Trojan Horses: Appear to provide a useful service but contain hidden functions
intended to violate security.
 Viruses: Executable code that embeds into legitimate programs to copy itself
and cause harm.
 Phishing: Tricking users into revealing sensitive information through fake
webpages or emails.

Exploiting System Weaknesses

 Intrusions can exploit OS weaknesses due to programming errors or careless

programming, such as buffer overflow attacks and worms.

Confining Mobile Code

 Techniques like interpretation and sandboxing are used to guard against

unauthorized activities by confining code to a restricted memory area.

User Authentication

 Discusses user authentication based on knowledge, possession, or physical

characteristics. It covers protecting passwords, one-time passwords, one-way
hash functions, and challenge-response authentication.

Role-Based Access Control (RBAC)

  Describes assigning privileges and programs to roles, with users taking roles
based on passwords, enhancing system protection by applying the principle of
least privilege.

Mandatory Access Control (MAC)

 Explains MAC as a stronger form of protection than discretionary access control

(DAC), enforced as system policy that restricts access based on labels assigned to
objects and subjects.

Access Control

 Details the access matrix as a representation of protection domains, showing how

access rights are managed for different users and objects within a system.

This summary encapsulates the document's exploration of computer security,

highlighting the importance of understanding and protecting against various types of
security violations through effective mechanisms and policies.

16.2

The document "ch16.2.pdf" elaborates on the implementation of security mechanisms,

focusing on access control, cryptography, and secure communication. Here’s a summary
of the first 29 pages out of 35, including key topics and definitions:

Access Control

 Access Matrix: A conceptual framework representing the rights of each domain

(users or processes) over objects (files, devices). It's implemented through access
lists (ALs) associated with objects and capability lists (CLs) associated with
domains.
 Access Lists (ALs): Specify operations a domain may perform on an object,
potentially leading to a long search time for each request.
 Capability Lists (CLs): Specify operations a domain may perform, where
possession of a capability serves as authorization. The main challenge is the
difficulty in revoking rights due to dispersed capabilities.
Secure Communication and Cryptography

 Cryptography: Transforms plaintext into ciphertext (encryption) and back

(decryption), ensuring confidentiality, authenticity, and non-repudiation.
 Man-in-the-Middle Attack (MITM): An attacker secretly alters the
communication between two parties.
 Secret-Key Cryptography (Symmetric): Uses the same key for encryption and
decryption, offering secrecy but limited authenticity.
 Public-Key Cryptography (Asymmetric): Uses different keys for encryption and
decryption, eliminating the need for exchanging secret keys and supporting non-
repudiation.
 RSA Algorithm: A well-known public-key cryptosystem based on the
computational difficulty of factoring large primes.

Authentication and Digital Signatures

 Message Authentication Code (MAC): A bit string that verifies the sender's
identity and message integrity.
 Digital Signatures: Use public-key cryptography to link a document indelibly to
its sender, verifying both the document's and sender's authenticity.

Security Problems and Protection Strategies

 Security concerns range from confidentiality breaches to unauthorized resource

use and denial of service. Protection against these issues requires a multi-layered
approach, including physical security, network protection, operating system
defenses, and secure applications.

Principles of Protection

 Emphasizes the principle of least privilege and compartmentalization, aiming to

limit access and operations within the system to minimize potential damage from
attacks.

The document discusses various mechanisms and strategies to

maintain security and integrity within computer systems,
highlighting the importance of access control, cryptography, and
a comprehensive security model to protect against unauthorized
access and data breaches.