Note 1

## Core Concepts and Functions

### Operating System Definition

- Acts as an intermediary between users and computer hardware
- Functions as both a resource allocator and control program
- Main goals:
- Execute user programs and solve user problems
- Make computer systems convenient to use
- Use hardware efficiently
- Prevent errors and improper system use

### Computer System Components

1. Hardware: Basic computing resources (CPU, memory, I/O devices)
2. Operating System: Controls and coordinates hardware usage
3. Application Programs: Define ways to solve user computing problems
4. Users: People, machines, other computers

## System Architecture and Organization

### Computer System Operation

- Uses one or more CPUs and device controllers connected through a common bus
- Supports concurrent execution of CPUs and devices
- I/O devices and CPU can execute simultaneously
- Device controllers manage specific device types using local buffers
- Uses interrupt-driven operation for efficient multitasking

### Multiprocessing Systems

1. Asymmetric Multiprocessing (AMP)
- CPUs are treated unequally
- Specific CPUs handle specific tasks
- Limited CPU access to system operations

2. Symmetric Multiprocessing (SMP)

- All processors are treated equally
- Share single main memory
- Full access to I/O devices
- Controlled by single OS instance

### Clustered Systems

- Multiple computers working together as a single system
- Share storage through storage-area network (SAN)
- Provides high availability and fault tolerance
- Supports both asymmetric and symmetric clustering
- Used for high-performance computing

## Memory and Storage Management

### Memory Hierarchy

- Organized by speed, cost, and volatility
- Implements caching for improved performance
- Main memory: Direct CPU access, volatile storage
- Secondary storage: Non-volatile, larger capacity
- Includes various levels from registers to tertiary storage

### Storage Management Functions

- File system management
- Mass-storage management
- Free-space management
- Storage allocation
- Disk scheduling
- Backup and recovery

## Process Management

### Process Characteristics

- Active program in execution
- Requires resources: CPU, memory, I/O, files
- Can be single-threaded or multi-threaded
- Supports concurrent execution through CPU multiplexing

### Key Activities

- Process creation and deletion
- Process suspension and resumption
- Process synchronization
- Inter-process communication
- Deadlock handling

## Protection and Security

- User identification and access control

- Protection mechanisms for resource access
- Security against internal and external threats
- Group-based access management
- Privilege escalation capabilities

## Modern Computing Environments

### Distributed Computing

- Networks of heterogeneous systems
- Supports LANs, MANs, and WANs
- Network operating system features
- Communication between systems

### Special Purpose Systems

- Real-time embedded systems
- Multimedia systems
- Handheld systems
- Client-server computing
- Peer-to-peer networks
- Web-based computing

### Open-Source Systems

- Source code availability
- Examples: GNU/Linux, BSD UNIX
- Supports GPL licensing
- Contrasts with closed-source systems
=============Note 2==================

### Core Operating System Services

- **User-Facing Services**
- User Interface: Includes Command-Line Interface (CLI), Graphical User Interface (GUI), and batch
processing
- Program Execution: Loading and running programs, handling normal and abnormal termination
- I/O Operations: Managing input/output for files and devices
- File System Management: Reading, writing, creating, deleting files and directories
- Communications: Process information exchange through shared memory or message passing
- Error Detection: Monitoring hardware, I/O devices, and user programs for errors

- **System Management Services**

- Resource Allocation: Managing CPU cycles, memory, and storage for concurrent users/jobs
- Accounting: Tracking resource usage by users
- Protection and Security: Controlling access to resources, user authentication, system defense

### System Interface and Implementation

#### User Interfaces

- Command Line Interface (CLI)
- Direct command entry
- Can be kernel-implemented or system program
- Multiple shell implementations possible

- Graphical User Interface (GUI)

- Desktop metaphor with mouse, keyboard, and monitor
- Uses icons for files, programs, and actions
- Originally developed at Xerox PARC
- Many systems now offer both CLI and GUI

#### System Calls

