[S1..S8] Process Management / Memory Management / File Systems / Networking / Device Drivers / Scheduling & Synchronization / Security / Architecture & Interrupts [S1|I1] Task Struct | Kernel structure describing a process, its state, resources, credentials, relationships | Steps: allocate struct -> initialize fields -> link lists -> schedule task | Corruption breaks scheduling, accounting, and process isolation [S1|I2] Clone and Fork | System calls creating new process sharing or copying parent resources | Steps: parse flags -> copy structures -> assign PID -> enqueue child | Copy errors leave half-created child tasks [S1|I3] Execve | Replaces current process image with new program from file | Steps: open file -> parse format -> flush old -> load new | Failure after flush leaves process unrecoverable [S1|I4] Exit and Zombie State | Terminates process, releases resources, retains status until parent waits | Steps: mark exiting -> release memory -> close files -> become zombie | Orphaned zombies accumulate until init reaps them [S1|I5] Wait | Lets parent reap terminated children and collect exit status | Steps: sleep on queue -> check children -> copy status -> release task | Blocking wait can hang parent indefinitely [S1|I6] Signals | Asynchronous notifications interrupting processes for events or control | Steps: generate signal -> queue pending -> check return -> deliver handler | Blocked signals may delay critical termination [S1|I7] Ptrace | Debugging interface letting tracer observe and control tracee processes | Steps: attach tracer -> stop tracee -> inspect registers -> resume tracee | Tracer compromise exposes tracee memory fully [S1|I8] Process Groups and Sessions | Groupings controlling job control, terminal access, signal delivery scope | Steps: create session -> assign group -> attach terminal -> signal group | Wrong group signals kill unrelated jobs [S1|I9] PID Allocation | Allocates unique numeric identifiers for tasks within each namespace | Steps: lock bitmap -> find free -> assign number -> publish task | PID reuse can confuse stale references [S1|I10] Credentials Structure | Stores user, group, capabilities governing process access decisions | Steps: copy credentials -> modify fields -> commit atomically -> check permissions | Privilege errors grant unintended root access [CP 1/8 | NEXT: S2|I1] [S2|I1] Buddy Allocator | Allocates free physical pages in power-of-two blocks efficiently | Steps: find order -> split block -> mark allocated -> return page | Fragmentation blocks large contiguous allocations despite free memory [S2|I2] SLUB Allocator | Allocates small kernel objects from cached slabs of pages | Steps: find cache -> take object -> track freelist -> return object | Use-after-free corrupts slab freelist silently [S2|I3] Virtual Memory Areas | Structures describing contiguous virtual address ranges and their permissions | Steps: lookup range -> check permissions -> fault pages -> update mappings | Overlapping ranges cause mapping inconsistencies and crashes [S2|I4] Page Tables | Hierarchical structures translating virtual addresses to physical page frames | Steps: walk levels -> read entry -> check present -> return frame | Stale entries map wrong physical memory [S2|I5] Page Fault Handler | Handles accesses to unmapped or protected pages, loading content | Steps: trap fault -> find area -> allocate page -> resume execution | Fault loops signal memory access errors [S2|I6] Swap Subsystem | Moves anonymous pages to disk when physical memory scarce | Steps: select victim -> write disk -> update entry -> free page | Thrashing destroys performance under memory pressure [S2|I7] Transparent Huge Pages | Automatically backs suitable regions with large pages reducing translation overhead | Steps: scan regions -> collapse pages -> update tables -> split when needed | Compaction latency spikes unpredictable application delays [S2|I8] NUMA Balancing | Migrates pages and tasks toward nodes minimizing remote access | Steps: sample faults -> identify node -> migrate page -> reschedule task | Excess migration costs exceed locality gains [S2|I9] Kernel Samepage Merging | Deduplicates identical anonymous pages into single copy-on-write page | Steps: scan pages -> hash content -> merge identical -> protect page | Side channels can leak merged page contents [S2|I10] Out-of-Memory Killer | Selects and kills processes when memory exhaustion threatens system stability | Steps: detect exhaustion -> score processes -> choose victim -> kill task | Wrong victim kills critical system services [CP 2/8 | NEXT: S3|I1] [S3|I1] Virtual File System | Common abstraction layer unifying diverse filesystems behind identical interfaces | Steps: resolve path -> call operation -> dispatch driver -> return result | Abstraction leaks expose filesystem-specific inconsistencies [S3|I2] Inode | Metadata structure describing file data, ownership, permissions, block locations | Steps: allocate inode -> fill metadata -> link dentry -> write back | Corrupted metadata orphans or misattributes files [S3|I3] Dentry Cache | Caches directory entries accelerating pathname lookup in kernel memory | Steps: hash name -> lookup cache -> validate inode -> return dentry | Memory pressure shrinks cache slowing lookups [S3|I4] Page Cache | Caches file data in memory to avoid repeated disk reads | Steps: lookup page -> read disk -> insert cache -> serve data | Dirty pages risk loss on crash [S3|I5] ext4 | Journaling filesystem supporting extents, delayed allocation, large storage volumes | Steps: allocate extents -> journal metadata -> write data -> commit journal | Journal replay may lose recent writes [S3|I6] XFS | Scalable journaling filesystem optimized for parallel large-file workloads | Steps: allocate groups -> journal changes -> write extents -> reclaim space | Repair tools require unmounted clean state [S3|I7] Btrfs | Copy-on-write filesystem providing snapshots, checksums, compression, integrated volumes | Steps: copy block -> update tree -> checksum data -> commit transaction | Metadata exhaustion blocks writes despite free space [S3|I8] procfs | Virtual filesystem exposing process and kernel state as files | Steps: register entry -> generate content -> serve read -> parse write | Information exposure aids privilege escalation reconnaissance [S3|I9] sysfs | Virtual filesystem exposing devices, drivers, kernel objects hierarchically | Steps: create kobject -> add attributes -> publish directory -> handle access | ABI changes break userspace tools unexpectedly [S3|I10] NFS Client | Accesses remote filesystems over network using NFS protocol operations | Steps: mount server -> issue RPC -> cache results -> handle replies | Server failure hangs processes in uninterruptible sleep [CP 3/8 | NEXT: S4|I1] [S4|I1] Socket Layer | User interface creating endpoints for network communication between processes | Steps: create socket -> bind address -> listen connect -> transfer data | Leaked descriptors exhaust file limits quickly [S4|I2] Socket Buffer | Structure carrying packet data and metadata through networking stack | Steps: allocate buffer -> add headers -> traverse layers -> free buffer | Cloning errors corrupt shared packet data [S4|I3] TCP | Reliable ordered byte-stream protocol with congestion and flow control | Steps: handshake connection -> sequence data -> acknowledge receipt -> retransmit losses | Retransmission storms worsen severe network congestion [S4|I4] UDP | Lightweight datagram protocol without delivery, ordering, or retransmission guarantees | Steps: build datagram -> route packet -> send datagram -> receive queue | Lost datagrams silently drop application data [S4|I5] IP Routing | Selects outgoing paths for packets using routing tables and policies | Steps: lookup destination -> choose route -> decrement TTL -> forward packet | Routing loops expire packets via TTL [S4|I6] Netfilter | Framework hooking packet traversal for filtering, NAT, packet modification | Steps: register hook -> inspect packet -> verdict packet -> modify forward | Bad rules silently drop legitimate traffic [S4|I7] Network Device Layer | Abstraction managing network interfaces, queues, drivers, packet transmission reception | Steps: register device -> open interface -> transmit frames -> receive interrupts | Queue overflow drops packets under load [S4|I8] Congestion Control | Algorithms adjusting sending rates based on loss and delay signals | Steps: measure signals -> compute window -> pace packets -> react loss | Unfair algorithms starve competing flows completely [S4|I9] Traffic Control Qdisc | Queuing disciplines shaping, scheduling, policing packets on network interfaces | Steps: enqueue packet -> classify flow -> schedule dequeue -> transmit packet | Misconfiguration adds latency and packet loss [S4|I10] Neighbour Subsystem | Resolves network addresses to link-layer addresses, caching neighbour entries | Steps: lookup cache -> broadcast request -> receive reply -> update entry | Stale entries send traffic to wrong hosts [CP 4/8 | NEXT: S5|I1] [S5|I1] Character Devices | Devices accessed as sequential byte streams through file operations | Steps: register major -> create node -> implement operations -> handle ioctls | Unsafe ioctls expose privileged kernel operations [S5|I2] Block Layer | Layer scheduling block device IO for performance and fairness | Steps: build bio -> merge requests -> schedule queue -> complete request | Queue starvation delays critical IO operations [S5|I3] PCI Subsystem | Enumerates and manages PCI devices, resources, configuration space access | Steps: scan bus -> read configuration -> assign resources -> bind driver | Resource conflicts leave devices unusable [S5|I4] USB Core | Manages USB hosts, devices, endpoints, transfers across connected topologies | Steps: enumerate device -> parse descriptors -> configure endpoints -> submit transfers | Faulty devices can stall entire bus [S5|I5] Device Tree | Data structure describing hardware topology to kernel at boot | Steps: load blob -> parse nodes -> match compatibles -> probe devices | Wrong descriptions prevent hardware detection entirely [S5|I6] Direct Memory Access | Lets devices transfer data directly to memory without CPU copying | Steps: map buffer -> program controller -> start transfer -> signal completion | Bad mappings let devices overwrite memory [S5|I7] IOMMU | Translates device DMA addresses, isolating devices from system memory | Steps: create domain -> map pages -> assign device -> translate accesses | Misconfiguration blocks devices or permits attacks [S5|I8] Platform Drivers | Drivers for integrated devices described by firmware or board data | Steps: register driver -> match device -> probe resources -> initialize hardware | Probe deferral delays dependent devices indefinitely [S5|I9] Firmware Loading | Retrieves device firmware blobs from userspace or built-in storage | Steps: request firmware -> locate blob -> load device -> release blob | Missing firmware leaves hardware nonfunctional [S5|I10] Runtime Power Management | Suspends idle devices and resumes them on demand saving power | Steps: count usage -> suspend idle -> power down -> resume access | Race conditions resume suspended devices incorrectly [CP 5/8 | NEXT: S6|I1] [S6|I1] EEVDF Scheduler | Schedules tasks fairly using virtual deadlines and eligible virtual runtime | Steps: compute eligibility -> pick deadline -> run task -> update runtime | Misweighted tasks monopolize CPU time unfairly [S6|I2] Runqueues | Per-CPU queues holding runnable tasks awaiting scheduler selection | Steps: enqueue task -> update load -> balance queues -> dequeue task | Imbalance overloads CPUs while others idle [S6|I3] Context Switch | Saves current task state and restores next task for execution | Steps: save registers -> switch stack -> switch memory -> restore registers | Excessive switching wastes CPU on overhead [S6|I4] Spinlocks | Busy-wait locks protecting short critical sections in kernel code | Steps: test lock -> spin waiting -> enter section -> release lock | Long holds waste CPUs and deadlock [S6|I5] Mutexes | Sleeping locks allowing one owner, queueing waiters for fairness | Steps: try acquire -> queue waiter -> sleep blocked -> wake owner | Owner death can leave mutex locked [S6|I6] Semaphores | Counting synchronization primitives limiting concurrent access to shared resources | Steps: decrement count -> block if zero -> use resource -> increment count | Over-release permits excess concurrent access [S6|I7] Read-Copy Update | Synchronization allowing lockless reads while updates copy and defer reclamation | Steps: read locklessly -> copy update -> publish pointer -> defer freeing | Early freeing causes reader use-after-free [S6|I8] Futexes | Fast userspace mutexes using kernel only on contention paths | Steps: try atomic -> syscall wait -> queue sleep -> wake waiters | Missed wakeups hang waiting threads indefinitely [S6|I9] Wait Queues | Queues where tasks sleep awaiting events, conditions, resource availability | Steps: add waiter -> check condition -> sleep task -> wake queue | Lost wakeups leave tasks sleeping forever [S6|I10] Real-Time Scheduling | Priority scheduling guaranteeing latency bounds for deadline-sensitive tasks | Steps: assign priority -> admit task -> preempt lower -> meet deadline | Priority inversion delays highest priority task [CP 6/8 | NEXT: S7|I1] [S7|I1] Linux Security Modules | Framework letting security modules hook kernel access control decisions | Steps: register module -> hook operations -> evaluate policy -> allow deny | Stacking conflicts produce inconsistent policy decisions [S7|I2] SELinux | Mandatory access control using labels, types, fine-grained policy rules | Steps: label objects -> load policy -> check access -> audit denial | Mislabeling breaks legitimate application access [S7|I3] AppArmor | Path-based mandatory access control confining programs by profiles | Steps: load profile -> attach program -> check paths -> enforce mode | Permissive profiles offer little actual confinement [S7|I4] Capabilities | Divides root privileges into discrete units granted to processes | Steps: assign set -> check operation -> drop privileges -> inherit selectively | Excess capabilities effectively restore root power [S7|I5] Seccomp | Filters system calls for sandboxed processes using specified rules | Steps: build filter -> install filter -> evaluate calls -> kill allow | Overly strict filters break sandboxed applications [S7|I6] Audit Subsystem | Records security-relevant events for accountability, forensics, compliance monitoring | Steps: generate event -> filter rules -> log record -> deliver userspace | Flooded logs drop important security events [S7|I7] Kernel Keyrings | Stores cryptographic keys securely for kernel subsystems and userspace | Steps: create keyring -> add key -> set permissions -> retrieve key | Leaked keys compromise encrypted data immediately [S7|I8] Integrity Measurement Architecture | Measures files into TPM registers detecting unauthorized software changes | Steps: hash file -> extend register -> log measurement -> appraise policy | Measurement gaps leave unmeasured files trusted [S7|I9] Landlock | Unprivileged sandboxing restricting process access to filesystems and networks | Steps: create ruleset -> add rules -> restrict self -> enforce access | Incomplete rules leave escape paths open [S7|I10] Kernel Random Number Generator | Provides cryptographically secure randomness for keys, tokens, security decisions | Steps: gather entropy -> mix pool -> extract randomness -> reseed periodically | Low entropy makes generated keys predictable [CP 7/8 | NEXT: S8|I1] [S8|I1] System Call Interface | Controlled entry point for userspace requesting kernel services safely | Steps: trap kernel -> validate number -> dispatch handler -> return userspace | Validation flaws allow privilege escalation attacks [S8|I2] Interrupt Descriptor Handling | Architecture tables directing hardware interrupts and exceptions to handlers | Steps: receive vector -> lookup entry -> switch stack -> call handler | Corrupt tables crash kernel on interrupt [S8|I3] IRQ Handling | Processes hardware interrupt requests promptly while deferring longer work | Steps: acknowledge device -> run handler -> schedule deferred -> enable interrupts | Interrupt storms starve normal process execution [S8|I4] Softirqs | Deferred interrupt processing for networking, timers, block, other subsystems | Steps: raise softirq -> schedule ksoftirqd -> process pending -> clear bits | Overload forces fallback thread processing delays [S8|I5] High-Resolution Timers | Precise timers driving timeouts, scheduling, delays, periodic kernel work | Steps: program clock -> enqueue timer -> expire callback -> reprogram clock | Timer errors cause missed deadline events [S8|I6] Local APIC | Per-CPU interrupt controller routing, prioritizing, delivering interrupts locally | Steps: receive interrupt -> prioritize pending -> deliver CPU -> send EOI | Misrouting loses or duplicates device interrupts [S8|I7] Memory Barriers | Instructions enforcing ordering of memory accesses across CPUs and devices | Steps: issue barrier -> order accesses -> flush buffers -> resume execution | Missing barriers cause subtle data races [S8|I8] Atomic Operations | Indivisible operations synchronizing concurrent access without traditional locking overhead | Steps: load value -> modify atomically -> compare swap -> retry failure | ABA problems hide changes between comparisons [S8|I9] Kernel Entry and Exit | Code transitioning between user and kernel modes preserving state | Steps: save context -> switch stack -> handle request -> restore context | State leaks expose kernel data userspace [S8|I10] Boot and Early Initialization | Early code initializing hardware, memory, subsystems before userspace starts | Steps: setup architecture -> initialize memory -> start scheduler -> launch init | Early failures panic before console output [CP 8/8 | COMPLETE]