Operating Systems MCQ

Explanation

An OS acts as an intermediary between user programs and hardware, managing CPU, memory, I/O devices, and files while providing abstractions like processes, files, and sockets.

Explanation

A process is a running program with its own virtual address space, stack, heap, code, data, open files, and CPU registers state.

Explanation

Threads (lightweight processes) share code, data, and open files with other threads in the same process but have their own stack and registers.

Explanation

Virtual memory abstracts physical memory, giving each process its own address space. Pages not in RAM are swapped to disk (paging/swapping).

Explanation

System calls (read, write, fork, exec, open) are the interface between user programs and the OS kernel, requiring a mode switch from user to kernel mode.

Explanation

Context switching saves the running process's registers, PC, and state to its PCB, then restores another process's PCB. It is the mechanism enabling multitasking.

Explanation

CPU scheduling selects which ready process runs next. Goals include maximizing CPU utilization, throughput, and minimizing wait time, turnaround time, and response time.

Explanation

Deadlock requires all four Coffman conditions simultaneously: mutual exclusion, hold-and-wait, no preemption, and circular wait.

Explanation

Semaphores have an integer value. Wait (P) decrements and blocks if negative; Signal (V) increments and wakes a blocked process. Binary semaphores are essentially mutexes.

Explanation

Paging eliminates external fragmentation. A page table maps virtual page numbers to physical frame numbers. The MMU and TLB accelerate address translation.

Explanation

Preemptive scheduling (SRTF, Round Robin) allows the OS to interrupt a running process. Non-preemptive (FCFS, SJF non-preemptive) waits until the process blocks or finishes.

Explanation

The PCB (task control block) is the OS's data structure for a process. It is saved/restored during context switches.

Explanation

A page fault triggers the OS page fault handler, which loads the missing page from disk into a physical frame, possibly evicting another page.

Explanation

File systems (ext4, NTFS, APFS, FAT32) provide hierarchical directories, file naming, metadata, and access control on disk.

Explanation

Internal fragmentation: allocated block is larger than needed (paging). External fragmentation: total free memory is enough but not contiguous (segmentation, variable partitioning).

Explanation

FCFS is non-preemptive and simple. The convoy effect occurs when a long process delays short ones, causing high average wait time.

Explanation

Round Robin is fair and widely used in time-sharing systems. Performance depends heavily on time quantum: too small → high context-switch overhead; too large → behaves like FCFS.

Explanation

Multiprogramming: when one process waits for I/O, another runs (maximizes CPU usage). Multitasking: time-sliced switching creates illusion of simultaneity for interactive users.

Explanation

A mutex (mutual exclusion) ensures only one thread enters a critical section at a time. Unlike binary semaphores, ownership is enforced — only the locking thread can unlock.

Explanation

Thrashing occurs when too many processes compete for physical memory, causing constant page faults and swapping, making CPU utilization drop near zero.

Explanation

fork() duplicates the calling process. Parent gets child's PID (>0); child gets 0. Both continue executing from the point after fork(). exec() replaces the process image.

Explanation

The producer-consumer (bounded buffer) problem requires synchronization with semaphores: empty (count of free slots), full (count of filled slots), and mutex for buffer access.

Explanation

Segmentation maps logical segments to physical memory. It causes external fragmentation. Combined with paging (segmented paging) is used in x86 protected mode.

Explanation

The CPU runs in privileged kernel mode for OS code (full hardware access) and unprivileged user mode for applications. System calls trigger a mode switch via software interrupt or SYSCALL.

Explanation

LRU approximates OPT (optimal) by replacing the least recently used page. It is theoretically good but expensive to implement exactly; approximations (clock algorithm) are used in practice.

Explanation

Inodes store file metadata and pointers to data blocks. Directory entries map filenames to inode numbers. Hard links share the same inode; symbolic links have their own inode pointing to a path.

Explanation

Swapping moves entire processes to disk to free RAM. Modern OSes use demand paging (swap individual pages) instead of whole-process swapping for efficiency.

Explanation

The Banker's Algorithm (Dijkstra) checks if granting a resource request would leave the system in a safe state (a state where all processes can eventually complete). If not, the request is denied.

Explanation

Interrupts allow I/O devices to notify the CPU asynchronously. The CPU saves context, jumps to the ISR, handles the event, and resumes. Enables efficient I/O without busy-waiting.

Explanation

DMA controllers handle bulk data transfers between I/O devices and memory. The CPU initializes the transfer, then continues executing until the DMA controller fires a completion interrupt.

Explanation

