Purpose of System Calls

2.1 What is the purpose of system calls?

Purpose of System Calls

System calls act as an interface between user applications and the operating system (OS).
They allow programs to request services from the OS, such as file management, process
control, memory allocation, and device handling.

Key Purposes of System Calls:

1. Accessing Hardware Resources: Programs use system calls to interact with hardware
like printers, disks, and network devices.

2. Process Management: They enable processes to be created, terminated, and scheduled.

3. File and Directory Operations: System calls allow reading, writing, opening, and closing
files.

4. Memory Management: Programs can request memory allocation and deallocation from
the OS.

5. Interprocess Communication (IPC): System calls help different processes communicate

and synchronize.

6. Security and User Privileges: They enforce security by controlling user access to system
resources.

In summary, system calls provide controlled access to OS functionalities, ensuring security

and efficient resource management.

What is the purpose of the command interpreter? Why is it

usually
separate from the kernel?

Purpose of the Command Interpreter

The command interpreter, also known as the shell, provides an interface between the user
and the operating system. It allows users to execute commands, run programs, and manage
system resources through a command-line interface (CLI).

Key Functions of the Command Interpreter:

1/16
 1. Command Execution: Interprets and executes user commands (e.g., file operations,
process management).

2. Script Execution: Runs shell scripts to automate tasks.

3. Process Management: Allows users to start, stop, and monitor processes.

4. File System Navigation: Enables users to move between directories and manipulate
files.

5. User Interaction: Provides feedback on command execution and errors.

Why is the Command Interpreter Separate from the Kernel?

1. Modularity & Flexibility: Keeping it separate allows different shells (e.g., Bash,
PowerShell) to be used without modifying the OS kernel.

2. Security: Running the interpreter in user space prevents direct kernel access, reducing
risks of system crashes or vulnerabilities.

3. Ease of Updates: The shell can be updated or replaced independently of the kernel,
improving maintainability.

4. Multi-User Support: Different users can use different shells based on preference
without affecting the OS core.

By separating the command interpreter from the kernel, operating systems enhance
security, flexibility, and maintainability while allowing users to interact with the system
efficiently.

What system calls have to be executed by a command

interpreter or shell
in order to start a new process on a UNIX system?

System Calls for Starting a New Process in UNIX

When a command interpreter (shell) starts a new process in a UNIX system, it typically
executes the following sequence of system calls:

1. fork() – Creates a new child process by duplicating the current process (the shell).

2. exec() – Replaces the child process’s memory with a new program (the command to be
executed). Variants include execve() , execlp() , execvp() , etc.

3. wait() / waitpid() – Makes the parent process (the shell) wait for the child process to
complete execution before continuing.

2/16
 4. exit() – Terminates the process after execution is complete.

Typical Execution Flow in a Shell:

1. The shell calls fork() , creating a child process.

2. The child process calls exec() to replace itself with the requested program.

3. The parent shell process calls wait() to pause until the child process finishes.

4. Once the program finishes, exit() is called to terminate the child process.

This process ensures that new commands are executed efficiently while maintaining shell
control over process management.

2.4 What is the purpose of system programs?

Purpose of System Programs

System programs provide essential utilities and services that allow users and applications to
interact with the operating system effectively. They act as an intermediary between the user
and system resources, enabling smooth operation and management of the computer.

Key Purposes of System Programs:

1. File Management: Perform operations like creating, deleting, copying, and moving files
(e.g., cp , rm , mv ).

2. Process Management: Monitor and control running processes (e.g., ps , kill , top ).

3. Device Management: Configure and interact with hardware devices (e.g., lsusb ,
lspci ).

4. System Status and Information: Provide details about system performance and
configuration (e.g., df , free , uptime ).

5. Communication: Facilitate user and system communication (e.g., ping , ssh , mail ).

6. Programming Support: Provide tools like compilers, debuggers, and interpreters (e.g.,
gcc , gdb ).

7. Security and Access Control: Manage user authentication, permissions, and encryption
(e.g., passwd , chmod , sudo ).

