Complete Operating Systems in Short

Function of an Operating System (OS):

An operating system acts as the maestro of a computer system. It’s the software that manages the hardware components, system resources, and provides a platform for running applications. Here are some of its essential functions:

• Resource Management: The OS allocates and controls resources like memory, CPU, storage, and I/O devices.
• Process Management: It creates and manages processes (running programs), ensuring smooth execution and handling conflicts.
• Memory Management: The OS allocates and deallocates memory for programs, optimizing its use.
• File Management: It organizes files and folders on storage devices, enabling users to store and retrieve data.
• Security: The OS provides security mechanisms to protect the system from unauthorized access and malicious software.
• User Interface: It offers a user interface (UI) for users to interact with the system, be it a graphical interface (GUI) or command-line interface (CLI).

Evolution of Operating Systems:

Operating systems have come a long way since their humble beginnings. Here’s a simplified look at their evolution:

• Early OS (1950s-1960s): Simple, single-user, single-tasking systems with limited functionality.
• Batch Processing Systems (1960s-1970s): Introduced job queuing for improved efficiency, allowing multiple jobs to be processed sequentially.
• Multitasking and Multi-user Systems (1970s-1980s): Enabled multiple programs to run concurrently and supported multiple users on a single system.
• Personal Computer OS (1980s-present): The rise of user-friendly GUIs and personal computers led to OS advancements for individual users.
• Modern OS (present): Today’s OSes are complex, multitasking, multi-user systems with features like networking, security, and virtualization.

Different Types of Operating Systems:

There are various types of operating systems designed for specific purposes:

• Desktop OS (Windows, macOS, Linux): Used on personal computers for everyday tasks.
• Mobile OS (Android, iOS): Power smartphones and tablets, focusing on touch interfaces and mobility.
• Server OS (Windows Server, Linux): Manage servers for tasks like file sharing, web hosting, and network administration.
• Embedded OS: Designed for specialized devices like smart appliances or routers, with limited features but high efficiency.

Desirable Characteristics of an Operating System:

A good operating system should possess several key characteristics:

• User-friendly: Easy to learn and use for both novice and experienced users.
• Efficient: Manages resources effectively for smooth performance.
• Reliable: Provides stable operation and minimizes crashes or errors.
• Secure: Protects the system from unauthorized access and malware.
• Scalable: Adapts to accommodate changing hardware configurations and user demands.

Operating System Services:

An OS offers a variety of services to both programs and users. Here’s a breakdown of the service types:

• Process Management: Services related to creating, scheduling, and managing processes.
• Memory Management: Services for allocating and managing memory for programs.
• File Management: Services for creating, deleting, accessing, and manipulating files.
• Input/Output (I/O) Management: Services for controlling peripheral devices like printers, keyboards, and disks.
• Security: Services for user authentication, access control, and data protection.
• Networking: Services for communication and resource sharing over networks.

Providing Operating System Services:

There are two primary ways operating systems provide these services:

• Utility Programs: These are standalone applications that offer specific functionalities, such as file management tools or disk formatting utilities.
• System Calls: Programs can request services directly from the operating system kernel through system calls. These act as an interface between a program and the OS kernel.

---

File Concept:

A file is the fundamental unit of data storage in a computer system. It’s a named collection of related information that users and applications can create, access, modify, and delete.

User’s View of a File System:

For users, the file system provides a logical organization of files. They see directories (folders) to organize files hierarchically and interact with files through user interfaces or commands.

System Programmer’s View of a File System:

From a system programmer’s perspective, the file system manages the physical storage of data on devices like disks. It keeps track of file location, attributes (size, permissions), and provides an abstraction layer between applications and the raw storage device.

Disk Organization:

A disk is a common storage device divided into sectors, tracks, and cylinders. The file system organizes data storage on a disk using allocation methods.

Tape Organization:

Magnetic tapes are sequential access storage devices. Unlike disks with random access, data on tapes can only be accessed sequentially. File systems for tapes handle linear data placement and file marking for identification.

Modules of a File System:

A file system typically consists of several modules:

• File Control Block (FCB): Stores file metadata like size, creation time, access permissions.
• Directory Implementation: Manages the directory structure for organizing files.
• Free Space Management: Tracks available disk space for allocating new files.
• I/O Module: Handles data transfer between memory and storage devices.

