Operating System Basics

OS Structure, Operations, and Services

An Operating System (OS) is the most fundamental software that manages a computer's hardware and software resources. It acts as an intermediary between the user and the computer hardware, making the computer system usable and efficient. Understanding its structure, operations, and services is crucial for comprehending how computers function.

OS Structure

The structure of an OS refers to how its various components are organized and interact with each other. Different structures offer varying levels of complexity, modularity, and efficiency.

• Monolithic Structure: In this structure, all operating system services (like process management, memory management, file system, device drivers, and networking) are combined into a single large program, running in kernel mode. It's efficient because function calls between components are very fast. However, it's difficult to develop, debug, and maintain, and a bug in one part can crash the entire system. Linux and early Unix systems are examples.
• Layered Structure: The OS is designed as a hierarchy of layers, from the hardware at the bottom to the user interface at the top. Each layer has access only to the layers below it. This modularity simplifies design and debugging, as changes in one layer don't affect others significantly. However, it can be less efficient due to the overhead of passing requests through multiple layers.
• Microkernel Structure: In this design, only the most essential services (like inter-process communication, basic memory management, and scheduling) run in kernel mode. Other services (file systems, device drivers, network protocols) run as user-level processes called servers. This enhances reliability and security, as a failure in a server process doesn't crash the entire OS. It's also more flexible and easier to extend. However, it can suffer from performance degradation due to frequent context switching and message passing between user-level servers and the microkernel. Examples include MINIX 3 and Mach.
• Hybrid Structure: Combines aspects of monolithic and microkernel designs. Most services run in kernel mode for performance, but some services might run in user mode for modularity and reliability. Modern operating systems like Windows NT and macOS use a hybrid approach.

OS Operations

The OS performs several key operations to manage the computer system:

• Process Management: The OS creates, deletes, suspends, resumes, and synchronizes processes (running programs). It also handles inter-process communication.
• Memory Management: The OS allocates and deallocates memory space to processes as needed. It keeps track of which parts of memory are currently being used and by whom, and decides which processes (or parts of processes) and data to move into and out of memory.
• File Management: The OS organizes files and directories, provides mechanisms for creating, deleting, reading, writing, and manipulating files, and controls access to them.
• Device Management: The OS manages all input/output devices connected to the computer. It uses device drivers to communicate with hardware and provides a consistent interface to applications.
• Networking: Modern OSs manage network connections, protocols, and communication between computers.
• Security: The OS protects system resources from unauthorized access and ensures data integrity.
• User Interface: Provides a way for users to interact with the computer, either through a Command-Line Interface (CLI) or a Graphical User Interface (GUI).

OS Services

These are the functions provided by the OS to make the computer system easier to use and more efficient.

• Program Execution: The OS loads programs into memory and executes them.
• I/O Operation Management: Handles requests for input and output operations from applications.
• File System Manipulation: Provides services for creating, deleting, and manipulating files.
• Communication: Enables processes to communicate with each other (inter-process communication).
• Error Detection and Handling: Detects errors in hardware and software and takes appropriate action.
• Resource Allocation: Manages and allocates system resources like CPU time, memory, and I/O devices among various processes.
• Protection and Security: Protects user files and general system resources from accidental or intentional destruction or unauthorized access.

System Calls

System calls are the interface between a user program and the operating system. When a program needs to perform an operation that requires privileges beyond those of a user program (like accessing hardware, creating a new process, or writing to a file), it makes a system call. The OS then performs the requested operation on behalf of the program.

Think of it like ordering food at a restaurant. You (the user program) can't go into the kitchen (kernel mode) to cook your meal. Instead, you tell the waiter (system call interface) what you want. The waiter then communicates with the kitchen staff (OS kernel) to prepare your order and brings it back to you.

Types of System Calls

System calls can be broadly categorized based on the service they provide:

• Process Control: Create process, terminate process, load program, execute program, get process attributes, set process attributes, wait for time, allocate/free memory.
• File Management: Create file, delete file, open file, close file, read file, write file, get file attributes, set file attributes.
• Device Management: Request device, release device, read device, write device, get device attributes, set device attributes.
• Information Maintenance: Get time or date, set time or date, get system data, get process data, get file data.
• Communication: Create communication connection, delete communication connection, send message, receive message, transfer status information, attach/detach remote devices.
• Protection: Control access to resources.

How System Calls Work

When a program makes a system call, the following generally happens:

