Kernel and Systems Programming Basics

Obtaining a clean tree, verifying tags, and preparing for configuration and builds.

How tasks are represented, scheduled, and transitioned from user space perspective to kernel structures.

The user/kernel boundary, syscall tables, parameters, error paths, and calling conventions.

Address spaces, pages, kmalloc versus vmalloc, zones, and first-pass debugging of memory issues.

Scheduler goals, priorities, CFS intuition, real-time classes, and latency/throughput tradeoffs.

IRQ flow, top and bottom halves, deferring work with tasklets and workqueues.

Module layout, build/load lifecycle, parameters, and symbol visibility rules.

printk discipline, reading oops traces, GDB patterns, and lightweight tracing hooks.

VFS layering, inodes and dentries, file operations, and how mounts attach to the tree.

End-to-end micro change: branch, patch, build, boot or module test, and document what you learned.

Page tables, TLB pressure, demand paging, faults, and memory mappings in depth.

Per-CPU runqueues, load balancing, affinity, domains, and latency drivers.

Spinlocks, mutexes, rwlocks, RCU intro, and atomic patterns without deadlocking the box.

Character devices, file operations, ioctl designs, block hooks, and the driver model.

Sockets, protocol plumbing, sk_buff lifecycle, netdevices, and packet walk-throughs.

Request queues, bio structs, schedulers, drivers, and direct I/O cautions.

ftrace, perf, eBPF harnesses, sanitizers, and controlled live patching concepts.

PREEMPT_RT themes, RT scheduling, latency profiling, and safety margins.

Idle states, runtime PM, suspend/resume, ACPI touchpoints, and power domains.

Design, implement, test, document, and maintain a focused driver-quality change.

Slab internals, compaction, NUMA, huge pages, and hotplug considerations.

Grace periods, read-side rules, lockless structures, and memory ordering constraints.

CPU maps, hotplug flows, scheduler interaction, and topology-aware tuning.

Threat models for ring 0, hardening surface area, and keeping privileges minimal.

Resource controllers, namespaces interactions, and kernel support for isolation.

Profiling, bottleneck isolation, tunables, and verifying wins with metrics—not guesses.

Sending patches, covering letters, maintainer trees, and review etiquette.

Regression tests, CI signals, subsystem norms, and iterative refinement after feedback.

kselftest, automation hooks, flake handling, and release readiness gates.

A substantive change with measurable risk controls and a clear rollback story.

Vendor trees, long-term support, backport discipline, and fleet safety.

Designing out-of-tree needs with upstream alignment and operational guardrails.

Board constraints, boot chains, deterministic latency, and flash-friendly configs.

Lockdown, LSM touchpoints, credentials, and continuous hardening programs.

Evidence collection, configuration baselines, and audit-friendly change records.

Rollouts, canaries, observability for kernels, and incident hooks.

Shared ownership, review rotations, coding standards, and knowledge transfer.

Growing reviewers, constructive feedback, and scaling quality without bottlenecks.

Community norms, public communication, and sustainable maintainership.

A capstone plan spanning architecture, validation, deployment, and support readiness.