Disk Space Allocation Methods:

There are three main methods for allocating disk space to files:

• Contiguous Allocation: Stores a file in a single contiguous block of sectors on the disk. Simple but can lead to external fragmentation as free space becomes scattered.
• Linked Allocation: Each file data block has a pointer to the next block, forming a chain. Efficient for adding/removing files but can lead to internal fragmentation due to wasted space within blocks.
• Indexed Allocation: An index table keeps track of the data block locations for a file. Offers flexibility and reduces fragmentation but adds overhead for managing the index table.

Directory Structures:

Directory structures organize files within the file system. Common structures include:

• Single-Level Directory: All files reside in a single directory, limiting scalability.
• Hierarchical Directory Structure: Files are organized in a tree-like structure with nested directories for better organization.

File Protection:

File systems provide mechanisms to control access to files:

• Access Control Lists (ACLs): Specify user/group permissions for read, write, and execute operations on files.
• Capabilities: Grant specific rights to users for accessing files, enhancing security.

System Calls for File Management:

System calls act as an interface between programs and the file system kernel. Common system calls include:

• open(): Opens a file for reading, writing, or both.
• close(): Closes a file.
• read(): Reads data from a file.
• write(): Writes data to a file.
• create(): Creates a new file.
• delete(): Deletes a file.

Disk Scheduling Algorithms:

When multiple disk I/O requests are pending, the disk scheduling algorithm determines the order in which requests are served. Common algorithms include:

• FCFS (First-Come-First-Serve): Processes requests in the order they arrive. Can lead to long seek times if requests are scattered.
• Shortest Seek Time First (SSTF): Prioritizes requests with the nearest seek distance, reducing seek time.
• SCAN: The disk head moves back and forth between two boundaries, servicing requests along the way.
• C-SCAN: Similar to SCAN but only moves in one direction, reducing head movement.

---

CPU Scheduling

Process Concept:

A process is the fundamental unit of work in a computer system. It represents an instance of a program in execution. Each process has its own execution context, including:

• Program code and data
• Program counter (keeps track of the instruction being executed)
• CPU registers
• A stack for storing function calls and temporary data

Scheduling Concepts:

CPU scheduling is the process of selecting a process from the pool of ready processes (those waiting for the CPU) and allocating it to the CPU for execution. It’s a crucial part of multiprogramming, allowing efficient sharing of the CPU among multiple processes.

Types of Schedulers:

There are two main types of schedulers based on scheduling decisions:

• Long-Term Scheduler (Job Scheduler): Decides which jobs (batches of processes) to be admitted to the system. It considers factors like system load and memory availability.
• Short-Term Scheduler (CPU Scheduler): Selects which process among the ready processes gets allocated the CPU. It focuses on factors like process priority, execution time, and I/O wait times.

Process State Diagram:

A process can be in various states during its lifecycle:

• New: The process is just created.
• Ready: The process is waiting for the CPU and has all necessary resources.
• Running: The process is currently executing on the CPU.
• Waiting: The process is waiting for an event (e.g., I/O completion) before proceeding.
• Terminated: The process has finished execution.

Scheduling Algorithms:

There are various CPU scheduling algorithms with different goals and trade-offs:

• First-Come-First-Served (FCFS): Simple approach, processes are served in the order they arrive. May lead to starvation for short processes if long processes arrive frequently.
• Shortest Job First (SJF): Prioritizes processes with the shortest execution time. Minimizes average waiting time but requires knowing process execution times upfront (often not available).
• Priority Scheduling: Assigns priorities to processes. Higher priority processes are served first. Useful for real-time systems but can lead to starvation for lower priority processes.
• Round Robin (RR): Processes are allocated the CPU for a fixed time slice (quantum). After the slice, the process is preempted (put back in the ready queue) and the next process gets a chance. Ensures fairness and responsiveness but may lead to context switching overhead.

Algorithm Evaluation:

Scheduling algorithms are evaluated based on various metrics:

• Average Waiting Time: The average time processes spend waiting for the CPU.
• Average Turnaround Time: The average time from process submission to completion.
• Average Response Time: The average time between a process submitting a request and the first response from the OS.
• Throughput: The number of processes completed per unit time.
• CPU Utilization: The percentage of time the CPU is busy.

