Operating System

Unit 1

An Operating system (OS) is system software that manages computer hardware and
software resources and provides common services for computer programs. It acts as an
intermediary between users and the computer hardware, enabling communication and
efficient resource usage.

Functions of an Operating System

1. Process Management
o Schedules processes for execution.
o Manages process creation, execution, and termination.
o Provides mechanisms for process synchronization and inter-process communication.

2. Memory Management
o Allocates and deallocates memory to processes.
o Keeps track of each byte in a computer’s memory.
o Manages virtual memory and swapping.

3. File System Management

o Manages files and directories on storage devices.
o Provides file access, storage, and retrieval mechanisms.
o Ensures data integrity and implements permissions.

4. Device Management
o Manages device communication via drivers.
o Controls access to input/output devices (e.g., keyboards, printers, disk drives).
o Ensures efficient utilization of peripheral devices.

5. User Interface
o Provides interfaces like Command Line Interface (CLI) or Graphical User Interface
(GUI) for user interaction.
o Allows users to issue commands or manipulate graphical elements.

6. Security and Access Control

o Protects data and system resources from unauthorized access.
o Implements authentication, encryption, and permissions.
 7. System Performance Monitoring
o Tracks system performance through metrics like CPU usage, memory usage, and disk
I/O.
o Provides tools to analyze and optimize performance.

8. Multitasking and Multithreading

o Supports running multiple processes or threads simultaneously.
o Balances workloads for efficient system operation.

What is Booting?

Booting is the process of starting up a computer or device and loading the operating system
(OS) into the system's memory (RAM) so that the device can become operational. It involves
a series of steps that prepare the computer to execute user programs and applications.

The term "booting" is short for "bootstrap", which refers to the process of starting with a
small, basic program and gradually loading more complex software until the system is fully
functional.

Types of Booting:

There are two main types of booting:

1. Cold Booting (Hard Booting):

o This is the process of starting a computer from a powered-off state. It happens when
the system is turned on or rebooted after being completely shut down.
o During cold booting, the computer's hardware components are initialized, and the
operating system is loaded into memory from a storage device (like a hard disk, SSD,
or ROM).
o This process often takes longer than warm booting because all components are
initialized from scratch.

2. Warm Booting (Soft Booting):

o This is the process of restarting a computer without turning off the power. It happens
when you reboot a system from within the operating system (e.g., selecting "Restart"
from the Start menu in Windows or issuing a command like reboot in Linux).
o Warm booting is faster because the system is not powered down completely; only
certain parts of the system are reset, and the operating system is reloaded without the
need to initialize hardware components from scratch.

Booting Process (Steps Involved):

Booting involves several steps, whether it's a cold boot or warm boot. Below is a simplified
breakdown of the booting process:

1. Power-on Self-Test (POST):

o When the computer is powered on, the first thing that happens is the Power-On Self-
Test (POST). This is a diagnostic test that checks the basic hardware components,
such as the CPU, RAM, hard drive, and other essential parts, to ensure they are
functioning correctly.
 o If any critical hardware is malfunctioning, an error message or beep code will
indicate the problem.

2. Bootstrap Loader:
o After the POST, the computer looks for a small program called the Bootstrap
Loader (or simply "bootloader") that is usually stored in read-only memory (ROM)
or flash memory on the motherboard. This program's role is to locate and load the
operating system.
o The bootstrap loader typically looks for a bootable device, such as a hard drive, SSD,
or USB drive, based on the boot sequence configured in the system's BIOS or UEFI.

3. BIOS/UEFI (Basic Input/Output System / Unified Extensible Firmware

Interface):
o The BIOS or UEFI firmware is responsible for initializing hardware components and
setting up the environment needed for the operating system to run.
o BIOS or UEFI provides an interface to configure system settings like boot order, time
settings, hardware configurations, etc.
o UEFI is the modern replacement for BIOS, offering faster boot times, support for
larger drives, and more advanced features.

4. Loading the Bootloader:

o Once the BIOS/UEFI completes its tasks, it transfers control to the bootloader, a
small program that loads the main operating system into memory.
o The bootloader can reside in different locations:
 In legacy BIOS systems, the bootloader is often located in the Master Boot
Record (MBR) of the primary storage device (e.g., hard disk).
 In UEFI systems, the bootloader is typically stored in the EFI System
Partition (ESP) and may be more flexible in supporting multiple operating
systems.

5. Loading the Operating System:

o The bootloader loads the kernel of the operating system into memory. The kernel is
the core component of the OS, responsible for managing system resources and
facilitating communication between hardware and software.
o Once the kernel is loaded, it takes over control of the system, and additional essential
services (such as device drivers, file systems, and network configurations) are loaded.

6. System Initialization:
o The kernel initializes system services and processes, such as user interface, network
services, and background system processes.
o User-level processes, such as login screens, desktop environments, and other system
applications, are started.

7. User Login and Operation:

o After the kernel and system services are fully loaded, the user can log in to the system
and begin using applications and tools.
o The system is now ready for use, with all the hardware and software components
initialized.
Boot Sequence Example (PCs):

1. Power is turned on.

2. POST (Power-On Self-Test) checks the hardware.
3. BIOS/UEFI firmware initializes system components and identifies boot devices.
4. The bootloader is loaded from the selected device (e.g., hard drive or USB).
5. The bootloader loads the kernel of the operating system.
6. The kernel initializes system services and user programs.
7. The user is prompted to log in, and the system is ready for use.

Classification of Operating System:

Operating systems can be classified based on their functionality and the type of tasks they are
designed to handle. Below is a detailed classification:

1. Batch Operating Systems

 Description: Executes a batch of jobs without user interaction during processing.

 Features:
o Jobs are collected and processed sequentially.
o Users do not interact with the system during execution.
o Example: Early IBM mainframe systems.
 Use Cases: Payroll systems, large-scale data processing.

Advantages and Disadvantages of Batch Operating System:

A batch operating system processes tasks (jobs) in groups or batches without user
interaction during execution. This system was widely used in early computers and is still used
in specific applications today.

Advantages of Batch Operating System

1. Efficient Resource Utilization:

o By grouping jobs, system resources like the CPU, memory, and I/O devices are
utilized more efficiently.

2. Reduced Setup Time:

o Similar tasks are processed together, reducing the time spent switching between jobs.

3. Automation:
o Once a batch is submitted, jobs are executed without user intervention, saving time
and effort.
 4. Cost-Effective for Large Jobs:
o Ideal for repetitive, long-running tasks, such as payroll processing or large-scale data
analysis.

5. Prioritization:
o Jobs can be scheduled based on priority, ensuring critical tasks are processed first.

6. Simplified Operation:
o Users submit jobs, and the system handles execution, making it straightforward for
end-users.

Disadvantages of Batch Operating System

1. Lack of Interaction:
o Users cannot interact with their programs while they are running, which can be
problematic if input or corrections are required.

2. Debugging Challenges:
o Errors are typically identified after the batch execution is complete, making
debugging time-consuming.