- Programming interface to OS services
- Typically written in C/C++
- Accessed through APIs (Win32, POSIX, Java API)
- Benefits of using APIs:
- Platform independence
- Enhanced feature support
- Better functionality
- Multiple OS version support

### Operating System Design

#### Design Approaches

- **Simple Structure**
- Example: MS-DOS - designed for minimal space usage
- Limited separation of interfaces and functionality
- **Layered Approach**
- OS divided into hierarchical layers
- Each layer builds on lower layers
- Promotes modularity

- **UNIX Structure**
- Two main parts: System programs and kernel
- Kernel manages core functions below system-call interface

- **Microkernel Structure**
- Minimal kernel design
- Most functionality in user space
- Uses message passing for communication
- Benefits: Extensibility, portability, reliability
- Drawback: Performance overhead

#### Modern Implementation Features

- Modular Approach
- Object-oriented design
- Loadable kernel modules
- Flexible component interaction

### Virtual Machines

- Provides interface identical to underlying hardware
- Benefits:
- Multiple execution environments
- Development and testing support
- System consolidation
- Resource isolation
- Examples include VMware and Java Virtual Machine

### System Management

- **Debugging**
- Log files for error tracking
- Core dumps for application failures
- Crash dumps for kernel failures
- Tools like DTrace for system monitoring

- **System Generation and Boot**

- SYSGEN configures OS for specific hardware
- Bootstrap program loads kernel
- Two-step boot process common
- Firmware stores initial boot code

==============note 3==============

- A process is a program in execution that must progress sequentially

- Components of a process include:
 - Program code (text section)
- Current activity (program counter, processor registers)
- Stack (temporary data, function parameters, return addresses, variables)
- Data section (global variables)
- Heap (dynamically allocated memory)
- Program is passive while process is active
- Multiple users can execute the same program, creating multiple processes

## Process States
- New: Process being created
- Running: Instructions being executed
- Waiting: Process waiting for event
- Ready: Process waiting for processor assignment
- Terminated: Process finished execution

## Process Control Block (PCB)

Contains critical process information:
- Process state
- Program counter
- CPU registers
- CPU scheduling information
- Memory management information
- Accounting information
- I/O status information

## Process Scheduling
- Managed by process scheduler to maximize CPU usage
- Maintains different queues:
- Job queue: All processes in system
- Ready queue: Processes in memory ready to execute
- Device queues: Processes waiting for I/O

## Schedulers
- Long-term scheduler (job scheduler):
- Selects processes for ready queue
- Controls degree of multiprogramming
- Runs infrequently
- Short-term scheduler (CPU scheduler):
- Selects next process to execute
- Runs very frequently
- Medium-term scheduler:
- Handles swapping
- Reduces degree of multiprogramming

## Process Creation and Termination

### Creation
- Parent processes create child processes
- Resource sharing options between parent and child
- Execution can be concurrent or sequential
- UNIX uses fork() and exec() system calls

### Termination
- Normal completion (exit())
- Parent termination of child (abort())
- Cascading termination
- Zombie processes: Terminated but parent hasn't called wait()
- Orphan processes: Parent terminated before child

## Interprocess Communication (IPC)

Two main models:
1. Shared Memory
- Processes share a region of memory
- Faster communication
- Example: Producer-Consumer problem

2. Message Passing
- Processes exchange messages
- Can be direct or indirect communication
- Synchronous (blocking) or asynchronous (non-blocking)
- Uses mailboxes or ports for indirect communication

## Mobile Systems Process Management

- iOS:
- Single foreground process
- Limited background processes
- Android:
- Multiple foreground and background processes
- Uses services for background tasks
- Services can run independently of background processes

## Context Switching
- Saves state of old process and loads state of new process
- Represents system overhead
- Time depends on hardware support and OS complexity

This comprehensive overview covers the fundamental concepts of processes in operating systems, their
management, scheduling, creation, termination, and communication mechanisms, as presented in Chapter
3 of the operating systems textbook.

==============note 4==============

## Background
- Cooperating processes can affect or be affected by other processes in the system
- Processes can share logical address space or share data through files/messages
- Concurrent access to shared data may result in data inconsistency
- Mechanisms needed to ensure orderly execution of cooperating processes

