You're on a call at 23:40 because a kernel update dropped, and someone wants to know whether rebooting the box will bring the site back. The answer depends entirely on what changed and how the host is managed, which is why the generic advice you'll find online is so unreliable.
Here's the short version. On a systemd host, the graceful restart is sudo systemctl reboot. Run it, and the service manager coordinates shutdown targets, stops units in dependency order, unmounts filesystems cleanly, and reboots. On a SysV host, it's sudo reboot. If only one daemon is misbehaving, you probably shouldn't reboot at all, and the section on reload versus restart explains why.
What follows matches the action to the change you're applying. That's the difference between a five second reload and a forty minute outage nobody approved.
Table of Contents
- Restart Commands for systemd and SysV Servers
- Choose Between Reload, Restart and Full Reboot
- Prepare a Remote Server Before the Reboot
- When a Forced Reboot Is Justified
- Verify the Server Came Back Healthy
- Roll Back a Kernel That Will Not Boot
- Confirm Remote Access Before Your Next Restart
Restart Commands for systemd and SysV Servers
On a systemd host, sudo systemctl reboot requests a graceful restart through the service manager. Older hosts may use SysV init or Upstart, where sudo reboot is the standard command. Check the init system before choosing.
$ ps -p 1 -o comm=
systemd
If the command prints systemd, use the systemd command. If it prints init, identify the distribution and release before proceeding; the output alone does not distinguish SysV from Upstart.
| Init system | Typical distributions | Graceful restart | Forced restart (last resort) |
|---|---|---|---|
| systemd | Ubuntu 16.04 and later, Debian 8 and later, RHEL, Rocky Linux and AlmaLinux 7 and later | sudo systemctl reboot | sudo systemctl reboot --force |
| SysV init | Debian 7 and earlier | sudo reboot | sudo reboot -f |
| Upstart | Ubuntu 14.04 LTS and earlier, CentOS and RHEL 6 | sudo reboot | sudo reboot -f |
Why the distinction matters at shutdown
systemd runs as process ID 1 and manages userspace services. A reboot request through systemctl asks it to enter the reboot target, stopping units according to their dependencies and allowing filesystems to unmount before the kernel restarts. Interrupting that sequence can leave databases or other applications with incomplete writes.
The freedesktop.org reboot documentation explains that reboot, poweroff and halt retain their SysV names for compatibility. Under systemd, reboot restarts the machine, poweroff turns it off, and halt stops the operating system while leaving power on. That is why sudo reboot also works on systemd hosts: it is handled through the service manager.
The forced variant is not a faster reboot
reboot -f bypasses the init system. Filesystems may not be cleanly unmounted, so use it only when a graceful shutdown is not possible and the risk is acceptable. On a host running mail queues, MariaDB or virtual machines, forcing the restart can lead to filesystem checks or data-integrity problems.
For an older host, the release matters: Ubuntu 14.04 and earlier used Upstart, as did CentOS and RHEL 6. Debian 7 and earlier used SysV init. Check the distribution and release, then match them to the table before issuing a command.
Choose Between Reload, Restart and Full Reboot
Most "restart the server" requests are really service requests. The most common case by a wide margin is a config edit that a reload can apply without dropping a single connection.
Start with three checks, in this order. They take under a minute and they usually tell you the answer before you touch anything.
$ systemctl status nginx --lines=0
nginx.service - A high performance web server and a reverse proxy server
Loaded: loaded (/lib/systemd/system/nginx.service; enabled; preset: enabled)
Active: active (running) since Tue 2025-03-11 09:14:02 UTC; 6 days ago
Process: 1187 ExecStartPre=/usr/sbin/nginx -t -q -g 'daemon on; master_process on;' (code=exited, status=0/SUCCESS)
$ journalctl -u nginx --since '10 minutes ago' --no-pager
Mar 17 22:41:03 web1 nginx[1187]: 2025/03/17 22:41:03 [emerg] unexpected "}" in /etc/nginx/sites-enabled/shop.conf:88
$ sudo nginx -t
nginx: [emerg] unexpected "}" in /etc/nginx/sites-enabled/shop.conf:88
nginx: configuration file /etc/nginx/nginx.conf test failed
That emerg line is the whole diagnosis. Fix the brace, re-run nginx -t, then reload.
| Change or symptom | Action | Command |
|---|---|---|
nginx configuration edited and tested with nginx -t | Reload the service | sudo systemctl reload nginx |
| PHP-FPM pool or worker settings changed | Restart the service | sudo systemctl restart php8.3-fpm |
| MariaDB unresponsive, service still active | Restart after reading the logs | sudo systemctl restart mariadb |
| Userspace restart needed, kernel unchanged, systemd 254 or later | Soft reboot | sudo systemctl soft-reboot |
| Kernel package updated | Full reboot in a planned window | sudo systemctl reboot |
Reload is preferable whenever the service can reread its configuration without terminating active processes. nginx does this cleanly. PHP-FPM does not: pool settings such as pm.max_children are read by the master process at start, so a reload won't pick them up and a restart is required. Check the unit name first with systemctl list-units 'php*', because it carries the version.
The rule that saves the most downtime: reload when the service supports it, restart when it doesn't, and reboot only when the kernel changed or when so many services are affected that restarting them one at a time costs more than a single window.
Libraries don't reload themselves
A restart of one service does not pull updated shared libraries into processes that already have them mapped. If glibc or OpenSSL was patched, long-running daemons keep using the old code in memory until each process is replaced. That's why a security update can show as "applied" while the vulnerable code is still executing.
The practical check is sudo lsof | grep -i deleted or needs-restarting -r on the RHEL family. Both point at processes holding removed files.
That distinction, service versus host, is the core of restarting a Linux service without rebooting the server, and it's the decision that keeps unrelated workloads online.
Prepare a Remote Server Before the Reboot
A reboot is only routine when you can watch the machine come back. On a remote host with no failover, the console is the thing that turns a failed restart from an outage into a five minute fix.

