2006-03-23 19:00:03 +08:00
|
|
|
/*
|
|
|
|
* linux/kernel/power/user.c
|
|
|
|
*
|
|
|
|
* This file provides the user space interface for software suspend/resume.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2006 Rafael J. Wysocki <rjw@sisk.pl>
|
|
|
|
*
|
|
|
|
* This file is released under the GPLv2.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/suspend.h>
|
|
|
|
#include <linux/syscalls.h>
|
2006-12-07 12:34:06 +08:00
|
|
|
#include <linux/reboot.h>
|
2006-03-23 19:00:03 +08:00
|
|
|
#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/fs.h>
|
2006-10-11 16:20:45 +08:00
|
|
|
#include <linux/console.h>
|
2006-09-26 14:32:48 +08:00
|
|
|
#include <linux/cpu.h>
|
2006-12-07 12:34:23 +08:00
|
|
|
#include <linux/freezer.h>
|
2006-03-23 19:00:03 +08:00
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
|
|
|
|
#include "power.h"
|
|
|
|
|
|
|
|
#define SNAPSHOT_MINOR 231
|
|
|
|
|
|
|
|
static struct snapshot_data {
|
|
|
|
struct snapshot_handle handle;
|
|
|
|
int swap;
|
|
|
|
int mode;
|
|
|
|
char frozen;
|
|
|
|
char ready;
|
2007-02-10 17:43:35 +08:00
|
|
|
char platform_suspend;
|
2006-03-23 19:00:03 +08:00
|
|
|
} snapshot_state;
|
|
|
|
|
2007-05-07 05:50:45 +08:00
|
|
|
atomic_t snapshot_device_available = ATOMIC_INIT(1);
|
2006-03-23 19:00:03 +08:00
|
|
|
|
|
|
|
static int snapshot_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
struct snapshot_data *data;
|
|
|
|
|
2007-05-07 05:50:45 +08:00
|
|
|
if (!atomic_add_unless(&snapshot_device_available, -1, 0))
|
2006-03-23 19:00:03 +08:00
|
|
|
return -EBUSY;
|
|
|
|
|
2007-05-07 05:50:44 +08:00
|
|
|
if ((filp->f_flags & O_ACCMODE) == O_RDWR) {
|
2007-05-07 05:50:45 +08:00
|
|
|
atomic_inc(&snapshot_device_available);
|
2006-03-23 19:00:03 +08:00
|
|
|
return -ENOSYS;
|
2007-05-07 05:50:44 +08:00
|
|
|
}
|
|
|
|
if(create_basic_memory_bitmaps()) {
|
2007-05-07 05:50:45 +08:00
|
|
|
atomic_inc(&snapshot_device_available);
|
2007-05-07 05:50:43 +08:00
|
|
|
return -ENOMEM;
|
2007-05-07 05:50:44 +08:00
|
|
|
}
|
2006-03-23 19:00:03 +08:00
|
|
|
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) {
|
2006-12-07 12:34:07 +08:00
|
|
|
data->swap = swsusp_resume_device ?
|
2007-01-06 08:36:28 +08:00
|
|
|
swap_type_of(swsusp_resume_device, 0, NULL) : -1;
|
2006-03-23 19:00:03 +08:00
|
|
|
data->mode = O_RDONLY;
|
|
|
|
} else {
|
|
|
|
data->swap = -1;
|
|
|
|
data->mode = O_WRONLY;
|
|
|
|
}
|
|
|
|
data->frozen = 0;
|
|
|
|
data->ready = 0;
|
2007-02-10 17:43:35 +08:00
|
|
|
data->platform_suspend = 0;
|
2006-03-23 19:00:03 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int snapshot_release(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
struct snapshot_data *data;
|
|
|
|
|
|
|
|
swsusp_free();
|
2007-05-07 05:50:43 +08:00
|
|
|
free_basic_memory_bitmaps();
|
2006-03-23 19:00:03 +08:00
|
|
|
data = filp->private_data;
|
2007-05-07 05:50:47 +08:00
|
|
|
free_all_swap_pages(data->swap);
|
2006-03-23 19:00:03 +08:00
|
|
|
if (data->frozen) {
|
2006-12-07 12:34:35 +08:00
|
|
|
mutex_lock(&pm_mutex);
|
2006-03-23 19:00:03 +08:00
|
|
|
thaw_processes();
|
2006-12-07 12:34:35 +08:00
|
|
|
mutex_unlock(&pm_mutex);
|
2006-03-23 19:00:03 +08:00
|
|
|
}
|
2007-05-07 05:50:45 +08:00
|
|
|
atomic_inc(&snapshot_device_available);
|
2006-03-23 19:00:03 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2007-02-10 17:43:35 +08:00
|
|
|
static inline int platform_prepare(void)
|
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
|
2007-05-09 17:33:18 +08:00
|
|
|
if (hibernation_ops)
|
|
|
|
error = hibernation_ops->prepare();
|
2007-02-10 17:43:35 +08:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void platform_finish(void)
|
|
|
|
{
|
2007-05-09 17:33:18 +08:00
|
|
|
if (hibernation_ops)
|
|
|
|
hibernation_ops->finish();
|
2007-02-10 17:43:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int snapshot_suspend(int platform_suspend)
|
2007-02-10 17:43:33 +08:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
mutex_lock(&pm_mutex);
|
|
|
|
/* Free memory before shutting down devices. */
|
|
|
|
error = swsusp_shrink_memory();
|
|
|
|
if (error)
|
|
|
|
goto Finish;
|
|
|
|
|
2007-02-10 17:43:35 +08:00
|
|
|
if (platform_suspend) {
|
|
|
|
error = platform_prepare();
|
|
|
|
if (error)
|
|
|
|
goto Finish;
|
|
|
|
}
|
2007-02-10 17:43:33 +08:00
|
|
|
suspend_console();
|
|
|
|
error = device_suspend(PMSG_FREEZE);
|
|
|
|
if (error)
|
|
|
|
goto Resume_devices;
|
|
|
|
|
|
|
|
error = disable_nonboot_cpus();
|
|
|
|
if (!error) {
|
|
|
|
in_suspend = 1;
|
|
|
|
error = swsusp_suspend();
|
|
|
|
}
|
|
|
|
enable_nonboot_cpus();
|
|
|
|
Resume_devices:
|
2007-02-10 17:43:35 +08:00
|
|
|
if (platform_suspend)
|
|
|
|
platform_finish();
|
|
|
|
|
2007-02-10 17:43:33 +08:00
|
|
|
device_resume();
|
|
|
|
resume_console();
|
|
|
|
Finish:
|
|
|
|
mutex_unlock(&pm_mutex);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2007-02-10 17:43:35 +08:00
|
|
|
static inline int snapshot_restore(int platform_suspend)
|
2007-02-10 17:43:33 +08:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
mutex_lock(&pm_mutex);
|
|
|
|
pm_prepare_console();
|
2007-02-10 17:43:35 +08:00
|
|
|
if (platform_suspend) {
|
|
|
|
error = platform_prepare();
|
|
|
|
if (error)
|
|
|
|
goto Finish;
|
|
|
|
}
|
2007-02-10 17:43:33 +08:00
|
|
|
suspend_console();
|
|
|
|
error = device_suspend(PMSG_PRETHAW);
|
|
|
|
if (error)
|
|
|
|
goto Resume_devices;
|
|
|
|
|
|
|
|
error = disable_nonboot_cpus();
|
|
|
|
if (!error)
|
|
|
|
error = swsusp_resume();
|
|
|
|
|
|
|
|
enable_nonboot_cpus();
|
|
|
|
Resume_devices:
|
2007-02-10 17:43:35 +08:00
|
|
|
if (platform_suspend)
|
|
|
|
platform_finish();
|
|
|
|
|
2007-02-10 17:43:33 +08:00
|
|
|
device_resume();
|
|
|
|
resume_console();
|
2007-02-10 17:43:35 +08:00
|
|
|
Finish:
|
2007-02-10 17:43:33 +08:00
|
|
|
pm_restore_console();
|
|
|
|
mutex_unlock(&pm_mutex);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-03-23 19:00:03 +08:00
|
|
|
static int snapshot_ioctl(struct inode *inode, struct file *filp,
|
|
|
|
unsigned int cmd, unsigned long arg)
|
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
struct snapshot_data *data;
|
2006-12-07 12:34:10 +08:00
|
|
|
loff_t avail;
|
|
|
|
sector_t offset;
|
2006-03-23 19:00:03 +08:00
|
|
|
|
|
|
|
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;
|
2006-12-07 12:34:35 +08:00
|
|
|
mutex_lock(&pm_mutex);
|
2007-02-10 17:43:33 +08:00
|
|
|
if (freeze_processes()) {
|
|
|
|
thaw_processes();
|
|
|
|
error = -EBUSY;
|
2006-03-23 19:00:03 +08:00
|
|
|
}
|
2006-12-07 12:34:35 +08:00
|
|
|
mutex_unlock(&pm_mutex);
|
2006-03-23 19:00:03 +08:00
|
|
|
if (!error)
|
|
|
|
data->frozen = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SNAPSHOT_UNFREEZE:
|
|
|
|
if (!data->frozen)
|
|
|
|
break;
|
2006-12-07 12:34:35 +08:00
|
|
|
mutex_lock(&pm_mutex);
|
2006-03-23 19:00:03 +08:00
|
|
|
thaw_processes();
|
2006-12-07 12:34:35 +08:00
|
|
|
mutex_unlock(&pm_mutex);
|
2006-03-23 19:00:03 +08:00
|
|
|
data->frozen = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SNAPSHOT_ATOMIC_SNAPSHOT:
|
|
|
|
if (data->mode != O_RDONLY || !data->frozen || data->ready) {
|
|
|
|
error = -EPERM;
|
|
|
|
break;
|
|
|
|
}
|
2007-02-10 17:43:35 +08:00
|
|
|
error = snapshot_suspend(data->platform_suspend);
|
2006-03-23 19:00:03 +08:00
|
|
|
if (!error)
|
|
|
|
error = put_user(in_suspend, (unsigned int __user *)arg);
|
|
|
|
if (!error)
|
|
|
|
data->ready = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SNAPSHOT_ATOMIC_RESTORE:
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
snapshot_write_finalize(&data->handle);
|
2006-03-23 19:00:03 +08:00
|
|
|
if (data->mode != O_WRONLY || !data->frozen ||
|
|
|
|
!snapshot_image_loaded(&data->handle)) {
|
|
|
|
error = -EPERM;
|
|
|
|
break;
|
|
|
|
}
|
2007-02-10 17:43:35 +08:00
|
|
|
error = snapshot_restore(data->platform_suspend);
|
2006-03-23 19:00:03 +08:00
|
|
|
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:
|
|
|
|
avail = count_swap_pages(data->swap, 1);
|
|
|
|
avail <<= PAGE_SHIFT;
|
|
|
|
error = put_user(avail, (loff_t __user *)arg);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SNAPSHOT_GET_SWAP_PAGE:
|
|
|
|
if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
|
|
|
|
error = -ENODEV;
|
|
|
|
break;
|
|
|
|
}
|
2007-05-07 05:50:47 +08:00
|
|
|
offset = alloc_swapdev_block(data->swap);
|
2006-03-23 19:00:03 +08:00
|
|
|
if (offset) {
|
|
|
|
offset <<= PAGE_SHIFT;
|
2006-12-07 12:34:10 +08:00
|
|
|
error = put_user(offset, (sector_t __user *)arg);
|
2006-03-23 19:00:03 +08:00
|
|
|
} else {
|
|
|
|
error = -ENOSPC;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SNAPSHOT_FREE_SWAP_PAGES:
|
|
|
|
if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
|
|
|
|
error = -ENODEV;
|
|
|
|
break;
|
|
|
|
}
|
2007-05-07 05:50:47 +08:00
|
|
|
free_all_swap_pages(data->swap);
|
2006-03-23 19:00:03 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SNAPSHOT_SET_SWAP_FILE:
|
2007-05-07 05:50:47 +08:00
|
|
|
if (!swsusp_swap_in_use()) {
|
2006-03-23 19:00:03 +08:00
|
|
|
/*
|
|
|
|
* User space encodes device types as two-byte values,
|
|
|
|
* so we need to recode them
|
|
|
|
*/
|
|
|
|
if (old_decode_dev(arg)) {
|
2007-01-06 08:36:28 +08:00
|
|
|
data->swap = swap_type_of(old_decode_dev(arg),
|
|
|
|
0, NULL);
|
2006-03-23 19:00:03 +08:00
|
|
|
if (data->swap < 0)
|
|
|
|
error = -ENODEV;
|
|
|
|
} else {
|
|
|
|
data->swap = -1;
|
|
|
|
error = -EINVAL;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
error = -EPERM;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2006-03-23 19:00:09 +08:00
|
|
|
case SNAPSHOT_S2RAM:
|
2007-02-10 17:43:35 +08:00
|
|
|
if (!pm_ops) {
|
|
|
|
error = -ENOSYS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2006-03-23 19:00:09 +08:00
|
|
|
if (!data->frozen) {
|
|
|
|
error = -EPERM;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2006-12-07 12:34:35 +08:00
|
|
|
if (!mutex_trylock(&pm_mutex)) {
|
2006-03-23 19:00:09 +08:00
|
|
|
error = -EBUSY;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pm_ops->prepare) {
|
|
|
|
error = pm_ops->prepare(PM_SUSPEND_MEM);
|
|
|
|
if (error)
|
|
|
|
goto OutS3;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Put devices to sleep */
|
2006-10-11 16:20:45 +08:00
|
|
|
suspend_console();
|
2006-03-23 19:00:09 +08:00
|
|
|
error = device_suspend(PMSG_SUSPEND);
|
|
|
|
if (error) {
|
|
|
|
printk(KERN_ERR "Failed to suspend some devices.\n");
|
|
|
|
} else {
|
2007-03-22 16:11:20 +08:00
|
|
|
error = disable_nonboot_cpus();
|
|
|
|
if (!error) {
|
|
|
|
/* Enter S3, system is already frozen */
|
|
|
|
suspend_enter(PM_SUSPEND_MEM);
|
|
|
|
enable_nonboot_cpus();
|
|
|
|
}
|
2006-03-23 19:00:09 +08:00
|
|
|
/* Wake up devices */
|
|
|
|
device_resume();
|
|
|
|
}
|
2006-10-11 16:20:45 +08:00
|
|
|
resume_console();
|
2006-03-23 19:00:09 +08:00
|
|
|
if (pm_ops->finish)
|
|
|
|
pm_ops->finish(PM_SUSPEND_MEM);
|
|
|
|
|
2006-12-07 12:34:44 +08:00
|
|
|
OutS3:
|
2006-12-07 12:34:35 +08:00
|
|
|
mutex_unlock(&pm_mutex);
|
2006-03-23 19:00:09 +08:00
|
|
|
break;
|
|
|
|
|
2006-12-07 12:34:06 +08:00
|
|
|
case SNAPSHOT_PMOPS:
|
2007-02-10 17:43:35 +08:00
|
|
|
error = -EINVAL;
|
|
|
|
|
2006-12-07 12:34:06 +08:00
|
|
|
switch (arg) {
|
|
|
|
|
|
|
|
case PMOPS_PREPARE:
|
2007-05-09 17:33:18 +08:00
|
|
|
if (hibernation_ops) {
|
2007-02-10 17:43:35 +08:00
|
|
|
data->platform_suspend = 1;
|
|
|
|
error = 0;
|
|
|
|
} else {
|
|
|
|
error = -ENOSYS;
|
2006-12-07 12:34:06 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PMOPS_ENTER:
|
2007-02-10 17:43:35 +08:00
|
|
|
if (data->platform_suspend) {
|
|
|
|
kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);
|
2007-05-09 17:33:18 +08:00
|
|
|
error = hibernation_ops->enter();
|
2007-02-10 17:43:35 +08:00
|
|
|
}
|
2006-12-07 12:34:06 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case PMOPS_FINISH:
|
2007-02-10 17:43:35 +08:00
|
|
|
if (data->platform_suspend)
|
|
|
|
error = 0;
|
|
|
|
|
2006-12-07 12:34:06 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
printk(KERN_ERR "SNAPSHOT_PMOPS: invalid argument %ld\n", arg);
|
|
|
|
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2006-12-07 12:34:15 +08:00
|
|
|
case SNAPSHOT_SET_SWAP_AREA:
|
2007-05-07 05:50:47 +08:00
|
|
|
if (swsusp_swap_in_use()) {
|
2006-12-07 12:34:15 +08:00
|
|
|
error = -EPERM;
|
|
|
|
} else {
|
|
|
|
struct resume_swap_area swap_area;
|
|
|
|
dev_t swdev;
|
|
|
|
|
|
|
|
error = copy_from_user(&swap_area, (void __user *)arg,
|
|
|
|
sizeof(struct resume_swap_area));
|
|
|
|
if (error) {
|
|
|
|
error = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* User space encodes device types as two-byte values,
|
|
|
|
* so we need to recode them
|
|
|
|
*/
|
|
|
|
swdev = old_decode_dev(swap_area.dev);
|
|
|
|
if (swdev) {
|
|
|
|
offset = swap_area.offset;
|
2007-01-06 08:36:28 +08:00
|
|
|
data->swap = swap_type_of(swdev, offset, NULL);
|
2006-12-07 12:34:15 +08:00
|
|
|
if (data->swap < 0)
|
|
|
|
error = -ENODEV;
|
|
|
|
} else {
|
|
|
|
data->swap = -1;
|
|
|
|
error = -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2006-03-23 19:00:03 +08:00
|
|
|
default:
|
|
|
|
error = -ENOTTY;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-12-07 12:40:36 +08:00
|
|
|
static const struct file_operations snapshot_fops = {
|
2006-03-23 19:00:03 +08:00
|
|
|
.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);
|