Suspend and hibernate
Related articles
Currently there are three methods of suspending available: suspend to RAM (usually called just suspend), suspend to disk (usually known as hibernate), and hybrid suspend (sometimes aptly called suspend to both):
- Suspend to RAM method cuts power to most parts of the machine aside from the RAM, which is required to restore the machine's state. Because of the large power savings, it is advisable for laptops to automatically enter this mode when the computer is running on batteries and the lid is closed (or the user is inactive for some time).
- Suspend to disk method saves the machine's state into swap space and completely powers off the machine. When the machine is powered on, the state is restored. Until then, there is zero power consumption.
- Suspend to both method saves the machine's state into swap space, but does not power off the machine. Instead, it invokes usual suspend to RAM. Therefore, if the battery is not depleted, the system can resume from RAM. If the battery is depleted, the system can be resumed from disk, which is much slower than resuming from RAM, but the machine's state has not been lost.
There are multiple low level interfaces (backends) providing basic functionality, and some high level interfaces providing tweaks to handle problematic hardware drivers/kernel modules (e.g. video card re-initialization).
Contents
Low level interfaces
Though these interfaces can be used directly, it is advisable to use some of high level interfaces to suspend/hibernate. Using low level interfaces directly is significantly faster than using any high level interface, since running all the pre- and post-suspend hooks takes time, but hooks can properly set hardware clock, restore wireless etc.
kernel (swsusp)
The most straightforward approach is to directly inform the in-kernel software suspend code (swsusp) to enter a suspended state; the exact method and state depends on the level of hardware support. On modern kernels, writing appropriate strings to /sys/power/state
is the primary mechanism to trigger this suspend.
See kernel documentation for details.
uswsusp
The uswsusp ('Userspace Software Suspend') is a wrapper around the kernel's suspend-to-RAM mechanism, which performs some graphics adapter manipulations from userspace before suspending and after resuming.
See main article Uswsusp.
tuxonice
TuxOnIce is a fork of the kernel implementation of suspend/hibernate that provides kernel patches to improve the default implementation. It requires a custom kernel to achieve this purpose.
See main article TuxOnIce.
High level interfaces
systemd
systemd provides native commands for suspend, hibernate and a hybrid suspend, see Power management#Power management with systemd for details.
See Power management#Sleep hooks for additional information on configuring suspend/hibernate hooks. Also see man systemctl
, man systemd-sleep
, and man systemd.special
.
pm-utils
pm-utils is a set of shell scripts that encapsulate the backend's suspend/hibernate functionality. It comes with a set of pre- and post-suspend tweaks and various hooks to customize the process.
See main article pm-utils.
Suspend to RAM
Suspend to RAM should work out of the box.
Hibernation
In order to use hibernation, you need to create swap partition or swap file. See Swap for details.
About swap partition/file size
Even if your swap partition is smaller than RAM, you still have a big chance of hibernating successfully. According to kernel documentation:
-
/sys/power/image_size
controls the size of the image created by the suspend-to-disk mechanism. It can be written a string representing a non-negative integer that will be used as an upper limit of the image size, in bytes. The suspend-to-disk mechanism will do its best to ensure the image size will not exceed that number. However, if this turns out to be impossible, it will try to suspend anyway using the smallest image possible. In particular, if "0" is written to this file, the suspend image will be as small as possible. Reading from this file will display the current image size limit, which is set to 2/5 of available RAM by default.
You may either decrease the value of /sys/power/image_size
to make the suspend image as small as possible (for small swap partitions), or increase it to possibly speed up the hibernation process.
Required kernel parameters
The kernel parameter resume=swap_partition
has to be used. Either the name the kernel assigns to the partition (for example /dev/sda1
) or its UUID (for example UUID=4209c845-f495-4c43-8a03-5363dd433153
) can be used as swap_partition
. Generally, the naming method used for the resume
parameter should be the same as used for the root
parameter.
The configuration depends on the used boot loader, some examples are given below.
Example for syslinux
Just edit your syslinux.cfg
file and add the resume
parameter to APPEND
. For example:
/boot/syslinux/syslinux.cfg
APPEND root=/dev/sda1 rw resume=swap_partition
Example for GRUB
The kernel name for the partition (for example /dev/sda1
) should be used if and only if GRUB_DISABLE_LINUX_UUID is set to true
in GRUB. The resume
parameter can be set for example in the GRUB_CMDLINE_LINUX_DEFAULT
variable:
/etc/default/grub
GRUB_CMDLINE_LINUX_DEFAULT="resume=swap_partition"
Remember to run grub-mkconfig -o /boot/grub/grub.cfg
afterwards.
Example for gummiboot
If gummiboot is used as boot manager, you have to add the resume=swap_partition
parameter in the options-list of the entry file.
For example if your efi system partition is mounted in /boot
, then the option list should look like this:
/boot/loader/entries/arch.conf
options root=/dev/sdaX rw resume=swap_partition
Hibernation into swap file
Using a swap file instead of a swap partition requires an additional kernel parameter resume_offset=swap_file_offset
.
The value of swap_file_offset
can be obtained by running filefrag -v swap_file
, the output is in a table format and the required value is located in the first row of the physical_offset
column. For example:
# filefrag -v /swapfile
Filesystem type is: ef53 File size of /swapfile is 4294967296 (1048576 blocks of 4096 bytes) ext: logical_offset: physical_offset: length: expected: flags: 0: 0.. 0: 38912.. 38912: 1: 1: 1.. 22527: 38913.. 61439: 22527: unwritten 2: 22528.. 53247: 899072.. 929791: 30720: 61440: unwritten ...
In the example the value of swap_file_offset
is 38912
.
Configure the initramfs
When an initramfs with the base
hook is used, which is the default, the resume
hook is required in /etc/mkinitcpio.conf
. Whether by label or by UUID, the swap partition is referred to with a udev device node, so the resume
hook must go after the udev
hook. This example was made starting from the default hook configuration.
HOOKS="base udev resume autodetect modconf block filesystems keyboard fsck"
Rebuild the initramfs for these changes to take effect:
# mkinitcpio -p linux
The systemd
hook provides its own resume mechanism, so if using this hook, no modification to the initramfs needs to be made.
Troubleshooting
ACPI_OS_NAME
You might want to tweak your DSDT table to make it work. See DSDT article
VAIO Users
Add acpi_sleep=nonvs kernel flag to your loader, and you are done!
Suspend/hibernate doesn't work
There have been many reports about the screen going black without easily viewable errors or the ability to do anything when going into and coming back from suspend and/or hibernate. These problems have been seen on both laptops and desktops. This is not an official solution, but switching to an older kernel, especially the LTS-kernel, will probably fix this.