## Critical Section Problem

- System consists of n processes {P0, P1, ..., Pn-1}
- Each process has a critical section where it may modify common variables
- Only one process can execute in its critical section at a time
- Process structure includes:
- Entry section
- Critical section
- Exit section
 - Remainder section

### Solution Requirements

1. Mutual Exclusion: Only one process can execute in critical section at a time
2. Progress: Selection of processes entering critical section cannot be postponed indefinitely
3. Bounded Waiting: Limit on number of times other processes can enter before a waiting process

## Peterson's Solution
- Limited to two processes
- Uses shared variables:
- turn: Indicates whose turn it is
- flag array: Indicates if process is ready to enter critical section
- Provides mutual exclusion but has limitations on modern architectures

## Synchronization Hardware Support

- Hardware atomic instructions:
- test_and_set()
- compare_and_swap()
- Locks for protecting critical regions
- Uniprocessors can disable interrupts
- Modern systems provide special atomic hardware instructions

## Semaphores
- Synchronization tool avoiding busy waiting
- Two atomic operations:
- wait() - decrements semaphore
- signal() - increments semaphore
- Types:
- Counting semaphore: Unrestricted domain
- Binary semaphore: Values 0 or 1 only
- Implementation includes waiting queue for blocked processes

## Classic Synchronization Problems

### Readers-Writers Problem

- Multiple readers can read simultaneously
- Only one writer can write at a time
- Uses semaphores:
- rw_mutex: Controls write access
- mutex: Controls read_count access
- read_count: Tracks number of readers

### Dining Philosophers Problem

- Five philosophers alternate between thinking and eating
- Need two chopsticks to eat
- Challenge: Avoid deadlock and starvation
- Solution uses monitors and state variables

## Operating System Examples

- Windows XP: Uses interrupt masks and spinlocks
- Linux: Provides semaphores and spinlocks
- Both systems implement various synchronization mechanisms
- Modern versions support preemptive kernels

## Recovery and Checkpoints

- Checkpoints shorten log and recovery time
- Process includes:
1. Output log records to stable storage
2. Output modified data to stable storage
3. Record checkpoint in log
- Reduces recovery time by limiting scope of recovery operations

================note 5========

## Basic Concepts
- CPU scheduling is fundamental for multiprogrammed operating systems
- Process execution alternates between CPU execution and I/O wait (CPU-I/O Burst Cycle)
- Maximum CPU utilization is achieved through multiprogramming
- CPU burst distribution is a key consideration in scheduling

## CPU Scheduler and Dispatcher

### CPU Scheduler
- Short-term scheduler selects processes from ready queue for CPU allocation
- Scheduling decisions occur when a process:
1. Switches from running to waiting state
2. Switches from running to ready state
3. Switches from waiting to ready
4. Terminates
- Types of scheduling:
- Nonpreemptive: Cases 1 and 4
- Preemptive: All other cases

### Dispatcher
- Gives CPU control to selected process
- Functions include:
- Context switching
- Switching to user mode
- Program restart at proper location
- Dispatch latency: Time to stop one process and start another

## Scheduling Criteria and Optimization

### Key Metrics
- CPU utilization
- Throughput (completed processes per time unit)
- Turnaround time
- Waiting time
- Response time (first response production time)

## Scheduling Algorithms

### First-Come, First-Served (FCFS)

- Simplest scheduling algorithm
- Example with processes P1(24), P2(3), P3(3):
- Average waiting time: 17 units when ordered P1,P2,P3
- Average waiting time: 3 units when ordered P2,P3,P1
- Suffers from convoy effect

### Shortest-Job-First (SJF)

- Optimal algorithm for minimum average waiting time
- Two variants:
- Nonpreemptive
- Preemptive (Shortest-Remaining-Time-First)
- Challenge: Predicting next CPU burst length

### Priority Scheduling

- Assigns priority numbers to processes
- Can be preemptive or nonpreemptive
- Issues:
- Starvation of low-priority processes
- Solution: Aging (increasing priority over time)