Race conditions produce unpredictable results when concurrent processes share data without proper synchronization. Prevented by critical sections, mutexes, and semaphores.

Explanation

The critical section is code accessing shared resources. A solution must satisfy mutual exclusion, progress, and bounded waiting to prevent race conditions and starvation.

Explanation

Without TLB, every memory access requires multiple page table lookups. The TLB caches recent translations, achieving near-hardware-speed memory access most of the time.

Explanation

When a child exits, its PCB stays until the parent calls wait(). Until then, it's a zombie. Orphan processes (parent exits first) are adopted by init/PID 1.

Explanation

Monolithic kernels (Linux, Windows) are fast but a driver bug can crash the OS. Microkernels (Mach, L4, seL4) are more secure/reliable but have higher IPC overhead.

Explanation

SJF is optimal for minimizing average wait time but requires knowing burst lengths in advance (estimated via exponential averaging for prediction). Preemptive SJF is called SRTF.

Explanation

IPC mechanisms: anonymous pipes (parent-child), named pipes/FIFOs, message queues, shared memory (fastest), semaphores, sockets (network). Each offers different tradeoffs.

Explanation

Boot loaders (GRUB, Windows Boot Manager) are loaded by BIOS/UEFI from the boot sector. They load and start the OS kernel, enabling multi-boot configurations.

Explanation

After fork(), parent and child share physical pages marked read-only. On a write, the OS creates a private copy just for that page. This makes fork() efficient.

Explanation

A ready process is loaded in memory and able to run immediately once the scheduler picks it; it just isn't currently holding the CPU. This differs from "running" (has the CPU) and "blocked/waiting" (needs an event like I/O completion).

Explanation

All four conditions are necessary for deadlock. Breaking any one prevents it: allow preemption, use resource ordering (prevent circular wait), or detect and recover.

Explanation

Binary semaphore: 0 (locked) or 1 (unlocked). Counting semaphore: tracks a resource count (e.g., available buffer slots in producer-consumer). Signal increments; Wait decrements.

Explanation

Denning's working set model tracks pages referenced in the last Δ time units. If total working sets exceed physical memory, processes are swapped out, preventing thrashing.

Explanation

Hard links: multiple directory entries pointing to the same inode. Deleting one doesn't affect the file. Symbolic (soft) links store the path — deleting the target breaks the link.

Explanation

Peterson's algorithm uses flag[] and turn variables to achieve mutual exclusion, progress, and bounded waiting for two processes without hardware support.

Explanation

Demand paging starts processes with no pages in memory. Each page is loaded on first access. This enables running programs larger than physical RAM and faster startup.

Explanation

The clock algorithm traverses pages in circular order. If reference bit=1, clear it and move on (second chance). If 0, replace it. This approximates LRU efficiently.

Explanation

Priority inversion: high-P task waits for a lock held by low-P task. If medium-P tasks run meanwhile, high-P is indefinitely delayed. Solved by priority inheritance (Mars Pathfinder bug).

Explanation

MLFQ estimates process behavior: new processes start at high priority; if they use their quantum, they are demoted; if they yield early, they stay high. This approximates SJF without knowing burst times.

Explanation

CFS models an ideal multi-tasking CPU. It uses vruntime (wall time scaled by nice value) and a red-black tree, picking the leftmost node (lowest vruntime) as the next to run.

Explanation

Eager (prepaging) loads pages into memory proactively. Demand paging (lazy) loads pages only on fault. Modern systems use demand paging with working-set prefetching.

Explanation

A 4-level page table (x86-64: PML4, PDPT, PD, PT) only allocates subtables for used address ranges, handling the 48-bit virtual address space without a 512GB flat page table.

Explanation

User threads: fast creation/switching, but one blocking syscall blocks all threads. Kernel threads: OS-managed, enabling parallel execution on multiple CPUs but with higher overhead per thread.

Explanation

POSIX (Portable Operating System Interface) standardizes Unix-like OS interfaces. Programs using POSIX APIs (fork, pthread, open, read) are portable across Linux, macOS, and other Unix systems.

Explanation

Multiple readers can share a resource simultaneously. A writer needs exclusive access. Solutions favor readers (risk starving writers) or writers (risk starving readers), or use fair algorithms.

Explanation

Three scheduler levels: long-term (job scheduler, admits to ready queue), short-term (CPU scheduler, picks next to run), medium-term (swaps processes for multiprogramming degree control).

Explanation

Journaling (ext3, ext4, NTFS) writes a transaction to a log first. On crash, replaying the journal restores consistency in seconds instead of running fsck on the entire disk.

Explanation