8. Networking: Support network configuration and monitoring (e.g., ifconfig , netstat ).

Why Are System Programs Important?

3/16
 Enhance Usability: They provide a user-friendly way to interact with system resources.

Increase Efficiency: Automate and simplify administrative tasks.

Ensure System Stability: Help monitor and manage system health and performance.

In summary, system programs are crucial for operating system functionality, enabling users
to perform essential system tasks efficiently.

What is the main advantage of the layered approach to

system design?
What are the disadvantages of the layered approach?

Advantages and Disadvantages of the Layered Approach to System

Design
The layered approach organizes an operating system into a hierarchy of layers, each built on
top of the lower layers, with well-defined functions and interfaces.

Advantages of the Layered Approach:

1. Modularity: The system is divided into smaller, manageable layers, making it easier to
design, debug, and maintain.

2. Abstraction: Each layer only interacts with adjacent layers, simplifying interactions and
reducing complexity.

3. Improved Security & Stability: Since each layer has limited access to lower layers, faults
in one layer do not affect the entire system.

4. Ease of Modification: Changes can be made to a specific layer without impacting the
rest of the system.

5. Scalability: New functionalities can be added by creating new layers without altering the
existing ones.

Disadvantages of the Layered Approach:

4/16
 1. Performance Overhead: The need to pass data through multiple layers can slow down
system performance.

2. Complex Layer Design: Designing appropriate and efficient layer interactions can be
difficult, leading to potential inefficiencies.

3. Strict Layering Constraints: If a higher layer needs a service from a lower (non-adjacent)
layer, the request must pass through intermediate layers, which can be inefficient.

4. Potential Redundancy: Some functions might be duplicated across layers, leading to

unnecessary resource usage.

Conclusion:
The layered approach enhances modularity, security, and maintainability, but it may
introduce performance inefficiencies and design complexities. Proper balance and
optimization are required for an effective layered system.

List five services provided by an operating system, and

explain how each
creates convenience for users. In which cases would it be
impossible for
user-level programs to provide these services? Explain your
answer.

Five Services Provided by an Operating System & Their Convenience

An operating system (OS) provides various services to enhance user convenience, system
performance, and security. Here are five essential services:

1. File Management:

What it does: Allows users to create, delete, read, write, and organize files.

User Convenience: Provides an intuitive way to store and retrieve data without
needing to manage disk sectors manually.

Why User Programs Can’t Provide It: User programs lack direct access to low-level
disk operations and security mechanisms required for managing files safely.

2. Process Management:

What it does: Handles process creation, execution, scheduling, and termination.

5/16
 User Convenience: Ensures multitasking, allowing users to run multiple programs
smoothly.

Why User Programs Can’t Provide It: User programs do not have the authority to
manage CPU scheduling or terminate other processes.

3. Memory Management:

What it does: Allocates and deallocates memory for processes, preventing conflicts.

User Convenience: Ensures efficient memory usage, preventing crashes due to

overlapping memory usage.

Why User Programs Can’t Provide It: Direct memory access could lead to security
breaches and crashes due to conflicts between programs.

4. I/O Device Management:

What it does: Provides drivers and manages communication between applications

and hardware devices like printers, keyboards, and USB drives.

User Convenience: Users can interact with devices seamlessly without worrying
about low-level hardware communication.

Why User Programs Can’t Provide It: User programs lack the necessary
permissions and knowledge of hardware-specific details to manage I/O devices
directly.

5. Security & Access Control:

What it does: Ensures authentication, encryption, and access control to protect user
data.

User Convenience: Prevents unauthorized access, ensuring data integrity and

privacy.

Why User Programs Can’t Provide It: Security requires system-wide enforcement,
which cannot be guaranteed at the user level.

Conclusion:
User-level programs cannot provide these services because they lack direct hardware
access, security enforcement, and system-wide control required to manage resources
safely and efficiently. The OS acts as an intermediary, ensuring reliability, security, and ease
of use.