3. Idle Time:
o If a job in the batch depends on user input or additional data, the system may remain
idle, waiting for input.

4. Complex Job Scheduling:

o Properly scheduling jobs to optimize resource usage can be challenging and requires
careful planning.

5. Expensive Setup:
o Early batch systems required specialized personnel and expensive setups to manage
and process batches efficiently.

6. Inefficient for Small Tasks:

o Batch processing is overkill for quick or small jobs, where real-time systems are more
suitable.

7. Dependency on Operators:
o Early batch systems relied heavily on operators to group and load jobs, which could
introduce delays or errors.

Use Cases

 Payroll Processing: Handling large volumes of repetitive transactions.

 Bank Statement Generation: Processing multiple customer statements in batches.
 Data Backup: Creating backups of large datasets at scheduled intervals.
2. Interactive Operating Systems

 Description: Provides direct communication between the user and the system.
 Features:
o Real-time feedback to user commands.
o User inputs are processed immediately.
o Example: Modern desktop operating systems like Windows and macOS.
 Use Cases: Word processing, web browsing, games.

Advantages and Disadvantages of Interactive Systems:

Interactive systems are operating systems that allow direct communication between the user
and the computer during program execution. Examples include modern operating systems
like Windows, macOS, and Linux.

Advantages of Interactive Systems

1. Real-Time User Interaction:

o Users can provide input and receive immediate feedback during execution.

2. User-Friendly Interfaces:
o Designed for ease of use with graphical interfaces, command-line tools, or touch-
based controls.

3. Faster Problem Resolution:

o Issues can be identified and resolved instantly, as users can monitor the system and
interact with it.

4. Flexibility:
o Users can modify or control processes dynamically, making these systems adaptable
for diverse tasks.

5. Enhanced Productivity:
o Real-time interaction helps users perform multiple tasks quickly and efficiently.

6. Support for Multitasking:

o Allows users to run multiple applications simultaneously, such as browsing while
editing a document.

7. Interactive Debugging:
o Developers can debug programs during execution by observing outputs and changing
inputs on the fly.

Disadvantages of Interactive Systems

1. Resource Intensive:
 o Requires significant CPU, memory, and I/O resources to support real-time
interaction.

2. Complexity:
o Managing simultaneous user interactions and processes increases system complexity.

3. Higher Cost:
o The hardware and software requirements for interactive systems are often more
expensive compared to simpler systems.

4. Security Risks:
o Increased interaction provides more opportunities for unauthorized access or security
breaches.

5. Slower Performance for Some Tasks:

o Real-time interaction can introduce delays in batch processing or background tasks.

6. Potential for Errors:

o Users may inadvertently cause errors through incorrect inputs or commands.

7. Dependency on User:
o Execution may stall if the system requires constant user input, reducing efficiency.

3. Time-Sharing Operating Systems

 Description: Shares system resources among multiple users or processes by time slicing.
 Features:
o Each user gets a small time slice (quantum) for their tasks.
o Ensures responsiveness for all users.
o Example: Unix, Linux.
 Use Cases: Multi-user systems like servers.

Advantages and Disadvantages of Time Sharing Operating Systems:

A time-sharing operating system allows multiple users or processes to share system

resources concurrently by dividing time into small intervals (time slices). Each process gets a
time slice to execute, creating the illusion that all processes run simultaneously.

Advantages of Time-Sharing Operating Systems

1. Efficient Resource Utilization:

o CPU, memory, and I/O devices are shared among multiple users or processes,
ensuring optimal usage.

2. Interactive Environment:
o Users can interact with the system in real time, making it suitable for multitasking
and multiuser applications.
 3. Reduced Idle Time:
o The system switches between tasks quickly, ensuring minimal idle time for the CPU.

4. Quick Response:
o The system allocates time slices in such a way that users experience minimal delay.

5. Fair Resource Allocation:

o Time slices are typically distributed evenly among processes, ensuring fairness.

6. Improved Productivity:
o Multiple users can work on the same system without interfering with each other,
increasing efficiency.

7. Isolation:
o Faults in one process do not typically affect other processes, ensuring system
stability.

Disadvantages of Time-Sharing Operating Systems

1. High Resource Requirements:

o Requires significant CPU speed, memory, and efficient scheduling algorithms to
handle multiple processes effectively.

2. Complex Implementation:
o The design of time-sharing systems involves complex scheduling and process
management.

3. Overhead of Context Switching:

o Frequent switching between tasks can cause overhead, reducing overall system
performance.

4. Security Concerns:
o With multiple users sharing the system, ensuring data privacy and security is
challenging.

5. Potential Delays:
o A large number of processes or users can lead to delays in response time if the system
is overloaded.

6. Inefficiency for Simple Tasks:

o For small, single-user systems, time-sharing adds unnecessary complexity and
overhead.

7. Cost:
o The need for advanced hardware and software makes time-sharing systems more
expensive.
4. Real-Time Operating Systems (RTOS)

 Description: Ensures task completion within strict timing constraints.

 Types:
o Hard Real-Time Systems: Guarantees task completion within deadlines (e.g.,
pacemakers, airbag systems).
o Soft Real-Time Systems: Meets deadlines most of the time but not guaranteed (e.g.,
video streaming).
 Features:
o Low latency and predictable behavior.
o Direct hardware access.
o Example: VxWorks, QNX, FreeRTOS.
 Use Cases: Embedded systems, robotics, industrial automation.

Advantages and Disadvantages of Real time Operating System:

A Real-Time Operating System (RTOS) is designed to process data and execute tasks
within strict time constraints. It is commonly used in systems where timing is critical, such as
embedded systems, medical devices, and industrial automation.

Advantages of Real-Time Operating Systems

1. Deterministic Behavior:
o RTOS ensures predictable and consistent response times, crucial for time-critical
applications.

2. High Reliability:
o Designed to function without failure under defined conditions, making them ideal for
mission-critical systems.

3. Efficient Resource Utilization:

o RTOS manages system resources effectively, ensuring minimal wastage and
maximum performance.

4. Low Latency:
o Tasks are processed with minimal delay, meeting stringent deadlines.

5. Priority-Based Task Scheduling:

o High-priority tasks are always executed first, ensuring critical operations are handled
promptly.

6. Supports Multitasking:
o Can handle multiple tasks simultaneously while adhering to time constraints.

7. Enhanced System Stability:

o Designed to prevent tasks from interfering with each other, ensuring system stability.

8. Scalability:
 o Suitable for both small-scale embedded systems and large-scale real-time
applications.

Disadvantages of Real-Time Operating Systems

1. Complex Design and Implementation:

o Developing and configuring an RTOS is challenging due to its precise timing and
scheduling requirements.

2. High Cost:
o RTOS solutions often require specialized hardware and software, increasing costs.

3. Limited Resource Availability:

o RTOS typically runs on systems with limited memory and processing power,
imposing design constraints.

4. Overhead for Context Switching:

