grep -rl "systemd" ./blog

systemd Guides

The init system that boots and supervises nearly every modern Linux distribution: units, services, timers, and the journal.

24 articles

Core Dumps on Linux: Debugging Crashes With coredumpctl When a program crashes, Linux can save a snapshot of its memory. How core dumps work, where systemd-coredump stores them, how to list and inspect crashes with coredumpctl and gdb, get debug symbols with debuginfod, and control disk use. Speeding Up Linux Boot With systemd-analyze Find out where boot time actually goes with systemd-analyze time, blame, critical-chain, and plot, then fix the usual culprits: network-wait services, slow firmware, unneeded services, and timeouts on missing disks. systemd User Services: Running Your Own Services Without Root systemctl --user lets any user run background services and timers under their own account, with logging, restarts, and dependencies. Where unit files go, how lingering keeps them running after logout, and common pitfalls over SSH. Dinit Explained: The Small Init System Chimera, Artix, and KaOS Chose Over systemd Dinit is a dependency-based init and service manager that fits between runit and systemd. How it boots a system, how service files and dinitctl work, how it compares to systemd, OpenRC and runit, and why distros are adopting it. run0 vs sudo-rs vs sudo: The Three Ways to Get Root on Modern Linux sudo is being rewritten in Rust, and systemd now ships run0, which gets root without a setuid binary at all. How each one works, what they do differently, what sudo-rs leaves out, and which to use. Unlock LUKS With the TPM: systemd-cryptenroll Explained Bind your encrypted disk to the TPM so it unlocks automatically at boot, or with a short PIN, and only on your untouched machine. How TPM sealing and PCRs work, the exact enrollment steps, recovery keys, and the security trade-offs. Memory Pressure, PSI and the OOM Killer: Deciding What Dies The kernel OOM killer picks by score and the score is mostly size, which is why it takes your desktop shell instead of the browser. How to read pressure stall information, set OOM scores that reflect importance, and why systemd-oomd and the kernel disagree. cron vs systemd Timers: Which to Use Why a cron job that fails silently is the default behaviour, what timers give you that cron cannot, and when cron is still the right answer. Process Supervisors: s6, runit, and supervisord Why you might want a supervisor that is not systemd, how each handles the zombie reaping problem in containers, and where each one fits. Hardening systemd Services: The Directives That Actually Confine ProtectSystem, PrivateTmp, NoNewPrivileges, and the rest, what each one blocks, and how to use systemd-analyze security to find out how exposed your services are right now. systemd Socket Activation Explained How systemd holds the listening socket so a service starts on first connection, why that removes startup ordering problems, and where it does and does not help. Cockpit: A Web Console for Linux Servers What Cockpit gives you, why it does not maintain its own state, the security considerations of exposing it, and when a web console beats SSH. systemd-nspawn: Containers Without a Container Runtime How systemd-nspawn runs a full OS in a namespace with no daemon and no image registry, and where it fits between chroot and Docker. systemd-resolved Explained: Why /etc/resolv.conf Is a Symlink Now What systemd-resolved does, why 127.0.0.53 appears in resolv.conf, how split DNS works, and how to actually configure or disable it. Podman Quadlet: Containers as Real systemd Services Quadlet turns a short declarative file into a generated systemd unit, so containers get dependency ordering, journal logging, and restart handling from systemd instead of from a container runtime. ulimit Explained: Per-Process Resource Limits and Why Services Ignore Them Too many open files is one of the most common server errors, and raising the limit is more subtle than it looks. Here is how soft and hard limits work, and why the shell setting does not apply to your systemd service. cgroups Explained: Limiting CPU, Memory, and I/O With systemd Control groups are the kernel mechanism behind container resource limits, and you can use them directly on any service. Here is what cgroups v2 does and how to cap a process without writing a container. journalctl and /var/log Explained Linux logs live in two places on most modern systems: the systemd journal, queried with journalctl, and traditional plain-text files under /var/log. This guide covers reading, filtering, and following logs in both. timedatectl and NTP Explained Accurate system time matters more than most people realize, from TLS certificate validation to log ordering across servers. This guide covers checking and setting time and timezone with timedatectl, and how NTP keeps clocks synchronized automatically. Writing systemd Service Files Explained Beyond using systemctl to manage existing services, writing your own .service unit file lets you run any script or program as a properly managed systemd service. This guide covers unit file structure, common directives, and enabling a custom service. Linux Boot Process Explained From pressing the power button to a login prompt, a Linux system goes through a precise sequence of steps. Understanding each stage -- firmware, bootloader, kernel, initrd, and systemd -- demystifies boot failures and makes the system less of a black box. Managing Services with systemctl systemctl is the command-line interface to systemd. This guide covers starting, stopping, enabling, inspecting, and troubleshooting services, along with the most useful systemctl commands for daily system administration. Scheduling Tasks with systemd Timers systemd timers are the modern alternative to cron for scheduling tasks on Linux. They offer better logging, dependency support, randomisation, and integration with the rest of the systemd ecosystem. What Is systemd? systemd is the init system and service manager used by most major Linux distributions. Understanding what it does, how it is structured, and why it replaced older init systems explains a lot about how modern Linux works.

Browse all topics →