6/16
 Why do some systems store the operating system in
firmware, while
others store it on disk?

Why Some Systems Store the OS in Firmware vs. on Disk

The choice of where to store the operating system (OS) depends on the type of system, its
requirements, and its design constraints.

1. Storing the OS in Firmware (e.g., Embedded Systems, IoT Devices)

Firmware refers to software stored in non-volatile memory, such as ROM, EEPROM, or flash
memory.

✅ Reasons for Using Firmware:

Reliability: Firmware is non-volatile, meaning the OS remains intact even if power is lost.

Speed: The OS loads faster since it is stored in directly accessible memory.

Space Constraints: Many small devices (e.g., routers, smart TVs, industrial machines)
lack hard drives.

Security: Firmware-based OSes are harder to modify, reducing the risk of tampering or
malware.

❌ Limitations:
Difficult to Update: Updating requires flashing new firmware, which can be risky.

Limited Storage: Firmware storage is smaller than disk storage, restricting OS size and
features.

Examples:

Embedded systems (e.g., smart appliances, medical devices)

Real-time systems (e.g., automotive control units, aircraft systems)

Game consoles (e.g., PlayStation, Xbox)

7/16
2. Storing the OS on Disk (e.g., PCs, Servers)
Most general-purpose computers store the OS on a hard disk (HDD/SSD) and load it into
RAM at startup.

✅ Reasons for Using a Disk:

Flexibility & Upgradability: The OS can be updated or replaced without hardware
modifications.

Larger Storage Capacity: Allows for feature-rich OSes with graphical interfaces, drivers,
and applications.

Cost-Effective: Storing the OS on a disk is cheaper than embedding it in firmware for

larger systems.

❌ Limitations:
Boot Time: It takes longer to load the OS from disk compared to firmware.

Data Corruption Risk: Disk failure or accidental deletion can make the OS inaccessible.

Examples:

Personal computers (Windows, macOS, Linux)

Servers and enterprise systems

Workstations and laptops

Conclusion:
Firmware-based OSes are ideal for dedicated, low-power, and embedded systems
requiring reliability and security.

Disk-based OSes offer flexibility, scalability, and ease of updates, making them suitable
for general-purpose computing.

How could a system be designed to allow a choice of

operating systems
from which to boot? What would the bootstrap program
need to do?

8/16
Designing a System to Allow Multiple Operating Systems (Multi-Boot
System)
A system that allows users to choose between multiple operating systems at startup is
known as a multi-boot system. To achieve this, the system requires a bootloader that
enables users to select which OS to load.

Key Components of a Multi-Boot System

1. Bootloader (e.g., GRUB, LILO, Windows Boot Manager):

A program that runs at startup and presents a menu to select an OS.

It is stored in the Master Boot Record (MBR) or UEFI firmware.

2. Partitioned Storage:

Each OS must be installed on a separate disk partition.

A dedicated boot partition may be needed to store bootloader configuration files.

3. Configuration Files:

The bootloader configuration file (e.g., /boot/grub/grub.cfg for GRUB) defines OS

entries.

Users can modify these files to add or remove OS options.

Tasks of the Bootstrap Program (Bootloader)

1. Power-On & Firmware Execution:

The system powers on, and the BIOS/UEFI firmware initializes hardware.

The firmware locates the bootloader (usually in the MBR or EFI partition).

2. Display OS Selection Menu:

The bootloader presents a menu listing available operating systems.

3. Load Selected OS Kernel:

Once a user selects an OS, the bootloader loads its kernel into memory.

9/16
 It also initializes essential drivers and system parameters.

4. Transfer Control to the OS:

The bootloader hands over control to the selected OS, which completes the startup
process.

Examples of Bootloaders Supporting Multi-Boot:

GRUB (GRand Unified Bootloader): Common in Linux and supports Windows/Linux
dual-boot setups.

Windows Boot Manager: Used for Windows multi-boot environments.