o Frequent context switches in multitasking environments can introduce performance
overhead.

5. Debugging Challenges:
o Testing and debugging real-time systems is complex due to the time-critical nature of
tasks.

6. Lack of Flexibility:
o RTOS is optimized for specific applications, making it less adaptable to general-
purpose tasks.

7. Requires Skilled Developers:

o Designing and maintaining RTOS-based systems demand specialized knowledge and
expertise.

8. Failure Risks:
o Missing a deadline in a real-time system can lead to critical failures, especially in
safety-critical applications.

Difference between Hard Real time and Soft Real time Operating Systems:

The key difference between Hard Real-Time and Soft Real-Time operating systems lies in
the criticality of meeting deadlines for task execution and the consequences of missing those
deadlines.

Summary of Key Differences:

Feature Hard Real-Time OS Soft Real-Time OS

Flexible, occasional deadline misses

Deadline Importance Strict, deadlines must be met.
are acceptable.
 Feature Hard Real-Time OS Soft Real-Time OS

Consequence of Missing Catastrophic failure or loss of Minor performance degradation, no

Deadline critical functionality. critical failure.

Life-critical systems, automotive Multimedia, gaming, online

Use Cases
safety, industrial control. communications.

Guaranteed completion of tasks Tasks may miss deadlines

Task Scheduling
within deadlines. occasionally but still function.

5. Multiprocessor Operating Systems

 Description: Designed for systems with multiple processors.

 Features:
o Parallel processing for increased speed.
o Shared memory and resource management.
o Example: SMP (Symmetric Multiprocessing) and NUMA (Non-Uniform Memory
Access) systems.
 Use Cases: High-performance computing, scientific simulations.

Advantages and Disadvantages of Multi-processor Operating System:

A Multiprocessor Operating System (MPOS) is designed to manage multiple processors in

a system, allowing them to work in parallel, sharing tasks and resources. This can lead to
significant performance improvements, but it also introduces complexities. Here's a look at
the advantages and disadvantages of a multiprocessor operating system:

Advantages of Multiprocessor Operating Systems:

1. Increased Throughput:
o Multiprocessor systems can execute multiple tasks simultaneously, which leads to
higher overall throughput. By distributing tasks across processors, the system can
handle more operations in less time.

2. Improved Performance:
o Parallel Processing: The ability to execute parallel tasks increases system
performance, especially for computationally intensive applications, such as scientific
simulations, image processing, or complex calculations.
o Faster Processing: Multiprocessor systems can handle more data and complete tasks
faster by dividing the workload among several processors.

3. Enhanced Reliability:
o Fault Tolerance: With multiple processors, if one processor fails, the other
processors can take over its workload, ensuring that the system continues to operate
smoothly. This redundancy improves system reliability and availability.
o Error Recovery: The system can detect processor failure and reassign tasks, which
ensures continuity in service.

4. Scalability:
 o Multiprocessor systems can easily scale by adding more processors, allowing for
growth in system capacity and performance without a major overhaul. The ability to
scale makes it easier to adapt to increasing demands.

5. Better Resource Utilization:

o With multiple processors working simultaneously, the system can make better use of
its resources (CPU, memory, etc.), which reduces idle times and enhances efficiency.

6. Load Balancing:
o Multiprocessor operating systems can intelligently distribute tasks among processors,
ensuring that no processor is overloaded, and work is evenly spread out, optimizing
performance.

Disadvantages of Multiprocessor Operating Systems:

1. Complexity in Design and Management:

o Scheduling Complexity: Distributing tasks and ensuring efficient scheduling across
multiple processors is more complex than in a single-processor system. The operating
system must ensure tasks are balanced and that processors do not conflict or wait
unnecessarily.
o Synchronization: Managing synchronization between processors, especially when
they share resources or data, can be tricky. Race conditions, deadlocks, and
inconsistent data states can occur if not properly managed.

2. Cost:
o Hardware: A multiprocessor system is typically more expensive to build and
maintain than a single-processor system. The cost of multiple processors,
interconnects, and additional hardware (like memory) can add up.
o Power Consumption: More processors mean higher power consumption, which can
lead to increased operational costs, especially in large-scale systems.

3. Software Complexity:
o Parallel Programming: Software needs to be written to take advantage of multiple
processors, which often requires specialized knowledge of parallel programming.
Programs need to be divided into smaller tasks that can be processed concurrently.
o Concurrency Issues: Managing data consistency and preventing conflicts (such as
race conditions) when processors access shared resources or memory can be difficult.

4. Overhead:
o Communication Overhead: Multiprocessor systems require communication
between processors, especially when they are sharing data. This communication can
introduce significant overhead, affecting system performance if not carefully
managed.
o Context Switching: Managing multiple processors requires frequent context
switching, which can lead to additional overhead and reduced efficiency.

5. Diminishing Returns:
o Adding more processors to a system does not always result in a linear increase in
performance. There are diminishing returns as the number of processors increases due
to overhead from managing multiple processors, coordination, and inter-process
communication.
 6. Hardware Dependence:
o Multiprocessor systems are often tightly coupled, meaning that the operating system
is highly dependent on the hardware architecture. The efficiency and capabilities of
the OS are limited by the underlying hardware's design.

Difference between Symmetric and Asymmetric Multi processing:

Symmetric Multiprocessing
Feature Asymmetric Multiprocessing (AMP)
(SMP)

All processors are equal, with no One master processor controls the
Processor Role
master-slave relation system, others are slaves

All processors share common Only the master processor has access
Memory Access
memory to memory

Task All processors can manage and The master processor manages tasks
Management execute tasks and assigns them to slaves

Higher fault tolerance; failure of

Lower fault tolerance; failure of the
Fault Tolerance one processor doesn’t halt the
master halts the system
system

Less scalable; adding processors has

More scalable with the addition of
Scalability limited impact unless master is
processors
powerful

Better performance, balanced load Performance depends on the master

Performance
distribution processor’s capacity

Cost and
More expensive and complex Less expensive and simpler
Complexity

6. Multiuser Operating Systems

 Description: Allows multiple users to access the system simultaneously.

 Features:
o Resources are allocated efficiently among users.
o Implements security and user isolation.
o Example: Unix, Linux.
 Use Cases: Servers, mainframes, database management.

Advantages and Disadvantages of Multiuser Operating Systems:

A Multiuser Operating System is designed to allow multiple users to access and interact
with the computer's resources simultaneously, or at different times, with the system ensuring
that users do not interfere with each other. Examples include Unix, Linux, and Windows
Server editions. Below are the advantages and disadvantages of multiuser operating
systems:

Advantages of Multiuser Operating Systems:

1. Resource Sharing:
o Multiuser systems allow several users to share resources (such as CPU, memory,
storage, and peripherals) efficiently. This can help reduce costs, as one system can
serve multiple users without needing separate hardware for each user.

2. Centralized Administration:
o System administrators can manage user accounts, permissions, security settings, and
resources from a central location. This simplifies system maintenance and user
management.