### Round Robin (RR)

- Uses time quantum (typically 10-100ms)
- Processes get CPU time in chunks
- Better response time than SJF
- Time quantum considerations:
- Must be larger than context switch time
- Too large becomes FIFO
- Too small increases overhead

## Advanced Scheduling Concepts

### Multilevel Queue

- Multiple separate queues for different process types
- Each queue has its own scheduling algorithm
- Example: Foreground (RR) and Background (FCFS)
- Requires inter-queue scheduling

### Multilevel Feedback Queue

- Three queues example:
- Q0: RR with 8ms quantum
- Q1: RR with 16ms quantum
- Q2: FCFS
- Processes move between queues based on behavior

## Modern Operating System Implementations

### Linux Scheduling

- Pre-2.5: Standard UNIX scheduling
- Version 2.5: O(1) scheduling time
- Version 2.6.23+: Completely Fair Scheduler (CFS)
- Priority-based proportional CPU time allocation
- Uses virtual runtime concept
- Two main scheduling classes: default and real-time

### Windows Scheduling

- Priority-based preemptive scheduling
- 32-level priority scheme
- Real-time (16-31) and Variable (1-15) classes
- Separate queue for each priority level
- Idle thread runs when no other threads are available

================note 6 ========

### Basic Concepts

- Programs must be loaded from disk into memory to run
- CPU can only directly access registers and main memory
- Register access takes one CPU clock cycle or less
- Main memory access requires multiple cycles
- Cache sits between main memory and CPU registers
- Memory protection is essential for correct system operation

### Address Binding

Three stages of address binding:
- Compile time: When memory location is known beforehand
- Load time: When relocatable code is needed
- Execution time: When processes can move between memory segments

### Memory Addressing

- Logical (virtual) addresses: Generated by CPU
- Physical addresses: Actual memory locations
- Memory Management Unit (MMU): Hardware that maps virtual to physical addresses
- Base and limit registers define logical address space and provide protection

### Memory Allocation Techniques

#### Contiguous Allocation
- Memory divided into OS partition (low memory) and user processes (high memory)
- Multiple partition allocation manages:
- Allocated partitions
- Free partitions (holes)
- Allocation strategies:
- First-fit: First hole that fits
- Best-fit: Smallest sufficient hole
- Worst-fit: Largest available hole

#### Fragmentation
- External: Total space exists but not contiguous
- Internal: Allocated space slightly larger than needed
- Compaction can reduce external fragmentation

### Paging
- Divides physical memory into fixed-size frames
- Logical memory divided into pages of same size
- Page table translates logical to physical addresses
- Uses page number and page offset for address translation
- Translation Look-aside Buffer (TLB) speeds up address translation
- Protection implemented through valid-invalid bits

### Segmentation
- Supports user view of memory
- Programs divided into logical units (segments)
- Segment table contains:
 - Base address
- Limit
- Protection bits
- Logical address consists of segment number and offset

### Advanced Implementations

#### Page Table Structures
- Hierarchical paging (multi-level)
- Hashed page tables
- Inverted page tables

#### Intel Pentium Example

- Supports both segmentation and paging
- Uses two-step process:
1. Segmentation unit produces linear address
2. Paging unit generates physical address

### Memory Management in Mobile Systems

- Typically doesn't support traditional swapping
- Uses flash memory
- iOS: Apps asked to voluntarily release memory
- Android: Terminates apps when memory is low
- Both support paging

### Shared Memory

- Shared code (read-only) can be shared among processes
- Private code and data kept separate for each process
- Shared pages must appear at same logical address for all processes

This organization of memory management techniques provides the foundation for modern operating
systems to efficiently manage system memory while ensuring protection and optimal performance.

================note 7========

## File Concept and Structure

- Files provide contiguous logical address space
- File types include:
- Data (numeric, character, binary)
- Program
- File structures:
- Basic: sequence of words or bytes
- Simple record structure (fixed/variable length lines)
- Complex structures (formatted documents, relocatable load files)