rEFInd: A graphical boot manager for EFI systems, often used for macOS/Linux/Windows
setups.

Conclusion:
A multi-boot system requires a bootloader that allows users to select an OS at startup. The
bootstrap program (bootloader) is responsible for loading the selected OS kernel into
memory and transferring control to it. This design enables users to run multiple operating
systems on the same machine efficiently.

The services and functions provided by an operating

system can be
divided into two main categories. Briefly describe the two
categories,
and discuss how they differ.

Two Main Categories of Operating System Services and Functions

Operating system (OS) services and functions can be divided into two main categories:

1. User-Oriented Services

2. System-Oriented Services

These categories differ in their purpose and the type of users they serve.

10/16
1. User-Oriented Services
These services provide a convenient and efficient environment for users to interact with
the system. They focus on ease of use, accessibility, and application support.

Examples of User-Oriented Services:

User Interface (UI): Provides a way for users to interact with the OS (e.g., GUI, CLI).

Program Execution: Loads and runs applications.

File Management: Allows users to create, delete, read, and write files.

I/O Device Management: Enables interaction with hardware devices like keyboards,
printers, and USB drives.

Communication: Facilitates data exchange between processes and users (e.g., IPC,
networking).

✅ Key Difference: These services are designed to improve the user experience and
application execution.

2. System-Oriented Services
These services ensure efficient system operation by managing hardware and system
resources. They focus on performance, security, and reliability.

Examples of System-Oriented Services:

Process Management: Controls process scheduling, creation, and termination.

Memory Management: Allocates and deallocates memory for processes.

Security & Access Control: Protects system resources through authentication and
permissions.

Error Detection & Handling: Monitors and resolves system errors to ensure stability.

Resource Allocation: Manages CPU time, disk space, and other system resources
efficiently.

11/16
✅ Key Difference: These services work behind the scenes to manage system resources and
maintain system stability.

How They Differ:

Feature User-Oriented Services System-Oriented Services

Purpose Enhance user experience Maintain system efficiency & security

Focus Ease of use & application support Resource management & process control

Examples UI, file management, I/O device Process scheduling, memory allocation,
handling security

Who Users & applications OS & system administrators

Benefits?

Visibility Visible to users Mostly operates in the background

Conclusion:
User-oriented services focus on making the system accessible and easy to use.

System-oriented services ensure efficient and secure management of system resources.

Both categories work together to provide a stable, secure, and user-friendly operating
system. 🚀
What are the advantages of using loadable kernel
modules?

Advantages of Using Loadable Kernel Modules (LKMs)

Loadable Kernel Modules (LKMs) allow the operating system kernel to be extended
dynamically without requiring a full system reboot or recompilation. These modules are
loaded and unloaded into the kernel as needed.

12/16
Key Advantages of Loadable Kernel Modules:
1. Modularity & Flexibility:

LKMs allow new functionality (e.g., device drivers, file systems, network protocols) to
be added without modifying or recompiling the entire kernel.

This makes the system more adaptable to different hardware and software
environments.

2. Efficiency & Performance Optimization:

Unused modules can be unloaded to free system resources, improving

performance.

Only necessary components are loaded, reducing memory footprint.

3. Ease of Maintenance & Updates:

Developers can update or fix kernel functionality by modifying individual modules

instead of rebuilding the entire kernel.

Security patches or bug fixes can be applied without rebooting the system.

4. Better System Stability:

If an LKM crashes, it can be unloaded and replaced without crashing the entire
system.

This minimizes downtime and improves overall system reliability.

5. Faster Development & Testing:

Kernel developers can test new features more efficiently by loading/unloading

modules instead of constantly recompiling the kernel.

This speeds up debugging and experimentation.

6. Enhanced Security & Access Control:

Some security-related modules (e.g., firewall rules, encryption services) can be

dynamically added when needed.

Access to kernel internals can be restricted, improving system security.

Example Use Cases of Loadable Kernel Modules:

13/16
 Device Drivers: A USB driver can be loaded when a device is plugged in and removed
