/* * 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/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/compat.h>#include <linux/console.h>#include <linux/cpu.h>#include <linux/freezer.h> #include <linux/uaccess.h> #include "power.h"  #define SNAPSHOT_MINOR	231 static struct snapshot_data {	struct snapshot_handle handle;	int swap;	int mode;	bool frozen;	bool ready;	bool platform_support;	bool free_bitmaps;} 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, nr_calls = 0; 	if (!hibernation_available())		return -EPERM; 	lock_system_sleep(); 	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;	}	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;		data->free_bitmaps = false;		error = __pm_notifier_call_chain(PM_HIBERNATION_PREPARE, -1, &nr_calls);		if (error)			__pm_notifier_call_chain(PM_POST_HIBERNATION, --nr_calls, NULL);	} else {		/*		 * Resuming.  We may need to wait for the image device to		 * appear.		 */		wait_for_device_probe(); 		data->swap = -1;		data->mode = O_WRONLY;		error = __pm_notifier_call_chain(PM_RESTORE_PREPARE, -1, &nr_calls);		if (!error) {			error = create_basic_memory_bitmaps();			data->free_bitmaps = !error;		} else			nr_calls--; 		if (error)			__pm_notifier_call_chain(PM_POST_RESTORE, nr_calls, NULL);	}	if (error)		atomic_inc(&snapshot_device_available); 	data->frozen = false;	data->ready = false;	data->platform_support = false;  Unlock:	unlock_system_sleep(); 	return error;} static int snapshot_release(struct inode *inode, struct file *filp){	struct snapshot_data *data; 	lock_system_sleep(); 	swsusp_free();	data = filp->private_data;	free_all_swap_pages(data->swap);	if (data->frozen) {		pm_restore_gfp_mask();		free_basic_memory_bitmaps();		thaw_processes();	} else if (data->free_bitmaps) {		free_basic_memory_bitmaps();	}	pm_notifier_call_chain(data->mode == O_RDONLY ?			PM_POST_HIBERNATION : PM_POST_RESTORE);	atomic_inc(&snapshot_device_available); 	unlock_system_sleep(); 	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; 	lock_system_sleep(); 	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:	unlock_system_sleep(); 	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; 	lock_system_sleep(); 	data = filp->private_data; 	if (!pg_offp) {		res = snapshot_write_next(&data->handle);		if (res <= 0)			goto unlock;	} else {		res = PAGE_SIZE - pg_offp;	} 	if (!data_of(data->handle)) {		res = -EINVAL;		goto unlock;	} 	res = simple_write_to_buffer(data_of(data->handle), res, &pg_offp,			buf, count);	if (res > 0)		*offp += res;unlock:	unlock_system_sleep(); 	return res;} 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; 	lock_device_hotplug();	data = filp->private_data; 	switch (cmd) { 	case SNAPSHOT_FREEZE:		if (data->frozen)			break; 		printk("Syncing filesystems ... ");		ksys_sync();		printk("done.\n"); 		error = freeze_processes();		if (error)			break; 		error = create_basic_memory_bitmaps();		if (error)			thaw_processes();		else			data->frozen = true; 		break; 	case SNAPSHOT_UNFREEZE:		if (!data->frozen || data->ready)			break;		pm_restore_gfp_mask();		free_basic_memory_bitmaps();		data->free_bitmaps = false;		thaw_processes();		data->frozen = false;		break; 	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) {			error = put_user(in_suspend, (int __user *)arg);			data->ready = !freezer_test_done && !error;			freezer_test_done = false;		}		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 = false;		/*		 * 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_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_SIZE:		size = count_swap_pages(data->swap, 1);		size <<= PAGE_SHIFT;		error = put_user(size, (loff_t __user *)arg);		break; 	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_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 = false;		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_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; 	} 	unlock_device_hotplug();	mutex_unlock(&pm_mutex); 	return error;} #ifdef CONFIG_COMPAT struct compat_resume_swap_area {	compat_loff_t offset;	u32 dev;} __packed; static longsnapshot_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg){	BUILD_BUG_ON(sizeof(loff_t) != sizeof(compat_loff_t)); 	switch (cmd) {	case SNAPSHOT_GET_IMAGE_SIZE:	case SNAPSHOT_AVAIL_SWAP_SIZE:	case SNAPSHOT_ALLOC_SWAP_PAGE: {		compat_loff_t __user *uoffset = compat_ptr(arg);		loff_t offset;		mm_segment_t old_fs;		int err; 		old_fs = get_fs();		set_fs(KERNEL_DS);		err = snapshot_ioctl(file, cmd, (unsigned long) &offset);		set_fs(old_fs);		if (!err && put_user(offset, uoffset))			err = -EFAULT;		return err;	} 	case SNAPSHOT_CREATE_IMAGE:		return snapshot_ioctl(file, cmd,				      (unsigned long) compat_ptr(arg)); 	case SNAPSHOT_SET_SWAP_AREA: {		struct compat_resume_swap_area __user *u_swap_area =			compat_ptr(arg);		struct resume_swap_area swap_area;		mm_segment_t old_fs;		int err; 		err = get_user(swap_area.offset, &u_swap_area->offset);		err |= get_user(swap_area.dev, &u_swap_area->dev);		if (err)			return -EFAULT;		old_fs = get_fs();		set_fs(KERNEL_DS);		err = snapshot_ioctl(file, SNAPSHOT_SET_SWAP_AREA,				     (unsigned long) &swap_area);		set_fs(old_fs);		return err;	} 	default:		return snapshot_ioctl(file, cmd, arg);	}} #endif /* CONFIG_COMPAT */ 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,#ifdef CONFIG_COMPAT	.compat_ioctl = snapshot_compat_ioctl,#endif}; 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);