1. The application program requests a service from the OS, typically via a library function (e.g., `printf()` might internally use a `write()` system call).
2. The library function prepares the arguments for the system call.
3. The library function executes a special instruction (like `SYSCALL` or `INT`) that causes a trap to the operating system kernel. This instruction switches the execution mode from user mode to kernel mode.
4. The OS kernel identifies the system call number and its parameters.
5. The kernel executes the requested service.
6. The kernel returns control to the user program, switching back from kernel mode to user mode.
7. The library function returns the result of the system call to the application.

OS Design and Implementation

Designing and implementing an operating system is a complex undertaking. It involves making fundamental choices about the OS structure, algorithms, and data structures that will govern its behavior.

Design Goals

OS designers typically aim to achieve a balance between several competing goals:

• Efficiency: The OS should use system resources (CPU, memory, I/O) effectively to maximize throughput and minimize response time.
• Reliability: The OS should operate correctly and consistently, minimizing crashes and data loss.
• Usability: The OS should be easy for users and application developers to interact with.
• Maintainability: The OS code should be well-structured, documented, and easy to modify or extend.
• Portability: The OS should be adaptable to different hardware platforms with minimal effort.
• Security: The OS must protect system resources from unauthorized access and malicious attacks.

Implementation Considerations

Implementation involves translating the design into actual code. This often requires making trade-offs. For instance, a highly modular design (like a microkernel) might be easier to maintain but less efficient than a monolithic design.

• Programming Language: Operating systems are typically written in low-level languages like C and Assembly for performance and direct hardware access. Higher-level languages might be used for specific components or user-level utilities.
• Kernel vs. User Mode: The core of the OS (the kernel) runs in privileged kernel mode, with direct access to hardware. Other services and applications run in less privileged user mode.
• Abstraction: The OS provides abstractions for hardware (e.g., files for storage, processes for execution) to simplify programming.
• Concurrency: Modern OSs must manage multiple tasks running concurrently, requiring mechanisms for synchronization and deadlock prevention.

System Boot

The system boot process, often called booting or bootstrapping, is the sequence of operations performed by a computer when it starts up, from the moment power is applied until the operating system is fully loaded and ready to accept user commands.

The Boot Process Steps

The boot process is initiated by the hardware itself and involves several stages:

1. Power On & BIOS/UEFI: When the computer is powered on, the CPU starts executing instructions from a fixed memory address. This address typically points to the system's firmware, which is either the Basic Input/Output System (BIOS) or its modern successor, the Unified Extensible Firmware Interface (UEFI).
2. POST (Power-On Self-Test): The BIOS/UEFI performs a POST to check that essential hardware components (CPU, RAM, graphics card) are functioning correctly. If errors are detected, the system may halt or beep to signal the problem.
3. Boot Device Selection: The BIOS/UEFI then consults its configuration (often stored in CMOS memory) to determine the order of boot devices (e.g., hard drive, SSD, USB drive, network). It attempts to load the boot loader from the first device in the sequence.
4. Boot Loader: The BIOS/UEFI loads a small program called a boot loader from a specific sector (like the Master Boot Record or MBR on older systems, or the EFI System Partition on UEFI systems) of the selected boot device into memory and executes it. The boot loader's primary job is to load the operating system kernel into memory. Examples include GRUB (GRand Unified Bootloader) for Linux and the Windows Boot Manager.
5. Kernel Loading: The boot loader locates the operating system kernel file on the boot device, loads it into RAM, and then transfers control to the kernel.
6. Kernel Initialization: Once the kernel takes control, it initializes itself. This involves:
   • Initializing core data structures.
   • Detecting and initializing hardware devices (using device drivers).
   • Setting up memory management.
   • Starting essential system processes (like the init process in Linux or smss.exe in Windows).
7. User Space Initialization: The kernel then starts the first user-space process (often called `init` or `systemd` on Linux, or `smss.exe` on Windows). This process is responsible for starting all other user-level services and applications, including the login manager or graphical desktop environment.
8. System Ready: Once all necessary services are running, the system is considered booted and ready for user interaction.

BIOS vs. UEFI

UEFI is the modern replacement for BIOS. Key differences include:

• Boot Speed: UEFI generally boots faster than BIOS.
• Interface: UEFI can offer a graphical interface, while BIOS is typically text-based.
• Disk Support: UEFI supports larger disk drives (over 2.2 TB) using GPT partitioning, whereas BIOS is limited to MBR.
• Security: UEFI supports Secure Boot, which helps prevent malicious software from loading during the boot process.
• Modularity: UEFI is more modular, allowing for pre-OS applications and drivers.

The boot loader is a critical component. If the boot loader is corrupted or missing, the operating system cannot start, and the computer will likely display an error message like "Boot device not found" or "Operating system not found."