Operating System Architecture: Notes

This section focuses on the architectural structures of operating systems and the critical
processes and components that make them function efficiently. It covers monolithic systems,
layered systems, microkernels, client-server models, and key concepts like system calls,
linkers and loaders, and booting.

1. Monolithic System Architecture

Definition:

• In a monolithic system, the entire operating system (OS) is designed as a single, large
block of code.
• All services (such as process management, memory management, file management,
and device drivers) are provided by the kernel itself.

Key Features:

• Single Address Space: All system services run in kernel mode within the same
address space.
• High Performance: Since services are tightly integrated, the communication between
components is fast.
• Complexity: A monolithic system can become large and complex, making it harder to
maintain.

Example:

• Traditional UNIX and Linux kernels (before modularization) were monolithic.

2. Layered System Architecture

Definition:

• A layered system organizes the OS into layers, with each layer providing specific
services and interacting only with adjacent layers.
• Each layer provides a well-defined interface to the layer above and below it.

Key Features:

• Modular Design: Each layer is designed independently, making the system easier to
manage and extend.
• Abstraction: Layers offer abstraction, where lower layers handle hardware
interaction and higher layers handle user-level interactions.

1
 • Communication: Layers communicate with one another using well-defined
interfaces.

Example:

• Xenomai: A real-time OS that uses layered architecture.

• Windows NT and Linux (kernel) also exhibit layered-like structures, though not
strictly layered.

3. Microkernel Architecture
Definition:

• A microkernel architecture aims to minimize the kernel's responsibilities. The

microkernel only manages the most basic functions (e.g., communication, process
scheduling) while other services like device drivers, file systems, and network
protocols are moved to user space as separate processes (servers).

Key Features:

• Minimalistic Kernel: The microkernel has only essential services, such as inter-
process communication (IPC) and basic scheduling.
• Modularity: Non-essential services are implemented outside the kernel, making the
system more modular and flexible.
• Fault Isolation: Since many services run in user space, failures in one service do not
directly impact the kernel or other services.

Advantages:

• Stability: If a non-essential service crashes, the kernel continues to run without

interruption.
• Flexibility: Components can be replaced or upgraded independently.

Disadvantages:

• Performance Overhead: Communication between the kernel and user-space

components can be slower due to more context switching.

Example:

• MINIX: A microkernel-based OS used for educational purposes.

• L4: A family of microkernels that form the basis of several OS projects.

4. Client-Server Model
2
Definition:

• The client-server model is a distributed architecture where tasks are divided between
clients and servers.
o Client: A process that requests services from the server.
o Server: A process that provides services or resources to the client over a
network.

Key Features:

• Separation of Concerns: Clients handle the user interface, while servers manage the
core resources and services.
• Network Communication: Communication typically happens over a network using
protocols like TCP/IP.
• Scalability: Servers can handle multiple client requests simultaneously, making it
suitable for distributed computing.

Examples:

• Web servers (e.g., Apache, Nginx) and database servers (e.g., MySQL) follow the
client-server model.
• Remote Procedure Calls (RPC) and Sockets are commonly used for
communication.

5. System Calls
Definition:

• System calls are the programming interface through which applications interact with
the operating system. They allow user-level programs to request services provided by
the kernel, such as creating processes, managing memory, or handling files.

Common Types of System Calls:

1. Process Control:
o fork(), exec(), wait(), exit()
2. File Management:
o open(), read(), write(), close()
3. Device Management:
o ioctl(), read(), write()
4. Memory Management:
o mmap(), brk(), sbrk()
5. Information Maintenance:
o getpid(), gettimeofday(), gethostname()

Key Features:

3
 • Interface to Kernel: System calls act as an interface between user applications and
the kernel.
• Security and Protection: The OS can control which system calls can be invoked,
ensuring security and proper resource management.

6. Linker and Loader

Linker:

• Definition: A linker combines different program modules or object files into an

executable program.
• It resolves symbolic references between modules and ensures that all functions and
variables are properly addressed.

Key Features:

• Static Linking: Linker combines all the code into a single executable during the
compile-time.
• Dynamic Linking: Linker resolves references at runtime, allowing programs to share
libraries.

Loader:

• Definition: A loader loads the executable file into memory for execution.
• The loader prepares the program by allocating memory, loading shared libraries, and
setting up the program for execution.

Key Features:

• Memory Allocation: The loader allocates memory spaces for the program and its
associated libraries.
• Program Execution: Once loaded, the OS passes control to the program's entry point
(usually main()).

7. Booting of an Operating System

Definition:

• Booting is the process of starting up a computer and loading the operating system into
memory.

Steps in Booting:

4
 1. Power-On: When the computer is powered on, the BIOS (Basic Input/Output
System) or UEFI (Unified Extensible Firmware Interface) runs.
2. POST (Power-On Self Test): The system checks hardware components to ensure
they are functional.
3. Bootloader: After the POST, the bootloader is loaded from the boot device (e.g.,
hard drive, SSD, USB). The bootloader is responsible for loading the OS kernel into
memory.
4. Kernel Initialization: The kernel initializes hardware devices, system services, and
sets up the environment for user-level applications.
5. User Space Initialization: Finally, user-level programs (like the shell or GUI) are
loaded, and the system is ready for interaction.

Types of Booting:

• Cold Booting (Hard Boot): Booting the system after completely turning off the
power.
• Warm Booting (Soft Boot): Restarting the system without turning off the power.

Summary Table
Concept Description
Monolithic System Single, large OS kernel with integrated services.
Layered System OS divided into layers, each with specific responsibilities.
Microkernel Minimalistic kernel with most services in user space for flexibility.
Client-Server Model Divides tasks between clients and servers in a distributed system.
System Calls Interface for user programs to request services from the OS kernel.
Linker Combines program modules into executable files.
Loader Loads executable files into memory and prepares them for execution.
Booting Process of starting a computer and loading the OS.

Conclusion:
The architecture of an operating system influences its structure, performance, and the way it
interacts with hardware and software. Understanding the various OS architectures, such as
monolithic, layered, and microkernel, as well as components like system calls, linkers and
loaders, and the booting process, provides valuable insights into how modern operating
systems operate and manage resources.