systemd 260: SysV Init Removed — What Sysadmins Must Audit and Migrate Now

On March 17, 2026, systemd 260 shipped as the newest stable release — and it cut a bridge that had been standing since the 1980s. systemd 260 SysV removed is not a deprecation warning or a soft cutoff. Every component that handled legacy System V init scripts is gone: systemd-sysv-generator, rc-local.service, and the entire SysV compatibility layer are deleted. Beyond that removal, systemd 260 also raises the minimum kernel requirement from 5.4 to 5.10, introduces a new mstack framework for OverlayFS-based service deployments, and adds a unified metrics pipeline via systemd-report. If you manage Linux servers that still rely on SysV init scripts, this version breaks them silently. This guide covers exactly what changed, how to find affected scripts, and how to migrate them before the update hits your fleet.

What Is systemd 260 and Why Does It Matter?

systemd has shipped incremental updates for years, but version 260 stands apart because of what it removes rather than what it adds. Since systemd first appeared in 2010, it has carried a compatibility layer that translated old SysV-style /etc/init.d/ scripts into something the new init system could manage. That layer was marked deprecated in 2021. However, it kept shipping because removing it would have broken things. With version 260, the project finally pulled the trigger.

As a result, systemd-sysv-generator — the tool that auto-converted SysV scripts into transient unit files — no longer exists. Because it is gone, any service that relies exclusively on a SysV script will simply not start after upgrading. There is no fallback, no warning at boot, and no automatic migration. The service just disappears from systemctl list-units. That is the risk for sysadmins who upgrade without auditing first.

Rolling-release distributions like Arch Linux, Fedora, and openSUSE Tumbleweed have already absorbed this change. Meanwhile, enterprise distributions like RHEL and LTS Ubuntu builds will take additional time, since the kernel 5.10 baseline requirement is itself a significant ask for some server fleets. Even so, now is the right time to audit — before the update arrives, not after.

How to Audit Your Servers for SysV Scripts

Before upgrading any system to systemd 260, run this audit on every server in your fleet. It identifies services that rely only on SysV scripts and have no native unit file counterpart:

# Find all SysV init scripts still present on the system
ls /etc/init.d/