## File Attributes and Operations

### Attributes
- Name (human-readable form)
- Identifier (unique tag)
- Type, location, size
- Protection settings
- Time, date, user identification
- Information stored in directory structure on disk
### Operations
- Create, write, read
- Reposition within file
- Delete, truncate
- Open: searches directory structure
- Close: updates directory structure

## Open Files Management

- Requires tracking:
- File pointer
- File-open count
- Disk location
- Access rights
- File locking:
- Mandatory: enforced access control
- Advisory: optional lock checking

## Directory Structure
### Organization
- Collection of nodes containing file information
- Stored on disk with backup on tapes
- Directory operations:
- Search, create, delete files
- List directory contents
- Rename files
- Traverse file system

### Directory Types

1. Single-Level Directory
- One directory for all users
- Limited by naming conflicts

2. Two-Level Directory
- Separate directory per user
- Supports path names
- Efficient searching

3. Tree-Structured Directory
- Hierarchical organization
- Supports grouping
- Uses working directory concept
- Absolute/relative path names

## File System Mounting

- File systems must be mounted before access
- Mount points connect different file systems
- Enables access to multiple file systems

## File Sharing and Protection

### Sharing Features
- Multi-user support
- Network file sharing (NFS, CIFS)
- Client-server model
- Distributed systems support
### Protection Mechanisms
- Access control types:
- Read, Write, Execute
- Append, Delete, List
- User classifications:
- Owner access
- Group access
- Public access
- Access control lists (ACL)
- Numerical permissions (e.g., 761)
- Detailed access management

## File System Implementation

- Disk organization:
- Partitions/volumes
- RAID protection
- Raw or formatted usage
- Special-purpose file systems
- Directory management for efficiency
- Recovery mechanisms for remote systems

================note 8========

## Core Concepts
- I/O management is a crucial component of operating system design and operation
- Devices connect through ports, buses, and device controllers
- Device drivers encapsulate device details and provide uniform interface
- Wide variety of I/O devices: storage, transmission, and human-interface devices

## I/O Hardware Architecture

- Ports serve as connection points for devices
- Buses enable daisy chain or shared direct access
- Controllers (host adapters) manage port, bus, and device operations
- Controllers often include processor, microcode, private memory, and bus controller
- Devices have registers for commands, data transfer, and status monitoring
- Two main addressing methods:
- Direct I/O instructions
- Memory-mapped I/O

## Data Transfer Methods

### Polling
1. Host continuously checks device busy bit
2. Host sets read/write operations
3. Host signals command ready
4. Controller executes transfer
5. Controller clears status bits upon completion

### Interrupts
- More efficient than polling for infrequent events
- CPU checks interrupt-request line after each instruction
- Includes interrupt handler and vector for proper routing
- Supports priority-based processing
- Also used for exceptions and system calls
- Supports concurrent processing in multi-CPU systems

### Direct Memory Access (DMA)

- Bypasses CPU for large data transfers
- Uses DMA controller to move data between I/O device and memory
- OS creates command block with transfer details
- Controller handles transfer independently
- Signals completion via interrupt

## Application I/O Interface

### Device Classifications

- Character-stream vs block devices
- Sequential vs random-access
- Synchronous vs asynchronous
- Sharable vs dedicated
- Speed variations
- Read-write capabilities

### I/O Operations Types

- Blocking I/O: Process waits for completion
- Non-blocking I/O: Returns immediately with available data
- Asynchronous I/O: Process continues while I/O executes

## Kernel I/O Subsystem

### Key Components

- Scheduling: Manages per-device queues and request ordering
- Buffering: Handles device speed and size mismatches
- Caching: Improves performance through data copying
- Spooling: Manages exclusive-use devices
- Error handling: Manages recovery and logging
- Protection: Prevents unauthorized access

### Performance Optimization

- Reduce context switches
- Minimize data copying
- Optimize interrupt handling
- Utilize DMA
- Deploy smart controllers
- Balance system components
- Move processes to kernel threads