when unplugged.

File Systems: Support for new file systems (e.g., NTFS, ext4) can be added dynamically.

Networking: Adding VPN, firewall, or packet-filtering functionalities without restarting

the system.

Security Modules: Tools like SELinux or AppArmor can be integrated as security policies
without modifying the core kernel.

Conclusion:
Loadable Kernel Modules provide flexibility, efficiency, stability, and security by allowing
kernel functionality to be modified dynamically. This makes them essential for modern
operating systems that require continuous updates and adaptability without downtime. 🚀
2.21 How are iOS and Android similar? How are they
different?

Similarities Between iOS and Android

1. Mobile Operating Systems:
Both iOS and Android are mobile operating systems designed for smartphones, tablets,
and other mobile devices. They provide the necessary framework for applications (apps)
to run and access hardware features like cameras, GPS, sensors, etc.

2. App Stores:
Both platforms have centralized app stores (Apple App Store for iOS and Google Play
Store for Android) where users can download, install, and update apps.

3. Touch-Based Interface:
Both iOS and Android are optimized for touchscreen interfaces, offering features like
gestures, swiping, and multi-touch to navigate and interact with apps and content.

4. Third-Party App Support:

Both systems support a wide range of third-party applications developed by external
developers, enabling users to customize their devices with various functionalities (e.g.,
social media, games, utilities).

14/16
5. Security Features:
Both systems offer security measures like encryption, authentication (PIN, biometrics),
app permissions, and system-level sandboxing to protect user data and privacy.

Differences Between iOS and Android

1. Operating System Design & Architecture:

iOS is a closed-source operating system created by Apple. It runs only on Apple

devices (iPhones, iPads, etc.), and its source code is proprietary.

Android, developed by Google, is open-source and based on Linux. It can be

customized and used by a wide range of manufacturers (Samsung, Google, Huawei,
etc.).

2. Customization and Control:

iOS offers limited customization options for users and developers. The UI and
overall experience are tightly controlled by Apple to maintain consistency and user-
friendliness.

Android offers more customization options, allowing users to change the

appearance, settings, and even install custom ROMs. This flexibility appeals to users
who prefer more control over their devices.

3. App Store Guidelines:

iOS apps are tightly controlled by Apple’s strict guidelines. All apps must go through
a review process before being listed on the Apple App Store.

Android is more lenient, and apps can be distributed through multiple channels,
including the Google Play Store or other third-party stores, with fewer restrictions.

4. Updates:

iOS updates are rolled out uniformly to all compatible devices, ensuring users get
the latest features and security patches simultaneously.

Android updates are manufacturer-dependent, meaning that devices from

different brands may receive updates at different times. The fragmentation of
Android devices can result in slower or inconsistent updates.

5. Hardware Variety:

15/16
 iOS is exclusive to Apple devices, ensuring a more unified hardware and software
experience, but limiting choices for users.

Android is available on a wide range of devices with varying specs, price points, and
features, offering a broader selection for consumers.

6. Voice Assistants:

iOS uses Siri, Apple’s proprietary voice assistant, which is tightly integrated with
other Apple services and hardware.

Android uses Google Assistant, which is known for its deep integration with
Google's search engine and services.

7. Integration with Ecosystem:

iOS has seamless integration with the broader Apple ecosystem (Mac, Apple Watch,
Apple TV, iCloud, etc.), making it ideal for users already using Apple devices.

Android integrates well with Google services (Google Drive, Gmail, Google Photos)
and has better integration with Google’s ecosystem, including options for syncing
with a variety of devices.

Conclusion:
While iOS and Android share many similarities in terms of their core functionalities and
services, such as app stores, touch interfaces, and security features, they differ significantly
in their design philosophies, customizability, update mechanisms, and integration with their
respective ecosystems. iOS offers a more controlled and uniform experience, while Android
provides greater flexibility and variety. The choice between them often depends on user
preferences for customization, hardware variety, and ecosystem alignment.

2/2

16/16