# Cross-reference against available native systemd unit files
for script in /etc/init.d/*; do
  name=$(basename $script)
  unit_path=$(systemctl cat ${name}.service 2>/dev/null | head -1)
  if [ -z "$unit_path" ]; then
    echo "NO UNIT FILE: $name -- migration required"
  else
    echo "OK: $name has native unit"
  fi
done

# Also check if any SysV scripts are currently enabled
systemctl list-unit-files | grep generated
# 'generated' units came from systemd-sysv-generator -- these break in v260

# Check which systemd version is currently installed
systemctl --version | head -1

Any service marked NO UNIT FILE in that output needs a native .service unit file before you upgrade. Fortunately, writing a basic unit file is straightforward once you understand the structure.

How to Convert a SysV Script to a systemd Unit File

systemd includes a built-in tool called systemd-analyze that can generate a unit file skeleton from an existing SysV script. While it is not perfect for complex scripts, it handles the majority of common cases:

# Auto-generate a unit file skeleton from an existing SysV script
# Replace 'myservice' with your actual script name
systemd-analyze cat-config myservice 2>/dev/null

# Alternatively, use the sysv-generator manually (while it still exists)
# on your current pre-260 system:
/lib/systemd/system-generators/systemd-sysv-generator \
  /etc/init.d/myservice /tmp/generated-units /tmp/generated-units
cat /tmp/generated-units/myservice.service

After generating the skeleton, review and refine it. A typical converted unit file looks like this:

# /etc/systemd/system/myservice.service
[Unit]
Description=My Legacy Service
After=network.target
Wants=network.target

[Service]
Type=forking
# Replace with the actual binary your SysV script called
ExecStart=/usr/sbin/myservice --daemon
ExecStop=/usr/sbin/myservice --stop
PIDFile=/var/run/myservice.pid
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target

# Install, enable, and test the new unit file
cp /etc/systemd/system/myservice.service /etc/systemd/system/
systemctl daemon-reload
systemctl enable --now myservice
systemctl status myservice
journalctl -u myservice -n 50

New Features Worth Knowing in systemd 260

While the SysV removal dominates the headlines, several new capabilities in systemd 260 are worth understanding for day-to-day operations.

mstack: OverlayFS-Based Service Deployment

The most significant new addition is mstack, which allows defining OverlayFS and bind-mount setups using a structured .mstack/ directory layout. With it, services and containers can be deployed from self-contained directories that describe their entire runtime environment. A new systemd-mstack command-line tool lets you interact with these configurations directly. Additionally, OCI image handling is improved through systemd-importd, making it easier to assemble filesystem layer stacks without relying entirely on external tools like Docker or Podman.

Unified Metrics Pipeline via systemd-report

systemd 260 introduces a new reporting framework where system components expose structured data through Varlink endpoints under /run/systemd/report/. These can then be collected using the new systemd-report tool, which outputs everything in JSON format. For observability pipelines and monitoring systems, this creates a standardized way to gather system-level metrics across components without scraping log files:

# Collect system metrics via the new reporting framework
systemd-report --json=pretty 2>/dev/null | head -60

# Check available Varlink endpoints under the report socket
ls /run/systemd/report/ 2>/dev/null

# Query specific component metrics
varlinkctl call /run/systemd/report/io.systemd.Report \
  io.systemd.Report.Describe '{}' 2>/dev/null

Kernel Baseline Raised to 5.10

systemd 260 requires Linux kernel 5.10 as a minimum, up from 5.4 in the previous baseline. In practice, this means systems still running kernels older than 5.10 cannot upgrade to systemd 260 until the kernel is updated first. Since kernel 5.10 is the basis for RHEL 9, Ubuntu 22.04 LTS, and Debian 11, most modern systems already meet this requirement. However, if you manage any legacy systems still on older LTS kernels, check the kernel version before scheduling the upgrade:

uname -r
# Must be 5.10.x or newer for systemd 260 compatibility
# If below 5.10, update the kernel first:
# RHEL / AlmaLinux / Rocky:
dnf upgrade kernel -y && reboot
# Ubuntu / Debian:
apt update && apt upgrade linux-image-generic -y && reboot

TPM2 and Secure Boot Improvements

For environments using UEFI Secure Boot, systemd 260 adds a new tpm2_id udev built-in that significantly speeds up boot times on TPM2-equipped systems by resolving a long-standing slow-boot issue. Beyond that, the release also improves handling of intermittent network connections in systemd-networkd and adds better support for displaying friendly distribution names via the new FANCY_NAME field in os-release.

Upgrade Path by Distribution

Because the SysV removal is a breaking change, the upgrade timeline varies significantly across distributions. Here is the current state as of June 2026:

Automate the Audit Across a Fleet with Ansible

For teams managing more than a handful of servers, running the audit manually on each host is impractical. Instead, use Ansible to scan the entire fleet and report back which servers have SysV scripts that need migration. Our Ansible automation guide covers the broader setup, but here is a focused playbook for this specific audit:

---
- name: Audit SysV init scripts before systemd 260 upgrade
  hosts: all
  become: true
  tasks:

    - name: Find all SysV init scripts
      find:
        paths: /etc/init.d
        file_type: file
        excludes: ['README', '.placeholder']
      register: sysv_scripts

    - name: Check each script for a matching native unit file
      shell: |
        systemctl cat {{ item.path | basename }}.service > /dev/null 2>&1
        echo $?
      loop: "{{ sysv_scripts.files }}"
      register: unit_check
      changed_when: false

    - name: Report scripts with no native unit file
      debug:
        msg: "NEEDS MIGRATION: {{ item.item.path }}"
      loop: "{{ unit_check.results }}"
      when: item.stdout != '0'

    - name: Check current systemd version
      command: systemctl --version
      register: sd_version
      changed_when: false

    - name: Show systemd version
      debug:
        msg: "{{ inventory_hostname }}: {{ sd_version.stdout_lines[0] }}"

After running this playbook, you get a clear list of every server that needs migration work before the upgrade. That makes it possible to prioritize by environment — production first, then staging, then dev — and track progress systematically rather than discovering breakage after the fact.

What Disappears Completely in systemd 260

Beyond the SysV generator, several other components are removed or disabled. Before upgrading, verify that none of these are in active use on your systems:

# Check if rc-local.service was in use
systemctl status rc-local.service 2>/dev/null
cat /etc/rc.local 2>/dev/null
# If /etc/rc.local has custom commands, move them to a proper unit file

# Check if cgroups v1 is forced (disabled by default in systemd 260)
grep cgroup /proc/cmdline
# If systemd.unified_cgroup_hierarchy=0 is present, plan to remove it

# Verify no services depend on the nscd cache flush behaviour
# (automatic nscd cache flushing was removed in this version)
systemctl status nscd 2>/dev/null | head -5
getent passwd root 2>/dev/null  # Test name resolution still works post-upgrade

Additionally, cgroups v1 support is now disabled by default in systemd 260 and requires deliberate action to re-enable. Since cgroups v2 has been the recommended architecture since RHEL 9 and Ubuntu 22.04, this change primarily affects very old container setups. If your Docker or Kubernetes environment has already migrated to cgroups v2 — which the Linux server hardening checklist recommends — this change has no operational impact.

The Broader Direction: systemd as Runtime Fabric

The SysV removal is the most visible change in systemd 260, but the mstack feature reveals the longer-term direction. As Phoronix noted, systemd is evolving from a boot manager into something closer to the runtime fabric of the entire Linux operating system — handling containers, OCI images, secrets, metrics, and service sandboxing in addition to process supervision. The Register observed that this direction continues to deepen the divide between users who find systemd’s scope useful and those who prefer minimal init systems. In practice, for sysadmins managing enterprise Linux fleets, the practical question is simpler: audit your SysV scripts now and migrate them before the update lands.

Conclusion

With systemd 260 SysV removed now shipping in rolling-release distributions and heading toward enterprise builds, the time to act is before the upgrade arrives rather than after. Start by running the audit commands above on every server to identify any SysV scripts with no native unit file counterpart. After that, generate unit file skeletons using systemd-analyze, refine them, test them on a non-production system, and deploy systematically using Ansible. Beyond the SysV migration, also verify your kernel meets the 5.10 baseline, confirm cgroups v2 is active, and remove any rc.local commands that need a permanent new home. SysV had a long and distinguished run. However, in 2026, sequential shell scripts at boot time no longer fit the way Linux infrastructure actually works. Native systemd unit files are more expressive, more auditable, and more compatible with everything the ecosystem is building toward.