swsusp: userland interface
Subsystems (3)
PATCH 1/1 swsusp: userland interface
Hi,
This patch introduces a user space interface for swsusp.
The interface is based on a special character device, called the snapshot device, that allows user space processes to perform suspend and resume-related operations with the help of some ioctls and the read()/write() functions. Additionally it allows these processes to allocate free swap pages from a selected swap partition, called the resume partition, so that they know which sectors of the resume partition are available to them.
The interface uses the same low-level system memory snapshot-handling functions that are used by the built-it swap-writing/reading code of swsusp.
The interface documentation is included in the patch.
The patch assumes that the major and minor numbers of the snapshot device will be 10 (ie. misc device) and 231, the registration of which has already been requested.
The patch does not affect the existing swsusp code, except that it changes the behavior of the /sys/power/image_size interface so that the preferred image size is always specified in bytes (for consistency).
Please consider for applying.
Greetings,
Rafael
Documentation/power/interface.txt | 2 Documentation/power/swsusp.txt | 2 Documentation/power/userland-swsusp.txt | 153 ++++++++++++++++ init/do_mounts_initrd.c | 1 kernel/power/Makefile | 2 kernel/power/disk.c | 6 kernel/power/power.h | 17 + kernel/power/swsusp.c | 8 kernel/power/user.c | 298 ++++++++++++++++++++++++++++++++ 9 files changed, 477 insertions(+), 12 deletions(-)
kernel/power/user.c new file +298 -0
@@ -0,0 +1,298 @@ +/* +* linux/kernel/power/user.c +* +* This file provides the user space interface for software suspend/resume. +* +* Copyright (C) 2006 Rafael J. Wysocki <[email protected]> +* +* This file is released under the GPLv2. +* +*/ + +#include <linux/suspend.h> +#include <linux/syscalls.h> +#include <linux/string.h> +#include <linux/device.h> +#include <linux/miscdevice.h> +#include <linux/mm.h> +#include <linux/swap.h> +#include <linux/swapops.h> +#include <linux/pm.h> +#include <linux/uaccess.h> +#include <linux/fs.h> + +#include "power.h" + +#define SNAPSHOT_MINOR 231 + +static struct snapshot_data { +struct snapshot_handle handle; +int swap; +struct bitmap_page *bitmap; +int mode; +char frozen; +char ready; +} snapshot_state; + +static atomic_t device_available =ATOMIC_INIT (1 ); + +int snapshot_open (struct inode *inode,struct file *filp) +{ +struct snapshot_data *data; + +if (!atomic_dec_and_test (&device_available)) { +atomic_inc (&device_available); +return -EBUSY ; + } + +if ((filp->f_flags &O_ACCMODE ) ==O_RDWR ) +return -ENOSYS ; + +nonseekable_open (inode, filp); + data = &snapshot_state; + filp->private_data = data; +memset (&data->handle,0 ,sizeof (struct snapshot_handle )); +if ((filp->f_flags &O_ACCMODE ) ==O_RDONLY ) { + data->swap =swap_type_of (swsusp_resume_device); + data->mode =O_RDONLY ; + }else { + data->swap =-1 ; + data->mode =O_WRONLY ; + } + data->bitmap =NULL ; + data->frozen =0 ; + data->ready =0 ; + +return 0 ; +} + +int snapshot_release (struct inode *inode,struct file *filp) +{ +struct snapshot_data *data; + +swsusp_free (); + data = filp->private_data; +free_all_swap_pages (data->swap, data->bitmap); +free_bitmap (data->bitmap); +if (data->frozen) { +down (&pm_sem); +thaw_processes (); +enable_nonboot_cpus (); +up (&pm_sem); + } +atomic_inc (&device_available); +return 0 ; +} + +static ssize_t snapshot_read (struct file *filp,char __user *buf, +size_t count,loff_t *offp) +{ +struct snapshot_data *data; +ssize_t res; + + data = filp->private_data; + res =snapshot_read_next (&data->handle, count); +if (res >0 ) { +if (copy_to_user (buf,data_of (data->handle), res)) + res = -EFAULT ; +else + *offp = data->handle.offset; + } +return res; +} + +static ssize_t snapshot_write (struct file *filp,const char __user *buf, +size_t count,loff_t *offp) +{ +struct snapshot_data *data; +ssize_t res; + + data = filp->private_data; + res =snapshot_write_next (&data->handle, count); +if (res >0 ) { +if (copy_from_user (data_of (data->handle), buf, res)) + res = -EFAULT ; +else + *offp = data->handle.offset; + } +return res; +} + +static int snapshot_ioctl (struct inode *inode,struct file *filp, +unsigned int cmd,unsigned long arg) +{ +int error =0 ; +struct snapshot_data *data; +loff_t offset; +unsigned int n; + +if (_IOC_TYPE (cmd) !=SNAPSHOT_IOC_MAGIC ) +return -ENOTTY ; +if (_IOC_NR (cmd) >SNAPSHOT_IOC_MAXNR ) +return -ENOTTY ; +if (!capable (CAP_SYS_ADMIN )) +return -EPERM ; + + data = filp->private_data; + +switch (cmd) { + +case SNAPSHOT_FREEZE : +if (data->frozen) +break ; +sys_sync (); +down (&pm_sem); +disable_nonboot_cpus (); +if (freeze_processes ()) + error = -EBUSY ; +up (&pm_sem); +if (!error) + data->frozen =1 ; +break ; + +case SNAPSHOT_UNFREEZE : +if (!data->frozen) +break ; +down (&pm_sem); +thaw_processes (); +enable_nonboot_cpus (); +up (&pm_sem); + data->frozen =0 ; +break ; + +case SNAPSHOT_ATOMIC_SNAPSHOT : +if (data->mode !=O_RDONLY || !data->frozen || data->ready) { + error = -EPERM ; +break ; + } +down (&pm_sem); +pm_prepare_console (); +/* Free memory before shutting down devices. */ + error =swsusp_shrink_memory (); +if (!error) { + error =device_suspend (PMSG_FREEZE ); +if (!error) { + in_suspend =1 ; + error =swsusp_suspend (); +device_resume (); + } + } +pm_restore_console (); +up (&pm_sem); +if (!error) + error =put_user (in_suspend, (unsigned int __user *)arg); +if (!error) + data->ready =1 ; +break ; + +case SNAPSHOT_ATOMIC_RESTORE : +if (data->mode !=O_WRONLY || !data->frozen || + !snapshot_image_loaded (&data->handle)) { + error = -EPERM ; +break ; + } +down (&pm_sem); +pm_prepare_console (); + error =device_suspend (PMSG_FREEZE ); +if (!error) { +mb (); + error =swsusp_resume (); +device_resume (); + } +pm_restore_console (); +up (&pm_sem); +break ; + +case SNAPSHOT_FREE : +swsusp_free (); +memset (&data->handle,0 ,sizeof (struct snapshot_handle )); + data->ready =0 ; +break ; + +case SNAPSHOT_SET_IMAGE_SIZE : + image_size = arg; +break ; + +case SNAPSHOT_AVAIL_SWAP : + n =count_swap_pages (data->swap,1 ); + error =put_user (n, (unsigned int __user *)arg); +break ; + +case SNAPSHOT_GET_SWAP_PAGE : +if (!access_ok (VERIFY_WRITE , (unsigned long __user *)arg,_IOC_SIZE (cmd))) { + error = -EINVAL ; +break ; + } +if (data->swap <0 || data->swap >=MAX_SWAPFILES ) { + error = -ENODEV ; +break ; + } +if (!data->bitmap) { + data->bitmap =alloc_bitmap (count_swap_pages (data->swap,0 )); +if (!data->bitmap) { + error = -ENOMEM ; +break ; + } + } + offset =alloc_swap_page (data->swap, data->bitmap); +if (offset) { + offset <<=PAGE_SHIFT ; +__put_user (offset, (loff_t __user *)arg); + }else { + error = -ENOSPC ; + } +break ; + +case SNAPSHOT_FREE_SWAP_PAGES : +if (data->swap >=0 && data->swap <MAX_SWAPFILES ) { + error = -ENODEV ; +break ; + } +free_all_swap_pages (data->swap, data->bitmap); +free_bitmap (data->bitmap); + data->bitmap =NULL ; +break ; + +case SNAPSHOT_SET_SWAP_FILE : +if (!data->bitmap) { +/* +* User space encodes device types as two-byte values, +* so we need to recode them +*/ + data->swap =swap_type_of (old_decode_dev (arg)); +if (data->swap <0 ) + error = -ENODEV ; + }else { + error = -EPERM ; + } +break ; + +default : + error = -ENOTTY ; + + } + +return error; +} + +static struct file_operations snapshot_fops = { + .open = snapshot_open, + .release = snapshot_release, + .read = snapshot_read, + .write = snapshot_write, + .llseek = no_llseek, + .ioctl = snapshot_ioctl, +}; + +static struct miscdevice snapshot_device = { + .minor =SNAPSHOT_MINOR , + .name ="snapshot" , + .fops = &snapshot_fops, +}; + +static int __init snapshot_device_init (void ) +{ +return misc_register (&snapshot_device); +}; + +device_initcall (snapshot_device_init);
kernel/power/Makefile +1 -1
@@ -5,7 +5,7 @@ endif obj-y := main.o process.o console.o obj-$(CONFIG_PM_LEGACY) += pm.o -obj-$(CONFIG_SOFTWARE_SUSPEND) += swsusp.o disk.o snapshot.o swap.o +obj-$(CONFIG_SOFTWARE_SUSPEND) += swsusp.o disk.o snapshot.o swap.o user.o obj-$(CONFIG_SUSPEND_SMP) += smp.o
init/do_mounts_initrd.c +1 -0
@@ -56,6 +56,7 @@ static void __init handle_initrd(void)sys_chroot ("." );mount_devfs_fs (); + current->flags |=PF_NOFREEZE ; pid =kernel_thread (do_linuxrc,"/linuxrc" ,SIGCHLD );if (pid >0 ) {while (pid !=sys_wait4 (-1 ,NULL ,0 ,NULL ))
kernel/power/power.h +15 -2
@@ -50,8 +50,8 @@ extern const void __nosave_begin, __nosaextern struct pbe *pagedir_nosave; -/* Preferred image size in MB (default 500) */ -extern unsigned int image_size; +/* Preferred image size in bytes (default 500 MB) */ +extern unsigned long image_size;extern int in_suspend;extern dev_t swsusp_resume_device;
@@ -77,6 +77,19 @@ extern int snapshot_read_next(struct snaextern int snapshot_write_next (struct snapshot_handle *handle,size_t count);int snapshot_image_loaded (struct snapshot_handle *handle); +#define SNAPSHOT_IOC_MAGIC '3' +#define SNAPSHOT_FREEZE _IO(SNAPSHOT_IOC_MAGIC, 1) +#define SNAPSHOT_UNFREEZE _IO(SNAPSHOT_IOC_MAGIC, 2) +#define SNAPSHOT_ATOMIC_SNAPSHOT _IOW(SNAPSHOT_IOC_MAGIC, 3, void *) +#define SNAPSHOT_ATOMIC_RESTORE _IO(SNAPSHOT_IOC_MAGIC, 4) +#define SNAPSHOT_FREE _IO(SNAPSHOT_IOC_MAGIC, 5) +#define SNAPSHOT_SET_IMAGE_SIZE _IOW(SNAPSHOT_IOC_MAGIC, 6, unsigned long) +#define SNAPSHOT_AVAIL_SWAP _IOR(SNAPSHOT_IOC_MAGIC, 7, void *) +#define SNAPSHOT_GET_SWAP_PAGE _IOR(SNAPSHOT_IOC_MAGIC, 8, void *) +#define SNAPSHOT_FREE_SWAP_PAGES _IO(SNAPSHOT_IOC_MAGIC, 9) +#define SNAPSHOT_SET_SWAP_FILE _IOW(SNAPSHOT_IOC_MAGIC, 10, unsigned int) +#define SNAPSHOT_IOC_MAXNR 10 +/** * The bitmap is used for tracing allocated swap pages *
Documentation/power/userland-swsusp.txt new file +153 -0
153 lines not on this page · raw message
kernel/power/swsusp.c +4 -4
@@ -53,12 +53,12 @@#include "power.h" /* -* Preferred image size in MB (tunable via /sys/power/image_size). +* Preferred image size in bytes (tunable via /sys/power/image_size). * When it is set to N, swsusp will do its best to ensure the image -* size will not exceed N MB, but if that is impossible, it will +* size will not exceed N bytes, but if that is impossible, it will * try to create the smallest image possible. */ -unsigned int image_size =500 ; +unsigned long image_size =500 *1024 *1024 ; int in_suspend __nosavedata = 0;
@@ -199,7 +199,7 @@ int swsusp_shrink_memory(void)if (!tmp)return -ENOMEM ; pages += tmp; - }else if (size > (image_size *1024 *1024 ) /PAGE_SIZE ) { + }else if (size > image_size /PAGE_SIZE ) { tmp =shrink_all_memory (SHRINK_BITE ); pages += tmp; }
Documentation/power/swsusp.txt +1 -1
@@ -27,7 +27,7 @@ echo shutdown > /sys/power/disk; echo di echo platform > /sys/power/disk; echo disk > /sys/power/state -If you want to limit the suspend image size to N megabytes, do +If you want to limit the suspend image size to N bytes, do echo N > /sys/power/image_size
Documentation/power/interface.txt +1 -1
@@ -44,7 +44,7 @@ it. /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 megabytes. The suspend-to-disk mechanism will +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
kernel/power/disk.c +3 -3
@@ -357,14 +357,14 @@ power_attr(resume);static ssize_t image_size_show (struct subsystem * subsys,char *buf) { -return sprintf (buf,"%u\n" , image_size); +return sprintf (buf,"%lu\n" , image_size); }static ssize_t image_size_store (struct subsystem * subsys,const char * buf,size_t n) { -unsigned int size; +unsigned long size; -if (sscanf (buf,"%u" , &size) ==1 ) { +if (sscanf (buf,"%lu" , &size) ==1 ) { image_size = size;return n; }
Quoted 12 lines · Rafael J. Wysocki
Hi,
This patch introduces a user space interface for swsusp.
The interface is based on a special character device, called the snapshot device, that allows user space processes to perform suspend and resume-related operations with the help of some ioctls and the read()/write() functions. Additionally it allows these processes to allocate free swap pages from a selected swap partition, called the resume partition, so that they know which sectors of the resume partition are available to them.
Quoted 2 lines
The interface uses the same low-level system memory snapshot-handling functions that are used by the built-it swap-writing/reading code of swsusp.
The identifiers and terminology are pretty similar to dm-snap.c. But I don't see any clashes there. Yet.
Quoted 5 lines
The interface documentation is included in the patch.
The patch assumes that the major and minor numbers of the snapshot device will be 10 (ie. misc device) and 231, the registration of which has already been requested.
Why does it need a statically-allocated major and minor? misc_register() will generate a uevent and the device node should just appear...
Quoted 8 lines
Quoted 5 lines
The interface documentation is included in the patch.
The patch assumes that the major and minor numbers of the snapshot device will be 10 (ie. misc device) and 231, the registration of which has already been requested.
Why does it need a statically-allocated major and minor?
misc_register()will generate a uevent and the device node should just appear...
Resume part is designed to run from early initrd. I do not think we should play with udev at thta point. We may not even have writable filesystem at that point.
Pavel
Signature · 1 line
Thanks, Sharp!
Quoted 7 lines · Andrew Morton
Quoted 3 lines · Rafael J. Wysocki
The patch assumes that the major and minor numbers of the snapshot device will be 10 (ie. misc device) and 231, the registration of which has already been requested.
Why does it need a statically-allocated major and minor?
misc_register()will generate a uevent and the device node should just appear...
Not everyone uses udev, so for things that are going to be in the kernel tree, it's good to still register a major/minor number for them.
thanks,
greg k-h