Advanced Operating System - Exam Study Guide

Long Questions with Full Exam-Ready Answers

Q: Explain the evolution of computing paradigms and the role of OS in modern mobile and ubiquitous

systems with examples.

The evolution of computing paradigms reflects how technology has shifted from centralized mainframes to

personal, networked, and now pervasive systems.

1. Mainframe Era (1960s'70s): Centralized systems where computing was performed on large, powerful

machines. Operating systems managed time-sharing and batch processing.

2. Personal Computing (1980s'90s): Introduction of desktop PCs. Operating systems like MS-DOS and

Windows were developed to provide GUIs and single-user multitasking.

3. Internet Age (2000s): Networked systems enabled client-server and distributed architectures. OS had to

support networking, web applications, and internet security.

4. Mobile Computing (2010s): Smartphones and tablets emerged. OS like Android and iOS introduced

features such as touch interfaces, app sandboxing, GPS integration, and power management.

5. Ubiquitous/IoT Era (2020s): Devices are embedded into everyday environments. OS in this era (like

Contiki, TinyOS) support real-time processing, sensor integration, ultra-low power usage, and distributed

control.

Modern OS responsibilities include context-awareness (adjusting behavior based on environment), secure

connectivity, interoperability, and real-time data processing.

Example: Android manages background tasks and power using job schedulers. In IoT, Contiki OS handles

duty-cycling for energy efficiency and sensor data collection in smart homes.

Q: Discuss the protection mechanisms used in modern operating systems. Highlight Access Control Lists and

Capability Lists.
 Advanced Operating System - Exam Study Guide

Modern operating systems implement robust protection mechanisms to prevent unauthorized access to

system resources. These mechanisms define and enforce policies determining which user or process can

access which object.

Access Control Lists (ACLs): These are object-centric and list all the permissions granted to various users for

a particular resource (e.g., read, write, execute permissions for files). In UNIX, file permissions are a classic

implementation of ACLs, defined for owner, group, and others.

Capability Lists: These are subject-centric and maintain a list of objects a user or process can access, along

with associated permissions. Systems like KeyKOS and Hydra implement capabilities as unforgeable tokens.

Other protection tools include:

- Access Matrix: A logical model defining rights of subjects (rows) over objects (columns).

- Domain-Based Access Control: Groups of access rights assigned to users based on their roles.

- Separation of Policy and Mechanism: Policies define 'what' access is allowed; mechanisms enforce 'how'

access is granted.

These tools ensure data confidentiality, enforce least privilege, and enable safe multitasking in multi-user

systems.

Q: Describe the various types and components of Distributed File Systems. Include replication, caching, and

consistency models.

A Distributed File System (DFS) manages files across multiple servers to provide high availability, fault

tolerance, and scalability. DFS enables users to access files as if they were on a local system, even when

stored remotely.

Types of DFS:

1. Client-Server DFS (e.g., NFS)

2. Peer-to-Peer DFS (e.g., IPFS)

3. Cluster-based DFS (e.g., HDFS, GFS)

4. Cloud DFS (e.g., AWS S3)

5. Parallel DFS (e.g., Lustre, PVFS)

Key Components:

- Replication: Data is duplicated across nodes to ensure availability and fault tolerance.

- Caching: Frequently accessed files are stored temporarily near the client to speed up access.

- Consistency Models: Determine how and when updates to replicas are visible (e.g., strong consistency,

eventual consistency).

- Metadata Management: Stores file structure, access rights, and locations. Handled by metadata servers.

Example: HDFS uses replication for fault tolerance, NameNode for metadata, and MapReduce for large-scale

data processing.

Challenges include managing consistency, latency, metadata bottlenecks, and ensuring secure

communication across distributed nodes.

Q: Elaborate on the CIA triad of security goals and explain how they are implemented in OS-level security.

The CIA triad forms the foundation of information security:

1. Confidentiality: Ensures data is accessible only to authorized users. Implementation includes encryption

(AES, TLS), access controls (ACLs), and secure channels for communication.

2. Integrity: Protects data from unauthorized modification. Techniques include checksums, hashing

(SHA-256), digital signatures, and secure audit logs.

3. Availability: Ensures systems and data are available to legitimate users. This is supported through

fault-tolerant systems, load balancing, DoS mitigation, and regular maintenance.

OS-Level Implementation:

- User authentication (passwords, biometrics, MFA)

- Sandboxing (e.g., Linux seccomp) to isolate applications

- Kernel hardening (e.g., SELinux, AppArmor)

- Secure boot to verify OS integrity

A secure OS must balance all three principles to create a trustworthy environment, particularly in cloud and

mobile platforms where threats are dynamic.

Q: Discuss Mobile vs. Ubiquitous Computing in terms of OS design: context awareness, energy efficiency,

security, and machine learning.

Mobile and ubiquitous computing present unique challenges for OS design. While both aim to provide

continuous access to computing services, their operational models and system constraints differ.

1. Context Awareness:

- Mobile: Focus on user location, motion, device state (e.g., Android's location services).

- Ubiquitous: Broader context including environment, user behavior, and ambient data.

- OS must support sensor fusion and real-time context modeling.

2. Energy Efficiency:

- Mobile: Techniques like Dynamic Voltage and Frequency Scaling (DVFS), app hibernation.

- Ubiquitous: Use of ultra-low-power microcontrollers, duty-cycling, and energy harvesting.

3. Security:

- Mobile: Threats include app leaks, MITM attacks. Uses permissions, sandboxing, and TEE.

- Ubiquitous: Deals with ambient threats and spoofed sensors. Requires secure firmware and policy

enforcement.

4. Machine Learning:

- Mobile: On-device models using TensorFlow Lite, CoreML.

- Ubiquitous: TinyML, federated learning for distributed, real-time inference.

OS must support real-time response, scalability, and data privacy in both environments while ensuring

minimal resource usage.

Q: What are the modern challenges in operating system security and how do techniques like sandboxing,

encryption, and intrusion detection address them?

Modern OS security faces advanced threats that target hardware, cloud infrastructure, and decentralized

devices.

Challenges:

- Spectre/Meltdown: Hardware-level speculative execution attacks.

- Cloud Security: Multi-tenant isolation and virtualization threats.

- IoT Security: Insecure default configurations, limited processing power.

- Insider Threats: Authorized users acting maliciously.

- AI Threats: Adversarial inputs targeting ML models.

Solutions:

1. Sandboxing: Restricts process capabilities, isolating them from critical resources. Example: Chrome

browser's tab sandboxing, Linux seccomp.

2. Encryption: Protects data at rest and in transit. Examples include AES for file systems (e.g., Secure File

System) and TLS for secure network communication.

3. Intrusion Detection Systems (IDS): Monitor traffic and system logs for anomalies. Host-based IDS (e.g.,

Tripwire) and Network-based IDS (e.g., Snort) are widely used.

Other techniques:

- Secure Boot

- Kernel patching and hardening

- Regular updates and vulnerability scans

Security is an ongoing process, and modern OS design integrates proactive and reactive measures to protect

against emerging threats.