🧠 OS 01: Process Structure, Memory Layout & Lifecycle

Targeted for: Juspay Elimination Round, Hackathon Part B & Systems Engineering Interviews
Key Focus: Process memory segments, Stack vs Heap internals, PCB structure, Process/Thread State Transitions, and Zombie/Orphan processes.

📌 1. Process Memory Layout (Virtual Address Space)

When a program (executable file stored on disk) is loaded into memory by the OS loader (execve on Linux), it becomes an active Process. The OS provides every 32-bit (4GB) or 64-bit (128TB virtual user space) process with its own private Virtual Address Space.

Segment Breakdown

🔍 2. Deep Dive: Stack vs Heap Internals

The Stack Frame (Activation Record) Anatomy

When a function foo(a, b) is invoked, the CPU pushes a stack frame onto the process stack:

• Stack Overflow: Occurs when recursion is too deep or massive local arrays (e.g., int arr[10000000];) are declared on the stack, pushing RSP past the stack boundary (typically 8MB on Linux, ulimit -s) into an unmapped page or the Heap guard page, triggering a SIGSEGV (Segmentation Fault).

Dynamic Memory Allocation (Heap Management)

• Small Allocations ($< 128\text{ KB}$): Managed by expanding the brk pointer using the sbrk() system call. The heap is a contiguous chunk of virtual memory.
• Large Allocations ($\ge 128\text{ KB}$): Allocated outside the main heap using mmap(MAP_ANONYMOUS | MAP_PRIVATE), creating an isolated memory-mapped page region. When free() is called on an mmap allocation, memory is returned immediately to the OS kernel.
• Heap Fragmentation:
  • Internal Fragmentation: Memory allocated to a block is slightly larger than requested (e.g., allocator aligns 13 bytes to 16 bytes).
  • External Fragmentation: Free blocks are scattered throughout the heap; total free memory is sufficient, but no single contiguous block is large enough for the requested allocation.

🗂️ 3. Process Control Block (PCB)

The PCB (in Linux kernel: struct task_struct in <linux/sched.h>) is the data structure maintained by the OS kernel for every active process. It is stored in protected kernel space.

[!IMPORTANT] Linux Thread Unification: In Linux, there is no separate "Thread Control Block" entity in the kernel. Both processes and threads are represented by struct task_struct. Threads created via clone() share the same mm_struct (memory), files_struct (file descriptors), and signal_struct, while having distinct PID/TID and registers.

🔄 4. Process State Lifecycle

A process undergoes 5 classic state transitions throughout its lifetime:

Detailed State Transitions

1. NEW (Created): The process is being created (memory allocated, PCB initialized, binary loaded), but has not yet joined the executable pool.
2. READY / RUNNABLE: The process resides in main memory and is placed in the OS Ready Queue. It is waiting for the CPU scheduler to allocate a core.
3. RUNNING: The CPU core is currently executing instructions from this process's code segment.
4. WAITING / BLOCKED / SLEEPING: The process cannot execute even if CPU cores are idle. It is waiting for an external event:
   • I/O operation (disk read, network socket receive).
   • Synchronization primitive (acquiring a Mutex or Semaphore).
   • Explicit sleep timer (sleep(5)).
   • In Linux: TASK_INTERRUPTIBLE (woken up by signals) vs TASK_UNINTERRUPTIBLE (ignores signals, e.g., waiting for direct disk I/O; shows as D state in ps).
5. TERMINATED (Zombie / Dead): Execution finished (exit(0)), resources (memory, file descriptors) are released, but the process entry remains in the process table so its parent can read its exit status.

💀 5. Special Process Types: Zombie vs Orphan vs Daemon

1. Zombie Process (<defunct>)

• Definition: A child process that has completed execution (exit()), but its parent has not yet called wait() or waitpid() to read its termination exit code.
• Resource Usage: Consumes zero CPU and zero RAM (its address space is fully deallocated), but retains an entry in the OS Process Table and a PID.
• Hazard: If a parent forks millions of children without calling wait(), it exhausts the OS process table / PID limit (/proc/sys/kernel/pid_max), preventing any new processes from spawning on the server.
• How to Kill a Zombie: You cannot kill a zombie with kill -9 <PID> because it is already dead. You must:
  1. Send SIGCHLD to the parent to trigger wait().
  2. Kill the parent process (kill -9 <Parent_PID>), which turns the zombie into an Orphan adopted by init/systemd, which immediately reaps it.

2. Orphan Process

• Definition: A running process whose parent process terminates before the child finishes.
• Resolution: The OS automatically reparents the orphan process to PID 1 (init or systemd). When the child eventually finishes, PID 1 automatically calls wait() to reap it. Orphans do not cause system resource leaks.

3. Daemon Process

• Definition: A background, non-interactive service process running indefinitely without an attached controlling terminal (e.g., sshd, nginx, mysqld, cron).
• Creation Mechanism (Daemonization):
  1. fork() from the parent and have the parent exit() (ensures daemon is not a process group leader).
  2. Call setsid() to create a new session and detach from controlling TTY.
  3. Change working directory to root (chdir("/")) to avoid locking unmounted file systems.
  4. Reset file mode creation mask (umask(0)).
  5. Close standard file descriptors (FD 0, 1, 2) and redirect them to /dev/null.

💬 6. Verbatim Interview Scripts (Say This Out Loud)

Q: "Explain the difference between .data and .bss segments. Why does .bss exist?"

Verbatim Answer:
"Both .data and .bss store global and static variables. The key distinction lies in initialization and binary size optimization.

The .data segment contains global and static variables that are explicitly initialized with non-zero values (e.g., int x = 42;). The compiler must write the actual bytes 42 into the compiled binary on disk.

The .bss (Block Started by Symbol) segment holds global and static variables that are uninitialized or initialized to zero (e.g., int arr[100000];). If the binary stored 100,000 zeros on disk, executable files would be massive. Instead, the binary header simply records the size of the .bss section (400 KB). When the OS loader maps the process into memory, it allocates zero-filled pages on demand. This saves disk storage and network download time for executables."

Q: "What is a Zombie Process, how do you debug it, and how do you remove it?"

Verbatim Answer:
"A zombie process is a child process that has finished execution via exit(), but its PCB and PID remain in the kernel process table because its parent hasn't collected its exit status using wait() or waitpid().

A zombie uses no CPU or RAM, but it leaks PID table entries. You identify them using ps aux | grep 'Z' or looking for [defunct].

You cannot terminate a zombie using kill -9 because the process is already terminated. To clear it, you either signal the parent with SIGCHLD so it executes a wait handler, or you kill the parent process. Once the parent dies, the init process (PID 1 / systemd) adopts the zombie and immediately calls wait() to reap it."