## STREAMS
- Full-duplex communication channel in Unix System V
- Components include:
- Stream head for user process interface
- Driver end for device interface
- Optional intermediate modules
- Uses message passing between queues
- Supports flow control
- Combines asynchronous internal operation with synchronous user interface
This comprehensive overview of I/O systems demonstrates the complexity and importance of I/O
management in modern operating systems, from hardware interfaces to software abstractions and
performance optimization strategies.

================note 9========

## Core Concepts
- Protection refers to mechanisms controlling access of processes/users to OS-defined resources
- Security focuses on defending against internal/external attacks like denial-of-service, worms, viruses
- Systems use user IDs and group IDs to manage access control
- Privilege escalation allows users to temporarily gain increased rights

## Goals and Principles

### Principle of Least Privilege
- Programs, users, systems should have minimum privileges needed for tasks
- Can be static (fixed during system/process life) or dynamic (changed as needed)
- Need to know concept applies to data access
- Grain aspects:
- Rough-grained: Simpler management but privileges in large chunks
- Fine-grained: More complex but better protection through ACLs, RBAC

### Protection Domains

- Access rights defined as object-name and rights-set pairs
- Domain comprises set of access rights
- UNIX implementation:
- Domain equals user-id
- Domain switching through setuid bit, su command, sudo command

## Access Matrix
- Rows represent domains
- Columns represent objects
- Matrix entries show allowed operations
- Special access rights include:
- owner rights
- copy operations
- control rights
- transfer rights

### Implementation Options

1. Global Table
- Stores domain, object, rights-set triples
- Challenge: Large table size

2. Access Lists
- Per-object lists of domain, rights-set pairs
- Easily extendable with default permissions

3. Capability Lists
- Domain-based lists of objects with allowed operations
- Capabilities protected and managed by OS
- Like secure pointers
4. Lock-key
- Objects have unique bit pattern locks
- Domains have matching keys
- Access granted when keys match locks

## Access Control and RBAC

- Solaris 10 implements Role-Based Access Control
- Privileges assigned to processes
- Users given roles with specific privileges
- Roles activated via passwords

## Revocation of Access Rights

### Options
- Immediate vs delayed
- Selective vs general
- Partial vs total
- Temporary vs permanent

### Implementation Methods

- Access List: Direct removal of entries
- Capability List: Various approaches including
- Reacquisition
- Back-pointers
- Indirection
- Key-based systems

## Language-Based Protection
- Java 2 protection through Java Virtual Machine
- Classes assigned protection domains on loading
- Stack inspection ensures proper privilege levels
- Allows high-level policy description
- Software enforcement when hardware support unavailable

================note 11========

## Core Concepts
- Virtual machines (VMs) abstract hardware of a single computer into multiple execution environments
- Key components include:
- Host: The underlying hardware system
- Virtual Machine Manager (VMM) or hypervisor: Creates and manages VMs
- Guest: Usually an operating system running in the virtual environment

## Types of Hypervisors
1. Type 0 Hypervisors
- Hardware-based solutions implemented in firmware
- Examples: IBM LPARs, Oracle LDOMs
- Each guest has dedicated hardware
- Can support virtualization-within-virtualization

2. Type 1 Hypervisors
 - Operating system-like software built for virtualization
- Examples: VMware ESX, Citrix XenServer
- Common in corporate datacenters
- Can include general-purpose OS functionality (like Windows Server with HyperV)

3. Type 2 Hypervisors
- Applications running on standard operating systems
- Examples: VMware Workstation, Parallels Desktop, Oracle VirtualBox
- Less OS involvement in virtualization
- Suitable for personal use and testing

## Implementation Methods

### Trap-and-Emulate
- Guest executes in user mode
- Privileged instructions cause traps to VMM
- VMM executes operations on behalf of guest
- Performance impact on kernel mode operations

### Binary Translation

- Used when CPUs lack clean separation of privileged instructions
- VMM examines and translates special instructions
- Uses caching to optimize performance
- Example: Windows XP boot caused 950,000 translations

### Hardware Assistance