3. Cost Efficiency:
o Multiple users can access a single machine and share resources like storage or
computing power, reducing the need for separate machines for each user. This makes
it more cost-effective, particularly in environments where many users need access to
computing resources but not full standalone systems.

4. Security and Isolation:

o A well-designed multiuser system ensures that users cannot access each other’s data
without permission. Each user operates in an isolated environment, providing security
and privacy. This helps maintain confidentiality, as each user is given specific access
privileges.

5. Concurrency and Collaboration:

o Multiple users can work on the system simultaneously, which can enhance
collaboration. For example, shared files, email systems, and databases enable real-
time work and communication among users.

6. Efficient Resource Utilization:

o Since multiple users are sharing a single system, the system can utilize its resources
(CPU, memory, etc.) more efficiently. The system can allocate idle resources to
active users, ensuring better utilization of available hardware.

7. Remote Access:
o Multiuser systems often support remote login, allowing users to access the system
from different locations. This is particularly useful in environments like businesses
and educational institutions, where users need access to centralized data and
applications from various locations.

8. Scalability:
o A multiuser system can easily accommodate more users by adding resources or
upgrading hardware, allowing the system to scale as more users require access.

Disadvantages of Multiuser Operating Systems:

1. Complexity in Management:
 o Managing multiple users, permissions, and security settings can be complex. Admins
need to ensure that resources are allocated efficiently and that users have appropriate
access without causing conflicts.

2. Security Risks:
o With multiple users accessing the same system, the risk of unauthorized access or
malicious activities increases. If one user’s account is compromised, it may lead to a
broader security breach unless proper isolation and access controls are enforced.

3. Resource Contention:
o As multiple users share the system's resources, there can be competition for resources
like CPU time, memory, and storage. This can lead to performance degradation,
particularly if the system is not designed to handle many concurrent users or lacks
sufficient resources.

4. System Overhead:
o The operating system must manage multiple user sessions, which adds overhead to
the system. The need for context switching, maintaining user environments, and
managing access rights can consume additional resources, potentially affecting
overall performance.

5. User Conflicts:
o In a multiuser environment, users may unintentionally interfere with each other. For
example, multiple users may try to modify the same file simultaneously, leading to
conflicts, data loss, or corruption if not properly managed.

6. Data Integrity Issues:

o If not properly managed, multiple users accessing shared files or databases can lead
to data integrity issues. Simultaneous data modifications without proper locking
mechanisms could cause data corruption.

7. Dependence on Network:
o In cases where users are accessing the system remotely or via a network, the
performance and availability of the system can be affected by network latency or
downtime. Users may experience delays or downtime if the network is unreliable.

8. Increased Risk of Malware:

o With many users interacting with the system, there is a higher chance of malware or
viruses being introduced, either intentionally or unintentionally. The system must be
adequately protected with robust security measures to prevent such threats.

7. Multiprogramming Operating Systems

 Description: Allows multiple programs to reside in memory and execute concurrently.

 Features:
o Maximizes CPU utilization by switching between processes.
o Processes are scheduled based on priority.
o Example: IBM OS/360.
 Use Cases: General-purpose computing, batch systems.
Advantages and Disadvantages of Multiprogramming Operating Systems:

A Multiprogramming Operating System allows multiple programs to be loaded into

memory and executed by the CPU, enabling the system to maximize CPU utilization by
switching between tasks during I/O wait times. This contrasts with single-programming
systems, where the CPU is idle during I/O operations. Below are the advantages and
disadvantages of multiprogramming operating systems:

Advantages of Multiprogramming Operating Systems:

1. Better CPU Utilization:

o Multiprogramming maximizes CPU utilization by ensuring the CPU is never idle.
When one program is waiting for I/O operations (e.g., reading or writing data), the
CPU switches to execute another program, keeping the CPU busy and productive.

2. Increased Throughput:
o By executing multiple programs concurrently, the system can process more tasks in a
given time frame, leading to increased throughput. More work gets done because the
system makes use of idle times when one program is waiting for resources like I/O.

3. Efficient Resource Utilization:

o It makes efficient use of system resources (CPU, memory, storage, etc.) by
overlapping computation and I/O operations. This results in better resource
management, as no resource is left idle for extended periods.

4. Reduced Turnaround Time:

o Since multiple programs can be processed in parallel (though not simultaneously), the
overall time to complete all tasks can be reduced. While one program is being
processed, others can be loaded and executed, thereby reducing the waiting time for
each program.

5. Improved System Efficiency:

o The operating system can dynamically allocate resources between programs based on
their needs. Programs that require CPU time are given priority, while others that
require I/O operations can release the CPU and wait, optimizing overall system
performance.

6. Increased System Responsiveness:

o Users or applications will generally experience quicker responses, as there is no
waiting for the CPU to become available. The system can quickly switch between
tasks, improving interactivity, especially for programs with variable resource
requirements.

7. Cost-Effective:
o Multiprogramming allows for better use of expensive hardware by supporting
multiple applications simultaneously, thus making it more cost-effective compared to
having separate systems for each task.

Disadvantages of Multiprogramming Operating Systems:

1. Increased Complexity:
 o Managing multiple programs at the same time adds complexity to the operating
system. Scheduling, memory management, and resource allocation must be handled
carefully to avoid conflicts or errors.

2. Resource Contention:
o With multiple programs running concurrently, there is potential for resource
contention, where two or more programs attempt to access the same resource at the
same time. This can lead to bottlenecks, delays, and decreased system performance if
not managed properly.

3. Overhead from Context Switching:

o Frequent context switching (the process of saving and loading the state of a program
when switching between tasks) introduces overhead. This can reduce the system's
efficiency, especially when the number of tasks is high, as switching between
programs consumes time and resources.

4. Memory Management Challenges:

o As multiple programs run simultaneously, the operating system must allocate and
manage memory efficiently. It must ensure that programs do not overwrite each
other’s memory areas, which increases the complexity of memory management.

5. Possibility of Deadlock:
o Since multiple programs might require the same resources at the same time,
deadlocks (where two or more programs are stuck waiting for each other to release
resources) can occur. Deadlock prevention and resolution are challenging and require
careful design.

6. Inefficient Performance for Short Tasks:

o For short, quick tasks, the overhead of switching between multiple programs and
managing memory allocation can negate any performance benefit. For very small
tasks, the system might spend more time managing the tasks than actually executing
them.

7. Security Risks:
o Since multiple programs share the same memory and resources, there is an increased
risk of one program corrupting another or gaining unauthorized access to sensitive
data. Proper isolation between programs must be ensured, which adds to the operating
system's complexity.

8. Resource Allocation Conflicts:

o Programs may compete for limited resources like CPU, memory, and I/O devices,
leading to conflicts. If the system is not efficiently allocating resources, some
programs may experience delays or even fail to run as expected.

Difference between Multiprocessing and Multiprogramming Operating

Systems:

Aspect Multiprocessing Multiprogramming

Definition Multiple processors run tasks One processor runs multiple tasks
 Aspect Multiprocessing Multiprogramming