Open the out-of-band path and log in once before you need it. On dedicated hardware that means IPMI or a provider console. On a VPS it means the remote reboot control in the client portal, which is also the only way back in if the guest stops answering on the network. Testing it during a quiet window costs nothing. Discovering it's broken at 02:00 costs the window.
Then work through the preflight in order.
- Announce the window. Post the start and expected end time to users, and silence the monitoring alerts for the host so the reboot doesn't page on-call for a planned event.
- Check who else is logged in. Run
whoandw. Another administrator mid-deploy is the most common cause of a "corrupted" change made by two people working at once. - Capture the baseline. Save
uptime,systemctl --failed,df -handfree -hto a file with a timestamp. Without a baseline you can't tell whether the host came back healthy or merely came back. - Verify the backup restores, not just that it completes. A backup job that reports success and a backup you can boot are different claims. For databases, check replication lag or queue depth so you know what in-flight writes you're about to interrupt.
- Confirm boot-critical units. Run
findmnt --verifyand check that network and mount units are enabled. Remote mounts belong in/etc/fstabwith thenofailoption, because a missing NFS share with default options will hold the boot at the mount unit until it times out. - Record the timestamp and the rollback plan. Which kernel you'll boot if this one fails, and where the snapshot lives. The rollback section covers the commands.
- Run the reboot.
sudo systemctl reboot, then start a stopwatch. The return is the start of the wait, not the end of it.
Skip step 3 and you'll spend the next hour guessing. A pre-reboot baseline of failed units and memory usage is what lets you say "this is normal" instead of "this is new".
Dedicated and VPS customers on our platform get remote reboot through the client portal plus real-time monitoring, which covers the recovery path in step one without a separate IPMI login.
For teams that want the sequence walked through in motion, this covers the same ground:
When a Forced Reboot Is Justified
Reaching for the force flag first is the wrong instinct, and it's the one that turns a slow shutdown into a corrupted database.
Diagnose before you force. Three commands tell you whether the machine is stuck or just taking its time:
$ systemctl list-jobs
JOB UNIT TYPE STATE
412 umount.target start waiting
398 systemd-umount start waiting
$ systemctl --failed
0 loaded units listed.
$ journalctl -b -1 -p warning..alert --no-pager | tail -20
A waiting job on a mount unit with a stuck NFS handle is a classic. The shutdown isn't hung, it's blocked on a device that will never answer.
What one –force actually does
The systemd systemctl documentation is explicit: one --force skips the normal shutdown of running services, kills processes, unmounts filesystems or remounts them read-only, and proceeds to reboot immediately. Two --force flags go further and execute the reboot without terminating processes or unmounting anything.
sudo systemctl reboot --force # skips service shutdown, tries to unmount
sudo systemctl reboot --force --force # no process termination, no unmount
The second form is a hardware reset delivered through software. It interrupts database writes, leaves application transactions half-applied, and hands the next boot a filesystem that needs recovery. That's an acceptable trade when the alternative is a host that stays dark, and an unacceptable one when someone just wanted the reboot to go faster.
The SysRq path when the console is dead
If the console itself is unresponsive, and only then, the kernel's magic SysRq interface gives you a controlled sequence instead of a power cycle. Enable it, then send the keys one at a time, confirming each on the console before the next:
sudo sysctl kernel.sysrq=1
echo s | sudo tee /proc/sysrq-trigger # sync dirty pages to disk
echo u | sudo tee /proc/sysrq-trigger # remount filesystems read-only
echo b | sudo tee /proc/sysrq-trigger # reboot immediately
The kernel SysRq documentation defines the key meanings, and the ordering is the whole point: s then u then b flushes data before the read-only remount, so the reboot has the best chance of a clean filesystem.
A forced reboot is an incident response step, not a scheduling convenience. If you can't name the failure mode you're recovering from, you don't have grounds to force anything.
One trap: journalctl -b -1 returns nothing unless the journal is persistent. Check for /var/log/journal before you promise anyone a previous-boot log.
Verify the Server Came Back Healthy
A lost SSH session does not confirm a successful reboot. systemctl reboot queues a reboot job and returns without waiting for the machine to finish restarting, so a disconnected session is expected but proves nothing about the host's state. The systemd systemctl documentation describes this asynchronous behavior.
| Check | Command | Healthy result |
|---|---|---|
| Init state | systemctl is-system-running | running |
| Failed units | systemctl --failed | 0 loaded units listed |
| Boot warnings | journalctl -b -p warning..alert | no new errors from the current boot |
| Uptime matches window | uptime | a few minutes since the restart |
| Mounts | findmnt --verify | no errors reported |
| Memory | free -h | usage close to the pre-reboot baseline |
A degraded result means at least one unit failed. Investigate it before declaring the host healthy, even if user-facing services appear available.
Host checks are necessary, not sufficient
After the host-level checks pass, verify the services users depend on. An HTTP request with curl -I https://your-site.example should return the expected status code. Run a database query and check its response time, then test an application transaction such as a login or cart add. These checks exercise the service path, not just whether a listener started.
Compare the results with the baseline saved before the restart. Pay particular attention to values that changed. For teams tracking those signals over time, infrastructure monitoring practices explains what to monitor.
What a stalled restart looks like
A guest can appear running in the hypervisor while SSH remains unavailable. Check the console and boot logs before taking action. If boot is stuck at a mount unit, or the network interface name changed after an upgrade, another reset may not address the cause. A rescue boot and correcting the mount configuration, such as adding nofail where appropriate, can be the better recovery path.
Close the maintenance window only after both host and service checks pass. Record the results alongside the pre-restart baseline so the next comparison has a clear reference.
Roll Back a Kernel That Will Not Boot
A rollback needs a kernel that still exists on disk. That's the constraint everything else follows from: never remove the previous kernel during the same maintenance window that installs the new one.
RHEL, Rocky Linux and AlmaLinux
List every installed kernel and its index, then set the known-good one as the default:
$ sudo grubby --info=ALL | grep -E '^(index|kernel|title)='
index=0
kernel="/boot/vmlinuz-5.14.0-427.13.1.el9_4.x86_64"
title="Red Hat Enterprise Linux (5.14.0-427.13.1.el9_4.x86_64) 9.4 (Plow)"
index=1
kernel="/boot/vmlinuz-5.14.0-362.8.1.el9_3.x86_64"
title="Red Hat Enterprise Linux (5.14.0-362.8.1.el9_3.x86_64) 9.3 (Plow)"
$ sudo grubby --set-default /boot/vmlinuz-5.14.0-362.8.1.el9_3.x86_64
$ sudo reboot
$ uname -r
5.14.0-362.8.1.el9_3.x86_64
The uname -r check is the confirmation. Without it you're trusting that GRUB read the change you made.
Debian and Ubuntu
GRUB handles this through the saved entry rather than a rewritten config. Confirm the setting first, then boot the old kernel exactly once:
$ grep GRUB_DEFAULT /etc/default/grub
GRUB_DEFAULT=saved
$ sudo grub-reboot "Ubuntu, with Linux 6.5.0-26-generic"
$ sudo reboot
$ uname -r
6.5.0-26-generic
$ sudo grub-set-default "Ubuntu, with Linux 6.5.0-26-generic"
$ sudo update-grub
The menu entry title must match what GRUB shows, so check it at the boot menu rather than guessing from the package version. grub-reboot applies to one boot only, which is deliberate: it lets you test the old kernel before committing to it with grub-set-default.
VPS rollback happens at the hypervisor
When the guest won't reach the network and the console won't let you into GRUB, the rollback is a snapshot restore from the control panel, not a command inside the guest. That's why a snapshot taken before the window matters more on a VPS than on hardware with IPMI, since there's no physical console to fall back on.
When to stop rebooting and escalate
Repeated attempts make diagnosis harder, because each boot overwrites the state you needed. Stop when you see any of these:
- A drop to an emergency or rescue shell after an fsck failure, or a prompt asking for the root password to enter maintenance mode.
- A kernel panic loop, where the host reaches the same panic within seconds of starting.
- A network interface that never comes up, leaving the guest unreachable even though it booted.
Collect journalctl -b -1 and a photograph or copy of the console output, then escalate with both attached. A panic trace without the preceding console lines wastes the first hour of anyone's investigation. The kernel panic guide explains how to read that trace once you have it.
The habit that prevents all of this: keep one previous kernel installed and one verified snapshot, every time, before any kernel update.
Confirm Remote Access Before Your Next Restart
Three actions before the next window. Test the console, IPMI or portal reboot path from a second device during a quiet hour. Store those credentials where the on-call person can reach them at 03:00. Run sudo systemctl reboot only after the baseline and backup checks in the preparation section pass, and treat that dropped session as unproven until the verification checks come back clean.
For teams without an operator on call, our managed services team handles Linux server maintenance and troubleshooting, including the escalation triggers above.
ARPHost, LLC runs the infrastructure these restarts happen on: Tampa colocation, single-tenant bare metal, VPS and Proxmox private clouds, backed by a 99.99% uptime SLA. If routine kernel maintenance keeps turning into an incident on your current platform, the recovery path underneath the host is usually the part worth changing. Visit ARPHost, LLC to see the options and talk through your maintenance windows.

Leave a Reply
You must be logged in to post a comment.