There’s no single “best” algorithm, the choice depends on the system’s requirements and goals.

System Calls for Process Management:

System calls provide an interface between programs and the operating system for process management tasks:

• fork(): Creates a new process (child) that is a copy of the calling process (parent).
• execve(): Loads a new program into the calling process, replacing its current code and data.
• wait(): A parent process waits for the termination of one of its child processes.
• exit(): Terminates the calling process.

Multiple Processor Scheduling:

With multiple CPUs, scheduling becomes more complex. Additional factors need to be considered:

• Load Balancing: Distributing processes evenly across available CPUs to maximize utilization.
• Synchronization: Ensuring proper coordination between processes accessing shared resources to avoid race conditions.

Concept of Threads:

A thread is a lightweight unit of execution within a process. A process can have multiple threads of control that share the same memory space and resources. Threads offer advantages:

• Improved Responsiveness: A process with multiple threads can remain responsive even if one thread is blocked (waiting for an event).
• Efficient Resource Sharing: Threads within a process share memory and resources, reducing overhead compared to separate processes.

---

Input/Output (I/O): A Guide for Programmers

I/O is fundamental for any program that interacts with the external world. Here’s a breakdown of its principles, programming considerations, and common approaches:

Principles and Programming:

• I/O Devices: These are hardware components that enable communication with the outside world, like keyboards, monitors, printers, disks, and network cards.
• I/O Operations: Programs perform I/O operations like reading data from a keyboard or writing data to a file.
• System Calls: Programs interact with I/O devices through system calls provided by the operating system. These calls handle device-specific details and ensure proper resource management.
• Error Handling: I/O operations can fail due to various reasons. Programs need to handle errors gracefully, such as disk full errors or network connectivity issues.

I/O Problems:

• Slowness: I/O operations are often much slower than processor operations. Programs need to be designed to minimize I/O wait times.
• Device Diversity: Different devices have varying capabilities and require specific handling.
• Synchronization: When multiple processes access shared resources like files, synchronization is needed to avoid data corruption.

Asynchronous Operations:

• Non-blocking I/O: Programs can initiate I/O operations without waiting for them to complete. This allows the program to continue execution while the I/O operation finishes in the background.
• Callbacks and Events: Programs can register callbacks or event handlers to be notified when an I/O operation completes. This avoids busy waiting and improves responsiveness.

Speed Gap and Format Conversion:

• Speed Gap: There’s a significant speed difference between processors and I/O devices. Techniques like buffering and caching can help mitigate this gap by storing frequently accessed data in memory.
• Format Conversion: Data formats can vary between devices and programs. Programs may need to handle format conversions to ensure compatibility during I/O operations.

I/O Interfaces:

• Device Drivers: These are software programs that act as intermediaries between the operating system and I/O devices. They translate generic I/O requests into device-specific instructions.

Program Controlled I/O (PIO):

• CPU Polling: In PIO, the CPU continuously checks the status of the I/O device to see if it’s ready for data transfer. This approach is inefficient as the CPU wastes time waiting even if the device isn’t ready.

Interrupt Driven I/O:

• Interrupts: The I/O device signals the CPU (generates an interrupt) when it’s ready or needs attention. This allows the CPU to continue processing until the interrupt occurs, improving efficiency.

Concurrent I/O:

• Multiple I/O operations can be initiated concurrently, further improving program responsiveness. Operating systems provide mechanisms for managing concurrent I/O requests.

---

Concurrent Processes

Concurrent processes are the backbone of modern multitasking systems. Here’s a breakdown of key concepts and challenges:

Real vs. Virtual Concurrency:

• Real Concurrency: Multiple processors or cores can truly execute processes simultaneously.
• Virtual Concurrency: A single processor rapidly switches between processes, creating the illusion of concurrency.

Synchronization and Mutual Exclusion:

• Synchronization: Ensures processes cooperate and access shared resources correctly to avoid data corruption.
• Mutual Exclusion: Guarantees only one process can access a critical section (code segment manipulating shared resources) at a time.

Inter-Process Communication (IPC):

