| /* |
| * 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> |
| #include <linux/reboot.h> |
| #include <linux/kmod.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/fs.h> |
| #include <linux/console.h> |
| #include <linux/cpu.h> |
| #include <linux/freezer.h> |
| #include <scsi/scsi_scan.h> |
| |
| #include <asm/uaccess.h> |
| |
| #include "power.h" |
| |
| /* |
| * NOTE: The SNAPSHOT_SET_SWAP_FILE and SNAPSHOT_PMOPS ioctls are obsolete and |
| * will be removed in the future. They are only preserved here for |
| * compatibility with existing userland utilities. |
| */ |
| #define SNAPSHOT_SET_SWAP_FILE _IOW(SNAPSHOT_IOC_MAGIC, 10, unsigned int) |
| #define SNAPSHOT_PMOPS _IOW(SNAPSHOT_IOC_MAGIC, 12, unsigned int) |
| |
| #define PMOPS_PREPARE 1 |
| #define PMOPS_ENTER 2 |
| #define PMOPS_FINISH 3 |
| |
| /* |
| * NOTE: The following ioctl definitions are wrong and have been replaced with |
| * correct ones. They are only preserved here for compatibility with existing |
| * userland utilities and will be removed in the future. |
| */ |
| #define SNAPSHOT_ATOMIC_SNAPSHOT _IOW(SNAPSHOT_IOC_MAGIC, 3, void *) |
| #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_MINOR 231 |
| |
| static struct snapshot_data { |
| struct snapshot_handle handle; |
| int swap; |
| int mode; |
| char frozen; |
| char ready; |
| char platform_support; |
| } snapshot_state; |
| |
| atomic_t snapshot_device_available = ATOMIC_INIT(1); |
| |
| static int snapshot_open(struct inode *inode, struct file *filp) |
| { |
| struct snapshot_data *data; |
| int error; |
| |
| mutex_lock(&pm_mutex); |
| |
| if (!atomic_add_unless(&snapshot_device_available, -1, 0)) { |
| error = -EBUSY; |
| goto Unlock; |
| } |
| |
| if ((filp->f_flags & O_ACCMODE) == O_RDWR) { |
| atomic_inc(&snapshot_device_available); |
| error = -ENOSYS; |
| goto Unlock; |
| } |
| if(create_basic_memory_bitmaps()) { |
| atomic_inc(&snapshot_device_available); |
| error = -ENOMEM; |
| goto Unlock; |
| } |
| 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) { |
| /* Hibernating. The image device should be accessible. */ |
| data->swap = swsusp_resume_device ? |
| swap_type_of(swsusp_resume_device, 0, NULL) : -1; |
| data->mode = O_RDONLY; |
| error = pm_notifier_call_chain(PM_HIBERNATION_PREPARE); |
| if (error) |
| pm_notifier_call_chain(PM_POST_HIBERNATION); |
| } else { |
| /* |
| * Resuming. We may need to wait for the image device to |
| * appear. |
| */ |
| wait_for_device_probe(); |
| scsi_complete_async_scans(); |
| |
| data->swap = -1; |
| data->mode = O_WRONLY; |
| error = pm_notifier_call_chain(PM_RESTORE_PREPARE); |
| if (error) |
| pm_notifier_call_chain(PM_POST_RESTORE); |
| } |
| if (error) { |
| free_basic_memory_bitmaps(); |
| atomic_inc(&snapshot_device_available); |
| } |
| data->frozen = 0; |
| data->ready = 0; |
| data->platform_support = 0; |
| |
| Unlock: |
| mutex_unlock(&pm_mutex); |
| |
| return error; |
| } |
| |
| static int snapshot_release(struct inode *inode, struct file *filp) |
| { |
| struct snapshot_data *data; |
| |
| mutex_lock(&pm_mutex); |
| |
| swsusp_free(); |
| free_basic_memory_bitmaps(); |
| data = filp->private_data; |
| free_all_swap_pages(data->swap); |
| if (data->frozen) { |
| pm_restore_gfp_mask(); |
| thaw_processes(); |
| } |
| pm_notifier_call_chain(data->mode == O_RDONLY ? |
| PM_POST_HIBERNATION : PM_POST_RESTORE); |
| atomic_inc(&snapshot_device_available); |
| |
| mutex_unlock(&pm_mutex); |
| |
| 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; |
| loff_t pg_offp = *offp & ~PAGE_MASK; |
| |
| mutex_lock(&pm_mutex); |
| |
| data = filp->private_data; |
| if (!data->ready) { |
| res = -ENODATA; |
| goto Unlock; |
| } |
| if (!pg_offp) { /* on page boundary? */ |
| res = snapshot_read_next(&data->handle); |
| if (res <= 0) |
| goto Unlock; |
| } else { |
| res = PAGE_SIZE - pg_offp; |
| } |
| |
| res = simple_read_from_buffer(buf, count, &pg_offp, |
| data_of(data->handle), res); |
| if (res > 0) |
| *offp += res; |
| |
| Unlock: |
| mutex_unlock(&pm_mutex); |
| |
| 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; |
| loff_t pg_offp = *offp & ~PAGE_MASK; |
| |
| mutex_lock(&pm_mutex); |
| |
| data = filp->private_data; |
| |
| if (!pg_offp) { |
| res = snapshot_write_next(&data->handle); |
| if (res <= 0) |
| goto unlock; |
| } else { |
| res = PAGE_SIZE - pg_offp; |
| } |
| |
| res = simple_write_to_buffer(data_of(data->handle), res, &pg_offp, |
| buf, count); |
| if (res > 0) |
| *offp += res; |
| unlock: |
| mutex_unlock(&pm_mutex); |
| |
| return res; |
| } |
| |
| static void snapshot_deprecated_ioctl(unsigned int cmd) |
| { |
| if (printk_ratelimit()) |
| printk(KERN_NOTICE "%pf: ioctl '%.8x' is deprecated and will " |
| "be removed soon, update your suspend-to-disk " |
| "utilities\n", |
| __builtin_return_address(0), cmd); |
| } |
| |
| static long snapshot_ioctl(struct file *filp, unsigned int cmd, |
| unsigned long arg) |
| { |
| int error = 0; |
| struct snapshot_data *data; |
| loff_t size; |
| sector_t offset; |
| |
| 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; |
| |
| if (!mutex_trylock(&pm_mutex)) |
| return -EBUSY; |
| |
| data = filp->private_data; |
| |
| switch (cmd) { |
| |
| case SNAPSHOT_FREEZE: |
| if (data->frozen) |
| break; |
| |
| printk("Syncing filesystems ... "); |
| sys_sync(); |
| printk("done.\n"); |
| |
| error = usermodehelper_disable(); |
| if (error) |
| break; |
| |
| error = freeze_processes(); |
| if (error) { |
| thaw_processes(); |
| usermodehelper_enable(); |
| } |
| if (!error) |
| data->frozen = 1; |
| break; |
| |
| case SNAPSHOT_UNFREEZE: |
| if (!data->frozen || data->ready) |
| break; |
| pm_restore_gfp_mask(); |
| thaw_processes(); |
| usermodehelper_enable(); |
| data->frozen = 0; |
| break; |
| |
| case SNAPSHOT_ATOMIC_SNAPSHOT: |
| snapshot_deprecated_ioctl(cmd); |
| case SNAPSHOT_CREATE_IMAGE: |
| if (data->mode != O_RDONLY || !data->frozen || data->ready) { |
| error = -EPERM; |
| break; |
| } |
| pm_restore_gfp_mask(); |
| error = hibernation_snapshot(data->platform_support); |
| if (error) { |
| thaw_kernel_threads(); |
| } else { |
| error = put_user(in_suspend, (int __user *)arg); |
| if (!error && !freezer_test_done) |
| data->ready = 1; |
| if (freezer_test_done) { |
| freezer_test_done = false; |
| thaw_kernel_threads(); |
| } |
| } |
| break; |
| |
| case SNAPSHOT_ATOMIC_RESTORE: |
| snapshot_write_finalize(&data->handle); |
| if (data->mode != O_WRONLY || !data->frozen || |
| !snapshot_image_loaded(&data->handle)) { |
| error = -EPERM; |
| break; |
| } |
| error = hibernation_restore(data->platform_support); |
| break; |
| |
| case SNAPSHOT_FREE: |
| swsusp_free(); |
| memset(&data->handle, 0, sizeof(struct snapshot_handle)); |
| data->ready = 0; |
| /* |
| * It is necessary to thaw kernel threads here, because |
| * SNAPSHOT_CREATE_IMAGE may be invoked directly after |
| * SNAPSHOT_FREE. In that case, if kernel threads were not |
| * thawed, the preallocation of memory carried out by |
| * hibernation_snapshot() might run into problems (i.e. it |
| * might fail or even deadlock). |
| */ |
| thaw_kernel_threads(); |
| break; |
| |
| case SNAPSHOT_SET_IMAGE_SIZE: |
| snapshot_deprecated_ioctl(cmd); |
| case SNAPSHOT_PREF_IMAGE_SIZE: |
| image_size = arg; |
| break; |
| |
| case SNAPSHOT_GET_IMAGE_SIZE: |
| if (!data->ready) { |
| error = -ENODATA; |
| break; |
| } |
| size = snapshot_get_image_size(); |
| size <<= PAGE_SHIFT; |
| error = put_user(size, (loff_t __user *)arg); |
| break; |
| |
| case SNAPSHOT_AVAIL_SWAP: |
| snapshot_deprecated_ioctl(cmd); |
| case SNAPSHOT_AVAIL_SWAP_SIZE: |
| size = count_swap_pages(data->swap, 1); |
| size <<= PAGE_SHIFT; |
| error = put_user(size, (loff_t __user *)arg); |
| break; |
| |
| case SNAPSHOT_GET_SWAP_PAGE: |
| snapshot_deprecated_ioctl(cmd); |
| case SNAPSHOT_ALLOC_SWAP_PAGE: |
| if (data->swap < 0 || data->swap >= MAX_SWAPFILES) { |
| error = -ENODEV; |
| break; |
| } |
| offset = alloc_swapdev_block(data->swap); |
| if (offset) { |
| offset <<= PAGE_SHIFT; |
| error = 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); |
| break; |
| |
| case SNAPSHOT_SET_SWAP_FILE: /* This ioctl is deprecated */ |
| snapshot_deprecated_ioctl(cmd); |
| if (!swsusp_swap_in_use()) { |
| /* |
| * User space encodes device types as two-byte values, |
| * so we need to recode them |
| */ |
| if (old_decode_dev(arg)) { |
| data->swap = swap_type_of(old_decode_dev(arg), |
| 0, NULL); |
| if (data->swap < 0) |
| error = -ENODEV; |
| } else { |
| data->swap = -1; |
| error = -EINVAL; |
| } |
| } else { |
| error = -EPERM; |
| } |
| break; |
| |
| case SNAPSHOT_S2RAM: |
| if (!data->frozen) { |
| error = -EPERM; |
| break; |
| } |
| /* |
| * Tasks are frozen and the notifiers have been called with |
| * PM_HIBERNATION_PREPARE |
| */ |
| error = suspend_devices_and_enter(PM_SUSPEND_MEM); |
| data->ready = 0; |
| break; |
| |
| case SNAPSHOT_PLATFORM_SUPPORT: |
| data->platform_support = !!arg; |
| break; |
| |
| case SNAPSHOT_POWER_OFF: |
| if (data->platform_support) |
| error = hibernation_platform_enter(); |
| break; |
| |
| case SNAPSHOT_PMOPS: /* This ioctl is deprecated */ |
| snapshot_deprecated_ioctl(cmd); |
| error = -EINVAL; |
| |
| switch (arg) { |
| |
| case PMOPS_PREPARE: |
| data->platform_support = 1; |
| error = 0; |
| break; |
| |
| case PMOPS_ENTER: |
| if (data->platform_support) |
| error = hibernation_platform_enter(); |
| break; |
| |
| case PMOPS_FINISH: |
| if (data->platform_support) |
| error = 0; |
| break; |
| |
| default: |
| printk(KERN_ERR "SNAPSHOT_PMOPS: invalid argument %ld\n", arg); |
| |
| } |
| break; |
| |
| case SNAPSHOT_SET_SWAP_AREA: |
| if (swsusp_swap_in_use()) { |
| 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 = new_decode_dev(swap_area.dev); |
| if (swdev) { |
| offset = swap_area.offset; |
| data->swap = swap_type_of(swdev, offset, NULL); |
| if (data->swap < 0) |
| error = -ENODEV; |
| } else { |
| data->swap = -1; |
| error = -EINVAL; |
| } |
| } |
| break; |
| |
| default: |
| error = -ENOTTY; |
| |
| } |
| |
| mutex_unlock(&pm_mutex); |
| |
| return error; |
| } |
| |
| static const struct file_operations snapshot_fops = { |
| .open = snapshot_open, |
| .release = snapshot_release, |
| .read = snapshot_read, |
| .write = snapshot_write, |
| .llseek = no_llseek, |
| .unlocked_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); |