Five philosophers alternate thinking and eating. Each needs two adjacent forks. Naive grab-one-fork leads to deadlock. Solutions: allow at most 4 to try simultaneously, ordered acquisition, or arbitration.

Explanation

FIFO replacement exhibits Belady's anomaly: more frames can cause more faults. LRU and OPT are stack algorithms (not susceptible to this anomaly).

Explanation

Cooperative multitasking relies on programs to yield. One buggy or greedy program freezes the system. Preemptive multitasking uses timer interrupts to forcibly switch, ensuring fairness.

Explanation

Spinlocks busy-wait (spin) in a loop until acquired — efficient for very short waits on multi-core but wasteful for long waits. Mutexes block the thread, yielding the CPU.

Explanation

VFS (in Linux/Unix) defines common data structures (super_block, inode, dentry, file) and operations. Concrete file systems implement these, allowing transparent access from user space.

Explanation

init/systemd (PID 1) is the ancestor of all user-space processes. It starts services and adopts orphan processes (whose parent died) to prevent zombie accumulation.

Explanation

CPU affinity (sched_setaffinity) pins a process to particular CPU(s), improving cache reuse. NUMA-aware schedulers extend this by keeping threads close to the memory node they access most, avoiding costly remote-node latency.

Explanation

SRTF is the preemptive version of SJF: whenever a new process arrives with a shorter remaining time than the currently running one, the CPU is taken away and given to the new process, which can reduce average waiting time further at the cost of more context switches.

Explanation

SJF favors processes with short CPU bursts. If short jobs keep arriving, a longer job may never be selected, causing starvation. Aging — gradually increasing a waiting process's priority over time — is a common fix.

Explanation

In pure priority scheduling, low-priority processes can wait indefinitely if higher-priority ones keep arriving. Aging incrementally raises the priority of waiting processes so that, eventually, every process is guaranteed to run.

Explanation

"empty" counts free slots and "full" counts filled slots, coordinating when producers/consumers must wait. The mutex separately ensures only one thread manipulates the shared buffer indices at a time — the three together prevent both races and incorrect blocking.

Explanation