concurrently sequentially

Number of CPUs Multiple CPUs (or cores) Single CPU

Tasks are executed Tasks are executed sequentially (time-

Task Execution
simultaneously in parallel sharing)

High efficiency in parallel Efficient use of CPU time (especially for

Efficiency
computing I/O-bound tasks)

Scientific computing, Desktop OS, multi-user systems, general-

Use Cases
supercomputers, servers purpose computing

Hardware Requires multiple processors or

Can work with a single processor
Requirements cores

Significant performance gain for Performance depends on task type (I/O-

Performance
parallel tasks bound vs CPU-bound)

Resource Utilization Utilizes multiple CPU resources Maximizes the use of a single CPU resource

8. Multithreaded Operating Systems

 Description: Supports multiple threads within a single process for parallel execution.
 Features:
o Threads share the same memory space.
o Improves application performance on multi-core CPUs.
o Example: Windows, Linux, macOS.
 Use Cases: Web servers, database management, concurrent programming.

Benefits of Multithreading
Benefit Description

User interface remains active even when performing lengthy operations in the
Responsiveness
background.

Resource Sharing Threads share memory and resources, reducing overhead.

Scalability Efficient use of multiprocessor systems (each core can run a separate thread).

Economy Creating threads is less costly than creating processes.

Disadvantages of Multithreaded Operating System

Disadvantage Description

Bugs like race conditions, deadlocks, and thread interference are hard to
Complex Debugging
detect and fix.

Synchronization Threads need mechanisms (like mutexes, semaphores) to access shared

Overhead resources safely, which adds overhead.
 Disadvantage Description

Thread Management Creating, destroying, and managing threads can become costly if not
Overhead handled properly.

Shared memory and resources can be exploited if thread boundaries are

Security Risks
not well protected.

Too many threads can overwhelm the system and cause performance
Scalability Limitations
degradation (thread thrashing).

Deadlocks and Improper synchronization can cause threads to wait indefinitely

Starvation (deadlock) or some to never get CPU time (starvation).

Switching between threads still consumes CPU time, especially if threads

Context Switching Cost
are kernel-managed.

Multithreaded programs can behave differently on each run depending on

Difficult Testing
thread scheduling, making testing harder.

Spooling:

Spooling stands for Simultaneous Peripheral Operations On-Line. It is a process in

computer systems where data is temporarily placed in a special area of memory or on disk
(often called a "spool") before being sent to a device, such as a printer, disk drive, or another
I/O device. Spooling is mainly used to manage the sequence of tasks that need to be
processed by slower I/O devices, allowing the system to continue executing other tasks while
waiting for those devices.
How Spooling Works:

1. Queueing Data: When a job (e.g., a print request) is generated, it is written to a temporary
storage area (like a disk or memory), often referred to as the "spool". This storage acts as a
buffer for the data.
2. Processing Jobs: The operating system or a dedicated spooling service fetches the jobs from
the spool in a queue and sends them to the appropriate device (e.g., a printer) when the device
is ready to process them.
3. Parallel Execution: While one job is being processed, other jobs can be spooled and stored
for future processing. This ensures that the CPU and other system resources are not idly
waiting for a slow I/O device.

Advantages of Spooling Over Buffering:

Aspect Spooling Buffering

Spooling involves storing data Buffering temporarily holds data in

temporarily in a queue for sequential memory to compensate for speed
Purpose processing by slow devices. It handles differences between the producer (e.g.,
tasks that require interaction with slower CPU) and the consumer (e.g., a slow I/O
devices like printers. device).

Spooling processes multiple jobs Buffering is typically for a single stream

sequentially and allows multiple tasks to of data between the producer and
Data Processing
be queued for execution by a slower consumer, meant for temporary storage
device. for faster processing.

Single-task focus: it holds data

Supports multiple tasks queued and
Multiple Task temporarily for continuous flow between
processed one after another, managing
Management two devices, typically for a single data
the tasks in the order they are received.
stream or task.

Spooling provides device independence

Buffering does not typically manage
Device by allowing jobs to be processed later by
multiple devices or tasks and is used in
Independence a device, and it can manage multiple
direct communication between devices.
devices in the queue.

Increases overall system efficiency by Improves data transfer speed between

System enabling other tasks to be performed the CPU and I/O devices by
Efficiency while slower devices are processing compensating for speed differences
queued jobs. between them.

Spooling uses job queuing and

Buffering typically does not manage or
Queuing and scheduling, which ensures that tasks are
schedule jobs but just ensures smooth
Scheduling processed in the order they were received
data flow from source to destination.
or according to priority.

Well-suited for printing, batch

Best for continuous data streams, such
processing, and other scenarios where
Suitability as video playback, network data transfer,
tasks involve external devices that may
or CPU-to-memory communication.
take a long time to process.
Summary Table
OS Type Key Feature Example

Batch Executes jobs in batches without interaction Early IBM systems

Interactive Real-time user interaction Windows, macOS

Time Sharing Time-sliced multi-user systems Unix, Linux

Real-Time Strict timing constraints FreeRTOS, VxWorks

Multiprocessor Uses multiple processors SMP, NUMA systems

Multiuser Access by multiple users simultaneously Unix, Linux

Multiprogramming Runs multiple programs concurrently IBM OS/360

Multithreaded Executes multiple threads in a process Windows, Linux

Difference Between Batch Processing System and Multiprogramming

System
Summary Table:
Aspect Batch Processing System Multiprogramming System

Job Execution One job is executed at a time. Multiple jobs are executed concurrently.

User No user interaction during Allows user interaction while tasks are
Interaction execution. running.

Task Jobs are processed sequentially, The CPU switches between tasks to
Scheduling one at a time. keep it busy.

CPU CPU may be idle while waiting for CPU is kept busy by switching between
Utilization I/O. tasks.

Less efficient, CPU may remain

Efficiency More efficient, maximizing CPU usage.
idle.

Payroll processing, banking Desktop computing, web servers, multi-

Examples
systems, scientific simulations. tasking environments.

System Simpler; mainly manages More complex due to concurrent task

Complexity sequential job processing. management.
Layered Structure of Operating Systems

The layered structure is an operating system design approach where the system is divided
into a hierarchy of layers, each performing specific functions. Higher layers utilize the
services provided by lower layers, creating a modular and organized framework.

Features of a Layered OS

1. Modularity: Each layer is a distinct module with clearly defined responsibilities.

2. Abstraction: Higher layers do not need to know the details of how lower layers work, as they
communicate only through well-defined interfaces.
3. Ease of Debugging and Maintenance: Problems can be isolated to specific layers, making
the system easier to test and maintain.
4. Security: Layers restrict direct access to the hardware and sensitive resources.
5. Flexibility: New functionality can be added by introducing additional layers.

Structure of a Layered Operating System

Each layer interacts only with the layer directly above or below it. Here's a typical breakdown
of layers:

1. Layer 0: Hardware
o The physical components of the computer (e.g., CPU, memory, I/O devices).
o Provides basic hardware operations.

2. Layer 1: Hardware Abstraction Layer (HAL)

o Abstracts the hardware details and provides a uniform interface to higher layers.
o Handles device drivers and low-level resource management.

3. Layer 2: Kernel
 o Core OS functions like process scheduling, memory management, and interrupt
handling.
o Acts as the bridge between hardware and higher-level software.

4. Layer 3: Device Management

o Manages device communication (e.g., printers, disks, network interfaces).
o Ensures efficient and concurrent access to hardware.

5. Layer 4: File System Management

o Provides file storage, access, and retrieval mechanisms.
o Manages file permissions and organization.

6. Layer 5: System Call Interface (API Layer)

o Offers an interface for user applications to request services from the OS.
o Abstracts complex operations like file handling and process management.

7. Layer 6: User Interface (Shell or GUI)

o Interacts directly with the user through a command-line interface (CLI) or graphical
user interface (GUI).
o Executes user commands and applications.

Advantages of Layered OS

1. Simplicity: The system is easier to understand and implement due to modular design.
2. Isolation: Changes in one layer don’t affect other layers, improving maintainability.
3. Security: Access control is inherent because each layer communicates only with its
neighbors.
4. Reusability: Common services provided by lower layers can be reused across higher layers.

Disadvantages of Layered OS

1. Performance Overhead: Communication between layers can introduce delays.

2. Complex Design: Designing appropriate layers and defining clear interfaces can be
challenging.
3. Layer Dependency: If a lower layer fails, it may affect all dependent higher layers.

Components of Operating System:

The system components of an operating system are the essential modules or subsystems
that collectively manage hardware and software resources, provide user services, and execute
applications efficiently. Here’s an overview of the main components:

1. Process Management

 Function: Manages processes (programs in execution), including their creation, execution,

and termination.
  Responsibilities:
o Process scheduling (CPU allocation).
o Inter-process communication (IPC).
o Synchronization and deadlock handling.
 Example: Context switching between processes.

2. Memory Management

 Function: Handles allocation and deallocation of memory spaces to processes.

 Responsibilities:
o Tracks memory usage (which memory is in use and by whom).
o Implements techniques like paging, segmentation, and virtual memory.
 Example: Swapping processes between main memory and disk.

3. File System Management

 Function: Manages files on storage devices, ensuring secure and organized data storage.
 Responsibilities:
o File creation, deletion, and access.
o Directory organization.
o File permissions and security.
 Example: Reading and writing data to a hard drive.

4. Device Management

 Function: Manages input/output devices and facilitates communication between hardware

and software.
 Responsibilities:
o Device driver installation and management.
o Handling device interrupts and I/O operations.
 Example: Interacting with a printer or a USB drive.

5. Storage Management

 Function: Manages secondary storage, such as hard drives and SSDs, for persistent data
storage.
 Responsibilities:
o Disk scheduling for read/write operations.
o Space allocation and free-space management.
 Example: Organizing files in a disk partition.

6. Security and Protection

 Function: Protects system data and resources from unauthorized access or malicious
activities.
 Responsibilities:
 o Authentication (e.g., user login credentials).
o Access control (e.g., permissions for files and processes).
o Encryption for secure data transmission and storage.
 Example: Password authentication and firewall management.

7. Networking

 Function: Enables communication between systems in a networked environment.

 Responsibilities:
o Implements network protocols (e.g., TCP/IP).
o Supports remote login, file sharing, and data transfer.
 Example: Sending files over a local network.

8. User Interface

 Function: Provides a way for users to interact with the operating system.
 Types:
o Command Line Interface (CLI): Text-based interaction.
o Graphical User Interface (GUI): Visual interaction using windows, icons, and
menus.
 Example: Shell (CLI) in Linux or the GUI in Windows.

9. System Performance Monitoring

 Function: Tracks and optimizes system performance.

 Responsibilities:
o Monitors CPU, memory, and disk usage.
o Detects system bottlenecks.
 Example: Task Manager in Windows.

10. Error Detection and Handling

 Function: Detects and resolves errors in hardware, software, or user operations.

 Responsibilities:
o Logs system errors.
o Implements recovery mechanisms to maintain stability.
 Example: Logging and reporting of application crashes.

Summary of Components
Component Key Function Example

Process Management Handles processes and CPU scheduling Multitasking

Memory Management Allocates and deallocates memory resources Virtual memory

File System Management Organizes and secures file storage File permissions
 Component Key Function Example

Device Management Manages hardware interactions Printer driver

Storage Management Handles secondary storage operations Disk partitioning

Security and Protection Protects data and resources User authentication

Networking Enables data communication between systems File sharing via network

User Interface Provides interaction medium for users CLI or GUI

Performance Monitoring Tracks system resource usage Task Manager

Error Detection Detects and resolves system errors Crash recovery

Operating System Services:

Operating system services are functionalities provided by the operating system to users,
applications, and system components. These services make it easier for users and software to
interact with the hardware and manage system resources effectively.

Key Operating System Services

1. Program Execution

 Purpose: Allows the execution of user programs and system programs.

 Features:
o Loads the program into memory.
o Schedules and runs the program.
o Handles termination (normal or abnormal).
 Example: Running a web browser or a text editor.

2. I/O Operations

 Purpose: Manages input/output devices and allows programs to perform I/O operations.
 Features:
o Abstracts hardware details for the user.
o Handles data transfer between devices and processes.
 Example: Reading a file from disk or sending output to a printer.

3. File System Manipulation

 Purpose: Provides methods to create, delete, read, write, and manage files and directories.
 Features:
o Enforces permissions and security for files.
 o Organizes files in a directory hierarchy.
 Example: Saving a document or retrieving a photo from a folder.

4. Communication

 Purpose: Facilitates communication between processes, whether on the same machine or

over a network.
 Features:
o Implements inter-process communication (IPC) mechanisms.
o Supports communication protocols for networked systems.
 Example: Sending data over a network or using shared memory for process communication.

5. Error Detection and Handling

 Purpose: Monitors system operations to detect and handle errors.

 Features:
o Identifies hardware, software, or user errors.
o Logs errors and attempts to recover from them.
 Example: Handling a disk read failure or a process crash.

6. Resource Allocation

 Purpose: Allocates system resources such as CPU, memory, and I/O devices to processes.
 Features:
o Ensures fair resource distribution among processes.
o Tracks resource usage to prevent conflicts.
 Example: Allocating CPU time to multiple processes in a multitasking system.

7. Security and Protection

 Purpose: Protects the system from unauthorized access and misuse.

 Features:
o Implements authentication mechanisms (e.g., passwords).
o Enforces permissions and access controls.
 Example: Preventing unauthorized users from accessing confidential files.

8. User Interface

 Purpose: Provides a medium for users to interact with the system.

 Types:
o Command-Line Interface (CLI): Text-based interaction.
o Graphical User Interface (GUI): Visual interaction with windows and icons.
 Example: Terminal in Linux (CLI) or the Windows desktop (GUI).