• Mechanisms for processes to exchange information and coordinate their activities. Common methods include:
  • Shared Memory: Processes access a common memory region for data exchange.
  • Message Passing: Processes send and receive messages through channels.

Critical Section Problem:

• A fundamental problem in concurrent programming. It occurs when multiple processes share a critical section of code that accesses shared resources. Without proper synchronization, these processes can interfere with each other, leading to incorrect results.

Solutions to Critical Section Problem:

• Semaphores: Synchronization tools that control access to shared resources.
  • Binary Semaphores: Have a value of either 0 or 1.
    • WAIT (s): If s is 0, the process waits. If s is 1, it decrements s to 0 and proceeds.
    • SIGNAL (s): Increments s by 1. If another process is waiting, it wakes it up.
  • Counting Semaphores: Can have a value greater than 1, allowing control of access for multiple resources.
• Mutex Locks: A special type of binary semaphore that guarantees mutual exclusion.

Deadlocks:

• A state where multiple processes are blocked forever, waiting for resources held by each other. Consider a scenario where Process A holds resource X and needs resource Y, while Process B holds resource Y and needs resource X.

Deadlock Characteristics:

• Mutual exclusion: Processes hold resources exclusively and wouldn’t release them unless they acquire needed resources.
• Hold and Wait: Processes hold at least one resource and wait for others.
• No preemption: Acquired resources can’t be forcibly taken away from a process.
• Circular wait: A wait-for chain exists where each process waits for a resource held by the next process in the chain.

Deadlock Prevention:

• Restrict resource allocation to ensure conditions for deadlocks cannot occur. This can be complex and limit system flexibility.

Deadlock Avoidance:

• Predict potential deadlocks by analyzing resource requests and process states. This requires advanced algorithms and overhead.

Deadlock Recovery:

• Terminate processes or forcibly preempt resources to break the deadlock cycle. This can lead to wasted work and data loss.

---

Operating Systems

Operating systems come in various flavors, each suited for specific needs. Here’s a breakdown of network, distributed, and multiprocessor operating systems, followed by case studies of popular contemporary options:

Network Operating Systems (NOS):

• Manage resources on a network of computers.
• Provide services like file sharing, printing, security, and user authentication across the network.
• Examples: Windows Server, Linux distributions like Samba or NFS.

Distributed Operating Systems (DOS):

• Manage a collection of geographically dispersed computers as a single system.
• Allow users to access resources (files, programs) on remote machines transparently.
• Focus on high availability, fault tolerance, and distributed resource management.
• Examples: Apache Hadoop (used for large-scale data processing), Google’s Spanner (database management).

Multiprocessor Operating Systems (MOS):

• Designed to take advantage of multiple processors or cores in a single computer.
• Provide mechanisms for process scheduling, synchronization, and memory management across multiple CPUs.
• Aim to improve system performance and throughput by efficiently utilizing parallel processing capabilities.
• Examples: Most modern desktop and server OSes support multiprocessors (e.g., Windows, Linux, macOS).

Case Studies:

1. Unix/Linux:

• Family of open-source operating systems known for their stability, security, and flexibility.
• Primarily command-line driven with graphical user interfaces (GUIs) available.
• Popular for servers, embedded systems, and personal computers.
• Offers strong multitasking, multi-user capabilities, and a rich ecosystem of open-source software.

2. Windows:

• Developed by Microsoft, a family of widely used desktop and server operating systems.
• Features a user-friendly GUI and extensive hardware compatibility.
• Offers strong networking integration and a vast array of software applications.
• Popular choice for personal computers and corporate environments.

3. Other Contemporary Operating Systems:

• macOS (Apple): Proprietary OS for Apple computers, known for its user-friendliness and integration with Apple hardware and software.
• Android (Google): Open-source OS for mobile devices, dominates the smartphone market with a large app ecosystem.
• iOS (Apple): Proprietary OS for iPhones and iPads, known for its security and tight integration with Apple hardware.
• Chrome OS (Google): Lightweight OS for Chromebooks, focused on web-based applications and cloud storage.

Choosing the right operating system depends on factors like:

• Hardware: Compatibility with specific processors and devices.
• Purpose: Server needs, desktop use, mobile computing, etc.
• User needs: User-friendliness, performance requirements, software compatibility.
• Cost: Open-source vs. proprietary licensing models.