Monitors (as in Java's synchronized methods or Pascal-style monitors) encapsulate shared data and the operations on it so that only one thread can be active inside at a time, with condition variables (wait/signal) for more complex coordination — reducing the chance of synchronization bugs compared to raw semaphores.

Explanation

If every process must request resources in a fixed global order, a circular chain of "waiting for" relationships can never form, eliminating circular wait. This is a practical, low-overhead strategy compared to changing mutual exclusion or preemption rules.

Explanation

Avoidance algorithms like the Banker's Algorithm decide in advance whether a resource request could ever lead to deadlock and deny risky requests. Detection algorithms let the system run and periodically check for cycles or unsafe states, then take recovery action (e.g., killing or rolling back a process).

Explanation

Segmented paging (used in x86 protected mode) lets programmers think in terms of meaningful segments (code, data, stack) for protection and sharing, while the underlying pages of each segment are allocated in fixed-size frames, avoiding the external fragmentation that pure segmentation suffers from.

Explanation

Each context switch has a fixed overhead cost. A very small quantum spends a large fraction of CPU time switching contexts, while a very large quantum makes Round Robin degenerate toward FCFS, hurting interactive response time. A good quantum is typically chosen so most interactive bursts complete within one slice.

Explanation

Demand paging only loads pages when they are actually referenced, so programs start quickly and use only the memory they need. This increases the degree of multiprogramming, though it does introduce page faults and, if memory is overcommitted, can still lead to thrashing.

Explanation

When a page replacement algorithm selects a victim page, the dirty (modified) bit tells the OS whether the page's contents differ from the copy on disk. Clean pages can simply be discarded, while dirty pages must be written back first, which is more costly.

Explanation

Metadata journaling (the ext4 default, "ordered" mode) protects file system structures so a crash won't corrupt directories or inode tables, recovering quickly. Full ("journal") mode also logs actual file data changes, giving stronger guarantees against data loss but roughly doubling write I/O.

Explanation

With message queues, the kernel copies and queues discrete messages, handling synchronization and ordering automatically — simpler but slower due to copying and system call overhead. Shared memory avoids copying by mapping the same physical pages into multiple address spaces, which is faster but leaves synchronization (e.g., via semaphores) entirely up to the programmer.

Explanation

The fundamental scheduling job — picking the next runnable thread — is similar in both designs. The practical difference is that microkernels push file systems, drivers, and network stacks into user-space servers, so satisfying a single request may involve several context switches and IPC calls that a monolithic kernel would handle in one privileged call.

Explanation

Without ASIDs, the TLB must be fully flushed on each context switch to avoid one process using another's stale translations, causing a burst of TLB misses afterward. ASID-tagged TLBs let entries from several address spaces coexist safely, so a process returning to the CPU can often still find its translations cached.

Explanation

Priority inheritance temporarily boosts the priority of the lock-holding thread to that of the highest-priority thread blocked on the same lock. This prevents medium-priority threads from indefinitely delaying the high-priority thread — the exact issue that caused the Mars Pathfinder reset bug.

Explanation

x86 uses hardware page walks (CR3 → page tables → TLB fill). MIPS uses software-managed TLBs (TLB miss → exception → OS fills TLB). Software TLBs are flexible; hardware are faster.

Explanation

DPDK (Data Plane Development Kit) maps NIC registers into user space. Polling instead of interrupts and lockless data structures achieve single-digit microsecond packet processing at line rate.

Explanation

seL4 (2009) was the first OS kernel with complete formal verification of implementation correctness, proving no bugs like buffer overflows, undefined behavior, or security violations.

Explanation

MMIO (memory-mapped I/O) maps device registers as memory addresses, enabling C pointer access. PMIO uses dedicated I/O instructions (IN/OUT on x86). Modern systems primarily use MMIO.

Explanation

Exokernels (MIT, 1995) provide minimal primitives (secure bindings, visible resource revocation, abort protocol). LibOSes implement file systems, networking, and scheduling as application libraries.

Explanation

On NUMA systems, accessing local memory is ~4ns but remote memory ~40ns. OS schedulers pin threads to CPUs near their memory (NUMA-aware allocation in Linux via libnuma).

Explanation

Huge pages (2MB or 1GB on x86) cover more memory with fewer TLB entries, reducing TLB misses in workloads with large working sets (databases, JVMs). Linux Transparent Huge Pages (THP) automates this.

Explanation

CFQ (now replaced by BFQ in Linux) fairness balancing. Deadline scheduler (mq-deadline) prevents request starvation with per-request deadlines, better for latency-sensitive workloads like databases.

Explanation

cgroups v2 enable resource accounting and limiting per process group. Docker and Kubernetes use cgroups + namespaces to implement container isolation without full VMs.

Explanation

eBPF programs pass kernel verification (no unbounded loops, no invalid memory access), are JIT-compiled to native code, and run at kernel hooks (tracepoints, kprobes, XDP). Used by Cilium, bpftrace, Falco.

Explanation

Type-1 (bare-metal) hypervisors (VMware ESXi, Hyper-V, KVM) run directly on hardware for performance. Type-2 (hosted) hypervisors (VirtualBox, VMware Workstation) run on a host OS.

Explanation

Hardware virtualization (VT-x, SVM) enables VMX root/non-root modes. Privileged instructions in the guest trap to the hypervisor. Near-native performance vs 100x overhead for software emulation.

Explanation

The slab allocator (Bonwick, 1994) groups kernel objects by type into caches. Freed objects are kept warm in the cache for reuse, avoiding initialization overhead and reducing fragmentation.

Explanation

The OOM (Out-Of-Memory) killer scores each process by memory usage, CPU time, root privilege, and nice value. It kills the highest-scoring process, freeing memory to allow the system to continue.

Explanation

Synchronous I/O: caller blocks until data is ready (simple but wastes CPU). Async I/O (io_uring, aio, IOCP on Windows): caller submits request and continues, getting notified on completion.

Explanation

io_uring (Linux 5.1, Jens Axboe) uses two ring buffers (submission/completion) shared between kernel and user. A single io_uring_enter() submits and reaps batches, achieving 10M+ IOPS with minimal overhead.

Explanation

Linux 2.6+ added full kernel preemption (CONFIG_PREEMPT). Preemption is disabled in interrupt context, with spinlocks held, and in preempt_disable() sections to prevent data structure corruption.

Explanation

Hard real-time (airbags, pacemakers, flight control): deadline miss is unacceptable. Soft real-time (video streaming, trading): deadline misses are tolerable with graceful degradation.

Explanation

RMS assigns static priorities inversely proportional to period (shorter period = higher priority). A set of n tasks is schedulable if ∑(Cᵢ/Tᵢ) ≤ n(2^(1/n) - 1) → ln(2) ≈ 69.3% as n → ∞.

Explanation

W^X (OpenBSD), NX bit (AMD), XD bit (Intel), DEP (Windows): pages are either writable or executable, never both. This prevents code injection attacks where data is written then executed.