- Modern CPUs include virtualization support (Intel VT-x, AMD-V)
- Provides additional CPU modes for guest and host
- Improves performance and simplifies implementation
- Includes support for nested page tables and DMA

## Memory Management
- Uses nested page tables (NPTs) for memory virtualization
- VMware ESX employs three methods:
1. Double-paging
2. Balloon memory management
3. Memory deduplication

## Advanced Features

### Live Migration

- Allows moving running VMs between systems without interruption
- Process includes:
1. Establishing connection between source and target
2. Creating new guest instance
3. Transferring memory pages
4. Final state transfer and guest activation

### Storage Management

- Supports boot disks and data access
- Uses disk images for guest storage
- Enables physical-to-virtual (P-to-V) and virtual-to-physical (V-to-P) conversion
- Supports network attached storage

## Benefits
- System protection and isolation
- Snapshot and restore capabilities
- Resource consolidation
- Multiple OS support
- Templating for rapid deployment
- Cloud computing enablement

## Special Implementations

### Programming Environment Virtualization

- Example: Java Virtual Machine (JVM)
- Provides platform-independent execution environment
- Includes features like garbage collection and JIT compilation

### Application Containment

- Lightweight alternative to full virtualization
- Examples: Oracle Containers, Solaris Zones
- Shares host OS kernel while providing application isolation
- More efficient resource utilization

================note 12========

## Core Concepts
- A distributed system consists of loosely coupled processors connected by a communications network
- Processors are referred to as nodes, computers, machines, or hosts
- Sites represent processor locations
- Servers provide resources that client nodes at different sites want to use

## Advantages of Distributed Systems

- Resource sharing (remote file access and printing, distributed databases, specialized hardware)
- Computation speedup through load sharing
- Enhanced reliability through failure detection and recovery
- Communication via message passing
- Better flexibility and maintenance through multiple smaller systems versus large systems

## Types of Distributed Operating Systems

### Network Operating Systems

- Users are explicitly aware of multiple machines
- Resource access requires specific remote access methods:
- Remote logging (telnet, ssh)
- Remote Desktop
- File Transfer Protocol (FTP)
- Requires users to adapt to network-based commands

### Distributed Operating Systems

- Hides multiplicity of machines from users
- Remote resource access appears similar to local access
- Supports:
- Data migration (full or partial file transfer)
- Computation migration via RPCs or messaging
 - Process migration for load balancing and specialized processing needs

## Network Structure

### Local Area Networks (LAN)

- Covers small geographical areas
- Multiple topology options (star, ring)
- Speeds from 1Mb/s to 40Gbps
- Components include computers, peripherals, and routers
- Ethernet is most common (IEEE 802.3 standard)
- Wireless networking (WiFi) increasingly prevalent

### Wide Area Networks (WAN)

- Links geographically separated sites
- Uses point-to-point connections over long-haul lines
- Implemented through routers
- Speed examples:
- T1: 1.544 Mbps
- T3: 45 Mbps
- OC-12: 622 Mbps

## Communication Structure
- Key design considerations:
1. Naming and name resolution
2. Routing strategies
3. Connection strategies
4. Contention management

## TCP/IP Implementation
- Requires both IP and MAC addresses for communication
- Uses DNS for IP address resolution
- Employs ARP for MAC address mapping
- Supports inter-network routing through routers

## System Robustness

### Failure Detection

- Uses heartbeat protocols for monitoring
- Regular I-am-up message exchanges
- Are-you-up messages for verification
- Multiple failure types possible (site down, link failure, message loss)

### Reconfiguration
- System must adapt to failures
- Broadcasts failure information to all sites
- Updates system when failed components recover

## Distributed File Systems (DFS)

- Manages dispersed storage devices
- Provides file sharing across multiple users
- Key features:
- Location transparency
- Location independence
- Remote file access
- Cache consistency management
## Design Principles
- Transparency: system appears centralized to users
- Fault tolerance: continues functioning despite failures
- Scalability: easily accommodates growth
- Supports clustering for unified resource management