Operating_System

What an operating system manages: processes, memory, devices, files, protection, and the boundary between applications and hardware.

Linux kernel responsibilities, processes, memory, filesystems, networking, devices, and user space.

Thread execution, shared process resources, scheduling, stacks, TLS, and synchronization.

Process address spaces, credentials, file descriptors, parent/child lifecycle, signals, and scheduling.

Process/thread lifecycle, scheduling, context switching, states, resources, synchronization, and IPC.

Core IPC mechanisms: shared memory, pipes, FIFOs, message queues, signals, semaphores, and sockets, with their trade-offs.

Critical sections, mutual exclusion, ordering, semaphores, mutexes, condition variables, and classic synchronization problems.

Deadlock conditions, prevention, avoidance, detection, recovery, and practical lock-ordering strategies.

The relationship between programs, processes, threads, and user-space tasks, including address spaces, scheduling, isolation, and context-switch costs.

Virtual address spaces, page tables, anonymous/file-backed memory, page cache, reclaim, swap, and OOM.

Virtual memory, paging, address translation, allocation, caching, reclaim, and persistent storage boundaries.

Virtual address spaces, page tables, demand paging, page faults, locality, swap, and why virtual memory is more than 'RAM plus disk'.

Virtual mappings, physical-page allocation, user-space allocators, reclaim, swap, and OOM.

Physical and virtual addresses, paging, segmentation, page tables, and why modern systems primarily rely on paging rather than universal segmentation-plus-paging.

Linux virtual memory, resident pages, page cache, anonymous memory, reclaim, and the role of swap as backing storage rather than virtual memory itself.

Page-replacement goals and classic OPT, FIFO, LRU, LFU, Clock, and working-set ideas, with the distinction between textbook algorithms and real kernels.

How user-space programs enter the kernel to request privileged services, how this differs from an ordinary function call, and why libc wrappers matter.

Blocking, non-blocking, readiness-based multiplexing, signal-driven I/O, asynchronous completion, and Reactor-style server architectures.

How Linux readiness APIs differ in descriptor representation, scanning cost, registration model, and level- vs. edge-triggered behavior.

File descriptors, page cache, buffered and direct I/O, blocking, readiness, and durable writes.

Why zero-copy techniques reduce CPU-mediated data movement, with mmap, sendfile, page cache, DMA, and the limits of the term 'zero copy'.

Diagnosing CPU saturation, run queues, context switching, hot code, affinity, and scheduler effects.

Interactive Linux process and host metrics for CPU, memory, load, task state, and quick triage.

Diagnosing resident memory, reclaim, page cache, swap, faults, NUMA, and application allocation behavior.

Sampling runnable/blocked tasks, memory, paging, block I/O, interrupts, context switches, and CPU states.

Diagnosing storage latency, throughput, queueing, cache behavior, filesystem, and application I/O patterns.

Diagnosing latency, throughput, packet loss, retransmission, queues, sockets, connection limits, and kernel networking.

Interpreting CPU and block-device throughput, latency, queueing, and utilization metrics.

An evidence-driven workflow across CPU, memory, disk, network, kernel, and application layers.

Visualizing aggregated stack samples to locate CPU or off-CPU hotspots.

Soft and hard per-process resource limits, inheritance, file descriptors, processes, and memory-related constraints.

Packet capture with BPF filters for debugging TCP, DNS, routing, retransmissions, and network failures.

A practical map of Linux commands for files, processes, networking, resources, and diagnostics.

Historical and sampled system activity for CPU, memory, I/O, network, and other kernel counters.

Per-process and per-task CPU, memory, I/O, fault, and context-switch statistics.

Tracing Linux system calls and signals to diagnose blocking, failures, and unexpected kernel interactions.

Linux namespaces as process-visible resource isolation for mount, PID, network, IPC, UTS, user, cgroup, and time domains.

cgroup v2 resource accounting and control for CPU, memory, I/O, process counts, pressure, and container workloads.

Changing a process's filesystem root and understanding why chroot alone is not a security container.