tag
37 posts
FreeBSD panicked and rebooted. Here's how to get the crash dump kgdb actually needs, and how to read it well enough to find the responsible driver or subsystem.
What a Solaris-assert-style ZFS panic actually means, why it almost always points to genuine pool corruption rather than a kernel bug, and how to safely get the system back up.
How a disagreement over FreeBSD 5's threading and SMP architecture led Matt Dillon to fork FreeBSD 4.8 into an entirely separate project in 2003.
FreeBSD 15.0's actual shipped feature set: 64-bit UFS inodes by default, MIT Kerberos replacing Heimdal, a native inotify(2) implementation, and the first release supporting binary updates via pkg.
How FreeBSD gathers entropy from interrupt timing and hardware sources, feeds it into Fortuna, and guarantees /dev/random never blocks without silently becoming predictable.
How the Virtual File System abstraction lets FreeBSD run UFS, ZFS, tmpfs, and NFS behind the exact same open()/read()/write() calls, and what that abstraction actually costs.
A walk through what actually happens between powering on a Haiku machine and reaching a usable desktop, and where things most commonly go wrong along the way.
Haiku's kernel wasn't built as a Unix variant with threading bolted on — it was designed around threads as the fundamental unit of execution from the very beginning.
How Linux capabilities split root's monolithic power into dozens of independent privileges, and why that's a meaningfully better security model than the traditional all-or-nothing setuid-root pattern.
The difference between an oops and a full panic, how to read the call trace in an oops message well enough to identify the responsible driver, and when an oops is safe to ignore versus a sign of real trouble ahead.
A complete walkthrough reading, changing, and persisting kernel runtime parameters — with a few of the most commonly tuned examples explained, not just listed.
Why io_uring's shared ring-buffer design eliminates most of the syscall overhead that made previous Linux async I/O interfaces disappointing in practice.
Released December 17, 2003, the 2.6 series brought in-kernel preemption, NPTL threading, SELinux, and support for far larger process/user counts — the foundation the kernel built the next two decades on.
How kernel.org administrator Konstantin Ryabitsev's b4 tool, introduced in March 2020, made the Linux kernel's mailing-list-based patch workflow substantially less painful without abandoning email itself.
How the kernel community's often-combative development culture led to a September 2018 policy change, and Linus Torvalds' own public acknowledgment that his past conduct needed to change.
Announced by Linus Torvalds in September 2024 and landing in kernel 6.12, PREEMPT_RT ended nearly two decades as an out-of-tree patchset — real-time Linux no longer needs a custom kernel build.
The badness scoring the kernel actually uses to pick a victim process when memory is exhausted, and why the process that gets killed is often not the one that caused the problem.
Why 'free' memory on a Linux system is mostly a lie in the useful direction, and how dirty pages actually get from RAM to disk without every write() blocking on it.
The path from a kernel detecting new hardware to a predictably-named device node appearing in /dev, and why udev's naming rules exist at all instead of just using whatever the kernel calls a device.
Why macOS's kernel is neither a pure microkernel nor a pure monolithic kernel, and what that hybrid design actually buys in practice.
Released to retail October 25, 2001, Windows XP was the first consumer edition of Windows built on the NT kernel rather than the MS-DOS-based 9x line — ending the split between Windows 9x/Me and Windows NT/2000 for good.
WSL2 doesn't borrow a distro's kernel — Microsoft maintains its own fork, patched specifically for the virtualized environment WSL2 runs in, and ships it independently of both Windows and any Linux distro's own kernel.
How character and block device drivers register with the DOS kernel through a standard request-header protocol, loaded declaratively from CONFIG.SYS.
A stage-by-stage walkthrough of how a FreeBSD machine goes from power-on to a login prompt, and where to intervene at each step.
How GEOM's graph of providers and consumers underlies partitioning, RAID, encryption, and disk labels on FreeBSD.
Why and how to build a custom FreeBSD kernel configuration, from copying GENERIC to installing the result.
Released January 19, 2003, FreeBSD 5.0 began dismantling the single 'Giant Lock' that had serialized most of the kernel, after years of SMPng project work.
A stage-by-stage tour from power-on firmware through GRUB, the kernel, initramfs, and systemd reaching a running system.
How cgroup v2's unified hierarchy replaces v1's tangled controller mounts, and how to read and write limits directly through the filesystem.
How eBPF lets sandboxed, verified programs run inside the kernel, and why that changed what's possible for tracing, networking, and security tooling.
A minimal but complete walkthrough of writing, building, loading, and communicating with a Linux kernel module.
How each of the Linux kernel's namespace types isolates a specific global resource, and why containers are just processes with a curated set of them.
Released March 14, 1994 at 176,250 lines of code, version 1.0 was the point Linus Torvalds and the community considered the kernel stable enough for production use.
Released December 11, 2022, Linux 6.1 became the first kernel version to officially accept Rust as a second language for kernel development, alongside C.
How procfs and sysfs expose live kernel state as ordinary files, and the specific paths worth knowing for debugging a running system.
How the VFS layer lets ext4, XFS, Btrfs, NFS, and procfs all answer to the same read/write/open calls.
How the Windows kernel represents processes as containers of handles and a security token, and the tools to inspect both live.