9. System Monitoring and Performance

 Purpose: Tracks and optimizes the performance of system components.

 Features:
o Provides tools for monitoring CPU, memory, and disk usage.
o Detects and resolves system bottlenecks.
 Example: Task Manager in Windows or top command in Linux.

10. Accounting

 Purpose: Keeps track of resource usage by users and processes.

 Features:
o Monitors CPU usage, memory consumption, and I/O operations.
o Generates usage reports for billing or system optimization.
 Example: User accounting in multiuser systems like UNIX.

11. Protection

 Purpose: Ensures the integrity and confidentiality of system resources.

 Features:
o Restricts process access to unauthorized resources.
o Prevents malicious or accidental interference between processes.
 Example: Preventing one user’s program from accessing another user’s data.

Summary Table of Services

Service Purpose Example

Program Execution Run user/system programs Running a browser

I/O Operations Manage device interactions Printing a document

File System Manipulation File and directory management Creating or reading a file

Process communication Sending a message over a

Communication
(local/network) network

Error Detection Detect and handle system errors Recovering from a disk failure

Resource Allocation Manage system resources Allocating CPU time to processes

Security and Protection Ensure system and data security User authentication

User Interface Provide interaction medium CLI or GUI

System Monitoring Track and optimize performance Task Manager

Accounting Resource usage tracking Generating user usage reports

What is a Kernel?

The kernel is the core component of an operating system (OS) that manages system
resources and provides essential services for all other parts of the system. It acts as an
intermediary between the hardware and the software, ensuring that processes have access to
the hardware resources they need to function efficiently. The kernel operates at a very low
level and directly interacts with the system’s hardware, performing tasks such as memory
management, process scheduling, and device handling.

The kernel is fundamental to the functioning of the operating system, as it provides the
necessary services that allow programs to run and interact with hardware.

Types of Kernels:

1. Monolithic Kernel:
o A monolithic kernel is a type of kernel where the entire operating system,
including device drivers, process management, and file system management, is
implemented as a single large block of code. Examples of monolithic kernels
include Linux and Unix.
o Advantages: High performance due to direct communication between different
parts of the kernel.
o Disadvantages: Complex to manage and debug due to the large codebase and
close coupling between components.

2. Microkernel:
o A microkernel is designed to run the most basic functions of an operating
system, such as communication between hardware and software, while leaving
other services (like device drivers and file systems) to be handled by user-
space programs. Examples of microkernel-based systems include Minix and
QNX.
o Advantages: More modular and easier to maintain. Crashes in user space do
not affect the kernel.
o Disadvantages: May incur a performance overhead due to frequent
communication between the kernel and user space.

3. Hybrid Kernel:
o A hybrid kernel combines elements of both monolithic and microkernel
architectures, aiming to provide the performance benefits of a monolithic
kernel while maintaining the modularity of a microkernel. Windows NT and
macOS are examples of hybrid kernels.
o Advantages: Balances performance with modularity.
o Disadvantages: Can be more complex to design and implement.

Operations of the Kernel:

 Operation Description

Process Manages creation, scheduling, and termination of processes. Handles

Management context switching and inter-process communication (IPC).

Memory Allocates and deallocates memory, provides virtual memory, and

Management implements memory protection and paging/segmentation.

Interfaces with hardware through device drivers and manages I/O

Device Management
operations. Provides hardware abstraction.

File System Manages files and directories, handles file operations, and enforces file
Management access permissions.

Security and Access Manages user authentication, file and resource access control, and
Control ensures process isolation.

Manages network communication, implements network protocols, and

Networking
handles socket communication.

Provides an interface for user applications to interact with the kernel

System Calls
and request services.

Handles hardware and software interrupts, invoking appropriate

Interrupt Handling
interrupt service routines (ISRs).

Manages power consumption by controlling device states and CPU

Power Management
power modes.

Difference between Kernel and Shell:

Aspect Kernel Shell

Core component of the OS User interface for interacting with

Definition
managing hardware and resources. the OS.

Manages system resources (CPU, Accepts and interprets user

Primary Function
memory, devices). commands.

Mode Runs in kernel mode (privileged). Runs in user mode.

Interaction with
No direct interaction with the user. Direct interface with the user.
User

Access to Indirect access via system calls to

Direct access to hardware resources.
Hardware the kernel.

Linux Kernel, Windows NT Kernel, Bash, Zsh, CMD, PowerShell,

Example
macOS Kernel GNOME, Windows Explorer

Responsibility Resource management, process Command interpretation, user

 Aspect Kernel Shell

control, security. interaction.

Direct communication with Communicates with the kernel

Communication
hardware and system components. through system calls.

Reentrant Kernels in Operating Systems

A reentrant kernel is a type of operating system kernel designed to allow multiple processes
to access the kernel simultaneously without interfering with each other. This capability is
crucial in multitasking environments where multiple processes might require kernel services
concurrently.

Key Characteristics of Reentrant Kernels

1. Concurrency Support:
o Multiple processes can execute kernel code simultaneously without conflict.
o Achieved using synchronization mechanisms like semaphores, locks, or monitors.

2. No Global State Modification:

o The kernel avoids modifying shared global variables directly.
o Instead, each process has its own copy of data or uses shared data protected by
synchronization primitives.

3. Code Reusability:
o The same kernel code can be executed by different processes at the same time.

4. Stateless Kernel Code:

o Kernel routines avoid maintaining state information between calls unless absolutely
necessary.
o Any state is usually stored in the process's own context.

Advantages of Reentrant Kernels

1. Efficient Multitasking:
o Multiple processes can use kernel services simultaneously, improving system
responsiveness.

2. Scalability:
o Ideal for multiprocessor systems where kernel code can run on multiple processors
concurrently.

3. Reduced Latency:
 o Kernel reentrancy minimizes delays by allowing processes to execute kernel code
concurrently without waiting for others to finish.

4. Fault Isolation:
o Since kernel code operates independently for each process, faults in one process are
less likely to impact others.

Disadvantages of Reentrant Kernels

1. Increased Complexity:
o Writing reentrant code requires careful handling of shared resources to avoid race
conditions or deadlocks.

2. Overhead from Synchronization:

o The use of locks and other synchronization mechanisms can introduce performance
overhead.

3. Resource Management:
o Allocating separate resources for each process can consume more memory and
processing power.

Comparison with Non-Reentrant Kernels

Feature Reentrant Kernel Non-Reentrant Kernel

Supports multiple processes in the Only one process can execute in the
Concurrency
kernel. kernel at a time.

Shared Resource Requires synchronization No synchronization needed (single

Access mechanisms. process at a time).

Optimized for multitasking and

Performance Slower in multitasking environments.
multiprocessing.

Complexity More complex to implement. Simpler design.

Examples of Reentrant Kernels

 Modern Unix/Linux Kernels: Utilize reentrant design to handle multiple processes and
