Unit 2: Process Management

A process is different from a program because:

1. A process is stored on disk
2. A process is an active entity in memory with its own PCB, while a program is a passive file on disk
3. A program can use CPU directly
4. There is no difference

Which of the following is NOT a field in the Process Control Block (PCB)?

1. Process ID (PID)
2. Program Counter
3. Hard Disk RPM
4. CPU Register values

The correct sequence of process states is:

1. New → Running → Ready → Terminated
2. New → Ready → Running → Waiting/Terminated
3. Ready → New → Running → Waiting
4. Running → New → Ready → Terminated

The fork() system call returns:

1. Always returns 0
2. Returns child's PID to parent and 0 to child
3. Returns parent's PID to both
4. Returns nothing

A zombie process is created when:

1. A process uses too much memory
2. A child process terminates but the parent hasn't called wait()
3. The CPU overheats
4. Two processes deadlock

Why is there no direct transition from Waiting state to Running state?

1. Because the CPU is always free
2. Because after I/O completes, the process must re-enter the Ready queue and wait for the scheduler to assign CPU
3. Because waiting processes are always terminated
4. Because the OS doesn't track waiting processes

Explain what happens to the address space when fork() is called:

1. The child shares the same memory as the parent
2. The child gets a copy of the parent's text, data, heap, and stack segments in its own memory space
3. The parent's memory is deleted
4. No memory is allocated to the child

How does exec() differ from fork()?

1. exec() creates a new process; fork() replaces the image
2. fork() creates a new child process; exec() replaces the current process's code with a new program without creating a new process
3. Both do the same thing
4. exec() only works on Windows

Why does the OS need to save CPU register values during a context switch?

1. To increase CPU speed
2. So that when the process resumes later, it can continue exactly from where it stopped — registers hold the process's computation state
3. To delete the process
4. Registers are never saved

What happens to an orphan process in Linux?

1. It is immediately killed
2. It becomes a zombie
3. It is adopted by the init process (PID 1), which becomes its new parent
4. It continues with no parent forever

What is the total number of processes created by the following code? fork(); fork(); fork();

1. 3
2. 6
3. 7
4. 8

In the following code, how many times is "Hello" printed?
fork(); printf("Hello\n"); fork(); printf("Hello\n");

1. 2
2. 4
3. 6
4. 8

To run the ls -la command from within a C program using exec, the correct call is:

1. execlp("ls", "ls", "-la", NULL);
2. exec("ls -la");
3. fork("ls -la");
4. run("ls", "-la");

A parent creates a child using fork(). The parent then calls wait(&status). If the child exits with exit(5), what value does WEXITSTATUS(status) return?

1. 0
2. 5
3. -1
4. Undefined

You need to write a shell that executes user commands. The correct approach using system calls is:

1. Directly call exec() in the shell's main process
2. fork() a child, call exec() in the child to run the command, parent calls wait() for the child to finish
3. Use only wait() without fork()
4. Call exit() after every command

Compare zombie and orphan processes. Which is more harmful to system stability?

1. Orphan — because it runs without a parent
2. Zombie — because it occupies process table entries without releasing them, potentially filling the process table
3. Both are equally harmful
4. Neither is harmful

Analyse why context switching overhead increases when the number of processes increases significantly:

1. Because each process needs more RAM
2. Because the CPU spends more time saving/restoring process states and less time doing actual work, and cache/TLB misses increase
3. Because the disk becomes full
4. Because context switching doesn't cause overhead

Differentiate between the text segment and the stack segment of a process:

1. Both store the same data
2. Text stores executable code (read-only, shared); Stack stores function calls, local variables, and return addresses (read-write, per-process)
3. Stack stores the program binary
4. Text is on disk; Stack is on the network

Analyse why fork() followed by exec() is used instead of a single "create process with new program" call:

1. Because exec() is faster alone
2. Separating creation (fork) from program loading (exec) gives flexibility — the child can set up file descriptors, environment variables, and pipes between fork and exec
3. There is no reason; it's just historical
4. Because exec() creates a new process

Compare independent and co-operating processes in the context of IRCTC's ticket booking system:

1. All IRCTC processes are independent
2. The booking process, payment gateway process, and seat allocation process are co-operating processes that share the seat database and must synchronise to prevent double-booking
3. Co-operating processes don't need synchronisation
4. IRCTC uses only one process

CoWIN crashed when 2 crore users hit simultaneously. Evaluate which process management concept was the primary failure point:

1. The programming language was wrong
2. Excessive process creation without pooling caused context switching overhead to consume nearly all CPU time, leaving no capacity for actual request processing
3. The servers had too much RAM
4. The database was too fast

A developer's server has 10,000 zombie processes. They say "zombies use no CPU, so they're harmless." Evaluate this claim:

1. Correct — zombies are completely harmless
2. Incorrect — while zombies don't use CPU, they occupy entries in the process table (finite size). When the table fills up, no new processes can be created, causing fork() to fail for ALL programs
3. Correct — zombies are automatically cleaned
4. Incorrect — zombies use 100% CPU

Evaluate: "Using exec() without fork() first is always a mistake." Is this true?

1. True — exec must always follow fork
2. False — exec() without fork() is valid when you intentionally want to replace the current process (e.g., a login shell calling exec to replace itself with the user's shell)
3. False — exec() can create new processes
4. True — exec() crashes without fork()

IRCTC uses a single-process model for handling Tatkal bookings. Evaluate this design decision:

1. Excellent — one process is simplest
2. Terrible — a single process can only handle one booking at a time. With 25 million requests, the queue would be hours long. Multi-process or multi-threaded architecture is essential
3. Good if the server is fast enough
4. It doesn't matter how many processes are used

A team argues: "We should increase the time quantum from 10ms to 1000ms to reduce context switching." Evaluate the trade-off:

1. Great idea with no downsides
2. Reduces context switching overhead but increases response time for interactive processes — a 1s quantum means a user might wait up to 1s for their keypress to be processed, making the system feel unresponsive
3. Terrible idea — bigger quantum always causes crashes
4. Time quantum has no effect on performance

Design a solution to prevent zombie processes in a long-running server application:

1. Never use fork()
2. Use signal(SIGCHLD, SIG_IGN) to automatically clean up child processes, or install a SIGCHLD handler that calls waitpid(-1, NULL, WNOHANG) in a loop
3. Restart the server every hour
4. Kill all child processes immediately after creation

Design a process architecture for a CoWIN-like vaccination booking system that can handle 2 crore concurrent users without crashing:

1. One process per user request
2. Process pooling (pre-fork a fixed number of worker processes), queue-based request handling, load balancing across multiple servers, and rate limiting at the gateway
3. Use a single thread for all users
4. Turn off the server during peak hours

Create a process family tree for the following code. How many leaf processes exist?

pid = fork();
if (pid == 0) {
    fork();
}
fork();

1. 2 leaf processes
2. 3 leaf processes
3. 4 leaf processes
4. 5 leaf processes

Design a shell command pipeline cat file.txt | grep "error" | wc -l using fork/exec/wait. How many processes are created?

1. 1 process
2. 3 child processes (one for cat, one for grep, one for wc), connected by 2 pipes
3. 6 processes
4. No processes are needed

Design a process monitoring alert system for Amazon's EC2 servers. Which metrics should trigger automatic alerts?

1. Only CPU temperature
2. Zombie process count > threshold, process table usage > 80%, context switch rate > 50,000/sec, any process consuming > 90% CPU for > 5 minutes, fork() failure rate increasing
3. Number of keyboard presses
4. Only RAM usage