A complete masterclass spanning Computer Organization, Memory Hierarchies, Kernel Architecture, Process Lifecycles, Concurrency Engineering, IPC, and POSIX Systems Programming across 72 technical modules with 864 concept-verified assessment questions.
Von Neumann architecture, system bus hierarchy (data, address, control), memory-CPU interfaces, and hardware execution pipelines.
Arithmetic Logic Unit (ALU), Control Unit, hardware registers, instruction formats, and execution cycles.
General-purpose registers, special registers, flags/status registers, accumulator, and x86/ARM register conventions.
Instruction sequence control, branch jumps, subroutine calls, interrupts, and program flow mechanics.
Call stack architecture, activation records, base pointer (EBP/RBP), return addresses, and buffer overflow prevention.
Instruction cycle states, opcode decoding, micro-operations, timing diagrams, and machine cycle execution.
Pipelined processor stages, structural hazards, data hazards (RAW, WAR, WAW), control hazards, forwarding, and branch prediction.
Locality of reference, cache mapping techniques (direct, associative, set-associative), cache lines, MESI protocol, and replacement policies.
SRAM vs DRAM cells, refresh cycles, DDR timing, non-volatile ROM/Flash architecture, and memory banking.
Hardware address translation, physical vs virtual addresses, protection bits, and MMU kernel privilege validation.
Page table entries (PTE), hierarchical page tables, Translation Lookaside Buffer (TLB) hits/misses, and inverted page tables.
Hardware page fault interrupts, demand paging flow, page replacement algorithms (FIFO, LRU, Optimal, Clock), and thrashing.
Process state transitions (Ready, Running, Blocked), context switching overhead, CPU registers saving, and PCB structural fields.
User space vs kernel space boundary, software interrupts, syscall/sysenter assembly instructions, errno, and system call wrappers.
Copy-on-Write (COW) optimization, parent and child process relationship, duplicate descriptors, and PID allocation.
POSIX standards, Single UNIX Specification (SUS), BSD vs System V lineage, Linux glibc architecture, and portability macros.
Kernel file table, inode table, file descriptors, atomicity with O_APPEND, seek offsets, and write barriers.
Preemptive vs non-preemptive scheduling, FCFS, SJF, Priority scheduling, Round Robin quantum tuning, and multilevel feedback queues.
Kernel threads vs user threads (N:1, 1:1, M:N models), Thread Control Block (TCB), thread creation cost vs processes, and thread safety.
Data transfer models, shared memory models, message passing, synchronization requirements, and Linux IPC comparison.
Synchronous vs asynchronous signals, signal masks, sigaction API, reentrant signal handlers, and real-time signals.
Calendar time vs process time, CLOCK_REALTIME, CLOCK_MONOTONIC, timer_create, nanosleep, and high-resolution POSIX timers.
stat/fstat structures, file types, st_mode bitmasks, UID/GID ownership, umask calculation, and setuid/setgid execution bits.
Hard links vs symbolic links, link/unlink syscalls, directory traversal (opendir, readdir, closedir), chdir, and inode lifecycle.
FILE pointer streams, unbuffered (_IONBF), line-buffered (_IOLBF), fully buffered (_IOFBF), fflush mechanics, and temporary files.
O_NONBLOCK flag, record locking with fcntl, I/O multiplexing with select, poll, and Linux high-performance epoll event loops.
Terminal logins, process groups (PGID), controlling terminals, sessions (SID), setsid(), and job control signal delivery.
Daemon coding rules, double-fork idiom, umask resetting, standard file descriptors closing, and syslog() integration.
main arguments (argc, argv, envp), environ pointer, getenv/setenv/putenv memory management, and process startup routines.
getrlimit and setrlimit syscalls, RLIMIT_CPU, RLIMIT_AS, RLIMIT_NOFILE, soft vs hard limits, and generating core dumps.
Password database (/etc/passwd, getpwnam), shadow passwords (/etc/shadow), group database (/etc/group), and crypt() hashing.
uname system call, utsname structure, gethostname, sysconf and pathconf configuration queries, and host identification.
Wall-clock time, user CPU time, system CPU time, struct tms, times() syscall, and getrusage() resource telemetry.
Termination macros (WIFEXITED, WEXITSTATUS, WTERMSIG), zombie and orphan process dynamics, wait3/wait4, and execve arguments vector.
Kernel BSD process accounting records (struct acct), accton system call, resource usage auditing, and pacct file decoding.
Completely Fair Scheduler (CFS) red-black tree, vruntime calculation, nice values, real-time priority bands (SCHED_FIFO, SCHED_RR), and processor affinity.
mmap system call, MAP_SHARED vs MAP_PRIVATE, MAP_ANONYMOUS allocation, msync flush synchronization, and munmap deallocation.
Position-Independent Code (PIC), Global Offset Table (GOT), Procedure Linkage Table (PLT), ld.so dynamic linker, and runtime loading with dlopen/dlsym.
Throughput and latency comparison across pipes, queues, shared memory, and network sockets; kernel persistence vs process lifetime.
pipe() system call, unidirectional descriptor pair, PIPE_BUF atomic write constraints, broken pipe signals (SIGPIPE), and shell pipelines.
mkfifo system call, filesystem entry binding, bidirectional rendezvous semantics, O_NONBLOCK open dynamics, and client-server FIFOs.
ftok key generation, ipc_perm permissions, ipcs and ipcrm administration tools, and lifecycle comparison with POSIX IPC.
POSIX IPC naming conventions (/dev/shm, /dev/mqueue), descriptor attributes, memory safety, and modern container isolation.
mq_open, mq_send, mq_receive, priority-ordered messages, mq_attr configuration, asynchronous notification with mq_notify, and timeouts.
sem_init vs sem_open, sem_wait (P operation), sem_post (V operation), sem_trywait, thread vs process synchronization, and deadlock prevention.
shm_open, ftruncate sizing, mmap mapping, atomic operations in shared memory, POSIX semaphores coordination, and shm_unlink cleanup.
pthread_attr_init, joinable vs detached states, stack size allocation, guard page size configuration, and CPU affinity masks.
pthread_mutex_t initialization, fast vs recursive vs error-checking mutexes, priority inversion protocols, and deadlock avoidance.
pthread_cond_wait atomicity with mutex release, spurious wakeups, while-loop verification, pthread_cond_signal vs pthread_cond_broadcast.
Shared reader vs exclusive writer locking, reader starvation mitigation, writer preference attributes, and lock performance benchmarks.
pthread_spin_lock, atomic test-and-set instructions, CPU busy-wait vs sleep tradeoff, cache-line bouncing, and false sharing.
pthread_barrier_init, barrier count synchronization, PTHREAD_BARRIER_SERIAL_THREAD return token, and phased multi-threaded algorithms.
pthread_key_create, destructor callbacks, pthread_setspecific/pthread_getspecific, and C11/C++11 __thread / thread_local keywords.
Asynchronous vs deferred cancellation, cancellation points (read, write, sleep), pthread_cleanup_push/pop stack, and resource reclamation.
pthread_sigmask, dedicated signal-waiter threads with sigwait(), directed signals via pthread_kill, and process-wide signal dispositions.
Contention scope (PTHREAD_SCOPE_SYSTEM vs PROCESS), real-time thread priorities, inherit scheduler attributes, and starvation protection.
Producer-consumer work queues, worker thread lifecycle management, graceful shutdown idioms, and dynamic pool resizing.
Reentrant functions (_r variants), MT-Safe, MT-Unsafe attributes, static variable hazards, and data race detection.
Compare-and-Swap (CAS), atomic operations (stdatomic.h), memory ordering models (acquire/release), and ABA problem mitigation.
socket(), bind(), listen(), accept(), connect(), AF_UNIX vs AF_INET, SOCK_STREAM vs SOCK_DGRAM, and passing file descriptors over sockets.
Detecting deadlocks, race conditions, using Valgrind Helgrind/DRD, LLVM ThreadSanitizer (-fsanitize=thread), and multi-threaded core dumps.
Advisory vs mandatory locking, fcntl F_SETLK, deadlock detection in file locks, and robust shared memory ring buffers.
ptrace system call architecture, intercepting system calls with strace, tracking memory allocations with ltrace, and attaching GDB to live PIDs.
Hardware performance counters, CPU sampling with Linux perf, kernel tracing with eBPF/bcc, and visualizing call stacks with FlameGraphs.
termios struct, canonical vs raw mode, baud rates, control characters (VINTR, VEOF), and password input masking.
Master and slave PTY pairs, posix_openpt, grantpt, unlockpt, ptsname, and terminal emulators/SSH daemon multiplexing.
/proc and /sys pseudo-filesystems, parsing /proc/[pid]/stat, /proc/meminfo, system load calculation, and custom Linux telemetry agents.
Lightweight key-value storage engine implementation, indexed file access, free-list management, record locking, and durability guarantees.
Dropping root privileges, Linux Capabilities (CAP_NET_BIND_SERVICE, CAP_SYS_ADMIN), POSIX Access Control Lists (ACLs), and secure programming practices.
Device driver control with ioctl, kernel module parameter interfaces via /sys, netlink sockets, and character device interaction.
Designing robust network services, client-server socket state machines, timeouts with SO_RCVTIMEO, daemon supervision, and signal handling.
Defensive system programming, error handling hygiene with errno, resource cleanup with RAII/goto fail patterns, compiler sanitizers, and production checklist.