threads.
 Windows NT Kernel: Designed with reentrancy to support concurrent execution on
multiprocessor systems.
Monolithic vs. Microkernel Systems

The architecture of an operating system kernel determines how it manages system resources
and communicates with hardware and applications. Monolithic kernels and microkernels
represent two fundamental design philosophies for OS kernels.

1. Monolithic Kernel

A monolithic kernel is a single large process running in a single address space. It includes
all the essential services like process management, memory management, file system, device
drivers, and more.

Features of Monolithic Kernel

1. Single Address Space:

o All kernel components share the same memory space.
2. Rich Functionality:
o The kernel includes many services such as device drivers, file systems, and IPC.
3. High Performance:
o Direct communication within the kernel avoids overhead.

Advantages

 Performance: All kernel services operate in the same memory space, reducing the overhead
of inter-process communication (IPC).
 Simplicity: Easier to design and implement.
 Device Driver Integration: Device drivers run in the kernel space, allowing fast interactions.

Disadvantages

 Poor Stability: A bug in one component can crash the entire system.
 Large Codebase: Monolithic kernels tend to be large and harder to maintain.
 Security Risks: Since all components run in kernel mode, any vulnerability affects the entire
kernel.

Examples

 Linux
 Unix
 MS-DOS

2. Microkernel

A microkernel is a minimalistic kernel that includes only essential services such as inter-
process communication (IPC), basic scheduling, and memory management. Other services
(e.g., device drivers, file systems) run in user space.
Features of Microkernel

1. Minimal Core:
o The kernel handles only basic tasks.
2. Modular Design:
o Most services run as separate user-space processes.
3. Enhanced Security and Stability:
o Crashes in user-space services don’t directly impact the kernel.

Advantages

 Stability: A failure in one service does not affect the entire system.
 Security: Services running in user space have limited access to the system.
 Flexibility: Easier to add or update components.

Disadvantages

 Performance Overhead: Communication between kernel and user-space services involves

IPC, which can be slower.
 Complexity: Writing and managing IPC mechanisms adds to the complexity.

Examples

 Minix
 QNX
 macOS (hybrid kernel with microkernel characteristics)
 Windows NT (hybrid kernel with microkernel characteristics)

Comparison Table

Feature Monolithic Kernel Microkernel

Minimal kernel with most services in user

Design All services run in kernel space.
space.

Performance High due to direct communication. Lower due to IPC overhead.

Less stable; a crash affects the whole More stable; service crashes don’t impact the
Stability
system. kernel.

Lower, as everything runs in kernel

Security Higher, as services run in user mode.
mode.

Code Size Larger and harder to maintain. Smaller and easier to manage.

Minix, QNX, macOS (hybrid), Windows NT

Examples Linux, Unix, MS-DOS
(hybrid).
What is a System Call?

A system call is a mechanism that allows a program to request services from the operating
system's kernel. It is an essential interface between user applications and the operating
system, enabling programs to perform actions that are not directly accessible in user space,
such as interacting with hardware, managing processes, accessing files, or handling system
resources.

System calls provide a controlled interface to the kernel, allowing programs to perform tasks
that would normally require direct interaction with system resources. They are crucial for
tasks such as input/output operations, process management, memory allocation, and network
communication.

Why System Calls Are Necessary:

 Accessing Privileged Operations: The operating system kernel runs in privileged mode,
meaning it can access system resources directly. Regular applications, on the other hand, run
in user mode with limited access. System calls act as a controlled gateway between the user
mode and the kernel mode.
 Security and Stability: By using system calls, the OS ensures that applications can't directly
interfere with the system's hardware or cause instability. The kernel mediates these
interactions, providing a safe environment for both system and user programs.

Types of System Calls:

System calls are typically categorized into the following types:

1. Process Control:
o These system calls deal with the creation, termination, and control of processes.
o Examples:
 fork() – Creates a new process.
 exit() – Terminates a process.
 wait() – Makes a process wait for a child process to finish.
 exec() – Replaces the current process with a new process.

2. File Management:
o These system calls are used to manage files and directories.
o Examples:
 open() – Opens a file.
 read() – Reads data from a file.
 write() – Writes data to a file.
 close() – Closes a file.

3. Device Management:
o These system calls allow programs to interact with hardware devices.
o Examples:
 ioctl() – Controls the behavior of a device.
  read() and write() – Perform I/O operations on devices like disks or network
interfaces.

4. Memory Management:
o These system calls manage memory allocation and deallocation.
o Examples:
 malloc() – Allocates memory.
 free() – Frees allocated memory.
 mmap() – Maps files or devices into memory.

5. Information Maintenance:
o These system calls retrieve or set system information.
o Examples:
 getpid() – Returns the process ID of the calling process.
 time() – Returns the current system time.
 getuid() – Returns the user ID of the calling process.

6. Communication:
o These system calls are used for inter-process communication (IPC) and networking.
o Examples:
 pipe() – Creates a pipe for communication between processes.
 send() and recv() – Send and receive data over a network.

How a System Call is Made:

System calls are invoked by programs in the following general steps:

1. Application Requests System Call:

o The application or user program needs to perform an operation that requires kernel
services, such as reading from a file or creating a process.
o The program prepares the necessary arguments for the system call (e.g., file name,
process ID, memory size).

2. Interrupt or Trap to the Kernel:

o When the program calls a system call, it transitions from user mode to kernel mode.
This transition is done using a mechanism like an interrupt or trap.
 An interrupt is a signal sent to the CPU to divert its attention to the system
call.
 A trap is a special type of software interrupt triggered by the program itself
to request kernel services.

3. System Call Handler:

o Once the interrupt or trap occurs, the CPU switches from user mode to kernel mode,
and the control is passed to the system call handler in the kernel. This is a special
routine that knows how to handle various system calls.
o The system call handler verifies the system call and its parameters. If everything is
valid, it processes the request; otherwise, it may return an error.

4. Kernel Executes the Requested Service:

o The kernel executes the service requested by the system call, such as reading data
from a disk or allocating memory.
 o It performs the task with full access to system resources, since it runs in privileged
mode.

5. Return to User Mode:

o Once the kernel finishes processing the system call, it returns the result (e.g., data,
success, or error code) back to the user program.
o The CPU then switches back from kernel mode to user mode, and the program
continues execution from where it left off.

6. System Call Return:

o The result of the system call (such as the data read, a process ID, or an error code) is
passed back to the user program, which can then use it as needed.

Example of a System Call:

Here's a simple example of how a read system call works in a Unix-like operating system
(such as Linux):

1. The user program needs to read data from a file.

2. The program calls the read() system call and passes the file descriptor, buffer (where data will
be stored), and the number of bytes to read.
3. The system call is triggered, and the CPU enters kernel mode.
4. The kernel checks if the file is open and whether the read operation is valid. It retrieves the
data from the file and copies it into the user program's buffer.
5. The result of the read operation (either the number of bytes read or an error code) is returned
to the program.
6. The CPU returns to user mode, and the program continues execution.