Assignment 01: System Calls and OS Structures

Self-Assessment

Instructions: Answer the following questions concisely. For code analysis and architectural design questions, ensure you justify your reasoning based on operating system principles.

Part A: Core Concepts and Workflows

1. System Call Definition: In your own words, define what a system call is and explain why user programs cannot bypass this interface to interact directly with hardware.
2. The Execution Flow: Outline the exact lifecycle of a system call, starting from the user application and ending at the kernel service routine. List the intermediate steps in order.
3. The Kernel Boundary: Why do system calls require a dedicated CPU instruction (such as a trap to kernel mode) rather than functioning like standard C function calls?

Part B: System Call Categorization

Match the following specific system calls to their correct functional category. Provide a brief explanation of what the system call does.

System Calls:

1. fork()
2. ioctl()
3. pipe()
4. gettimeofday()
5. open()

Categories:

• A. Information Maintenance
• B. Process Control
• C. Communication
• D. File Management
• E. Device Management

Part C: Architectural Design and Trade-offs

1. Monolithic vs. Microkernel: Compare and contrast the Monolithic kernel architecture with the Microkernel architecture. In your comparison, address the primary trade-off between execution speed and system reliability.
2. Architectural Application: Assume you are the lead architect for the following computing systems. Which classical OS architecture would you choose for each, and why?

• A safety-critical operating system used in an autonomous drone.
• A general-purpose desktop operating system.

Part D: Theoretical Code Analysis

Review the following conceptual C code snippet and answer the related questions.

#include <unistd.h>
#include <stdio.h>
int main() {
    pid_t pid = fork();
    if (pid == 0) {
        printf("Child Process\n");
    } else {
        printf("Parent Process\n");
    }
    return 0;
}

1. Process Duplication: When the fork() system call is executed, what lower-level syscall does the Linux operating system use internally to implement it?
2. Memory State: Immediately after the fork() execution succeeds, describe the state of the child process regarding its Process ID (PID) and its memory space relative to the parent.

Part E: Advanced Synthesis & Application (Exam Preparation)

Instructions: These exercises require you to synthesize multiple concepts from the lecture. Provide detailed, well-reasoned answers.

Exercise 1: The strace Investigation (System Boundary Analysis) In the laboratory, you are tasked with executing the command strace ls on a standard Linux terminal to observe how processes interact with the kernel in real time.

• Task: Based on your theoretical knowledge of system call categories, predict at least three distinct categories of system calls that strace will output during the execution of a simple ls command.

• Challenge: Provide one specific example of a system call for each of your predicted categories and explain its necessity in the context of listing directory contents.

Exercise 2: Architectural Case Study Defense You have been hired as the lead systems architect for a medical technology company developing the operating system for a next-generation, life-support ventilator.

• Task: You must choose between a Monolithic architecture and a Microkernel architecture. State your choice.
• Challenge: Defend your choice by explicitly comparing the trade-offs in performance, modularity, and fault isolation between the two architectures. What is the catastrophic risk of choosing the incorrect architecture in this specific scenario?

Exercise 3: Inter-Process Communication (IPC) Code Tracing Analyze the following theoretical C snippet designed to send data from a parent process to a child process using a pipe.

#include <unistd.h>
int main() {
    int fd[2];
    pipe(fd);
    if (fork() == 0) {
        close(fd[1]);
        dup2(fd[0], STDIN_FILENO);
        execlp("wc", "wc", "-w", NULL);
    } else {
        close(fd[0]);
        write(fd[1], "hello world\n", 12);
        close(fd[1]);
    }
    return 0;
}

• Task: Identify the exact system calls used for process control and the system calls used for communication.

• Challenge: Explain the necessity of the close(fd[1]) call inside the child process block and the close(fd[0]) call inside the parent process block. What happens at the kernel level if these are omitted?

Exercise 4: The Kernel Module Challenge (Exploratory) Modern operating systems allow for dynamic extensibility.

• Task: If you were tasked with writing a minimal kernel module that logs every system call made by user applications, at what specific layer of the system call flow diagram would your module need to intercept the data?

• Challenge: Why is it strictly impossible to implement this logging tool purely in user space as a standard library function (like a modified libc)?