An operating system can be built using different structures depending on how its components are organized and how they interact inside the kernel. Its system structure acts as a blueprint that shows how the OS is arranged so it can be understood and adapted to different needs. Since OS design is complex, breaking it into smaller, manageable parts makes development easier. The structure defines the strategy used to integrate these components within the kernel.
- OS structure depends on component organization and interaction.
- Acts as a blueprint that guides OS design.
- Breaking the OS into smaller parts simplifies development.
- Structure defines how components are integrated into the kernel.
Simple Structure
Simple-structure operating systems have no well-defined architecture and are small, simple and limited in functionality. Their interfaces and functional levels are not clearly separated, which makes them less reliable. Because of this lack of separation, a failure in any user program can cause the entire system to crash.
- No well-defined structure; small and limited.
- Interfaces and functionality levels are not separated.
- MS-DOS is an example of this structure.
- Applications can directly access basic I/O routines.
- A user program failure can crash the entire system.
Layered Structure
In Layered structure, the OS is divided into levels where each layer uses the services of the one below it—hardware at the bottom and the user interface at the top. This design improves organization and simplifies debugging, as errors can be isolated to specific layers. However, it adds overhead because data must pass through multiple layers and requires careful planning. UNIX is an example of this structure.
- OS is divided into multiple layers (hardware at bottom, UI at top).
- Each layer uses the functions of the layer below it.
- Easier debugging because errors are isolated to specific layers.
- Adds overhead due to data passing through many layers.
- Requires careful planning; layers can only use lower layers.
- UNIX is an example of a layered structure.
Modular Structure
A modular structure uses a kernel that contains only essential core components, while additional services are added as loadable modules during boot or runtime. It is similar to a layered design because it has defined and protected interfaces, but it is more flexible since modules can communicate freely. This approach is widely used in modern systems such as Solaris.
- Kernel contains only core components.
- Extra services are added as dynamically loadable modules.
- More flexible than layered structure; modules can call any other module.
- Used in systems like Solaris.
Virtual Machines (VMs)
A virtual machine abstracts physical hardware such as the CPU, memory, disk and network into multiple isolated environments, each functioning like an independent system. Tools like VirtualBox demonstrate this concept by allowing several virtual systems to run on one machine. Through CPU scheduling and virtual memory, the OS makes it appear as though each VM has its own dedicated resources. VMs abstract physical hardware into isolated environments.
- Each VM behaves like a separate, independent machine.
- VirtualBox is a common example of virtualization.
- CPU scheduling and virtual memory give each VM dedicated-like resources.
The fundamental issue with the virtual machine technique is disk-system limitations. If a host machine has only three physical disks but needs to support seven VMs, it cannot assign one disk per VM. Instead, the hypervisor creates virtual disks.
Monolithic Structure
A monolithic structure is an OS architecture in which the entire system is built as one large kernel. All major services—such as process management, memory management, file systems and device drivers—run together in a single code base. This design places all core functionality inside one unified kernel.
- Entire OS is implemented as one large kernel.
- Core services are combined into a single code base.
- Includes process, memory and file system management.
- Device drivers also operate inside the kernel.
Micro-Kernel Structure
A Micro-Kernel structure removes all non-essential services from the kernel and runs them in user space, leaving only a small core called the microkernel. This design allows new services to be added without modifying the kernel, improving security and reliability since failures in user-space services do not affect the whole system. macOS uses microkernel concepts but functions as a hybrid kernel (XNU).
- Non-essential services run in user space, leaving a small core kernel.
- New services can be added without changing the kernel.
- More secure and reliable because failures don’t crash the whole OS.
- macOS uses microkernel ideas within its hybrid XNU kernel.
Hybrid-Kernel Structure
A hybrid-kernel structure combines the features of both monolithic and microkernel architectures. It blends the speed and performance of monolithic kernels with the modularity and stability of microkernels. This approach offers a more flexible and efficient design than either structure alone.
- Combines monolithic and microkernel concepts.
- Provides monolithic-level speed and performance.
- Offers microkernel-style modularity and stability.
- Results in a more flexible and efficient OS design.
Exo-Kernel Structure
Exo-kernel is an OS architecture developed at MIT that gives applications direct control over hardware resources by separating resource protection from resource management. Its design avoids imposing OS-level abstractions, allowing applications to customize resources as needed. Because of this minimal approach, exokernels are small and offer developers greater flexibility.
- Provides application-level control of hardware resources.
- Separates protection from resource management.
- Avoids enforcing OS abstractions to allow customization.
- Small, minimal design that offers greater developer freedom.